Einführung in die Python-Programmierung (Teil 2)

Basiert auf "Introduction to Python programming" von J.R. Johansson (CC-BY). Anpassungen und Übersetzung durch mich (unter CC-BY).

Original verfügbar unter http://github.com/jrjohansson/scientific-python-lectures.

Programmablauf

if, elif, else

Die Keywords für bedingte Ausführung lauten in Python if, elif (else if), else:

In [7]:
x = True
y = True

if x:
    print("x ist wahr")
elif y:
    print("y ist wahr")
else:
    print("Nichts ist wahr")
x ist wahr
In [11]:
x = True
y = True

if x:
    print("x ist wahr")
if y:
    print("y ist wahr")
x ist wahr
y ist wahr
In [17]:
x = True
y = True
z = True

# Alles ist wahr
if x and y and z:
    print("Alles ist wahr")
elif x:
    print("x ist wahr")
elif y:
    print("y ist wahr")
elif z:
    print("z ist wahr")
else:
    print("Nichts ist wahr")
Alles ist wahr

In Python wird ein Codeblocks durch die Einrückungsebene definiert (normalerweise ein Tabulator oder vier Leerzeichen). Das bedeutet, dass der Code korrekt eingerückt sein muss, da es sonst Syntaxfehler gibt.

Beispiele:

In [26]:
x = False
y = True

if x:
    print("x ist wahr")
if y:
    print("y ist wahr")
    print("y ist noch immer wahr")
print("Immer ausgeben")
y ist wahr
y ist noch immer wahr
Immer ausgeben

Um zu prüfen, ob ein Wert in einer Liste oder in einem Dictionary ist, kann das Keyword in verwendet werden:

In [31]:
liste = [1, 2, 3]

a = 2

if a in liste:
    print(f"{a} ist in der Liste")
else:
    print(f"{a} nicht in der Liste")
2 ist in der Liste
In [32]:
liste = [1, 2, 3]

a = 2

if a not in liste:
    print(f"{a} nicht in der Liste")
else:
    print(f"{a} in der Liste")
2 in der Liste
In [37]:
params = {"name": "Hans", "alter": 20, "ort": "Mittweida"}

if "name" in params:
    print(f"{params['name']}")
Hans

Schleifen

Schleifen ermöglichen die mehrfache Ausführung eins Codeblocks. Die typische Schleife in Python ist die for-Schleife.

while-Schleife:

Eine while-Schleife wird solange ausgeführt, bis die Schleifenbedingung falsch ist.

In [45]:
a = 5

# != ungleich

while a != 0:
    print(a)
    a = a - 1
5
4
3
2
1

Ein Programm das prüft, ob eine Zahl gerade oder ungerade ist.

In [49]:
a = 5

# % Prozent-Zeichen (Shift + 5), Modulo (Division mit Rest)

while a > 0:
    if a % 2 == 0:
        print(f"{a} ist gerade")
    else:
        print(f"{a} ist ungerade")
    a = a - 1
5 ist ungerade
4 ist gerade
3 ist ungerade
2 ist gerade
1 ist ungerade
In [52]:
a = 5

while a > 0:
    if a / 2 == int(a / 2):
        print(f"{a} ist gerade")
    else:
        print(f"{a} ist ungerade")
    a = a - 1
5 ist ungerade
4 ist gerade
3 ist ungerade
2 ist gerade
1 ist ungerade

for-Schleife:

Die for-Schleife kann für alle Elemente verwendet werden, die "durchlaufbar" (iterierbar) sind. Dies gilt u.a. für Strings und Listen.

Der Block wird für jedes Element einmal ausgeführt.

In [53]:
for x in [1,2,3]:
    print(x)
1
2
3

Zur Erinnerung: Die range-Funktion gibt ebenfalls etwas iterierbares (die Elemente von 0 bis wert - 1) zurück

In [57]:
for x in range(10):
    print(x)
0
1
2
3
4
5
6
7
8
9
In [62]:
a = 5
while a > 0:
    if a % 2 == 0:
        print(f"{a} ist gerade")
    else:
        print(f"{a} ist ungerade")
    a = a - 1

a = 5
for x in range(1, a + 1):
    if x % 2 == 0:
        print(f"{x} ist gerade")
    else:
        print(f"{x} ist ungerade")
5 ist ungerade
4 ist gerade
3 ist ungerade
2 ist gerade
1 ist ungerade
1 ist ungerade
2 ist gerade
3 ist ungerade
4 ist gerade
5 ist ungerade

Bei Strings wird durch die einzelnen Zeichen gelaufen.

In [63]:
for x in "Hallo":
    print(x)
H
a
l
l
o

Auch Dictionaries können durchlaufen werden:

In [64]:
params = {"name": "Hans", "alter": 20, "ort": "Mittweida"}

for key, value in params.items():
    print(f"{key} = {value}")
name = Hans
alter = 20
ort = Mittweida

In einigen Fällen ist es praktisch, den Index während der Iteration zu haben. Dafür gibt es enumerate:

In [66]:
for i, word in enumerate(["coden", "in", "python"]):
    print(i, word)
0 coden
1 in
2 python
In [69]:
for i, x in enumerate("Hallo"):
    if x == "l":
        print(f"l bei {i}")
l bei 2
l bei 3
In [72]:
if "l" in "Hallo":
    print("l ist in Hallo")
l ist in Hallo

Module

Der größte Teil der Funktionalität in Python wird durch Module bereitgestellt. Die Python-Standardbibliothek ist eine große Sammlung von Modulen, die viele Funktionen wie z.B. Dateiein-/Ausgabe, Zeichenverarbeitung und Netzwerkkommunikation bereitstellt.

Um ein Modul in einem Python-Programm zu verwenden, muss es zunächst importiert werden. Ein Modul kann mit der Anweisung import importiert werden. Um zum Beispiel das Modul math zu importieren, das viele mathematische Standardfunktionen enthält:

In [77]:
import math

Dies importiert das komplette Modul und macht es verfügbar:

In [78]:
import math

math.cos(2 * math.pi)
Out[78]:
1.0
In [75]:
math.pi
Out[75]:
3.141592653589793

Alternativ können alle Symbole in den globalen Namensraum importiert werden:

In [76]:
from math import *

cos(2 * pi)
Out[76]:
1.0

Dies macht das Programm aber schnell chaotisch, wenn man viele Module importiert und sich dann eventuell verschiedene Funktionen gegenseitig überschreiben. Daher ist der Import mit import math empfohlen.

Alternativ können auch nur gezielt einzelne Symbole importiert werden:

In [79]:
from math import cos, pi
cos(2 * pi)
Out[79]:
1.0

Ein Modul inspizieren

Die dir-Funktion listet alle Felder eines Moduls auf

In [81]:
print(dir(math))
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

Und mit der Funktion help können wir eine Beschreibung von (fast) jeder Funktion bekommen.

In [83]:
help(math.sqrt)
Help on built-in function sqrt in module math:

sqrt(x, /)
    Return the square root of x.

In [86]:
sqrt(4)
Out[86]:
2.0

Weitere nützliche Module sind os, sys und re. Siehe http://docs.python.org/3/library/ für die Dokumentation.

Funktionen

Eine Funktion in Python wird mit dem Schlüsselwort def definiert, gefolgt von einem Funktionsnamen, der Parameterliste in () und einem Doppelpunkt :. Der Funktionsinhalt wird eingerückt daruntergeschrieben.

Nachfolgend wird eine Funktion namens funktion definiert. Diese nimmt keine Parameter an und gibt den Text test aus.

In [88]:
def funktion():
    print("test")
    
funktion()
test

Die Funktion laenge akzeptiert einen Parameter und gibt die Länge als Text aus.

In [90]:
def laenge(s):
    print(f"{s} enthält {len(s)} Zeichen")

laenge("Hallo")
laenge("Welt")
Hallo enthält 5 Zeichen
Welt enthält 4 Zeichen

Funktionen können direkt mit einem "docstring" dokumentiert werden:

In [91]:
def laenge(s):
    """
    Gibt String 's' und dessen Länge aus
    """
    print(f"{s} enthält {len(s)} Zeichen")

Ein docstring kann mittels help ausgelesen werden.

In [92]:
help(laenge)
Help on function laenge in module __main__:

laenge(s)
    Gibt String 's' und dessen Länge aus

Die Funktion quadrat berechnet das Quadrat von x und gibt diesen mit return zurück

In [94]:
def quadrat(x):
    return x ** 2

print(quadrat(4))
print(quadrat(10))
print(quadrat(5))
16
100
25

Parameter können auch benannt sein, dies macht insbesondere Sinn, wenn die Funktion sehr viele Parameter annimmt.

In [96]:
quadrat(x=4)
Out[96]:
16

Umrechnungen zwischen Zahlensystemen

In [99]:
print(bin(10))
print(hex(10))
print(0xA)
print(0b1010)
0b1010
0xa
10
10

Der euklidische Algorithmus

In [111]:
def euklid(a, b):
    """
    Berechnet den ggT von a und b mittels euklidischen Algorithmus.
    """
    if a == 0:
        return b
    else:
        while b != 0:
            #print(f"a={a} b={b}")
            if a > b:
                a = a - b
            else:
                b = b - a
        return a

print(euklid(44, 12))
print(euklid(12, 44))
print(euklid(100, 33))
print(euklid(b=12, a=44))
4
4
1
4
In [112]:
help(euklid)
Help on function euklid in module __main__:

euklid(a, b)
    Berechnet den ggT von a und b mittels euklidischen Algorithmus.

Weiterführende Literatur