Python (Wikipedia) ist eine multiparadigmatische (imperativ, prozedural, funktional, und objektorientierte) Programmiersprache. Sie wurde 1991 von Guido van Rossum veröffentlicht und wurde von ABC, Java, Haskell und anderen Sprachen maßgeblich beeinflusst. Seit bald 10 Jahren gehört sie zu den am weitesten verbreiteten und flexiblesten Programmiersprachen weltweit. Aus der Sicht der Mathematik ist die große Sammlung an mathematischen, statistischen und wissenschaftlichen Programmbibliotheken hervorzuheben, und darauf aufbauende Tools wie SageMath erwähnenswert. Außerdem ist Python eine exzellente Sprache zum funktionellen Kombinieren diverser Programme, Utilities und Systeme.
Der beste Weg Python kennen zu lernen ist ein Sprung ins kalte Wasser. Ein Programm zu programmieren folgt keinen kochrezeptartigen Regeln, sondern bedarf des kreativen Kombinierens von Konzepten, Regeln und Ideen. Daher ist kreatives Denken und ein Schatz an Erfahrungen wichtig -- ganz ähnlich wie das Führen von Beweisen in der Mathematik.
Die Funktionsweise der hier vorliegenden Worksheets ist die folgende:
Die mit In[]
gekennzeichneten Boxen sind die Eingabezellen.
In ihnen stehen in oder mehrere Zeilen Code.
Durch betätigen des Buttons oder der + Tasten wird die aktive Zelle ausgeführt.
Die Ausgabe steht darunter und ist mit Out[n]
gekennzeichnet.
Die folgenden Beispiele zeigen anschauliche Beispiele, die einen ersten groben Umriss um die Funktionalität Python's liefert. Davon neugierig gemacht, werden in der Folge die darin vorkommenden Grundprinzipien erklärt.
Keine Scheu, kopiere einzelne Zellen in ein neues IPython Notebook und fange an zu experimentieren!
14 + 3 * (8 - 1)
35
Achtung, potenziert wird mit **
!
banane = 3**2 + 1
print(banane)
10
Hierbei ist banane
eine Variable, die auf den Wert 10
gesetzt wurde.
Das ist das Ergebnis der Auswertung des Ausdrucks 3**2 + 1
.
Abgerufen kann der Wert von banane
, wenn es an letzter Stelle einer Code-Zelle steht,
oder durch den print
Befehl.
print(banane)
10
banane
10
Für "mathematisches" Dividieren muss mindestens ein Argument eine Flißekommazahl sein;
Ganzzahldivisionen werden abgerundet!
(Ausnahme: entweder es ist Python in Version 3 oder mittels from __future__ import division
wurde das modernere Verhalten importiert)
(2.2 * 9.81) / 2
10.791000000000002
Beide Zahlen sind Ganzzahlen, daher striktes Abrunden:
51 / 10
5.1
Ist mindestens eine der beiden Zahlen eine Fließkommazahl (sichtbar an dem kleinen .
nach der 51
),
so wird eine Fließkommadivision durchgeführt.
51. / 10
5.1
Aktivieren des alternativen Verhaltens für Divisionen.
from __future__ import division
51 / 10
5.1
Das IPython Notebook merkt sich derweilen weiter oben definierte Variable banane
,
solange die "Session" aktiv ist.
Kernel > Restart bzw. starten die Session neu.
print
kann in Python 2 als Statement verwendet werden,
es geht aber auch die in Python 3 gebräuchliche Variante als Funktion.
Damit können jederzeit Zwischenergebnisse, die während des Ablaufs des Programmes passieren, ausgegeben werden.
Ansonsten wird immer nur der Wert des letzten Ausdrucks ausgegeben.
apfel = 8.76
print(3 * banane + 2 * apfel)
apfel = 9.81
print(2 * banane + apfel)
47.519999999999996 29.810000000000002
Brüche können mit Fraction
angegeben werden
from fractions import Fraction
a = Fraction("33/31003100")
b = Fraction("-9/100000100001")
a * b ** 4
Fraction(2673, 38275585202254501783218213917955539030103719395100)
Liste von Zahlen von 0 bis 9. Es ist außerdem und ganz generell so, dass bei 0
zu zählen begonnen wird und Intervalle auf der linken Seite geschlossen und auf der rechten Seite offen sind.
range(10)
range(0, 10)
Jede dritte Zahl in $-10 \leq x < 10,\; x \in \mathbb{Z}$
range(-10, 10, 3)
range(-10, 10, 3)
Eine for
-Schleife iteriert -- das heißt, sie wiederholt den darin vorhandenen Codeblock -- für alle angegebenen Werte:
for x in range(-10, 10, 4):
y = 3 * x + 1
print("x ist %3d und y ist %3d" % (x, y))
x ist -10 und y ist -29 x ist -6 und y ist -17 x ist -2 und y ist -5 x ist 2 und y ist 7 x ist 6 und y ist 19
if
-Verzweigungen erlauben, Codeblöcke nur unter bestimmten Bedingungen auszuführen.
Das Wort else
kann optional dazu verwendet werden, einen Codeblock bei nichterfüllung der Bedingung auszuführen.
k = -4
if k >= 0:
print("k ist positiv")
else:
print("k ist negativ")
k ist negativ
Eine for
-Schleife mit einer darin enthaltenen if
-Bedingung.
Sie summiert alle Zahlen bis 100, die durch 3 und 7 teilbar sind, auf:
summe = 0
for i in range(100):
if i % 3 == 0 and i % 7 == 0:
summe += i
print(summe)
210
Das import
Statement dient dazu, Funktionalitäten aus diversen Programmbibliotheken zu importieren.
Beispiel: Die Sinusfunktion sin
aus der math
-Bibliothek importieren und mit Standardgenauigkeit berechnen.
from math import sin
sin(3.1415926535)
8.979318433952318e-11
Hier wird die sin
-Funktion mit 100 Stellen Genauigkeit durch dessen Version in der mpmath
-Bibliothek in Sympy berechnet.
Beachte, dass mpm
vorangestellt wird, um Vermischungen mit der schon importieren sin
zu vermeiden.
import mpmath as mpm
mpm.mp.dps = 100
mpm.sin(mpm.mpf("3.1415926535"))
mpf('0.00000000008979323846264338327938221965910388125990692946182694867743526330407406677351504727435623041438215811254')
Symbolische Ausdrücke können mit der Programmbibliothek SymPy
erzeugt werden.
Hierfür importieren wir z.B. in einem ersten Schritt die Variable $x$ und den Operator $\sin$,
mit der die Ausdrücke aufgebaut werden.
from sympy import sin, pi
from sympy.abc import x
$f(x) := \frac{2 x}{x - \sin(x)}$
f = 2 * x / (x - sin(x))
f
2*x/(x - sin(x))
Differenzieren nach $x$ mit .diff(x)
und anschließendes Vereinfachen des Ausdrucks durch .simplify()
.
f_prime = f.diff(x).simplify()
f_prime
2*(x*cos(x) - sin(x))/(x - sin(x))**2
Hier wird das x
in dem zuvor definierten symbolischen Ausdruck f
mittels der Methode .subs(<variable>, <expression>)
ersetzt.
$f(x)\Big\rvert_{x=1}=\dots$
f.subs(x, 1)
2/(-sin(1) + 1)
pi wurde weiter oben via from sympy import pi
definiert.
$f(x)\Big\rvert_{x=\pi}=\dots$
f.subs(x, pi)
2
Numerische Auswertung nach der Substitution durch .evalf()
f.subs(x, 1).evalf()
12.6159870328875
f.subs(x, 1).evalf(100)
12.61598703288748005502704347964832025794268409451527860450480203069959865248247113838572429676781402
from IPython.display import Math
from sympy import latex
Math(latex(f))
Math(latex(f_prime))
Eine "Liste" ist eine geordnete Sammlung von Objekten. Sie ist so ziemlich die zentralste Datenstruktur überhaupt.
l1 = ["Haus", 99]
l1
['Haus', 99]
l2 = ["a", 0, "x"]
l2
['a', 0, 'x']
l1 + l2
['Haus', 99, 'a', 0, 'x']
Verarbeiten von Listen mittels
[ <ausdruck> for <variable> in <liste> ]
(genannt "list-comprehension")
ll = [2., 2.5, 3., 5., 8.1, 10., 22.]
k1 = [2*i-2 for i in ll]
k1
[2.0, 3.0, 4.0, 8.0, 14.2, 18.0, 42.0]
[k**2 + 2*k + 1 for k in range(10)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Zugriff auf Elemente in einer Liste -- achtung, wie schon erwähnt wird ab 0
indiziert.
p = ["P", "y", "t", "h", "o", "n"]
p[3]
'h'
Das zweit-letzte Element mittels -2
p[-2]
'o'
Dies geschieht mittels der matplotlib
-Bibliothek. Sie muss zur Ausgabe von Grafiken aktiviert werden:
%matplotlib inline
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (10,6)
xx
und yy
beinhalten jeweils die x- und y-Koordinaten.
xx = [20, 15, 11, 7.57, 9.6, 13, 21, 24, 28, 23, 20]
yy = [3, 2.5, 2.3, 2.66, 3, 3.1, 2.3, 2.5, 2.8, 3, 3]
plt.plot(xx, yy, "o-")
plt.xlim(5, 30)
plt.ylim(2, 3.3)
(2, 3.3)
Definieren einer Funktionen mit SymPy
und zeichnen ihres Graphen:
from sympy import sin
from sympy.abc import x
sin_square = sin(x) * x**2
sin_square.subs(x, -2).evalf()
-3.63718970730273
sin_square.subs(x, 15).evalf()
146.314764035351
from sympy.plotting import plot
plot(sin_square, (x, -3, 15))
<sympy.plotting.plot.Plot at 0x7f9d00be0a58>
@interact
führt eine Funktion mit interaktiven Argumenten (a
und b
) aus.
a = (0, 20, .1)
definiert, dass der Slider von 0
bis 20
mit Schrittweite 0.1
gehen soll.
Das a = 10
in der Funktion damped_oscillation
selbst ist der initiale default Wert,
den der Slider am Anfang bekommen soll.
from IPython.html.widgets import interact
from sympy.abc import x
from sympy import exp, cos
from sympy.plotting import plot
@interact(a = (0, 20, .1), b = (0, 3, .1))
def damped_oscillation(a = 10, b = .5):
f2 = a * exp(-b * x) * cos(a * x) / a
plot(f2, (x, 0, 10), ylim=(-1, 1))
Die Matrix $\bigl(\begin{smallmatrix}a&b\\ c&d\end{smallmatrix} \bigr)$ beinhaltet die Parameter, und wird mit dem von $\phi$ abhängigen Vektor multipliziert.
from IPython.html.widgets import interact
import numpy as np
@interact(a=(-2, 2, .1), b =(-2, 2, .1), c=(-2, 2, .1), d=(-2, 2, .1))
def elliptic_plot(a = 1., b = 0, c = 0, d = -1):
phi = np.linspace(0, 8 * np.pi, 1000)
m = np.array([[a, b],
[c, d]])
v = np.c_[np.sin(phi),
np.cos(phi)].T
r = np.log1p(phi)
xx, yy = m.dot(r * v)
plt.plot(xx, yy)
plt.grid()
plt.ylim(-4, 4)
plt.xlim(-4, 4)
Gauss-Glocke für $\mu = 2$ und $\sigma = .5$
from random import gauss
data = [gauss(2, .5) for i in range(10000)]
_ = plt.hist(data, 20, color="grey")