00_01_PythonEinfuehrungsUnterlagen

Leo Keilmann & Yannick Fürst

3. Oktober 2018

Einführung in Python
0. Hinweise und Danksagung

1. Programmierumgebung

2. Grundfunktionen
2.1 Variablenzuweisungen
2.2 for-Schleife
2.3 Relationen
2.4 Bedingte Ausführung (if)
2.5 Bedingte Schleifen (while)
2.6 Programme

3. Wissenschaftliche-Module
3.1 Arrays mit NumPy
3.2 Wissenschaftlich rechnen mit SciPy
3.3 Grafik mit Matplotlib

4. Hilfe und Dokumentation

5. Editor und IDE

0. Hinweise und Danksagung

Diese Einführung soll mit der in der Vorlesung benutzten Programmiersprache Python vertraut
machen. Anfängern wird dringend empfohlen, diese vor der ersten Vorlesung zu lesen und die
aufgeführten Beispiele auszuprobieren. Neben dem vorliegenden Dokument wird die sehr gute
interaktive Python-Einführung von codecademy empfohlen!
Der folgende Text entstand zu groSSen Teilen aus den Vorlesungsunterlagen zur Vorlesung: Com-
putational Physics der TU Dresden bei Prof. Dr. A. Bäcker. Für die hervorragende Vorarbeit möchte
ich danken. Aktuelle Informationen zur Vorlesung an der TU Dresden und zu weiteren Unterla-
gen findet man unter: https://wwwpub.zih.tu-dresden.de/~baecker/teaching/cp2018/

1
1. Programmierumgebung
Python ist eine Skriptsprache, die sowohl interaktiv über den Kommandozeileninterpreter als
auch durch die Ausführung von Programmen benutzt werden kann. Der Kommandozeileninter-
preter wird hierzu bspw. aus der Kommandozeile (Synonyme: Terminal, Konsole etc.) des jeweili-
gen Betriebssystems gestartet.
Für die interaktive Verwendung wird IPython bzw. Jupyter-Console (beides Kommandozeile)
oder Jupyter-Notebook (Web-browser) empfohlen. Das gesamte Jupyter-Projekt ist eine (gewollte)
Abspaltung der Nutzereingabe vom IPython-Kern, die den IPython-Kern im Hintergrund verwen-
det. Wird daher im Folgenden von “IPython” gesprochen gelten die Anweisungen analog für die
Terminaleingabe in der Jupyter-Console“.
Möchte man ein Programm schreiben, welches nicht interaktiv verwendet wird, kann ein beliebi-
ger Text-Editor (oder eine IDE) verwendet werden. Eine Übersicht an empfohlenen Editoren und
IDEs findet man in Kapitel 5. Editor.
Zur Installation wird unter Windows und Mac OS X Anaconda empfohlen; unter Linux bietet es
sich an die jeweilige Packetverwaltung (APT, YUM, pacman etc.) zu verwenden. Im Kurs werden
wir mit Python3 arbeiten. Die Syntax des Codes hat sich zu Python2 etwas verändert, weshalb Py-
thon2 und Python3 nicht vollständig kompatibel sind. Dies betrifft häufig die”print"-Anweisung,
die in Python2 als print "hallo world" und unter Python3 print("hallo world") lautet. Um
alten Code von Python2 auf Python3 zu migrieren gibt es in Python3 das Tool 2to3 mit dem auto-
matisch ein groSSteil von Python2-Syntax auf Python3-Syntax verändert wird. Das Tool kann in
einem Kommandozeileninterpreter aufgerufen werden.

2. Grundfunktionen
Alle Funktionen der Programmiersprache können sofort an der Eingabeaufforderung von Python
in IPython oder in Jupyter(-Console/-Notebook) ausprobiert werden. Den jeweiligen Komando-
zeileninterpreter startet man im Terminal durch den Aufruf “python”, IPython entsprechend mit
“ipython” und die Jupyter-Console mit “jupyter-console”. Das vorliegende Dokument wurde als
Jupyter-Notebook erstellt und kann als solches interaktiv im Webbrowser oder als Export im PDF-
Format verwendet werden. Das Jupyter-Notebook kann bspw. aus der Konsole mit dem Aufruf
“jupyter-notebook” gestartet werden, was auf dem lokalen Rechner einen Server-Dienst startet
und den Webbrowser öffnet.

2.1 Variablenzuweisungen
Einer Variablen kann auf folgende Art ein Wert zugewiesen werden:

>>> x = 5

Es sind keine vorherigen Vereinbarungen (d.h. Typdeklarationen) notwendig, x ist eine ganze Zahl
(Typ “int” vom englischen Wort “integer”). Eine weitere Variablenzuweisung ist

>>> y = 4.2

Hierbei ist y eine reelle Zahl. Mittels

2
>>> z = x + y

wird z die Summe von x und y zugewiesen. Hierbei ist z automatisch eine reelle Zahl (die Summe
zweier ganzer Zahlen hingegen ist wieder eine ganze Zahl). Analoge Rechenoperationen sind
Subtraktion, Multiplikation, Division und Potenzierung:
- * / **
Durch
>>> print(z)

9.2

wird der Wert der Variablen z ausgegeben. Der Typ der Variablen z kann durch
>>> type(z)

float

angezeigt werden.

2.2 for-Schleife
Mit Schleifen können wiederholte Vorgänge automatisiert werden:
>>> for i in [1, 3, 7]:
... j = i**2
... print("Das Quadrat von", i, "ist", j)

Das Quadrat von 1 ist 1

Das Quadrat von 3 ist 9
Das Quadrat von 7 ist 49

Die Zeile, die den Block einleitet, muss mit einem Doppelpunkt enden. Die bei jedem Durchlaufen
der Schleife auszuführenden Befehle müssen um 4 Leerzeichen eingerückt sein. Eine weitere Kenn-
zeichnung erfolgt nicht. In IPython geschieht die Block-Einrückung automatisch und kann durch
zweimaliges Drücken der ”Enter“-Taste wieder verlassen werden.

2.3 Relationen
Relationen können direkt mit dem Interpreter ausprobiert werden. Für die Werte x = 5 und y = 4.2
gibt
x > y : True
x == y : False
aus. Man beachte den Unterschied zwischen dem vergleichenden == und dem zuweisenden =.
Weitere Relationen sind <=, >= und != (ungleich).

3
2.4 Bedingte Ausführung (if)
Relationen werden zum Aufstellen von Bedingungen benutzt. Eine Bedingung hat die allgemeine
Form:

>>> i = 4
... if i < 5: # Bedingung
... print(i) # Block von Befehlen, die ausgefuehrt werden
... print(i**i) # sollen, wenn die Bedingung erfuellt ist

4
256

Blöcke werden auch hier, analog zur for-Schleife, eingerückt. Die Raute # leitet einen Kommen-
tar ein. Die Ausführung von Befehlen für den Fall, dass die Bedingung nicht erfüllt ist, lässt sich
mittels else realisieren (Um die Einrückung für die nachfolgende else-Anweisung wieder aufzu-
heben, drücken Sie in IPython viermal ”Backspace“):

>>> i = 5
... if i < 5: # Bedingung
... print(i) # Block von Befehlen, die ausgefuehrt werden
... print(i**i) # sollen, wenn die Bedingung erfuellt ist.
... else:
... print("i ist >=5") # ..., wenn die Bedingung nicht erfuellt ist

i ist >=5

Die Unterscheidung mehrerer Fälle geling durch die Verwendung von elif:

>>> i = 5
... if i < 5:
... print(i)
... print(i**i)
... elif i < 10:
... print("5 <= i < 10")
... elif i < 20:
... print("10 <= i < 20")
... else:
... print("i >= 20")

5 <= i < 10

4
2.5 Bedingte Schleifen (while)
Bei einer while-Schleife ist die Ausführung der eingerückten Befehle an eine Bedingung geknüpft:

>>> k, l = 1, 1 # Anfangswert für k und l

... while k < 100: # Bedingung für Ausführung des Unterabschnitts
... k, l = k + l, k # dies ist der
... print(k, l, 1.0 * k/l) # Unterabschnitt
...
... print("Dies wird nicht mehr unterhalb der Schleife ausgegeben!")

2 1 2.0
3 2 1.5
5 3 1.6666666666666667
8 5 1.6
13 8 1.625
21 13 1.6153846153846154
34 21 1.619047619047619
55 34 1.6176470588235294
89 55 1.6181818181818182
144 89 1.6179775280898876
Dies wird nicht mehr unterhalb der Schleife ausgegeben!

Der vorangegangene Code berechnet die Fibonacci-Folge sowie den Goldenen Schnitt.

2.6 Programme
Man kann dem Komandozeileninterpreter mehrere Programmzeilen auf einmal übergeben, in-
dem man ein Programm in eine Datei schreibt. Als Editor kann beispielsweise Spyder (bei Anacon-
da enthalten), Notepad++, Emacs etc. verwendet werden (s. Kapitel 5. Editor). Python-Programme
sollten immer die Endung “.py” haben. Nehmen Sie als Beispiel obiges Programm (s. Abschn. 2.5)
zur Bestimmung der Fibonacci-Zahlen und des Goldenen Schnittes. Das mit dem Editor erstellte
und gespeicherte Programm wird in IPython durch den Befehl

run ./filename.py

ausgeführt. “./” zeigt an, dass sich die Datei in dem selben Verzeichnis befindet in dem auch
IPython gestartet wurde. Befindet sich die Datei an einem anderen Ort, muss “./” entsprechend
angepasst werden (Bsp.: Downloads/filename.py). Näheres erfährt man bspw. unter Pfadname,
wobei die Unix-Konvention (auch unter Windows) empfohlen wird. Danach stehen in IPython
alle (global deklarierten) Variablen des Programms zur Verfügung. Dies ist insbesondere bei der
Fehlersuche sehr hilfreich. Alternativ kann man ein Python-Programm auch direkt im Terminal-
fenster mit dem Befehl

python filename.py

ausführen oder es direkt aus dem verwendeten Editor (wenn dieser die Ausführung unterstützt)
starten.

5
Unterprogramme
Um Programme besser zu gliedern oder mehrmalige Aufrufe und Berechnungen zu vermeiden,
verwendet man Unterprogramme, sogenannte “Funktionen”:

>>> def sum_prod(x, y):

... """Berechne Summe und Produkt von x, y"""
... return(x + y, x*y)

Die Befehle der Funktion müssen ebenfalls um 4 Leerzeichen eingerückt werden. Probieren Sie
beispielsweise:

>>> print(sum_prod(4, 6))

... a, b = sum_prod(4, 6)
... print(a)
... print(b)

(10, 24)
10
24

Mittels help(sum_prod) erhalten Sie die Dokumentation zur Routine.

>>> help(sum_prod)

Help on function sum_prod in module __main__:

sum_prod(x, y)
Berechne Summe und Produkt von x, y

In IPython und Jupyter-Notebook funktioniert auch der Aufruf sum_prod?. Die Hilfsanweisun-
gen können in den Komandozeileninterpretern durch drücken der Taste “q” verlassen werden
(Die Steuerungskommandos innerhalb der Interpreter entspricht einer Untermenge von Vim-
Kommandos). Weiter Informationen zu Hilfs-Funktionen findet man in Kapitel 4. Hilfe und Do-
kumentation.

Dokumentation
Ein sehr wichtiger Aspekt bei der numerischen Umsetzung physikalischer Probleme ist eine sorg-
fältige und aussagekräftige Dokumentation. Hierzu können “Docstrings” und Kommentare ver-
wendet werden. “Docstrings” werden mit drei Anführungszeichen eingeleitet und beendet. Sie
werden bspw. beim Aufruf mit help(FUNKTION) ausgegeben (s. bspw. Kapitel 2.6.1 Unterprogram-
me) und helfen Programmierern und Anwendern (einer Funktion) gleichermaSSen. Kommentare
sind hingegen nur innerhalb des Quellcodes sichtbar und ausschlieSSlich für Programmierer ge-
dacht.

6
>>> """Kurzbeschreibung des Programms ("Titel")
...
... An dieser Stelle soll eine Beschreibung des Programms,
... der Methoden, offener Fragen etc. kommen.
... """
...
... from math import sqrt
...
...
... def newton_iteration(zahl, anz_iter=5):
... """Berechne Quadratwurzel von `zahl` mitttels Newton-Iteration.
...
... Die Newton Iteration
... x_k = 1/2 (x_{k-1} + zahl/x_{k-1})
... (mit x_0=1) konvergiert quadratisch
... zur gesuchten Wurzel.
...
... Der Parameter anz_iter (mit dem Default-Wert 5) bestimmt die
... Anzahl der durchgefuehrten Iterationen.
... """
... x = 1.0 # Startwert der Newton-Iteration
... iter = 0
... while iter < anz_iter: # Fuehre anz_iter Iterationen durch
... x = 0.5 * (x + zahl/x) # Newton-Iterationsschritt
... iter = iter + 1
...
... return(x)
...
... # Hauptprogramm
...
...
... print("Newton Iteration")
... # mit "format(INHALT)" wird der "INHALT" an die Stelle mit "{}" im String geschrieben
... print("sqrt(2) : {}".format(sqrt(2.0)))
... print("5 Iterationen: {}".format(newton_iteration(2.0)))
... print("3 Iterationen: {}".format(newton_iteration(2.0, 3)))
... print("2 Iterationen: {}".format(newton_iteration(2.0, 2)))

Newton Iteration
sqrt(2) : 1.4142135623730951
5 Iterationen: 1.414213562373095
3 Iterationen: 1.4142156862745097
2 Iterationen: 1.4166666666666665

7
Python-Style
Aufgrund der benötigten Blockbildung in Python hat der Code immer schon eine gewisse Grund-
struktur, die für ein funktionsfähiges Programm eingehalten werden muss. Eine genau Definition
was wie zu setzen ist findet sich im PEP-8 Style Guide. Einige Vorgaben sollen hier noch angege-
ben werden:
Die Zeilenlänge in Python-Programmen sollte 79 Zeichen nicht überschreiten (auch wenn das
Programm dennoch funktioniert). Um zu verhindern, dass Zeilen länger als 79 Zeichen werden,
gibt es verschiedene Möglichkeiten. Mittels \ kann eine Zeile verlängert werden

>>> a = 400 * (50 * "eine_lange_variable" + "und_noch_eine_lange_variable") + \

... "und_weiter_gehts_in_der_nächsten_zeile"

Auch ermöglichen Klammern eine automatische Fortführung in der nächsten Zeile:

>>> a = 400 * (50 * "eine_lange_variable + und_noch_eine_lange_variable" +

... "und_weiter_gehts_in_der_nächsten_zeile")

oder das Aufspalten in mehrere übersichtlichere Gleichungen:

>>> eq0 = 5 + 5
... eq1 = 3 * eq0
...
... # statt
...
... eq1 = 3 * (5 + 5)

Des Weiteren sollte zwischen mathematischen Zeichen (+, -, *, /) ein Leerzeichen eingefügt wer-
den (s. vorherige Formeln), was übersichtlichere Formeln ermöglicht.
All die im PEP-8 Style Guide vorgegebenen Hinweise lassen sich auch mit Programmen prüfen
bzw. direkt übernehmen. Hierzu zählt bspw. autopep8.

3. Wissenschaftliche-Module
Die drei wichtigsten Module zum wissenschaftlichen Rechnen mit Python sind NumPy, SciPy und
Matplotlib. Diese werden im Folgenden vorgestellt und kurz auf ihre Anwendung eingegangen.
Eine Umfangreiche Übersicht und Anwendung dieser Module und auch weiterer Module findet
man bspw. hier: http://www.scipy-lectures.org/index.html

3.1 Arrays mit NumPy

Python stellt einen Satz von Standardbefehlen zur Verfügung, der mit einer Vielzahl zusätzlicher
Module erweitert werden kann. Durch

from numpy import FUNKTION # FUNKTION ist eine beliebige numpy Funktion

8
kann eine bestimmte numpy-Funktion bzw. ein bestimmter Befehl geladen werden und anschlie-
SSend mit FUNKTION(VAR) verwendet werden. Mit VAR sind die verschiedenen Variablen die der
Funktion zu übergeben sind gemeint (vgl. Kapitel 2.6.1 Unterprogramme). Mit

from numpy import *

werden alle Befehle, die im Modul numpy enthalten sind, bekannt gemacht (Bsp.: arange()). Ei-
ne weitere Möglichkeit für den Import ist es (und auch die Empfohlene), die Funktionen nicht
global zu importieren (um Namenskonflikte mit anderen Modulen zu vermeiden), sondern mit
Abkürzungen zu arbeiten:

import numpy as np

Mit einem solchen Aufruf, lassen sich die Numpy-Funkionen mit np.BEFEHL aufrufen (Bsp.:
np.arange()). Wird nur eine bestimmte Funktion benötigt, kann diese einzeln importiert werden
(hier zusätzlich als Abkürzung), wie hier am numpy arange-Befehl gezeigt:

from numpy import arange as np_arange

Das NumPy-Modul stellt u. a. mathematische Funktionen und Arrays bereit. Laden Sie das
numpy-Modul für die folgenden Aufgaben zu eindimensionalen Arrays (Mehrdimensionale Ar-
rays werden später behandelt.).

>>> from numpy import *

Probieren Sie folgende Befehle aus:

>>> x = arange(10)
... print(x)
... y = zeros(10)
... print(y)
... z = 2*ones(10, dtype=int) # ganzzahlige Werte anlegen
... print(z)
... z2 = 2.0*ones(10, dtype=int)
... print(z2)

[0 1 2 3 4 5 6 7 8 9]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[2 2 2 2 2 2 2 2 2 2]
[2. 2. 2. 2. 2. 2. 2. 2. 2. 2.]

Was ist der Unterschied zwischen z und z2? Beachten Sie was passiert, wenn Sie z[3] = 7.345
setzen.

>>> z[3] = 7.345

... z

9
array([2, 2, 2, 7, 2, 2, 2, 2, 2, 2])

Hätten Sie das erwartet? Während zeros und ones FlieSSkommazahlen zurückgeben (oder ganze
Zahlen, wenn das Schlüsselwort dtype=int angegeben wird), liefert arange nur dann ganze Zah-
len, wenn es ausschlieSSlich mit ganzen Zahlen aufgerufen wird. Der enthaltene Datentype des
Arrays lässt sich statt mit

>>> type(x)

numpy.ndarray

(type zeigt nur, dass es sich um ein Numpy “ndarray” handelt) mit

>>> x.dtype, z2.dtype

(dtype('int64'), dtype('float64'))

prüfen.

Elementare Operationen
Neben der Multiplikation mit Skalaren ist auch die Addition und Division möglich:

>>> x = arange(10)
... print(4 * x)
... print(4.0 * x)
... print(x + 1)
... print(x / 10.0)
... print(x - pi)
... print(1.0 * (x < 3.5))
... print(1.0 * ((3 < x) * (x <= 7)))

[ 0 4 8 12 16 20 24 28 32 36]
[ 0. 4. 8. 12. 16. 20. 24. 28. 32. 36.]
[ 1 2 3 4 5 6 7 8 9 10]
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
[-3.14159265 -2.14159265 -1.14159265 -0.14159265 0.85840735 1.85840735
2.85840735 3.85840735 4.85840735 5.85840735]
[1. 1. 1. 1. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 1. 1. 1. 0. 0.]

Arrays kann man elementweise addieren, subtrahieren, multiplizieren und auch potenzieren:

10
>>> w = arange(1, 20, 2)
... x = ones(10)
... print(x + w)
... print(x - w)
... print(x * w)
... print(x / w)
... print(x**2)
... print(x**w)

[ 2. 4. 6. 8. 10. 12. 14. 16. 18. 20.]

[ 0. -2. -4. -6. -8. -10. -12. -14. -16. -18.]
[ 1. 3. 5. 7. 9. 11. 13. 15. 17. 19.]
[1. 0.33333333 0.2 0.14285714 0.11111111 0.09090909
0.07692308 0.06666667 0.05882353 0.05263158]
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

Für die oben genannten Operationen ist es wichtig, dass x und w die gleiche Anzahl von Elemen-
ten haben. Probieren Sie

>>> v1 = arange(10)
... v2 = zeros(9)
... # print(v1 + v2) # Fehler

Die Anzahl der Elemente eines Arrays (= Array-Länge) erhalten Sie durch den Befehl len,

>>> print(len(x))

10

Die Summe der Elemente eines Arrays erhält man mittels sum,

>>> print(sum(x))

10.0

Zugriff auf einzelne Elemente und Slicing

Auf einzelne Elemente eines Arrays kann man mittels

>>> print(x[5])

11
1.0

zugreifen. Beachten Sie, dass das erste Element durch x[0] und das letzte durch x[len(x)-1]
oder x[-1] angesprochen wird. Teilbereiche eines Arrays können mit der : Notation (“slicing”)
angesprochen werden:

>>> x = arange(10)
... print(x)
... print(x[0:4])
... print(x[5:7])
... print(x[4:])
... print(x[:6])
... print(x[1:6:2])
... print(x[:6:2])
... print(x[::2])

[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3]
[5 6]
[4 5 6 7 8 9]
[0 1 2 3 4 5]
[1 3 5]
[0 2 4]
[0 2 4 6 8]

Beachten Sie, dass (analog zum arange Befehl) die obere Grenze nicht mit eingeschlossen ist.

To copy or not to copy

Wichtig ist folgendes Beispiel:

>>> k = 10
... l = k
... print(k, l)
... l = 4
... print(k, l)

10 10
10 4

ACHTUNG! – Vergleichen Sie mit:

>>> q = arange(5)
... r = q

12
... print(q, r)
... r[2] = -100
... print(q, r)

[0 1 2 3 4] [0 1 2 3 4]
[ 0 1 -100 3 4] [ 0 1 -100 3 4]

Dies ist eine häufige Ursache für Fehler – können Sie sich vorstellen, warum für Arrays das Ver-
halten anders ist? Zum Kopieren eines Arrays verwendet man daher beispielsweise

>>> q = arange(5)
... r = 1*q # dies erzeugt eine `Kopie' von q
... # oder r = np.copy(q)
... print(q, r)
... r[2] = -100
... print(q, r)

[0 1 2 3 4] [0 1 2 3 4]
[0 1 2 3 4] [ 0 1 -100 3 4]

Erzeugung von Arrays

Ein Array reeller Zahlen (doppelte Genauigkeit) kann mittels

>>> a = zeros(10)
... print(a)
... print("Arraytyp", a.dtype.name) # liefert: Arraytyp float64

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
Arraytyp float64

erzeugt werden. Arrays mit reellen, linear ansteigenden Einträgen kann man wie folgt erzeugen

>>> print(arange(0.0, 7.2, 0.8)) # Start, Ende, Inkrement

[0. 0.8 1.6 2.4 3.2 4. 4.8 5.6 6.4]

ACHTUNG! – Vergleichen Sie mit:

>>> print(arange(0.0, 5.4, 0.6))

13
[0. 0.6 1.2 1.8 2.4 3. 3.6 4.2 4.8 5.4]

Was ist hier unterschiedlich? Hätten Sie das erwartet? Schauen Sie sich dazu die Ausgaben der
folgenden Zeilen an.

>>> print(repr(9.0 * 0.8))

... print(repr(9.0 * 0.6))

7.2
5.3999999999999995

Um bei reellen Arrays sicherzustellen, dass ein Array eine vorgegebene Anzahl von Elementen
hat, sollte man immer den Befehl linspace verwenden

>>> print(linspace(0.0, 5.0, 10)) # Start, Ende, Anzahl

[0. 0.55555556 1.11111111 1.66666667 2.22222222 2.77777778

3.33333333 3.88888889 4.44444444 5. ]

Möchte man hierbei den Endpunkt ausschlieSSen, so ist dies mittels

>>> print(linspace(0.0, 5.0, 10, endpoint=False))

[0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5]

möglich.

Weitere Array Operationen

Neben den oben aufgeführten kann man eine Vielzahl weiterer Operationen auf Arrays anwen-
den, z.B.:

>>> N = 100000
... x = linspace(0.0, 1.0, N) # Array mit Werten in [0.0, 1.0]
... y = cos(x)
... z = abs(y) # Betrag der Elemente

Vergleichen Sie die Geschwindigkeit der Berechung von (hier kommt ein sogenannter Magic-
Command, eingeleitet mit “%”, zum Einsatz. Dieser funktioniert in IPython und Jupyter-
Notebook (nicht unter Windows))

14
>>> %time
... print("Summe: ", sum(cos(x)))

CPU times: user 4 ţs, sys: 2 ţs, total: 6 ţs

Wall time: 11.9 ţs
Summe: 84147.02716025653

mit
>>> %time
... summe = 0.0
... for i in arange(N):
... summe = summe + cos(x[i])
... print("Summe: ", summe)

CPU times: user 4 ţs, sys: 1 ţs, total: 5 ţs

Wall time: 11.4 ţs
Summe: 84147.02716025518

Dieses Beispiel illustriert zwei wesentliche Aspekte + Verwendung von Arrays führt zu kürzeren
und damit übersichtlicheren Programmen. + for-Schleifen sind deutlich langsamer.

3.2 Wissenschaftlich rechnen mit SciPy

Aufbauend auf den Array-Funktionen und einigen grundlegenden Rechenoperationen die be-
reits in NumPy enthalten sind, bietet SciPy eine umfangreiche Sammlung an verschiedenen Re-
chenoperatoren. Die in NumPy enthaltenen Basis-Rechenoperationen sind häufig in einer Code-
optimierten Form nochmals in SciPy vorhanden. Um diese zu nutzen kann das SciPy-Modul im-
portiert werden (hier mit der Abkürzung sc):
>>> import scipy as sc

und auf ein vorher definiertes NumPy array angewendet werden:

>>> sc.sum(y)

84147.02716025653

Spezielle Funktionen gliedern sich in SciPy noch in Unter-Module, zu denen bspw. folgende zäh-
len
• scipy.integrate für numerische Integration
• scipy.optimize für die Lösung von Optimierungsproblemen
• scipy.linalg für Funktionen zur linearen Algebra
Eine vollständige Übersicht über die Funktionen und wie diese zu verwenden sind findet man
unter https://docs.scipy.org/doc/scipy/reference/.

15
3.3 Grafik mit Matplotlib
Ein wesentlicher Aspekt numerischer Untersuchungen in der Physik ist die grafische Darstellung
von Daten. Von der Vielzahl möglicher Grafikpakete verwenden wir Matplotlib, da es sowohl unter
Linux als auch Windows zufriedenstellend funktioniert und eine qualitativ hochwertige Ausgabe
erzeugt. AuSSerdem ist es der Defakto-Standard unter Python.
Zum Erzeugen eines statischen Plots werden zunächst die zu zeigenden Daten berechnet und
dann der plot-Befehl verwendet, welcher die Daten für die Ausgabe vorbereitet. Um die Daten
tatsächlich am Bildschirm anzeigen zu lassen, ist am Ende des Programms der show()-Befehl nö-
tig. Dieser stellt die Daten dar und ermöglicht das Zoomen, Verschieben und Abspeichern des
Plots (wenn Matplotlib interaktiv aufgerufen wird, bspw. im Jupyter-Notebook mit dem Magic-
Command %matplotlib notebook). Folgendes Programm stellt die Sinusfunktion und ihre zwei-
te Harmonische grafisch dar:

>>> from numpy import *

... from matplotlib import pyplot as plt # Grafikbefehle
...
... x = linspace(0.0, 2.0*pi, 100) # x-Werte erzeugen
...
... plt.figure() # Figure erzeugen
... plt.plot(x, sin(x)) # Werte darstellen
... plt.plot(x, sin(2*x)) # weitere Funktion hinzufuegen
... plt.show() # grafische Darstellung

<Figure size 640x480 with 1 Axes>

Durch from matplotlib import pyplot as plt werden die Plotbefehle unter plt. bereitgestellt.

Plot-Styles
Der Stil der Kurve lässt sich direkt beim plot-Befehl angeben:

plt.plot(x, sin(x), linestyle='-.', linewidth=5, color='g')

Es ist aber auch möglich, die Eigenschaften später anzupassen. Hierzu muss man sich allerdings
merken, was bisher geplottet wurde:

>>> from numpy import *

... from matplotlib import pyplot as plt # Grafikbefehle
...
... x = linspace(0.0, 2.0*pi, 100) # x-Werte erzeugen
...
... sinus = sin(x)
... sinus1 = plt.plot(x, sinus) # plotten - plot(xdata, ydata)
... sinus2 = plt.plot(x, sin(2*x)) # weitere Funktion hinzuplotten
...
... # Linienbreite setzen

16
... plt.setp(sinus1[0], linestyle='-.', linewidth=3)
... plt.show()

Hier eine Auswahl anderer Schlüsselwörter:

plt.setp(sinus[0], linestyle='-.') # Linientyp: Strich-Punkt

plt.setp(sinus[0], color='g') # gruen
plt.setp(sinus2[0], linestyle='None') # Linientyp: keine
plt.setp(sinus2[0], marker='s') # kleine Rechtecke als Marker
plt.setp(sinus2[0], markerfacecolor='r') # rote Marker
plt.setp(sinus2[0], markeredgecolor='k') # mit schwarzem Rand
plt.setp(sinus2[0], markersize=4) # Groesse der Marker
plt.setp(sinus2[0], markeredgewidth=2) # Breite ihres Randes

Wenn man einen einzelnen Punkt (x; y) als + plotten möchte, so muss man

>>> plt.plot([x], [sinus], marker='+')

... plt.show()

17
verwenden, da die ersten beiden Argumente von plot Arrays (oder Listen) sein müssen.

Plotbereich, Überschrift und Achsenbeschriftungen

Folgendes Beispiel zeigt, wie man den Plotbereich festlegt und eine Überschrift und Achsenbe-
schriftungen anbringt:

>>> from numpy import *

... from matplotlib import pyplot as plt # Grafikbefehle
...
... plt.title("Ueberschrift")
... plt.xlabel("x Beschriftung")
... plt.ylabel("y Beschriftung")
... x = linspace(0.0, 1.0, 100)
... plt.plot(x, 2.0*x*x)
... plt.axis([0.0, 1.0, 0.0, 2.0]) # Plotbereich [x0, x1, y0, y1]
... plt.show()

18
Mehrere Plotfenster/Plotbereiche
Mehrere Plotfenster lassen sich mit dem figure-Befehl wie folgt öffnen:

>>> from numpy import *

... from matplotlib import pyplot as plt # Grafikbefehle
...
... x = linspace(0.0, 1.0, 100)
... plt.figure(0) # neues Fenster 0
... plt.plot(x, 2.0*x*x)
... plt.figure(1) # neues Fenster 1
... plt.plot(x, sqrt(x))
... plt.figure(0) # wieder Fenster 0 aktivieren
... plt.plot(x, 3.0*x*x)
... plt.show()

19
Sollte – wie in den vorangegangenen Beispielen – nur ein Fenster nötig sein, so kann der figure-
Befehl weggelassen werden. Er wird dann implizit mit dem ersten plot-Befehl aufgerufen. Aller-
dings ist es guter Programmierstil, das Fenster explizit durch figure zu erstellen. Mit dem sub-
plot-Befehl können mehrere Plotbereiche in einem Fenster erzeugt werden. Hierbei selektiert sub-

20
plot(nmk) in einem Fenster mit n × m Plotbereichen den k-ten Plotbereich. Die verwendete Syntax
ist zunächst etwas gewöhnungsbedürftig:

>>> from numpy import *

... from matplotlib import pyplot as plt # Grafikbefehle
...
... x = linspace(0.0, 1.0, 100)
... plt.figure(0) # neues Fenster 0
... plt.subplot(423) # der dritte von 4*2=8 Bereichen
... # (angeordnet in 4 Zeilen und 2 Spalten)
... plt.plot(x, 2.0*x*x)
... plt.subplot(426) # Bereich 6
... plt.plot(x, sqrt(x))
... plt.subplot(423) # wieder Bereich 3 aktivieren
... plt.plot(x, 3.0*x*x)
... plt.show()

/usr/lib/python3.7/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarn
warnings.warn(message, mplDeprecation, stacklevel=1)

Die Zahlen des Beispiels sind absichtlich etwas ungewöhnlich gewählt, um die Wirkungsweise zu
demonstrieren. In der Praxis sind Werte wie 111, 211, 121, 122 für den subplot-Befehl üblicher. Hier
verhält es sich im Übrigen ähnlich zum figure-Befehl: Wird nur ein Plotbereich benötigt, kann auf
den subplot(111)-Befehl verzichtet werden, da auch der subplot-Befehl (wenn der Programmierer
ihn nicht explizit benutzt) implizit von plot aufgerufen wird.

4. Hilfe und Dokumentation

Dieser Abschnitt soll ein paar Hinweise zur Dokumentation in Python geben. Eine übliche Frage-
stellung ist: Was macht z.B. die Funktion plot?
Um Dokumentation zu einem Befehl oder Modul zu erhalten, werden folgende Möglichkeiten
empfohlen.

21
 • interaktive Hilfe am Python Prompt: help("<Befehl>")
• Information über ein Objekt: <Befehl>? (IPython und Jupyter-Notebook)
• Information über ein Objekt: Cursor befindet sich hinter einem <Befehl>. AnschlieSSend
“SHIFT+TAB” drücken (Jupyter-Notebook)
– Hinweis: Die Tastenkombination kann bis zu drei mal (schnell) hintereinander ausge-
führt werden, um nacheinander mehr Informationen auszugeben.

help( )
Diese Funktion wird von Python selbst zur Verfügung gestellt. Man benutzt sie, indem man
die gesuchte Funktion als Zeichenkette inklusive des Modulnamens übergibt. Beispiel für
den plot-Befehl: help(“matplotlib.pyplot.plot”) oder Hilfe zum gesamten Plot-Modul mittels
help(“matplotlib.pyplot”).

IPYTHONs “?” Hilfe

Möchte man auf die Schnelle von einer bereits erzeugten Variablen Details wissen, z. B. ihren
Typ, ist der Befehl “?” nützlich. Er funktioniert nur unter IPython und Jupyter. Man schreibt die
gewünschte Variable und hängt ein Fragezeichen an. Es werden verschiedene Informationen aus-
gegeben:

In [1]: i = 1 # i ist eine Integervariable

In [2]: i? # Ausgabe der Information zu i
Type: int
Base Class: <type 'int'>
String Form: 1
Namespace: Interactive
Docstring: # es folgt etwas Dokumentation zur Typumwandlung

Am wichtigsten sind die Werte “Type” (welchen Typ hat die Variable) und “String Form” (wie
sieht die Variable in einen String umgewandelt aus).

Python-Typen
Der Variablen-Typ in Python lässt sich mit dem Aufruf type() prüfen:

>>> type(k)

int

hier handelt es sich bei der Variablen k um eine Integer-Variable. Um den Variablen-Typ von
Numpy-Arrays zu prüfen, kann die Funktion dtype() verwendet werden

>>> x.dtype

dtype('float64')

22
Dokumentation und Hilfe im WWW
• Interaktive Python-Einführung: https://www.codecademy.com/learn/learn-python
• Einführung in Python: http://www.python-kurs.eu/
• Grundlegendes und Weiterführendes zu numpy, scipy, . . . : http://www.scipy.org
• Weiterführendes und Anwendung von numpy, scipy, . . . : http://www.scipy-lectures.
org/index.html
• Style Guide für Python Code (PEP8): https://www.python.org/dev/peps/pep-0008/

5. Editor und IDE

Hier noch einige Grundlegenden Informationen zu Texteditoren bzw. IDEs, die sich für Python
eignen. Diese Liste umfasst einige sehr gute Editoren, die sich insbesondere für Python eignen.
Grundlegend gilt: jeder Texteditor kann zum schreiben für Python-Code verwendet werden, nur
manche vereinfachen hierbei auch erheblich die Arbeit! Im Editor sollten folgende Einstellungen
vorgenommen werden: + Zeilenlänge sollte auf 79 Zeichen begrenzt werden (s. PEP8) + TAB sollte
vom Editor als 4 Leerzeichen (s. PEP8) interpretiert werden (kann man häufig umstellen)
Wer gerne eine IDE (integrated development environment) nutzen möchte kann z.B. zu Eclipse
oder PyCharm greifen. In meinen Augen sind diese jedoch häufig viel zu aufgeblasen und bieten
meist gegenüber einem guten Editor keine wesentlichen Vorteile.

Empfohlene Editoren
• Spyder
Spyder ist speziell für Python entwickelt und ähnelt dem Aufbau von Matlab. Neben dem
reinen Editor wird auch IPython direkt eingebunden. Der Editor ist bereits bei Anaconda
enthalten. Allerdings ist dieser Editor weitestgehend auf Python beschränkt.

• Notepad++
Für alle Windows Nutzer ein sehr empfehlenswerter Editor, der neben Python noch vieles
andere bietet. Im Gegensatz zu dem in Windows enthaltenen Notepad (das wirklich für
nichts zu gebrauchen ist), zeigt dieser Editor einige raffinierte Funktionen.

• Emacs
Die “Eierlegende Wollmilchsau” unter den Editoren. Eigentlich gibt es nichts was man mit
Emacs nicht machen kann. – Emails, Tetris, Kalender, . . . und natürlich Python. Alles was
es in der Grundinstallation nicht gibt kann man über zusätzliche Pakete nachinstallieren
oder sich selbst programmieren mit lisp. Als Erweiterung empfehle ich noch spacemacs zu
verwenden. Meine klare Empfehlung, jedoch nicht ganz einfach zu lernen. Emacs gibt es für
Linux, Mac OS X und Windows.

• VIM
Der ewige Rivale von Emacs. Beide Editoren sind alt, sehr mächtig und haben ihr eigenes Be-
dienungskonzept, das anfangs nicht gerade einfach zu lernen ist. Hat man es jedoch einmal
verinnerlicht, ist man um ein vielfaches schneller als mit anderen Editoren.

• Atom
Der “Neue” unter den Editoren. Er ist eigentlich nichts anderes als ein Webbrowser, der mit
Chromium (Open Source version von Google Chrome) und Node.js, als Texteditor genutzt

23
wird. Entwickelt wurde er von dem Projekt-Hosting-Dienst GitHub, die eigentlich einen Git-
Server zu verfügung stellt. Selbst habe ich den Editor noch nicht genutzt, allerdings schon
viel gutes gelesen.

24