Ganzzahlen

• Typ int

• können in verschiedenen Formaten angegeben werden:
  • normalerweise Basis 10: 5, 102, -135876
  • Basis 2 (binär) mit Präfix 0b: 0b111 → 7
  • Basis 8 (oktal) mit Präfix 0o: 0o21 → 17
  • Basis 16 (hexadezimal) mit Präfix 0x: 0x2F → 47

• keine Beschränkung des Werts: 999 ** 999 ist kein Problem (**: Potenz)

Fließkommazahlen

• Typ float

• Eingabe mit .: 1.5, -0.123476

• Eingabe in wissenschaftlicher Notation: 1e3 → 1000.0; 123e-5 → 0.00123

• Wertebereich und Genauigkeit beschränkt

  >>> 0.1 + 0.2
  0.30000000000000004

  Hier die Erläuterung.

  (Es gibt aber in der Standardbibliothek ein Modul zum exakten Rechnen mit Kommazahlen, z.B. für Finanzen etc.)

• explizite Umwandlung in Ganzzahl inkl. Runden Richtung 0:

  >>> int(5.3)
  5
  >>> int(5.8)
  5
  >>> int(-5.3)
  -5

• explizite Umwandlung von Ganzzahl:

  >>> float(3)
  3.0

arithmetische Operatoren

• ist einer der Operanden eine Fließkommazahl, wird Fließkomma-Arithmetik angewendet (u.U. Rundungsfehler)
• ansonsten: Ganzzahl-Arithmetik (exakt)
• +, -, *: wie erwartet
• /, // s.u.
• %: Modulo (123 % 10 → 3)
• **: Potenz (3 ** 2 → 9)

Es gelten die üblichen Rechenregeln. Im Zweifel oder um die Rangfolge von Operatoren zu überstimmen, können Klammern () verwendet werden. Die Anzahl Leerzeichen um die Operatoren spielt keine Rolle (üblicherweise ein Leerzeichen):

>>> 2 * 3 + 5
11
>>> 2 * (3 + 5)
16
>>> 2 ** 3 * 4
32
>>> 2 ** (3 * 4)
4096

Division

Es gibt zwei Divisionsoperatoren:

• / ist Fließkommadivision. Ergebnis immer float:
  3 / 5 → 0.6

• // ist Ganzzahldivision: rundet auf nächste kleinere ganze Zahl ab (Richtung  − ∞). Ergebnis int wenn beide Operanden int, sonst float):
  3 // 5 → 0
-3 // 5 → -1
-3.0 // 5 → -1.0

Weitere mathematische Funktionen

Das Modul math aus der Standardbibliothek enthält mathematische Konstanten und Funktionen (Trigonometrie, Logarithmen, etc.):

>>> import math  # lädt das Modul
>>> math.pi
3.141592653589793
>>> math.exp(-1)
0.36787944117144233
>>> math.log(2.71)
0.9969486348916096
>>> math.cos(3.14)
-0.9999987317275395

Objektmodell

In Python ist alles ein Objekt. Jedes Objekt hat

• eine Identität
• einen Typ
• einen Wert

Die Identität eines Objekts wird festgelegt, wenn das Objekt erzeugt wird und ändert sich danach nicht mehr.

Der Typ eines Objekts bestimmt, welche Werte das Objekt annehmen kann und welche Operationen mit dem Objekt möglich sind. Der Typ eines Objekts ändert sich ebenfalls nicht mehr, sobald das Objekt erzeugt wurde.

Abhängig vom Typ kann der Wert eines Objekts verändert werden oder nicht. Objekte bzw. Typen, bei denen das Ändern des Werts möglich ist, heißen mutable, die anderen heißen immutable.

Die verschiedenen Zahlentypen sind z.B. immutable.

(Mehr dazu hier.)

Die Anweisung kapital = 1249 bedeutet:

Dem Objekt 1249 (vom Typ int) wird der Name kapital gegeben.

Oder: Der Name kapital “verweist” auf das int-Objekt 1249.

Hinweis: Andere Programmiersprachen haben ein anderes Datenmodell, z.B. heißt in den Sprachen C oder C++ die Anweisung kapital = 1249: Der Speicherplatz für ein int mit dem Namen kapital wird mit dem Wert 1249 belegt.

Konsequenzen:

• Derselbe Name kann später für ein anderes Objekt (auch mit anderem Typ) neu vergeben werden.
• Dasselbe Objekt kann unter mehreren Namen bekannt sein.

Beispiel:

>>> kapital = 1249
>>> geld = kapital

Sowohl kapital als auch geld verweisen jetzt auf 1249.

>>> geld
1249
>>> kapital
1249

Es ist dasselbe Objekt (id gibt die Identität eines Objekts aus):

>>> id(kapital)
140331518656464
>>> id(geld)
140331518656464

Wenn man jetzt den Namen kapital neu vergibt:

>>> kapital = 398.76

hat das keine Auswirkung auf den Namen geld: geld verweist weiterhin auf dasselbe int-Objekt wie zuvor, aber kapital verweist jetzt auf ein anderes float-Objekt:

>>> geld
1249
>>> id(geld)
140331518656464
>>> kapital
398.76
>>> id(kapital)
140331517917136

Mehrfachzuweisung

Man kann auch mehrere Namen gleichzeitig vergeben:

>>> a, b = 3, 5
>>> a
3
>>> b
5

Somit können Namen ohne “temporäre Variable” einfach vertauscht werden:

>>> a, b = b, a
>>> a
5
>>> b
3

Eingabe

Strings werden mit Anführungszeichen eingegeben (einfache ' oder doppelte ").

Beispiele:

>>> print('Hallo Welt!')
Hallo Welt!
>>> print("Wie geht's?")
Wie geht's?
>>> print('Er heißt "Fritz".')
Er heißt "Fritz".

Bestimmte Sonderzeichen werden als Kombination mit \ beschrieben:

>>> print('Ein\nZeilenumbruch')
Ein
Zeilenumbruch
>>> print('Ein\tTabulator')
Ein     Tabulator
>>> print('Erste\tZweite Spalte'
Erste   Zweite Spalte

Für längere Texte mit mehreren Zeilen kann man auch dreifach-Anführungszeichen (''' oder """) benutzen:

>>> print('''Erste Zeile)
... Zweite Zeile''')
Erste Zeile
Zweite Zeile

(... ist der Prompt, falls eine Eingabe über eine Zeile hinaus geht)

Mehrere Strings können mit + aneinandergehängt werden:

>>> a = 'Hallo'
>>> b = 'Welt'
>>> a + ' ' + b
'Hallo Welt'

Ein String kann mit * vervielfältigt werden:

>>> 3 * 'Ha'
'HaHaHa'

Objekte vom Typ str sind immutable. Daher wird beim aneinanderhängen oder “multiplizieren” von Strings immer ein neues Objekt erzeugt, nicht das bestehende Objekt verändert.

Umwandlung zwischen Zahlen und Strings

int(x) wandelt ein beliebiges Objekt x in eine Ganzzahl um, falls möglich:

>>> int(5.6)      # float -> int
5
>>> int('23')     # str -> int
23
>>> int('20', 16) # Basis 16 anstatt Basis 10
32
>>> int('hallo')  # Fehler

float(x) wandelt ein beliebiges Objekt x in eine Fließkommazahl um, falls möglich:

>>> float(5)        # int -> float
5.0
>>> float('23.4')   # str -> float
23.4
>>> float('hallo')  # Fehler

str(x) wandelt ein beliebiges Objekt x in seine Textdarstellung um, falls möglich:

>>> str(5)   # int -> str
'5'
>>> str(3.4) # float -> str
'3.4'

Ausgabe

Die Funktion print wandelt Objekte automatisch in Strings um, falls möglich. Außerdem fügt sie zwischen mehrere Objekte (mit Komma getrennt) automatisch Leerzeichen ein (und am Ende einen Zeilenumbruch):

>>> kapital = 238475
>>> print('Das Kapital ist', kapital, '.')
Das Kapital ist 238475 .

Für mehr Kontrolle über die Formatierung:

>>> print('Das Kapital ist {}.'.format(kapital))
Das Kapital ist 238475.
>>> print('Pi ist ungefähr {:.2f}.'.format(math.pi))
Pi ist ungefähr 3.14.

Die Dokumentation von format ist hier.

Auf einzelne Zeichen und Teilstrings zugreifen

Mit dem []-Operator greift man auf einzelne Zeichen eines Strings an einer bestimmten Position (Index) zu. Das erste Zeichen hat den Index 0:

>>> s = 'Hallo Welt'
>>> s[0]
'H'
>>> s[1]
'a'

Auf eine Position zuzugreifen, die es nicht gibt, erzeugt eine Fehlermeldung:

>>> s[15]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Die Anzahl der Zeichen (“Länge”) eines Strings bekommt man mit der len-Funktion:

>>> len(s)
10

Der größte gültige Index wäre also 9 (nicht 10).

(Ein “Zeichen” ist auch ein String mit der Länge 1.)

Mit negativen Indizes wird von hinten gezählt:

>>> s[-1]   # letztes Zeichen
't'
>>> s[-10]  # erstes Zeichen
'H'
>>> s[-11]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Abschnitte eines Strings bekommt man auf ähnliche Weise:

>>> s[:5]   # die ersten 5 Zeichen
'Hallo'
>>> s[-4:]  # die letzten 4 Zeichen
'Welt'
>>> s[2:7]  # die ersten 7 ohne die ersten 2
'llo W'
>>> s[:]    # alles
'Hallo Welt'

Optional: Schrittweite

>>> s[::2]  # jedes 2. Zeichen
'HloWl'
>>> s[::-1] # rückwärts
'tleW ollaH'

Zeichen und Teilstrings finden

Ob ein String in einem anderen enthalten ist, bekommt man mit dem in-Operator heraus:

>>> 'a' in s
True
>>> 'Welt' in s
True
>>> 'x' in s
False

Speziell: Am Anfang oder am Ende?

>>> s.startswith('Hallo')
True
>>> s.endswith('Hallo')
False
>>> s.endswith('Welt')
True

Wo befindet sich ein Teilstring?

>>> s.index('H')
0
>>> s.index('l')  # der erste Treffer zählt
2
>>> s.index('Welt')
6
>>> s.index('Erde')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

(startswith, endswith und index sind “Methoden” eines String-Objekts)

Syntax-Regeln

• die Zeile mit if muss mit einem : enden
• die gruppierten Anweisungen müssen weiter eingerückt sein als die if-Zeile
• alle gruppierten Anweisungen müssen gleich weit eingerückt sein

if 5 > 3:
print('hallo')        # Syntax-Fehler

if True:
   x = 10
  print(x)            # Syntax-Fehler

if 'hallo':
    test = 3
     print(10 * test) # Syntax-Fehler

Üblicherweise werden 4 Leerzeichen für “einmal” Einrücken verwendet.

Im interaktiven Modus ändert sich der Prompt zu ... bis die zusammengesetzte Anweisung abgeschlossen ist:

>>> if 10 > 3:
...     print('Das stimmt.')
...

Man muss noch einmal mehr die Eingabetaste drücken, um dem Interpreter mitzuteilen, dass die Anweisung abgeschlossen ist.

Vergleichsoperatoren

• ==: gleicher Wert (z.B. bei Zahlen, Strings, …)
• !=: verschiedener Wert
• >, >=, <, <=:
  • Vergleich von Objekten, deren Typ eine Sortierung unterstützt (z.B. Zahlen nach Wert, Strings alphabetisch)
  • das geht auch: 3 < x < 10 (x > 3 “und” x < 10)

• is: gleiche Identität
  • zwangsweise dann auch gleicher Wert, aber nicht umgekehrt: verschiedene Objekte können den gleichen Wert haben
  • x is y äquivalent zu id(x) == id(y)
  • oft im Zusammenhang mit speziellem Objekt: None (“nichts”)

Wahrheitswerte

• True ist “wahr”
• False ist “falsch”
• None ist “falsch”
• 0 und 0.0 sind “falsch”, positive und negative Zahlen sind “wahr”
• ein String der Länge 0 ('') ist “falsch”, andere sind “wahr”

Verknüpfung von Wahrheitswerten

Mit den booleschen Operatoren kann man mit Wahrheitswerten “rechnen” (Boolsche Algebra):

• not x: “wahr” wenn x “falsch” ist
• statt not x in y auch: x not in y

• x and y: “wahr”, wenn beide “wahr” sind
• x or y: “wahr”, wenn einer der beiden oder beide “wahr” sind

Genaugenommen:

• x and y: y wenn x “wahr”, sonst x

  >>> 0 and 5
  0
  >>> 3 and 5
  5

• x or y: x wenn x “wahr”, sonst y

  >>> 0 or 5
  5
  >>> 3 or 5
  3

Außerdem: “ternärer Operator”

• x if c else y: x wenn c “wahr”, sonst y

Verschachtelung und Verzweigung

Zusammengesetzte Anweisungen können wiederum aus anderen zusammengesetzten Anweisungen bestehen:

if x > 3:
    if x < 10:
        print('mindestens 4, höchstens 9')
    print('10 oder mehr')

Optional können mit elif weitere Bedingungen der Reihe nach abgefragt werden. Die Anweisungen, deren Bedingung zuerst erfüllt sind, werden ausgeführt, die anderen nicht.

Ebenfalls optional können unter else Anweisungen angegeben werden, die ausgeführt werden, wenn keine der Bedingungen unter if und ggf. elif erfüllt sind:

if x > 100:
    print('groß')
elif x > 10:        # 10 < x <= 100
    print('mittel')
else:               # x <= 10
    print('klein')

Grundlagen

Eine Liste wird mit [] und , eingegeben. In einer Liste können beliebige Objekte enthalten sein (auch andere Listen):

>>> x = []                # leere Liste
>>> x = [3, 'haus', None]
>>> x = [[1, 2], [3, 4]]  # "Matrix"

• Die Elemente in einer Liste haben eine definierte Reihenfolge.
• Auf einzelne Elemente und Teillisten greift man genauso wie bei Strings mit dem Index-Operator [] zu.
• Auch len funktioniert genauso.
• Auch in funktioniert genauso.

Unterschied zu Strings:

>>> x = [1, 2, 3]
>>> x[1] = 'hallo'
>>> x
[1, 'hallo', 3]

Listen sind im Gegensatz zu Strings mutable.

Erinnerung Zuweisungsoperator =: x[1] ist auch ein “Name” für den String hallo.

x[1] war vorher das int-Objekt 2. Dieses wurde nicht verändert. Der “Name” x[1] wurde von 2 auf 'hallo' umgesetzt.

Iterieren

Um eine Gruppe von Anweisungen für jedes Element einer Liste auszuführen, kann man eine for-Schleife benutzen (meistens einer while-Schleife vorzuziehen):

>>> for name in names:
...     print(name)

Es gibt verschiedene Funktionen um komplexere Iterationen zu ermöglichen:

enumerate(liste): Iteriert über liste und nummeriert dabei durch (standardmäßig von 0 beginnend, aber man kann auch den Startwert angeben):

>>> for i, name in enumerate(names, 1):
...     print('{}. {}'.format(i, name))
1. Peter
2. Paul
3. Mary

zip(A, B): Iteriert gleichzeitig über A und B und gibt jeweils ein Tupel bestehend aus einem Element aus A und einem Element aus B aus:

>>> hobbies = ['Tennis', 'Klavier', 'Lesen']
>>> for name, hobby in zip(names, hobbies):
...     print(name, hobby)
Peter Tennis
Paul Klavier
Mary Lesen

Mit for kann man ebenso über Strings iterieren:

>>> for c in 'hallo':
...     print(c)
h
a
l
l
o

Umwandlung String/Liste

str(x) wandelt eine Liste x (wie jedes andere Objekt auch) in seine Textdarstellung um:

>>> str([1, 2, 3])
'[1, 2, 3]'

Umgekehrt passiert allerdings etwas anderes:

list(x) iteriert über x (falls möglich) und erzeugt eine Liste aller Elemente, die bei der Iteration herauskommen. Da man über Strings iterieren kann und dabei alle einzelnen Zeichen herauskommen, ergibt:

>>> list('[1, 2]')
['[', '1', ',', ' ', '2', ']']   # nicht [1, 2]!

Ein String kann mit der split-Funktion in eine Liste von Teilstrings umgewandelt werden:

>>> 'hallo welt'.split()  # standardmäßig wird an Leerzeichen aufgeteilt
['hallo', 'welt']
>>> 'asdf|qwer|cvbn'.split('|')
['asdf', 'qwer', 'cvbn']

Umgekehrt kann eine Liste von Strings mit join in einen einzelnen String umwandeln:

>>> names = ['Peter', 'Paul', 'Mary']
>>> ' + '.join(names)  # join ist "Methode" des Strings ', '
'Peter + Paul + Mary'

Sortieren, Umkehren

Falls die Elemente einer Liste untereinander vergleichbar sind (< etc.):

sorted(liste) iteriert über alle Elemente in liste, in sortierter Reihenfolge beginnend beim kleinsten:

>>> for name in sorted(names):
...     print(name)

liste bleibt dabei unverändert.

Im Gegensatz dazu gibt es noch liste.sort(), wobei liste so verändert wird, dass die Einträge danach sortiert sind.

>>> names
['Peter', 'Paul', 'Mary']
>>> names.sort()
>>> names
['Mary', 'Paul', 'Peter']

Analog mit reversed und reverse: reversed iteriert über eine Sammlung von Objekten in umgekehrter Reihenfolge, lässt die Sammlung aber unverändert. reverse ändert die Sammlung, indem die Reihenfolge der Objekte umgekehrt wird.

reversed und sorted funktionieren auch mit Strings, aber reverse und sort nicht! Strings können nicht verändert werden (“immutable”), nur eine sortierte bzw. umgekehrte Kopie erzeugt werden.

Erweitern

Neue Elemente können an eine Liste angehängt oder an einer anderen Stelle eingefügt werden (die Liste wird dabei verändert):

>>> names.append('John')  # hängt ein einzelnes Element an
>>> names
['Mary', 'Paul', 'Peter', 'John']
>>> names.extend(['Ringo', 'George'])
>>> names
['Mary', 'Paul', 'Peter', 'John', 'Ringo', 'George']

Vorsicht:

>>> names.extend('Fred')
>>> names
[..., 'F', 'r', 'e', 'd']

An beliebiger Stelle einfügen:

>>> names.insert(2, 'Albert')
['Mary', 'Paul', 'Albert', 'Peter', ...]

Neue Listen aus vorhandenen Listen erzeugen

Liste vervielfältigen mit *:

>>> names = 2 * names

Listen aneinanderhängen mit +:

>>> x = [1, 2, 3]
>>> y = [10, 11, 12]
>>> x + y
[1, 2, 3, 10, 11, 12]

List comprehensions

(auf deutsch: ???)

Ähnlich zur Mengen-Schreibweise in der Mathematik:

{x²|x ∈ 0, ..., 9, 2x < 10}

>>> [x**2 for x in range(10) if 2 * x < 10]
[0, 1, 4, 9, 16]

Der if-Teil ist optional.

(range(N) iteriert über alle ganzen Zahlen von 0 bis N - 1).

Äquivalent zu:

>>> result = []
>>> for x in A:
...     if 2 * x < 10:
...         result.append(x**2)

Dictionaries aus anderen Sammlungen erzeugen

Analog zu List comprehensions gibt es Dictionary comprehensions:

>>> {x: x**2 for x in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Iterieren

Beim Iterieren über ein Dictionary-Objekt kommen die Schlüssel (in beliebiger Reihenfolge) heraus:

>>> for atomic_number in elements:
...     print(atomic_number, elements[atomic_number])
17 Cl
14 Si
1 H
27 Co

Um gleichzeitig über die Schlüssel und die zugeordneten Objekte zu iterieren, gibt es die Methode items():

>>> for atomic_number, name in elements.items():
...     print(atomic_number, name)
[...]

Sichtbarkeit von Namen

Namen, die innerhalb einer Funktion vergeben werden, sind außerhalb der Funktion nicht sichtbar.

>>> def bla():
...     x = 5
...     return x
...
>>> bla()
5
>>> x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined

Docstrings

Es ist empfehlenswert, zu einer Funktion einen “Docstring” hinzuzufügen, der beschreibt, was die Funktion macht, und wie man sie benutzt.

def berechne_zinsen(kapital, zinssatz_prozent):
    """Berechne die Zinsen, die auf das Kapital beim angegebenen Zinssatz
    (in Prozent) anfallen.
    """
    zinssatz = zinssatz_prozent * 1e-2
    return kapital * zinssatz

Das besondere dabei ist, dass der Docstring vom Python-Hilfesystem verarbeitet werden kann:

>>> help(zinsen)
Help on function berechne_zinsen in module __main__:

berechne_zinsen(kapital, zinssatz_prozent)
    Berechne die Zinsen, die auf das Kapital beim angegebenen Zinssatz
    (in Prozent) anfallen.

Noch besser ist es, Beispiele für die Benutzung der Funktion in den Docstring zu integrieren. Diese können vom Modul doctest automatisch ausgeführt und überprüft werden!

def berechne_zinsen(kapital, zinssatz_prozent):
    """Berechne die Zinsen, die auf das Kapital beim angegebenen Zinssatz
    (in Prozent) anfallen.

    >>> berechne_zinsen(12983746, 2.3)
    298626.158
    """
    zinssatz = zinssatz_prozent * 1e-2
    return kapital * zinssatz

Angenommen, die Funktion berechne_zinsen ist in der Datei zinsen.py gespeichert, geschieht das von der Shell aus folgendermaßen:

$ python3 -m doctest zinsen.py