Einführung in die Python-Programmierung

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.

Umgang mit Jupyter-Notebooks

Jupyter-Notebooks erlauben es, Code und Erläuerungen zu kombinieren.

Für Code gibt es Code-Zellen. Code kann mit "Strg+Enter" ausgeführt werden und das Ergebnis erscheint direkt darunter.

Probieren Sie es aus:

In [7]:
1 + 23
Out[7]:
24

Neue Codezeilen können mit "Alt+Enter" hinzugefügt werden.

Probiere Sie es aus:

In [8]:
# Erzeuge mir einen Freund mit Alt+Enter
# dd: Zelle löschen
In [ ]:

Operatoren

Die Operatoren in Python funktionieren wie bei einem grafischen Taschenrechner. Auch Rechenregeln wie Punkt-Vor-Strich werden berücksichtigt:

  • Addition: +
  • Subtraktion: -
  • Multiplikation: *
  • Division: /, // (Ganzzahldivision),
  • Restdivision (Modulo): %
  • Potenz: **
In [10]:
1 + 2
Out[10]:
3
In [12]:
1 - 2
Out[12]:
-1
In [14]:
3 / 2
Out[14]:
1.5
In [16]:
3 // 2
Out[16]:
1
In [18]:
5 % 2
Out[18]:
1
In [27]:
(3 + 2) ** 3
Out[27]:
125

Vergleiche

Die boolschen Operatoren sind and, not und or.

In [41]:
True and False
Out[41]:
False
In [42]:
False and False
Out[42]:
False
In [33]:
True and True
Out[33]:
True
In [36]:
False or True
Out[36]:
True
In [38]:
not True
Out[38]:
False
In [40]:
# 0    False
# != 0 True
3 and 0
Out[40]:
0

Vergleichsoperatoren ähnlich wie bei SQL:

  • >, <
  • >= (größer oder gleich)
  • <= (kleiner oder gleich)
  • == Gleichheit (doppelt, ein einzelnes = ist eine Zuweisung)
  • != Ungleichheit
In [44]:
2 > 1
Out[44]:
True
In [46]:
2 < 1
Out[46]:
False
In [50]:
1.9999 <= 1 + 1
Out[50]:
True
In [53]:
5 == 4
Out[53]:
False
In [54]:
5 != 4
Out[54]:
True

Variablen und Typen

Symbolnamen

Variablenamen dürfen a-z, A-Z, 0-9 und einige Sonderzeichen (_) enthalten. Variablennamen dürfen nicht mit einer Zahl beginnen.

In Python gibt es reservierte Schlüsselwörter. Diese können nicht als Variablennamen verwendet werden. Dazu gehören u.a.

and, as, assert, break, class, continue, def, del, elif, else, except,
exec, finally, for, from, global, if, import, in, is, lambda, not, or,
pass, print, raise, return, try, while, with, yield
In [ ]:
In [63]:
abc = 1
_def = 2
_and = 3
print(abc, _def, _and)

1 2 3

Zuweisungen

Zuweisungen werden in Python mit dem =-Operator gemacht.

Python ist eine dynamisch typisierte Sprache, d.h. der Typ einer Variablen musst nicht angeben werden.

Das Zuweisen eines Wertes an eine neue Variable erzeugt die Variable:

In [65]:
x = 1.0
type(x)
Out[65]:
float

Obwohl nicht angegeben, hat jede Variable einen expliziten Typ. Dieser ergibt sich aus dem Wert, der ihr zugewiesen wurde.

In [66]:
y = 3
type(y)
Out[66]:
int

Mittels Neuzuweisung kann der Typ geändert werden:

In [68]:
x = y
print(x, type(x))

3 <class 'int'>

Der Zugriff auf unbekannte Variablen erzeugteinen NameError:

In [71]:
print(x + z)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-71-5bf2e5d9911c> in <module>
----> 1 print(x + z)

NameError: name 'z' is not defined

Elementare Datentypen

In [72]:
# Ganzzahl (Integer)
x = 1
In [74]:
x = 1.0 # Float
In [75]:
b1 = True
b2 = False
type(b1)
Out[75]:
bool

Typumwandlungen

Mit einem Cast kann der Typ von Variablen geändert werden.

In [79]:
x = 1.9
type(x)
Out[79]:
float
In [82]:
y = int(x)
print(y, type(y))

1 <class 'int'>
In [84]:
bool(0)
Out[84]:
False

Compound types: Strings, Listen und Dictionaries (Wörterbücher)

Strings

In Strings werden Texte abgespeichert.

In [91]:
s = "Hallo Welt"
print(s, type(s))
print(s)

Hallo Welt <class 'str'>
Hallo Welt

Die Länge von Strings (Zeichenanzahl) kann mit der integrierten Funktion len bestimmt werden.

In [93]:
len(s)
Out[93]:
10

Mit [] kann ein einzelnes Zeichen extrahiert werden (das 1. Zeichen ist bei Index 0):

In [96]:
s[0]
Out[96]:
'H'
In [97]:
s[6]
Out[97]:
'W'

Beim extrahieren können auch Bereiche (Slices) angegeben werden. Die Syntax ist [start:stop]. Dabei bekommt man alle Zeichen ab start bis ein Zeichen vor stop.

In [98]:
s[1:5]
Out[98]:
'allo'

Wenn der Start oder das Ende weggelassen werden, wird immer das erste bzw. letzte Zeichen als Position angenommen.

In [102]:
s[:5]
s[0:5]
Out[102]:
'Hallo'
In [103]:
s[6:]
Out[103]:
'Welt'

Typumwandlungen funktionieren auch zwischen Zahlen und Strings

In [87]:
str(123)
Out[87]:
'123'
In [89]:
int("123")
Out[89]:
123
In [104]:
int("abc")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-104-2dda1cc00c48> in <module>
----> 1 int("abc")

ValueError: invalid literal for int() with base 10: 'abc'

Textausgabe

Text kann mit der print Funktion ausgegeben werden.

In [107]:
s = "Hallo"
i = 1
print(s, i)
print(s, i, "Welt")

Hallo 1
Hallo 1 Welt

Strings können mit plus kombiniert werden:

In [113]:
"Hallo " + i + " Welt"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-113-ea5b35f2fd82> in <module>
----> 1 "Hallo " + i + " Welt"

TypeError: can only concatenate str (not "int") to str
In [115]:
"Hallo " + str(i) + " Welt"
Out[115]:
'Hallo 1 Welt'
In [117]:
"Hallo " + "1" + " Welt"
Out[117]:
'Hallo 1 Welt'
In [118]:
"Hallo " + "i"
Out[118]:
'Hallo i'

f-Strings sind aber schöner. Nicht-Strings werden sogar automatisch umgewandelt:

In [120]:
f"Hallo {i} Welt"
Out[120]:
'Hallo 1 Welt'
In [123]:
f"{s} {i+100} Welt"
Out[123]:
'Hallo 101 Welt'
In [131]:
f"s {i+100} Welt"
Out[131]:
's 101 Welt'
In [133]:
"ABc".lower()
Out[133]:
'abc'

Listen

Listen unterstüzen die Selben Funktionen wie Strings (len und Slicing), können aber beliebige Datentypen enthalten, nicht nur Zeichen.

In [126]:
l = [1,2,3,4]
l
Out[126]:
[1, 2, 3, 4]
In [127]:
len(l)
Out[127]:
4

Das slicen funktioniert exakt wie bei Strings:

In [130]:
print(l[1])
print(l[2:])
print(l[0:2])

2
[3, 4]
[1, 2]

Listenelemente können verschiedene Datentypen enthalten:

In [135]:
m = [1, "a", 3.0]
m
Out[135]:
[1, 'a', 3.0]

Mit der eingebauten range-Funktion können Listen aus Zahlenreihen generiert werden:

In [141]:
n = list(range(0, 20, 1))
print(n)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Durch eine Zuweisung können einzelnes Listenelemente ersetzt werden:

In [142]:
n[1] = "A"
print(n)

[0, 'A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Mit der eingebauten del-Funktion können einzelne Listenelemente gelöscht werden:

In [146]:
del n[0]
print(n)

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Tupel

Tupel sind quasi wie Listen, können aber nach der Erstellung nicht mehr modifiziert werden.

In [149]:
punkt = (10, 20) # Tupel
punkt2 = [10, 20] # Liste
In [150]:
punkt[0] = 0

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-150-c2bab7e4fd6c> in <module>
----> 1 punkt[0] = 0

TypeError: 'tuple' object does not support item assignment

Tupel können entpackt werden:

In [154]:
x, y = punkt
print(x, y)

10 20
In [156]:
x, y = punkt2
print(x, y)

10 20

Dictionaries (Wörterbücher)

Dictionaries bilden einen eindeutige Schlüssel auf einen Wert ab {key1 : value1, ...}:

In [158]:
params = {"name": "Hans", "alter": 20, "ort": "Mittweida"}
params
Out[158]:
{'name': 'Hans', 'alter': 20, 'ort': 'Mittweida'}
In [159]:
[params, params]
Out[159]:
[{'name': 'Hans', 'alter': 20, 'ort': 'Mittweida'},
 {'name': 'Hans', 'alter': 20, 'ort': 'Mittweida'}]

Zugriff funktioniert mit eckigen Klammern. In diese muss der Schlüssel geschrieben werden:

In [161]:
params["name"]
Out[161]:
'Hans'
In [163]:
params["xxx"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-163-c631ca7c1b6c> in <module>
----> 1 params["xxx"]

KeyError: 'xxx'
In [165]:
params["name"] = "Paul"
params
Out[165]:
{'name': 'Paul', 'alter': 20, 'ort': 'Mittweida'}
In [166]:
del params["name"]
params
Out[166]:
{'alter': 20, 'ort': 'Mittweida'}

Programmablauf

if, elif, else

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

In [169]:
x = False
y = True
In [175]:
if x:
    print("x ist wahr")
elif y:
    print("y ist wahr")
    print("bla")
else:
    print("nix is wahr")
print("immer ausgeben")

y ist wahr
bla
immer ausgeben

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 [ ]:

Weiterführende Literatur