Programmieren in Python

Hier ist eine Reihe von Themenbereichen aufgelistet, die du einzeln auf- und zuklappen kannst (Klick auf die kleine Pfeilspitze).

Die wichtigsten Informationen sind schwarz geschrieben.

Zusatz- oder Hintergrundinformationen sind grau geschrieben.

I. Funktionen

1. Funktionen definieren

Wenn ich eine Funktion definiere, programmiere ich aus Einzelteilen einen Baustein, den ich später (mithilfe des von mir festgelegten Funktionsbezeichners) als Ganzen verwenden kann.

Eine Funktion kann dazu dienen, einfach nur für gegebene Übergabewerte genau einen Rückgabewert bzw. Funktionswert zu berechnen (entsprechend einer Funktion in der Mathematik). Sie kann aber (vorher) auch noch allerhand anderes erledigen. Und sie kann auch nur anderes erledigen, ohne einen Rückgabewert zu berechnen.

Allgemein:

Beispiele:

def bezeichner(parameter, ...):
    ... ggf. algorithmus/programm ...
    return rückgabewert/-term

def quadratfläche_berechnen(kantenlänge):
    return kantenlänge * kantenlänge

def zehn_prozent_reduzieren(preis):
    print("So, kleinen Moment, ich rechne mal ...")
    return preis * 0.9

def begrüßen(name):
    print("Guten Tag,", name)

Die Parameter aus der Parameterliste sind nur "innerhalb der jeweiligen Funktion", hier also im eingerückten Code nach dem Doppelpunkt, gültig.

Beachte, dass bei Funktionen, die Methoden einer Klasse sind, an erster Stelle in der Parameter-Liste self stehten muss.

2. Funktionen verwenden

Nachdem eine Funktion definiert worden ist, kann ich sie in einem Term (allein oder in Kombination) verwenden. Wir sprechen auch davon, dass ich eine Funktion "aufrufe". Dabei benutze ich den Bezeichner der Funktion, gefolgt von der Parameterliste, in der jetzt für jeden Parameter ein passender Übergabewert stehen muss.

Funktionsdefinition:

Verwendung/Aufruf der Funktion:

def halbieren(zahl):
    return zahl / 2.0

halbieren(5.3)
Rückgabewert wird 2.65 sein

Wenn die Funktion einen Rückgabewert erzeugt, hat der Funktionsaufruf im Term den Wert des Rückgabewerts.

Term

Wert des Terms

halbieren(5.3) + 0.35

3.0

halbieren(halbieren(8.0))

2.0

II. Variablen

Eine Variable ermöglicht es, Werte im Arbeitsspeicher zu speichern, um sie zu einem späteren Zeitpunkt wieder abzurufen und damit weiterzuarbeiten. Mit einer Variablen kann ich das über einen von mir selbst festgelegten Bezeichner tun.

So muss ich mich nicht darum kümmern, wie ein geeigneter Speicherplatz gefunden werden kann, über welche Speicheradresse (eine Zahl) darauf zugegriffen werden muss, wie sichergestellt wird, dass kein anderes Programm mir meine Werte überschreibt usw.

1. Variablen deklarieren und initialisieren (= erzeugen und mit einem Startwert belegen)

Allgemein:

Beispiel:

bezeichner = startwert

postleitzahl = 95119
temperatur = 19.3
name = "Buchner"
es_regnet_gerade = False

2. Variablen verwenden

Wenn ich einen Variablenbezeichner in einem Term benutze, wird er durch den aktuellen Wert der Variable ersetzt.
Schreibe ich aber nach einem Variablenbezeichner ein =-Zeichen, so muss darauf ein Term folgen. Der Wert dieses Terms wird der Variable dann als neuer Wert zugewiesen. Dabei muss ich selbst darauf achten, dass der Datentyp des neuen Wertes zur Verwendung der Variablen passt.

Deklaration & Initialisierung:

Verwendung der Variable:

nachricht = "Hallo"

nachricht = nachricht + " Fritz!"
print(nachricht)

Zeichenkette Hallo Fritz! wird auf die Konsole geschrieben
nachricht = "Hallo Alberta!"
print(nachricht)

Zeichenkette Hallo Alberta! wird auf die Konsole geschrieben

erdbeschleunigung = 9.81
zeit = 1
geschwindigkeit = None

geschwindigkeit = erdbeschleunigung * zeit
Variablenwert von geschwindigkeit jetzt: 9.81
zeit = 2
geschwindigkeit = erdbeschleunigung * zeit

Variablenwert von geschwindigkeit jetzt: 19.62

Wenn es gerade keinen sinnvollen Wert für eine Variable gibt, kann ihr das Platzhalter-Objekt None als Wert zugewiesen werden.

III. Algorithmen und deren Grundbausteine (/ Kontrollstrukturen)

1. Programm und Algorithmus

Ein Algorithmus ist eine endliche Folge eindeutiger Anweisungen, die, wenn sie unter gleichen Ausgangsbedingungen ausgeführt wird, zum gleichen Ergebnis führt. Wenn ein Algorithmus in einer Programmiersprache formuliert wird, entsteht ein Programm. Die jeweilige Programmiersprache legt fest, was als eindeutige Anweisung gilt. In Python sind das Definitionen von bzw. Wertzuweisungen an Variablen, Funktionsaufrufe, Methodenaufrufe ...

2. Grundbausteine von Algorithmen

a) Die Sequenz / Folge von zusammengehörenden Anweisungen

Mehrere Anweisungen werden als zusammengehörig gekennzeichnet, indem sie gleich weit (um dieselbe Zahl von Leerzeichen – i. d. R. ein ganzzahliges Vielfaches von 4) eingerückt werden. Gebraucht wird das bei Funktionsdefinitionen, bedingten Anweisungen, bedingten Wiederholungen ...

Bedingte Anweisungen, bedingte Wiederholungen etc. können selbst auch innerhalb einer Sequenz vorkommen, dann gibt wird entsprechend weiter eingerückt.

b) Die bedingte Anweisung / Fallunterscheidung

Unter der gegebenen Bedingung etwas Bestimmtes machen, ansonsten gar nichts machen:

Allgemein:

Beispiel:

if aussagefunktion:
    
anweisung
    anweisung
    ...

geheimwort = "geheim"
eingabe = input("Rate das Geheimwort! ")
if eingabe == geheimwort:
    print("Glückwunsch!!!")
    print("Du hast das Geheimwort erraten.")

Unter der gegebenen Bedingung etwas Bestimmtes machen, ansonsten etwas anderes machen:

Allgemein:

Beispiel:

if aussagefunktion:
    
anweisung
    anweisung
    ...
else:
    
anweisung
    anweisung
    ...

geheimwort = "geheim"
eingabe = input("Rate das Geheimwort! ")
if eingabe == geheimwort:
    print("Glückwunsch!!!")
    print("Du hast das Geheimwort erraten.")
else:
    print("Pech gehabt!")
    print("Das war nicht das Geheimwort.")

Wenn mehr als zwei Fälle unterschieden werden sollen, kann statt mit else: mit elif aussagefunktion: weitergemacht werden; am Schluss folgt dann else:.

c) Die bedingte Wiederholung

Wenn die angegebene Bedingung erfüllt ist, etwas Bestimmtes machen, danach wieder von vorn prüfen, ob die Bedingung erfüllt ist, und wenn ja, dasselbe wieder machen und immer so weiter, bis die Bedingung nicht mehr erfüllt ist.

Wenn die Bedingung bei der ersten Prüfung nicht erfüllt ist, wird gar nichts gemacht (wie bei if).

Allgemein:

Beispiel:

while aussagefunktion:
    anweisung
    anweisung
    ...

geheimwort = "geheim"
eingabe = input("Rate das Geheimwort")
while (eingabe != geheimwort):
    print("Du hast das Geheimwort noch nicht erraten.")
    print("Versuche es noch einmal!")
    eingabe = input("Rate das Geheimwort")
print("Richtig, das ist das Geheimwort!")

IV. Objekte und Klassen

Objekte sind Bündel von Variablen und Funktionen, die unter einem einzigen Bezeichner abgespeichert werden können. Die Variablen im Bündel nennen wir Attribute, die Funktionen im Bündel nennen wir Methoden.

Solange es noch einen Bezeichner gibt, unter dem ein Objekt gespeichert ist, bleibt es – mit allen seinen Attributen und Methoden – erhalten. Gibt es keinen solchen Bezeichner mehr, wird das Objekt entsorgt.

Um Objekte zu erzeugen, programmiere ich üblicherweise eine Klasse, in der festgelegt ist, wie Objekte eines bestimmten Typs aussehen sollen. Die Klasse kann dann beliebig viele Objekte ihres Typs erzeugen. "Ihres Typs" ist hier in jeder Hinsicht wörtlich zunehmen: Mit jeder Klasse erzeuge ich auch einen neuen Datentyp. Dieser Datentyp hat denselben Bezeichner wie die Klasse.

1. Klassen definieren

Datenklassen legen nur Attribute, jedoch keine Methoden fest.

Allgemein:

Beispiel:

class Klassenbezeichner:

    def __init__(self,
parameter, ...):
        self.
attributbezeichner = parameter
        ...

    ... weitere Methoden ...

class Quadrat:

    def __init__(self, kantenlänge):
        self.kantenlänge = kantenlänge

    def umfang_geben(self):
        return self.kantenlänge * 4

    def raum_über_fläche_geben(self, höhe):
        return pow(self.kantenlänge, 2) * höhe

Eine Klasse wird einmal programmiert und dient dann als Vorlage für beliebig viele Objekte. Damit der einmal erzeugte Programmcode für jedes später erzeugte Objekt gelten kann, muss darin ein Platzhalter für das Objekt vorgesehen werden, für das er im jeweiligen Fall genutzt werden soll. Dazu dient der erste Parameter jeder Methode, der normalerweise self genannt wird (obwohl er auch anders heißen könnte). Wenn später eine Methode eines Objekts aufgerufen wird, liefert das System automatisch eine Referenz auf das entsprechende Objekt mit. So wird im Beispiel oben sichergestellt, dass die umfang_geben-Methode eines Objekts von der Klasse Quadrat für die Berechnung des Umfangs wirklich die Kantenlänge desjenigen Quadrat-Objekts benutzt, zu dem sie gehört.

Die Attribute der Klasse werden, mit vorangestelltem self., in der __init__-Methode deklariert. Sie können mit Übergabewerten aus Parametern der Methode initialisiert werden oder auch mit festen Werten.

b) Klassen verwenden => Objekte erzeugen => Objekte verwenden

Um ein Objekt zu erzeugen, benutze ich den Klassenbezeichner wie einen Funktionsbezeichner (es soll ja eine Funktion ausgeführt werden, die ein Objekt erzeugt). In die Parameterliste muss ich die nötigen Übergabewerte für die __init__-Methode(!) eintragen (ohne den Übergabewert für self, der wird, wie gesagt, automatisch bereitgestellt).

Klassendefinition:

Erzeugung und Verwendung von Objekten:

class Quadrat:

    def __init__(self, kantenlänge):
        self.kantenlänge = kantenlänge

    def umfang_geben(self):
        return self.kantenlänge * 4

    def raum_über_fläche_geben(self, höhe):
        return pow(self.kantenlänge, 2) * höhe

quadi = Quadrat(17.9)
drati = Quadrat(5.47)
drati.kantenlänge

Rückgabewert: 5.47
quadi.kantenlänge
Rückgabewert: 17.9
drati.umfang_geben()
Rückgabewert: 21.88
quadi.raum_über_fläche_geben(1.95)
Rückgabewert: 624.7995

Typischerweise werden neu erzeugte Objekte (wie hier im Beispiel) direkt einer Variablen als Wert zugewiesen. Das muss aber nicht sein: Was im Beispiel hinter dem =-Zeichen steht, könnte z. B. auch in einem Funktionsaufruf als Übergabewert verwendet werden.

Mithilfe der Punktnotation kann ich auf die Attribute und Methoden von Objekten zugreifen. Ich schreibe vor dem Punkt einen Objektbezeichner (also den Bezeichner einer Variable, als deren Wert ein Objekt gespeichert ist) und nach dem Punkt einen Attribut- bzw. Methodenbezeichner (jeweils ohne Leerzeichen dazwischen). Zusammen lässt sich dies genau so verwenden wie ein einfacher Variablen- bzw. Funktionsbezeichner (denke aber bei Methodenaufrufen daran, dass der Übergabewert für self automatisch bereitgestellt wird).

c) Datenkapselung?

Jedem Objekt soll die Kontrolle darüber, was mit seinen – in den Attributen gespeicherten – Daten gemacht wird, selbst überlassen werden. Andere Programmteile sollen lieber nicht (insbesondere nicht schreibend) auf die Attribute eines Objekts zugreifen. Das ist aber, wie oben festgestellt, in Python grundsätzlich möglich: Mithilfe der Punktnotation kann ich Attributwerte nicht nur lesen, sondern – per Zuweisungsoperator = – auch schreiben.

Was tun?

V. Vererbung

Eine Unterklasse "erbt" alle Attribute und Methoden ihrer Oberklasse. Üblicherweise "erweitert" sie die Oberklasse durch weitere Attribute bzw. Methoden. Oder sie "überschreibt" bestimmte Methoden, die sie geerbt hat.

Wenn ich in einer Klassendefinition hinter dem Klassenbezeichner in Klammern den Bezeichner einer anderen Klasse angebe, wird die neu definierte Klasse eine Unterklasse der in Klammern angegebenen Oberklasse.

Definition einer Unterklasse allgemein:

class Unterklassenbezeichner(Oberklassenbezeichner):

    def __init__(self,
parameter_fuer_oberklasse, ..., parameter_fuer_unterklasse, ...):
        super().__init__(
parameter_fuer_oberklasse, ...)
        self.
attributbezeichner = parameter_fuer_unterklasse
        ...

    ... weitere Methoden ...

In der __init__-Methode der Unterklasse muss (am besten gleich am Anfang) die __init__-Methode der Oberklasse (Zugriff über die super-Funktion) aufgerufen werden, damit die in der Oberklasse vorgesehenen Attribute richtig angelegt werden. Ob die Übergabewerte dafür aus der Parameterliste der __init__-Methode der Unterklasse stammen oder ob sie anders ermittelt werden, hängt von den jeweiligen Erfordernissen ab.

Beispiel für eine Oberklasse:

class Rechteck:

    def __init__(self, laenge, breite):
        self.laenge = laenge
        self.breite = breite

    def umfang_geben(self):
        return self.laenge * 2 + self.breite * 2

    def flaeche_geben(self):
        return self.laenge * self.breite

Beispiel für eine Unterklasse dazu:

class Quadrat(Rechteck):

    def __init__(self, kantenlaenge):
        super().__init__(kantenlaenge, kantenlaenge)

    def umfangGeben(self):
        return self.laenge * 4

Im Beispiel gibt die Unterklasse für die zwei Attribute der Oberklasse denselben Startwert an die Oberklasse weiter (weil das in diesem Zusammenhang sinnvoll ist). Die umfang_geben-Methode der Oberklasse wird von der Unterklasse (mit einer anderen, die etwas weniger aufwändig rechnet) überschrieben. Die flaeche_geben-Methode wird in der Unterklasse so beibehalten, wie sie von der Oberklasse geerbt wurde.

Hinweis zum Überschreiben: Wenn eine Methode einer Unterklasse eine Methode einer Oberklasse überschreibt, kann bei Bedarf unter Rückgriff auf die super-Funktion aus der Unterklassen-Methode heraus die entsprechende Oberklassen-Methode aufgerufen werden.

Zum Erzeugen von Objekten einer Unterklasse gibt es nichts Besonderes anzumerken.

VI. Listen

Listen erlauben es, beliebig viele (normalerweise gleichartige) Werte bzw. Objekte gemeinsam unter einem Bezeichner zu speichern. Die Werte werden in der Liste an aufsteigend durchnummerierten Speicherplätzen abgelegt. Mit der Kombination aus dem Bezeichner einer Liste und einer Speicherplatznummer – dem sogenannten Index – kann auf die einzelnen Werte zugegriffen werden. Dabei kann der Index auch mithilfe einer Variable (vom Typ int) angegeben werden. So ist es möglich, je nach Zustand des Sytems flexibel steuern zu lassen, auf welchen Wert zugegriffen werden soll.

1. Listen erzeugen

Eine leere Liste erzeuge ich, indem ich eckige Klammern öffne und schließe: []. Ich kann auch gleich Elemente mit angeben, die von vornherein in der Liste enthalten sein sollen, indem ich die entsprechenden Werte durch Komma getrennt in die eckigen Klammern schreibe.

Allgemein:

Beispiele:

[]

bzw.

[element , ...]

[]

["Esel"]

["Esel", "Hund", "Katze"]

[0, 1, 1, 2, 3, 5]

Manchmal möchte man eine Liste einer bestimmten Länge erzeugen, in der zunächst nur Platzhalter für die späteren Werte gespeichert sind. Dazu erzeugt man eine Liste der Länge 1, die nur den Platzhalter enthält, und 'multipliziert sie mit' einer der gewünschten Länge entsprechenden Ganzzahl, z. B. [None] * 10.

2. Listen verwenden

a) Elemente an eine Liste anhängen

Um an eine bereits vorhandene Liste ein Element anzuhängen kann ich deren append-Methode benutzen. Es ist aber auch möglich, Listen zu 'addieren'.

Erzeugung und Zuweisung an eine Variable:

Verwendung der Liste:

wahrheitswerte = []

wahrheitswerte.append(True)
wahrheitswerte += [False]

Die Liste enthält jetzt zwei Wahrheitswerte.

b) Auf einzelne Werte in einer Liste zugreifen

Um auf einen bestimmten Wert zuzugreifen, der in einer Liste gespeichert ist, schreibe ich

bezeichner[index].

Erzeugung und Zuweisung an eine Variable:

Verwendung der Liste:

tierturm = ["Esel", "Hund", "Katze", "Hahn"]

tierturm[0] = "Pferd"
Esel wird durch Pferd ersetzt
print(tierturm[3])
Zeichenkette Hahn wird auf die Konsole geschrieben
index = 2
tierturm[index].upper()

Rückgabewert: Zeichenkette KATZE

Typischerweise werden neu erzeugte Listen (wie hier im Beispiel) direkt einer Variable als Wert zugewiesen. Das muss aber nicht sein: Was im Beispiel hinter dem =-Zeichen steht, könnte z. B. auch in einem Funktionsaufruf als Übergabewert verwendet werden.

c) Nacheinander auf viele bzw. alle Werte in einer Liste zugreifen (über eine Liste iterieren)

Um flexibel auf verschiedene Werte in einer Liste zugreifen zu können, gebe ich den Index mithilfe einer Variable an. Den Wert der Variable verändere ich im Rahmen einer bedingten Wiederholung so, dass jeder gewünschte Index einmal 'an die Reihe kommt'.

Erzeugung und Zuweisung:

Iterieren über die Liste:

zahlen = [53, 12, 89, 47]

index = 0
while index < len(zahlen):
    print(zahlen[index])
    index += 1

Alle Zahlen in der Liste werden der
Reihe nach auf die Konsole geschrieben.

Alternative:
for index in range(4):
    print(zahlen[index])

VII. Weitere (praktische) Kontrollstrukturen

1. Bedingte Anweisung mit match (Mustervergleich)

Den Wert einer Variable mit verschiedenen Mustern vergleichen und jeweils entsprechend reagieren.

Allgemein:

Beispiel:

match variablenbezeichner:
    case
muster:
        
anweisung
    case muster:
        
anweisung
    ...
    case _:
        
anweisung

print("Was möchten Sie tun?")
print('1. "Guten Morgen" sagen')
print('2. "Guten Abend" sagen')
eingabe = input("Ihre Auswahl: ")
match eingabe:
    case "1":
        print("Guten Morgen")
    case "2":
        print("Guten Abend")
    case _:
        print("Ungültige Eingabe")

Die Muster können auch komplexer sein: Mehrere mögliche Werte können getrennt durch | angegeben werden. ... In "Konstuktor-Mustern" steht ein Klassenbezeichner, gefolgt von einer Liste möglicher Übergabewerte für seine init--Methode, für ein Objekt mit entsprechenden Attributwerten ... Übergabewerte können dann durch Bezeichner zu erzeugender Variablen ersetzt werden, die jeweils mit dem entsprechenden Attributwert initialisiert werden ...

2. Wiederholung mit for

a) Spezialfall: Verwendung zum "Durchzählen"

Einer (ggf. extra zu diesem Zweck erzeugten) Variable der Reihe nach jeden Wert aus einem Bereich von ganzzahligen Werten zuweisen – und demnach so oft wiederholen, wie es die Anzahl von Werten im Bereich vorgibt.

Allgemein:

Beispiel:

for bezeichner in range(ganzzahl):
    
anweisung
    
anweisung
    
...

for zahl in range(10):
    print(zahl)

Die Zahlen von 0 bis einschließ-
lich 9 werden auf die Konsole
geschrieben.

Die (ggf.) neu erzeugte Variable mit dem in jedem Wiederholungsdurchlauf anderen Wert kann, wie im Beispiel, in den zu wiederholenden Anweisungen verwendet werden, das muss aber nicht sein – dann liegt eine "klassische" Wiederholung mit fester Anzahl vor.

b) Allgemein: Verwendung zum Iterieren (ohne Indizes durchzuzählen)

Einer Variable der Reihe nach jeden Wert aus einem Container, z. B. einer Liste, zuweisen.

Allgemein:

Beispiel:

for bezeichner in containerbezeichner:
    
anweisung
    
anweisung
    
...

namen = ["Uli", "Ali", "Ulf"]
for name in namen:
    print(name)

Die drei Namen werden auf die Konsole geschrieben.

Hier wird die (ggf.) neu erzeugte Variable auf jeden Fall in den zu wiederholenden Anweisungen verwendet werden.

Achtung: Wenn ich for so verwende, kann ich mithilfe der (ggf.) neu erzeugten Variable keine Werte in den Container schreiben.

VIII. Fehlgeleitete Methodenaufrufe vermeiden

1. Duck-Typing

Wenn ich als Wert einer Variable ein Objekt (bzw. eine Referenz darauf) gespeichert habe, kann ich den Variablenbezeichner in der Punktnotation verwenden, um Methoden des Objekts aufzurufen. In einer Reihe von Sprachen wird sichergestellt, dass das Objekt die von mir aufgerufene Methode (wahrscheinlich) wirklich hat, indem man von vornherein festlegt, welchen Datentyp ein "in" der Variable gespeichertes Objekt haben muss – denn ein Objekt vom Typ XY hat auch die Methoden der Klasse XY. In Python ist ein anderer Ansatz gängig: Wenn ein Objekt die Methode, die ich aufrufen will, hat, wird das schon passen – egal welchen Datentyp das Objekt hat. Es gilt: "If it walks like a duck and swims like a duck and quacks like a duck, it must be a duck."

Das hilft mir allerdings nur dann etwas, wenn ich Objekte fragen kann, ob sie eine bestimmte Methode haben. Dazu benutze ich die vordefinierte hasattr-Funktion.

Allgemein:

Beispiel:

hasattr(objektbezeichner, zeichenkette)

if hasattr(mein_objekt, "singen"):
    mein_objekt.singen("Never alone!")

Wenn mir das so zu unsicher ist, kann ich mithilfe der vordefinierten isinstance-Funktion prüfen, ob ein Objekt den erwarteten Datentyp hat; hier ist der Übergabewert für den ersten Parameter ein Objektbezeichner, der für den zweiten Parameter ein Datentyp (oder ein Tupel von Datentypen oder ...).

2. Verschärftes Problem bei Verwendung des None-Objekts

Wenn ich das None-Objekt als Platzhalterwert verwende, weil ich gerade keinen passenden Wert zur Verfügung habe, stellt sich das oben genannte Problem in besonderer Weise: Denn zunächst einmal wird ein anderer Wert als None erwartet – von dem sich Methoden aufrufen lassen müssten, die None nicht hat. Wenn ich also einer Variable manchmal den Wert None zuweise, sollte ich deren Wert, bevor ich den Bezeichner in Punktnotation verwende, mithilfe einer der oben genannten Funktionen prüfen – oder ich prüfe in einer bedingten Anweisung, ob ich es mit etwas anderem als dem None-Objekt zu tun habe.

Beispiel:

if mein_objekt != None:
    
...

bzw.

if mein_objekt is not None:
    
...

IX. Wichtige Operatoren und Datentypen

1. Operatoren

a) Arithmetische Operatoren

Operator:

Bedeutung:

+

plus

-

minus

*

mal

/

geteilt durch

//

geteilt durch, ganzzahlig ohne Rest

%

modulo: Rest der ganzzahligen Division

**

hoch

b) Zuweisungsoperatoren

Operator:

Bedeutung:

=

weist den Wert des Terms rechts vom Operator der Variable mit dem Bezeichner links vom Operator zu! (Wertzuweisung)

+=

weist der Variable (links) ihren aktuellen Wert addiert mit dem Wert des Terms (rechts) zu

-=

weist der Variable (links) die Differenz zwischen ihrem aktuellen Wert und dem Wert des Terms (rechts) zu

*=

weist der Variable (links) ihren aktuellen Wert multipliziert mit dem Wert des Terms (rechts) zu

...

usw.

c) Vergleichsoperatoren (Aussagefunktionen)

Aussagefunktionen sind Funktionen, deren Rückgabewert entweder True oder False ist.

Operator:

Bedeutung:

==

ist gleich

!=

ist nicht gleich

>

ist größer als

<

ist kleiner als

>=

ist größer als oder gleich

<=

ist kleiner als oder gleich

is

ist dasselbe Objekt wie

is not

ist nicht dasselbe Objekt wie

in

ist enthalten in

not in

ist nicht enthalten in

d) Logische Operatoren (Logische Funktionen sind auch Aussagefunktionen)

Operator:

Bedeutung:

and

UND

or

ODER

not

NICHT

2. Datentypen

a) Vordefinierte Datentypen

Bezeichner:

'Art' der Daten:

Beispiele für Notation der Daten:

int

Ganzzahl

4  77  -23

float

Kommazahl

4.321  77.8  -23.08754

str

Zeichenkette

"Hase"    'Gurkensalat'    'Sie rief: "Auf geht's!"'

b) Durch Benutzerin/Benutzer erstellte Datentypen

Mit jeder Klasse erzeuge ich auch einen neuen Datentyp. Der Datentyp hat denselben Bezeichner wie die Klasse.