Computerphysik WS 2015/2016 - physik.fu-berlin.de · I Skriptsprache u.a. f ur Blender, Cinema 4D, GIMP, OpenO ce.org, PyMOL I Laufzeitkritische Skripts lassen sich relativ einfach

Computerphysik WS 2015/2016

Einfuhrung in die Programmierung mit Python und Jupyter

Alexander SchlaichAG Netz, FU Berlin

14. Oktober 2015

Hinweise zu den Ubungen

I Die Ubungsblatter werden Donnerstags auf der Vorlesungswebseite zumDownload bereit gestellt.

I Die Aufgaben sollen in IPython Notebooks implementiert und sinnvollkommentiert werden.

I Die Abgabe der Losungen erfolgt als Notebook (*.ipynb). Name, Nummerdes Ubungsblattes und Tutor sollten im Dateinamen und im Notebookenthalten sein. Plots (auf Beschriftungen achten!) und Rechnungen sindmoglichst in das Notebook einzubinden oder ggf. anzuhangen.

I Die Abgabe kopierter Losungen fuhrt zu null Punkten fur alle Einsender.

I Die bearbeiteten Aufgaben mussen Sie im Tutorium prasentieren underklaren konnen. Andernfalls fuhrt dies zum Verlust der Punkte fur dieseAufgabe.

I Die Losungen mussen bis Sonntag 24 Uhr der darauf folgenden Woche perEmail an Ihren Tutor geschickt werden.

Physik,Computerphysik WS 2015/2016, 14. Oktober 2015 2/72

Ubungsgruppen

I Die Anwesenheit in den Ubungsgruppen ist grundsatzlich erforderlich. BeiAbwesenheit werden die abgegebene Losungen nicht berucksichtigt(krankheitsbedingtes Fehlen wird entschuldigt).

I Die Abgegebenen Losungen messen stetig Ihren Lernfortschritt und bildendie Grundlage fur die Benotung!

I In der ersten Ubungswoche: Grundlagen zu Python (0. Ubungsblatt,freiwillig)

I Zum Bestehen des Moduls sind mindestens 50% der Punkte notig.

I Die Ubungsgruppen finden zu folgenden Terminen im Rechnerraum(1.3.01) statt:

I Di. 14:15-15:45 Dr. Markus Miettinen (englisch)I Do. 10:15-11:45 Alexander SchlaichI Do. 14:15-15:45 Julian KapplerI Fr. 10:15-11:45 Johann Hansing

I 14 Ubungsblatter zu je 20 Punkten(280 Punkte → 140 Punkte zum Bestehen).


Einfuhrung in dieProgrammierung

mit Python

Basierend auf der Vorlesug ”Computerphysik”von Axel ArnoldBeitrage von Christopher Mielack und Julius Schulz


Python

I schnell zu erlernende Programmiersprache– tut, was man erwartet

I objektorientierte Programmierung ist moglich

I viele Standardfunktionen (”all batteries included“)

I breite Auswahl an Bibliotheken

I freie Software mit aktiver Gemeinde

I portabel, gibt es fur fast jedes Betriebssystem

I entwickelt von Guido van Rossum, CWI, Amsterdam


Informationen zu Python

I aktuelle Versionen 3.5.0 bzw. 2.7.10I machtige numerische Bibliotheken verfugbar (NumPy)I effizientes wissenschaftliches Arbeiten mit SciPy, MatPlotLib, etc.I Komplettpaket: z.B. Anaconda http://www.continuum.io/downloads

verfugbar fur alle Betriebssysteme (Windows, Mac, Linux)

Hilfe zu Python

I offizielle Homepagehttp://www.python.org

I Einsteigerkurs”A Byte of Python“

http://swaroopch.com/notes/Python (englisch)http://abop-german.berlios.de (deutsch)

I mit Programmiererfahrung”Dive into Python“

http://diveintopython.net

I”A Primer on Scientific Programming with Python“

von Hans Petter Langtangen (verfugbar uber SpringerLink)Physik,

Computerphysik WS 2015/2016, 14. Oktober 2015 6/72

http://www.continuum.io/downloads

http://www.python.org

http://swaroopch.com/notes/Python

http://abop-german.berlios.de

http://diveintopython.net

http://www.springerlink.com/content/978-3-642-30293-0#section=1091465&page=1

Was ist Python?

I Skriptsprache, d.h. keine Kompilierung(im Gegensatz zu Programmiersprachen wie z.B. C)

I Interaktiv uber Python-KonsoleI Effiziente Routinen haufig auf C-Ebene implementiert (z.B. NumPy)I Ziel: moglichst einfach und ubersichtlichI Skriptsprache u.a. fur Blender, Cinema 4D, GIMP, OpenOffice.org, PyMOLI Laufzeitkritische Skripts lassen sich relativ einfach in C ubersetzen bzw. an

bestehende Projekte in C anbinden, z.B. mittels cython


Python2 vs Python3

I Python 3.0 veroffentlicht 2008 (2.7 Mitte of 2010)

I Nur kleine Inkompabilitaten ubrig (z.B. Unicode Strings in 3.x)

I print ist nun eine Funktion

I Per default keine Integerdivision (2/3 vs 2//3)

In Python 2 kann schon großtenteils Kompabilitat erreicht werden:

from __future__ import print_function

from __future__ import division

Empfehlung fur die Bearbeitung der Ubungsaufgaben:

I Moglichst aktuelles Release von Python und allen Paketen(Distributionsverwaltung oder pip)

I Falls Sie Python 2 verwenden mochten verwenden Sie die beidenFunktionen aus __future__

I im Rechnerraum z.B. python → python2 .7 aber auch python3→python3 .4 vorhanden


Python starten

Aus der Shell:

> python3

Python 3.4.2 (default, Oct 8 2014, 10:45:20)

[GCC 4.9.1] on linux

Type "help", "copyright", "credits" or "license" for more...

>>> print ("Hello World")

Hello World

>>> help("print")

>>> exit()

I >>> markiert Eingaben

I print (): Ausgabe auf das Terminal

I help(): interaktive Hilfe, wird mit ”q” beendet

I statt exit() reicht auch Control-d

I oder ipython (ipython3) mit Tab-Erganzung, History usw.


Python-Skripte

Als Python-Skript helloworld.py:

#!/usr/bin/python3

# unsere erste Python-Anweisung

print ("Hello World")

I mit python3 helloworld.py starten

I oder ausfuhrbar machen (chmod a+x helloworld.py)

I Umlaute vermeiden (v.a. Python2 und unter Windows)

I”

#! “ funktioniert genauso wie beim Shell-Skript (Shebang)

I Zeilen, die mit”

# “ starten, sind Kommentare

Kommentare sind wichtig,um ein Programm verstandlich zu machen!

I und nicht, um es zu verlangern!


IPython

I interaktiver, komfortabler python prompt (z.B. von bash aus gestartet):

> ipython3

Python 3.4.2 (default, Oct 8 2014, 10:45:20)

Type "copyright", "credits" or "license" for more information.

[...]

In [1]: print ("Hello World")

Hello World

I erkennt einige shell-Befehle, wie z.B. "ls", "cd" , . . .

I beherrscht Syntax Highlighting und Tab-Completion

I Hilfe zu jedem beliebigen Befehl/Objekt bekommt man durch Anhangeneines "?", z.B. " range?"

I beenden mit Strg-D, y


IPython Notebook

I Interaktive Nutzung und inline Darstellung mit Matplotlib magic% matplotlib inline (spater)

I Textsatz mittels Markdown und Latex-Gleichungen → wissenschaftlicheDokumentation on-the-fly bis hin zum Paper-draft


IPython Notebook / Jupyter

I Notebook Server wird gestartet mitipython notebook bzw. jupyter notebook

I . . . und kann im Browser geoffnet werden unter http://127.0.0.1:8888

I legt *. ipynb Dateien in dem Verzeichnis ab von dem aus ihr den Servergestartet habt

I Code in einer Zelle kann mit Shift-Enter ausgefuhrt werden

I Speichern mit Strg-S, Hilfe mit h

I Output (inklusive Plots!) erscheint direkt unter eurem Code, bleibt imNotebook gespeichert

I Notebooks konnen exportiert werden, z.b. als HTML, PDF, . . . mit

ipython nbconvert --to FORMAT notebook.ipynb

I Wichtig: Vor Abgabe der Hausaufgaben als *.ipynb Datei zum TestenKernel 〉 Restart ausfuhren und dann Cell 〉 Run All


http://127.0.0.1:8888

Datentypen 1

I ganze Zahlen:

>>> print (42)

42

>>> print (-12345)

-12345

I Fließkommazahlen:

>>> print (12345.000)

12345.0

>>> print (6.023e23)

6.023e+23

>>> print (13.8E-24)

1.38e-23

I 1.38e-23 steht z. B. fur 1.38× 10−23

I 12345 6= 12345.0 (z. B. bei der Ausgabe)


Datentypen 2

I Zeichenketten (Strings)

>>> print ("Hello World")

Hello World

>>> print (’Hello World’)

Hello World

>>> print ("""Hello

... World""")

Hello

World

I zwischen einfachen (’) oder doppelten (”) Anfuhrungszeichen

I Uber mehrere Zeilen mit dreifachen Anfuhrungszeichen(auch als Kommentarfunktion verwendbar)

I Leerzeichen sind normale Zeichen!"Hello World " 6= "Hello World"

I Zeichenketten sind keine Zahlen! "1" 6= 1


Variablen

>>> number1 = 1

>>> number2 = number1 + 5

>>> print (number1, number2)

1 6

>>> number2 = "Keine Zahl"

>>> print (number2)

Keine Zahl

I Variablennamen bestehen aus Buchstaben,Ziffern oder

”“ (Unterstrich)

I am Anfang keine Ziffer

I Groß-/Kleinschreibung ist relevant: Hase 6= hase

I Richtig: i, some_value , SomeValue , v123 , _hidden , _1

I Falsch: 1 _value , some value , somevalue


Arithmetische Ausdrucke

+ Addition, bei Strings aneinanderfugen, z.B.1 + 2 → 3, "a" + "b" → "ab"

- Subtraktion, z.B. 1 - 2 → -1

* Multiplikation, Strings vervielfaltigen, z.B.2 * 3 = 6, "ab" * 2 → "abab"

/ Division, z.B.3 / 2 → 1.5, -3 / 2 → -1.5, 3.0 / 2 → 1.5

cave: Python 2 Ganzzahldivision (bei Python 3 mittels //):3 / 2 → 1, -3 / 2 → -2, 3.0 / 2 → 1.5

% Rest bei Division, z.B. 5 % 2 → 1

** Exponent, z.B. 3**2 → 9, .1**3 → 0.001

I mathematische Prazedenz (Exponent vor Punkt vor Strich),z. B. 2**3 * 3 + 5 → 23 · 3 + 5 = 29

I Prazedenz kann durch runde Klammern geandert werden:2**(3 * (3 + 5)) → 23·8 = 16 777 216


Logische Ausdrucke

==, != Test auf (Un-)Gleichheit, z.B. 2 == 2 → True,

1 == 1.0 → True, 2 == 1 → False

<,>,<=,>= Vergleich, z.B. 2 > 1 → True, 1 <= -1 → False

or, and Logische Verknupfungen”oder“ bzw.

”und“

not Logische Verneinung, z.B. not False == True

I Vergleiche liefern Wahrheitswerte: True oder False

I Wahrheitstabelle fur die logische Verknupfungen:a b a and b a or b

True True True True

False True False True

True False False True

False False False False

I Prazedenz: logische Verknupfungen vor Vergleichen

I Beispiele: 3 > 2 and 5 < 7 → True ,1 < 1 or 2 >= 3 → False


if: bedingte Ausfuhrung

>>> a = 1

>>> if a < 5:

... print ("a ist kleiner als 5")

... elif a > 5:

... print ("a ist groesser als 5")

... else:

... print ("a ist 5")

a ist kleiner als 5

>>> if a < 5 and a > 5:

... print ("Das kann nie passieren")

I if-elif-else fuhrt den Block nach der ersten erfullten Bedingung(logischer Wert True) aus

I Trifft keine Bedingung zu, wird der else-Block ausgefuhrt

I elif oder else sind optional


Blocke und Einruckung

>>> a=5

>>> if a < 5:

... # wenn a kleiner als 5 ist

... b = -1

... else: b = 1

>>> # aber hier geht es immer weiter

... print (b)

1

I Alle gleich eingeruckten Befehle gehoren zum Block

I Nach dem if-Befehl geht es auf Einruckungsebene des if weiter, egalwelcher if-Block ausgefuhrt wurde

I Einzeilige Blocke konnen auch direkt hinter den Doppelpunkt

I Einrucken durch Leerzeichen (Achtung: immer gleich!)oder Tabulatoren (Vorsicht bei Dateiformaten und Editoren)


Blocke und Einruckung 2

I ein Block kann nicht leer sein, aber der Befehl pass tut nichts:

if a < 5:

pass

else:

print ("a ist groesser gleich 5")

I IndentationError bei ungleichmaßiger Einruckung:

>>> print ("Hallo")

Hallo

>>> print ("Hallo")

File "<stdin>", line 1

print ("Hallo")

^

IndentationError: unexpected indent

I Falsche Einruckung fuhrt im allgemeinen zu Programmfehlern!


while: Schleifen

>>> a = 1

>>> while a < 5:

... a = a + 1

>>> print (a)

5

I Fuhrt den Block solange aus, wie die Bedingung wahr ist

I kann auch nicht ausgefuhrt werden:

>>> a = 6

>>> while a < 5:

... a = a + 1

... print ("erhoehe a um eins")

>>> print (a)

6


for: Sequenz-Schleifen

>>> for a in range(1, 3): print (a)

1

2

>>> b = 0

>>> for a in range(1, 100):

... b = b + a

>>> print (b)

4950

>>> print (100 * (100 - 1) / 2)

4950

I for fuhrt einen Block fur jedes Element einer Sequenz aus

I Das aktuelle Element steht in a

I range(k,l) ist eine Liste der Zahlen a mit k ≤ a < l

I Kann auch fur eine Liste von Werten verwendet werden:for i in [3, 5, -8, 95]:


break und continue: Schleifen beenden

>>> for a in range(1, 10):

... if a == 2 or a == 4 or a == 6: continue

... elif a == 5: break

... print (a)

1

3

>>> a = 1

>>> while True:

... a = a + 1

... if a > 5: break

>>> print (a)

6

I beide uberspringen den Rest des Schleifenkorpers

I break bricht die Schleife ganz ab

I continue springt zum nachsten Schleifendurchlauf


Funktionen

>>> def printPi():

... print ("pi ist ungefaehr 3.14159")

>>> printPi()

pi ist ungefaehr 3.14159

>>> def printMax(a, b):

... if a > b: print (a)

... else: print (b)

>>> printMax(3, 2)

3

I eine Funktion kann beliebig viele Argumente haben

I Argumente sind Variablen der Funktion

I Beim Aufruf bekommen die Argumentvariablen Wertein der Reihenfolge der Definition

I Der Funktionskorper ist wieder ein Block


return: eine Funktion beenden

def printMax(a, b):

if a > b:

print (a)

return

print (b)

I return beendet die Funktion sofort

Ruckgabewert

>>> def max(a, b):

... if a > b: return a

... else: return b

>>> print (max(3, 2))

3

I eine Funktion kann einen Wert zuruckliefern

I der Wert wird bei return spezifiziertPhysik,


Lokale Variablen

>>> def max(a, b):

... if a > b: maxVal=a

... else: maxVal=b

... return maxVal

>>> print (max(3, 2))

3

>>> print (maxVal)

NameError: name ’maxVal’ is not defined

I Variablen innerhalb einer Funktion sind lokal

I lokale Variablen existieren nur wahrend der Funktionsausfuhrung

I globale Variablen konnen aber gelesen werden

>>> faktor=2

>>> def strecken(a): return faktor*a

>>> print (strecken(1.5))

3.0


Vorgabewerte und Argumente benennen

>>> def lj(r, epsilon = 1.0, sigma = 1.0):

... return 4*epsilon*( (sigma/r)**6 - (sigma/r)**12 )

>>> print (lj(2**(1./6.)))

1.0

>>> print (lj(2**(1./6.), 1, 1))

1.0

I Argumentvariablen konnen mit Standardwerten vorbelegt werden

I diese mussen dann beim Aufruf nicht angegeben werden

>>> print (lj(r = 1.0, sigma = 0.5))

0.0615234375

>>> print (lj(epsilon=1.0, sigma = 1.0, r = 2.0))

0.0615234375

I beim Aufruf konnen die Argumente auch explizit belegt werden

I dann ist die Reihenfolge egal


Funktionen als Werte

def printGrid(f, a, b, step):

"""

Gibt x, f(x) an den Punkten

x= a, a + step, a + 2*step, ..., b aus.

"""

x = a

while x < b:

print (x, f(x))

x = x + step

def test(x): return x*x

printGrid(test, 0, 1, 0.1)

I Funktionen ohne Argumentliste”(..)“ sind normale Werte

I Funktionen konnen in Variablen gespeichert werden

I ... oder als Argumente an andere Funktionen ubergeben werden


Komplexe Datentypen

I Komplexe Datentypen sind zusammengesetzte Datentypen

I Beispiel: Eine Zeichenkette besteht aus beliebig vielen Zeichen

I die wichtigsten komplexen Datentypen in Python:I Strings (Zeichenketten)I ListenI TupelI Dictionaries (Worterbucher)

I diese konnen als Sequenzen in for eingesetzt werden:

>>> for x in "bla": print ("->", x)

-> b

-> l

-> a


Listen

>>> kaufen = [ "Muesli", "Milch", "Obst" ]

>>> kaufen[1] = "Sahne"

>>> print (kaufen[-1])

Obst

>>> kaufen.append(42)

>>> del kaufen[-1]

>>> print (kaufen)

[’Muesli’, ’Sahne’, ’Obst’]

I komma-getrennt in eckigen Klammmern

I konnen Daten verschiedenen Typs enthalten

I liste[i] bezeichnet das i-te Listenelement,negative Indizes starten vom Ende Achtung: Zahlung beginnt bei 0!

I liste. append () fugt ein Element an eine Liste an

I del loscht ein Listenelement

I haben wir bereits in for i in [3, 5, -8, 95]: gesehen


Listen 2

>>> kaufen = kaufen + [ "Oel", "Mehl" ]

>>> print (kaufen)

[’Muesli’, ’Sahne’, ’Obst’, ’Oel’, ’Mehl’]

>>> for l in kaufen[1:3]:

... print (l)

Sahne

Obst

>>> print (len(kaufen[:4]))

4

I”+“ fugt zwei Listen aneinander

I [i:j+1] ist die Subliste vom i-ten bis zum j-ten Element

I Leere Sublisten-Grenzen entsprechen Anfang bzw. Ende,also stets liste == liste [:] == liste [0:]

I for-Schleife uber alle Elemente

I len() berechnet die Listenlange


Formatierte Ausgabe: der %-Operator

>>> print ("Integer %d %05d" % (42, 42))

Integer 42 00042

>>> print ("Fliesskomma %e |%+8.4f| %g" % (3.14, 3.14, 3.14))

Fliesskomma 3.140000e+00 | +3.1400| 3.14

>>> print ("Strings %s %10s" % ("Hallo", "Welt"))

Strings Hallo Welt

I Der %-Operator ersetzt %-Platzhalter in einem String

I %d: Ganzahlen (Integers)

I %e, %f, %g: Fliesskomma mit oder ohne Exponentoder wenn notig (Standardformat)

I %s: einen String einfugen

I %x[defgs]: auf x Stellen mit Leerzeichen auffullen

I %0x[defg]: mit Nullen auffullen

I %x.y[efg]: x gesamt, y Nachkommastellen


Ein-/Ausgabe: Dateien in Python

eingabe = open("ein.txt")

ausgabe = open("aus.txt", "w")

nr = 0

ausgabe.write("Datei %s mit Zeilennummern\n" % eingabe.name)

for zeile in eingabe:

nr += 1

ausgabe.write("%d: %s" % (nr, zeile))

ausgabe.close()

I Dateien sind mit open( datei, mode) erzeugte Objekte

I Mogliche Modi (Wert von mode):

r oder leer lesen

w schreiben, Datei zuvor leeren

a schreiben, an existierende Datei anhangen

I sind Sequenzen von Zeilen (wie eine Liste von Zeilen)

I Nur beim Schließen der Datei werden alle Daten geschrieben.

I Fur Dateien mit numerischen Daten siehe numpy. loadtxt (spater).Physik,


Module

>>> import random

>>> print (random.random(), random.randint(0, 100))

0.576899996137, 42

>>> from random import randint

>>> print (randint(0, 100))

14

I enthalten nutzliche Funktionen, Klassen, usw.

I sind nach Funktionalitat zusammengefasst

I werden per import zuganglich gemacht

I Hilfe: help( modul), alle Funktionen: dir(modul )

I einzelne Bestandteile kann man mit from . . . import . . . importieren– bei Namensgleichheit kann es zu Kollisionen kommen!

I Abkurzungen: import matplotlib . pyplot as plt


Das math-Modul

import math

import random

def boxmueller():

"""

liefert normalverteilte Zufallszahlen

nach dem Box-Mueller-Verfahren

"""

r1, r2 = random.random(), random.random()

return math.sqrt(-2*math.log(r1))*math.cos(2*math.pi*r2)

I math stellt viele mathematische Grundfunktionen zur Verfugung,z.B. floor/ceil, exp/log, sin/cos, pi

I random erzeugt pseudozufallige ZahlenI random (): gleichverteilt in [0, 1)I randint (a, b): gleichverteilt ganze Zahlen in [a, b)I gauss (m, s): normalverteilt mit Mittelwert m und Varianz s


Numerik mit Python – numpy

I numpy ist ein Modul fur effiziente numerische Rechnungen

I Baut auf n-dimensionalem Feld-Datentyp numpy .array aufI Feste Große und FormI Alle Elemente vom selben (einfachen) DatentypI Aber sehr schneller Zugriff (C-Niveau)I Viele Transformationen

I BietetI mathematische GrundoperationenI Sortieren, Auswahl von Spalten, Zeilen usw.I Eigenwerte, -vektoren, DiagonalisierungI diskrete FouriertransformationI statistische AuswertungI Zufallsgeneratoren

I Hilfe unter http://docs.scipy.org


http://docs.scipy.org

array – eindimensionale Arrays

>>> import numpy as np

>>> np.array([1.0, 2, 3])

array([ 1., 2., 3.])

>>> np.ones(5)

array([ 1., 1., 1., 1., 1.])

>>> np.arange(2.2, 3, 0.2, dtype=float)

array([ 2.2, 2.4, 2.6, 2.8])

I np.array erzeugt ein Array (Feld) aus einer Liste

I np. arange entspricht range fur beliebige Datentypen

I np.zeros /ones erzeugen 1er/0er-Arrays

I dtype setzt den Datentyp aller Elemente explizit

bool Wahrheitswerte

int ganze Zahlen

float IEEE-Fließkommazahlen

complex Komplexe Fließkommazahlen

I ansonsten der einfachste fur alle Elemente passende Typ


Mehrdimensionale Arrays

>>> np.array([[1, 2, 3], [4, 5, 6]])

array([[1, 2, 3],

[4, 5, 6]])

>>> np.array([[[1,2,3], [4,5,6]], [[7,8,9], [0,1,2]]])

array([[[1, 2, 3],

[4, 5, 6]],

[[7, 8, 9],

[0, 1, 2]]])

>>> np.zeros((2, 2))

array([[ 0., 0.],

[ 0., 0.]])

I Mehrdimensionale Arrays entsprechen verschachtelten Listen

I Alle Zeilen mussen die gleiche Lange haben

I np.zeros /ones : Große als Tupel von Dimensionen(Tupel: unveranderbare Listen, runde Klammern)


Elementzugriff und Subarrays

>>> a = np.array([[1,2,3,4,5,6], [7,8,9,0,1,2]])

>>> print (a.shape, a[1,2], a[1])

(2, 6) 9 [7 8 9 0 1 2]

>>> print (a[0,1::2])

[2, 4, 6]

>>> print (a[1:,1:])

[[8, 9, 0, 1, 2]]

>>> print (a[0, np.array([1,2,5])])

[2, 3, 6]

I [] indiziert Elemente und Zeilen usw.

I Auch Bereiche wie bei Listen

I a. shape ist die aktuelle Form (Lange der Dimensionen)

I int-Arrays, um beliebige Elemente zu selektieren


Methoden: Matrixoperationen

>>> a = np.array([[1,2], [3,4]])

>>> a = np.concatenate((a, [[5,6]]), axis=0)

>>> print (a.transpose())

[[1 3 5]

[2 4 6]]

>>> print (a.shape, a.transpose().shape)

(3, 2) (2, 3)

>>> print (a[1].reshape((2,1)))

[[3]

[4]]

I reshape () kann die Form eines Arrays andern,solange die Gesamtanzahl an Element gleich bleibt

I concatenate () hangt zwei Matrizen aneinander,axis bestimmt die Dimension, entlang der angefugt wird

I transpose (), conjugate (): Transponierte, Konjugierte

I min (),max() berechnen Minimum und Maximum aller ElementePhysik,


Lineare Algebra: Vektoren und Matrizen

>>> a = np.array([[1,2],[3,4]])

>>> i = np.array([[1,0],[0,1]]) # Einheitsmatrix

>>> print (a*i) # punktweises Produkt

[[1 0]

[0 4]]

>>> print (np.dot(a,i)) # echtes Matrixprodukt

[[1 2]

[3 4]]

>>> print (np.dot(a[0], a[1])) # Skalarprodukt der Zeilen

11

I Arrays werden normalerweise punktweise multipliziert

I np.dot entsprichtI bei zwei eindimensionalen Arrays dem Vektor-SkalarproduktI bei zwei zweidimensionalen Arrays der Matrix-MultiplikationI bei ein- und zweidim. Arrays der Vektor-Matrix-Multiplikation

I Die Dimensionen mussen passen


Lineare Algebra

>>> a = np.array([[1,0],[0,1]])

>>> print (np.linalg.det(a))

1

>>> print (np.linalg.eig(a))

(array([ 1., 1.]), array([[ 1., 0.],

[ 0., 1.]]))

I numpy. cross : Vektorkreuzprodukt

I numpy. linalg .det, .trace : Determinante und Spur

I numpy. linalg .norm, .cond : Norm und Kondition

I numpy. linalg .eig: Eigenwerte und -vektoren

I numpy. linalg .inv: Inverse einer Matrix berechnen

I numpy. linalg . cholesky , .qr, .svd: Matrixzerlegungen

I numpy. linalg .solve (A, b): Losen von Ax = b


Analyse und Visualisierung

Zeit Winkel Geschw. Energie55.0 1.1605 2.0509 8.00001555.2 1.3839 0.1625 8.00001755.4 1.2245 -1.7434 8.00001655.6 0.7040 -3.3668 8.00000855.8 -0.0556 -3.9962 8.00000056.0 -0.7951 -3.1810 8.00000956.2 -1.2694 -1.4849 8.00001656.4 -1.3756 0.43024 8.00001756.6 -1.1001 2.29749 8.00001456.8 -0.4860 3.70518 8.000004

I Zahlen anschauen ist langweilig!

I Graphen sind besser geeignet

I Statistik hilft, Ergebnisse einzuschatzen (Fehlerbalken)

I Histogramme, Durchschnitt, Varianz


Durchschnitt und Varianz

>>> samples=100000

>>> z = np.random.normal(0, 2, samples)

>>> print (np.mean(z))

-0.00123299611634

>>> print (np.var(z))

4.03344753342

I Arithmetischer Durchschnitt

〈z〉 =∑len(z)

i=1zi/len(z)

I Varianzσ(z) =

⟨(z − 〈z〉)2

⟩Physik,


Ein-/Ausgabe: numerische Daten

I Mochte man Dateien mit numerischen Daten einlesen, konnte man diesemit open laden und dann parsen, d.h. Strings in numerische Datenumwandeln.

I Einen einfacheren Weg bietet numpy. loadtxt (file) bzw.numpy. savetxt (file, array )

I Dabei werden die Zeilen und Spalten der Datei als zwei-dimensionalesnumpy. array gespeichert

I Die einzelnen Eintrage mussen ein numerisches Format haben(“.” als Dezimaltrenner)

I Zeilen die mit # beginnen, werden ignoriert.

I Viele Optionen zum Anpassen des Dateiformats.


Histogramme

>>> zz = np.random.normal(0,1,100000)

>>> werte, rand = np.histogram(zz, bins=100, normed=True)

I Histogramme geben die Haufigkeit von Werten an

I In bins vielen gleich breiten Intervallen

I werte sind die Haufigkeiten, raender die Grenzen der Intervalle(ein Wert mehr als in werte )


Malen nach Zahlen – matplotlib

I Ein Modul zum Erstellen von Graphen

I 2D oder 3D, mehrere Graphen in einem

I Speichern als Bitmap oder Vektorgrafik

I Kann auch animierte Kurven darstellen

I Beschriftungen mit title , xlabel , etc. (siehe Dokumentation)


2D-Plots

import matplotlib

import matplotlib.pyplot as plt

...

x = np.arange(0, 2*np.pi, 0.01)

y = np.sin(x)

plt.plot(x, y, "g", linewidth=2)

plt.text(1, -0.5, "sin(2*pi*x)")

plt.show() 10 5 0 5 100

5000

10000

15000

20000

25000

30000

35000

40000

I pyplot .plot erzeugt einen 2D-Graphen

I pyplot .text schreibt beliebigen Text in den Graphen

I pyplot .show() zeigt den Graphen an

I Parametrische Plots mit Punkten (x[t], y[t])

I fur Funktionen Punkte (x[t], y(x[t])) mit x Bereich

I Farbe und Form uber String und Parameter – ausprobieren


Matplotlib Ubersicht

I 3D-Plots

I Scatter plots

I Colormaps

I Mehrfach-Plots

I Polar-Koordinaten

I LATEX-Labels

I Grafische Ubersicht mitCode-Beispielen aufhttp://matplotlib.org/gallery.html


http://matplotlib.org/gallery.html

Numpy.Vectorize

I Haufig (beispielsweise fur Plots) mussen Werte als numpy. array vorliegen.Will man Funktionen plotten, mussen sie ein solches zuruckgeben.

I Solange man nur Standardoperatoren und Funktionen aus numpyverwendet, arbeiten Funktionen problemlos auf Arrays

I Folgendes Beispiel funktioniert nicht ohne Probleme:

def func(a, b):

if a > b:

return a - b

else:

return a + b

I In diesem Fall biete die Funktion numpy. vectorize die Moglichkeit, dieseFunktion mit numpy arrays kompatibel zu machen:g = vectorize (func)

p.plot(x, g(x,a))

Aussagekraftige Plots enthalten immer sinnvolleAchsenbeschriftungen, Titel und Legenden!


weitergehende Themen

Die hier behandelten Themen sind fur die ersten Ubungen nicht relevant, zeigenaber einige eindrucksvolle Einsatzmoglichkeiten fur Python, in der zurVerfugung stehend Zeit aber nicht behandelt werden konnen.

Außerdem werden typische Stolpersteine angesprochen und dieHerangehensweise an Probleme erlautert, weshalb wir allen Ubungsteilnehmerndie Lekture sehr ans Herz legen.


Methodik des Programmierens

Schritte bei der Entwicklung eines Programms

I ProblemanalyseI Was soll das Programm leisten?

Z.B. eine Nullstelle finden, Molekulardynamik simulierenI Was sind Nebenbedingungen?

Z.B. ist die Funktion reellwertig? Wieviele Atome?

I MethodenwahlI Schrittweises Zerlegen in Teilprobleme (Top-Down-Analyse)

Z.B. Propagation, Kraftberechnung, AusgabeI Wahl von Datentypen und -strukturen

Z.B. Listen oder Tupel? Worterbuch?I Wahl der Rechenstrukturen (Algorithmen)

Z.B. Newton-Verfahren, Regula falsi,...

I Implementation und DokumentationI Programmieren und gleichzeitig dokumentierenI Kommentare und externe Dokumentation (z.B. Formeln)


Methodik des Programmierens

I Testen auf KorrektheitI Funktioniert das Programm?

Z.B. findet es eine bekannte Losung?I Terminiert das Programm?

D.h. halt es immer an?

I Testen auf Effizienz

I Wie lange braucht das Programm bei beliebigen Eingaben?I Wieviel Speicher braucht es?

I Meistens wiederholt sich der Prozess:I Bei der Methodenwahl stellen sich weitere Einschrankungen als notig heraus:

z.B. Funktion darf keine Singularitaten aufweisenI Bei der Implementation zeigt sich, dass die gewahlte Methode nicht

umzusetzen ist: z.B. weil implizite Gleichungen gelost werden musstenI Beim Testen zeigt sich, dass die Methode ungeeignet oder nicht schnell

genug ist: z.B. zu langsam, numerisch instabil

I Mit wachsender Projektgroße zunehmend wichtig: Software Engineering


Allgemeine Programmier Empfehlungen

I Redundanz vermeidenI Tut eine Library vielleicht schon das, was ich implementieren will?I wiederkehrenden Code als Funktion auslagern

I Sinnvolle Benennung von Variablen und Funktionen ist besser alsKommentaregut: calculateVelocity (...)

schlecht: calc (...): # berechnet Geschwindigkeit

gut: numberOfParticles = 10

schlecht: n = 10 # Anzahl der Teilchen

I Funktionsargumente verwenden statt globaler Variablen

def createDuplicates( inputList, numberOfCopies):

return inputList * numberOfCopies

... ist besser als ...

numberOfCopies = 10

inputList = [1,2,3]

def createDuplicates():

return inputList*numberOfCopiesPhysik,


Testen auf Korrektheit und Effizienz

Korrektheit

I Extremwerte uberprufen (leere Eingabe, 0)

I Generische Falle prufen, d.h. alle Vorzeichen, bei reellen Zahlen nicht nurganzzahlige Eingaben

I Alle Fehlermeldungen sollten getestet, also ausgelost werden!⇒ mehr Tests fur unzulassige Eingaben als fur korrekte

Effizienz

I Wie viele elementare Schritte (Schleifendurchlaufe) sind notig?

I Moglichst langsam wachsende Anzahl elementarer Schritte

I Ebenso moglichst langsam wachsender Speicherbedarf

I Sonst konnen nur sehr kleine Aufgaben behandelt werden

I Beispiel: bei N = 106 ist selbst 0, 1µs×N2 = 1 Tag


Beispiel: Pythagoreische Zahlentripel

I ProblemanalyseGegeben: eine ganze Zahl c

Gesucht: Zahlen a, b mit a2 + b2 = c2

1. Verfeinerung: a = 0, b = c geht immer ⇒ a, b > 0

2. Verfeinerung: Was, wenn es keine Losung gibt? Fehlermeldung

I Methodenwahl

I Es muss gelten: 0 < a < c und 0 < b < cI Wir konnen also alle Paare a, b

mit 0 < a < c und 0 < b < c durchprobieren – verschachtelte SchleifenI Unterteilung in Teilprobleme nicht sinnvoll

I Effizienz?Rechenzeit wachst wie |c|2 – das ist langsam!



I Implementation

def zahlentripel(c):

"""

Liefert ein Ganzzahlpaar (a, b), dass a^2 + b^2 = c^2

erfuellt, oder None, wenn keine Loesung existiert.

"""

# Durchprobieren aller Paare

for a in range(1,c):

for b in range(1,c):

if a**2 + b**2 == c**2: return (a, b)

return None

I Test der Effizienz

Zahl (alle ohne Losung) 1236 12343 123456

Zeit 0.5s 41s 1:20h

I Das ist tatsachlich sehr langsam! Geht es besser?



I Methodenwahl zur EffizienzverbesserungO.B.d.A. a ≤ b

I Sei zunachst a = 1 und b = c− 1

I Ist a2 + b2 > c2, so mussen wir b verringern,und wir wissen, dass es keine Losung mit b = c− 1 gibt

I Ist a2 + b2 < c2, so mussen wir a erhohen und wir wissen, dass es keineLosung mit a = 1 gibt

I Ist nun a2 + b2 > c2, so mussen wir wieder b verringern,egal ob wir zuvor a erhoht oder b verringert haben

I Wir haben alle Moglichkeiten getestet, wenn a > b

I Effizienz?Wir verringern oder erhohen a bzw. b in jedem Schritt. Daher sind es nurmaximal |c|/2 viele Schritte.



I Implementation der effizienten Vorgehensweise

def zahlentripel(c):

"loest a^2 + b^2 = c^2 oder liefert None zurueck"

# Einschachteln der moeglichen Loesung

a = 1

b = c - 1

while a <= b:

if a**2 + b**2 < c**2: a += 1

elif a**2 + b**2 > c**2: b -= 1

else: return (a, b)

return None

I Demonstration der Effizienz

Zahl 12343 123456 1234561 12345676 123456789

Zeit 0.01s 0.08s 0.63s 6.1s 62s


Dokumentation von Funktionen

def max(a, b):

"Gibt das Maximum von a und b zurueck."

if a > b: return a

else: return b

def min(a, b):

"""

Gibt das Minimum von a und b zurueck. Funktioniert

ansonsten genau wie die Funktion max.

"""

if a < b: return a

else: return b

I Dokumentation optionale Zeichenkette vor dem Funktionskorper

I wird bei help( funktion ) ausgegeben


Rekursion

def fakultaet(n):

# stellt sicher, das die Rekursion irgendwann stoppt

if n <= 1:

return 1

# n! = n * (n-1)!

return n * fakultaet(n-1)

I Funktionen konnen andere Funktionen aufrufen, insbesondere sich selber

I Eine Funktion, die sich selber aufruft, heißt rekursiv

I Rekursionen treten in der Mathematik haufig auf

I sind aber oft nicht einfach zu verstehen

I Ob eine Rekursion endet, ist nicht immer offensichtlich

I Jeder rekursive Algorithmus kann auch iterativals verschachtelte Schleifen formuliert werden


Shallow copies

Shallow copy:

>>> bezahlen = kaufen

>>> del kaufen[2:]

>>> print (bezahlen)

[’Muesli’, ’Sahne’]

Subliste, deep copy:

>>> merken = kaufen[1:]

>>> del kaufen[2:]

>>> print (merken)

[’Sahne’, ’Obst’, ’Oel’, ’Mehl’]

”=“ macht in Python flache Kopien komplexer Datentypen!

I Flache Kopien (shallow copies) verweisen auf dieselben Daten

I Anderungen an einer flachen Kopie betreffen auch das Original

I Sublisten sind echte Kopien

I daher ist l[:] eine echte Kopie von l


Shallow copies 2 – Listenelemente

>>> elementliste=[]

>>> liste = [ elementliste, elementliste ]

>>> liste[0].append("Hallo")

>>> print (liste)

[[’Hallo’], [’Hallo’]]

Mit echten Kopien (deep copies)

>>> liste = [ elementliste[:], elementliste[:] ]

>>> liste[0].append("Welt")

>>> print (liste)

[[’Hallo’, ’Welt’], [’Hallo’]]

I komplexe Listenelemente sind flache Kopienund konnen daher mehrmals auf dieselben Daten verweisen

I kann zu unerwarteten Ergebnissen fuhren


Tupel: unveranderbare Listen

>>> kaufen = ("Muesli", "Kaese", "Milch")

>>> print (kaufen[1])

Kaese

>>> for f in kaufen[:2]: print (f)

Muesli

Kaese

>>> kaufen[1] = "Camembert"

TypeError: ’tuple’ object does not support item assignment

>>> print (k + k)

(’Muesli’, ’Kaese’, ’Milch’, ’Muesli’, ’Kaese’, ’Milch’)

I komma-getrennt in runden Klammern

I konnen nicht verandert werden

I ansonsten wie Listen einsetzbar

I Strings sind Tupel von Zeichen


Dictionaries

>>> de_en = { "Milch": "milk", "Mehl": "flour" }

>>> print (de_en)

{’Mehl’: ’flour’, ’Milch’: ’milk’}

>>> de_en["Oel"]="oil"

>>> for de in de_en: print (de, "=>", de_en[de])

Mehl => flour

Milch => milk

Oel => oil

>>> for de, en in de_en.iteritems(): (print de, "=>", en)

>>> if "Mehl" in de_en: (print "Kann \"Mehl\" uebersetzen")

I komma-getrennt in geschweiften Klammern

I speichert Paare von Schlusseln (Keys) und Werten

I Speicher-Reihenfolge der Werte ist nicht festgelegt

I daher Indizierung uber die Keys, nicht Listenindex o.a.

I mit in kann nach Schlusseln gesucht werden


Objekte in Python

>>> original = list()

>>> original.append(3)


>>> kopie = list(original)


>>> original.sort()

>>> print (original, kopie)

[1, 2, 3], [3, 2]

I In Python konnen komplexe Datentypen wie Objekte im Sinne derobjekt-orientierten Programmierung verwendet werden

I Datentypen entsprechen Klassen (hier list)

I Variablen entsprechen Objekten (hier original und kopie )

I Objekte werden durch durch Aufruf von Klasse() erzeugt

I Methoden eines Objekts werden in der Form Objekt.Methode() aufgerufen(hier list. append () und list.sort())

I help(Klasse/Datentyp) informiert uber vorhandene Methoden

I Per class kann man selber Klassen erstellen


Stringmethoden

I Zeichenkette in Zeichenkette suchen"Hallo Welt".find("Welt") → 6

"Hallo Welt".find("Mond") → -1

I Zeichenkette in Zeichenkette ersetzen" abcdabcabe ". replace ("abc", "123") → ’123 d123abe ’

I Groß-/Kleinschreibung andern"hallo ". capitalize () → ’Hallo ’

"Hallo Welt".upper () → ’HALLO WELT’

"Hallo Welt".lower () → ’hallo welt’

I in eine Liste zerlegen"1, 2, 3, 4".split (",") → [’1’, ’ 2’, ’ 3’, ’ 4’]

I zuschneiden" Hallo ".strip () → ’Hallo ’

".. Hallo ..". lstrip (".") → ’Hallo ..’


Fehlermeldungen: raise

def loesungen_der_quad_gln(a, b, c):

"loest a x^2 + b x + c = 0"

det = (0.5*b/a)**2 - c

if det < 0: raise Exception("Es gibt keine Loesung!")

return (-0.5*b/a + det**0.5, -0.5*b/a - det**0.5)

try:

loesungen_der_quad_gln(1,0,1)

except:

print ("es gibt keine Loesung, versuch was anderes!")

I raise Exception (" Meldung ") wirft eine Ausnahme (Exception)

I Funktionen werden nacheinander an der aktuellen Stelle beendet

I mit try: ... except : ... lassen sich Fehler abfangen,dann geht es im except -Block weiter


Das sys-Modul

stellt Informationen uber Python und das laufende Programm selber zurVerfugung.

I sys.argv : Kommandozeilenparameter,sys.argv [0] ist der Programmname

I sys.path : Liste der Verzeichnisse, in denen Python Module sucht

I sys.exit(" Fehlermeldung "): bricht das Programm ab

I sys. stdin ,sys. stdout ,sys. stderr : Dateiobjekte fur Standard-Ein-/Ausgabe

zeile = sys.stdin.readline()

sys.stdout.write("gerade eingegeben: %s" % zeile)

sys.stderr.write("Meldung auf der Fehlerausgabe")


Parameter: das optparse-Modul

from optparse import OptionParser

parser = OptionParser()

parser.add_option("-f", "--file", dest="filename",

help="Ausgabe in FILE", metavar="FILE")

parser.add_option("-q", "--quiet", dest="verbose",

action="store_false", default=True,

help="So wenige wie moeglich Ausgaben")

(options, args) = parser.parse_args()

I optparse liest Kommandozeilenparameter wie unter UNIX ublich

I liefert ein Objekt (hier options ) mit allen Argumenten

I und eine Liste (args) mit den verbliebenen Argumente

I Bei Aufruf python parse.py -f test a b c ist:I options . filename = "test"I options . verbose = True , da Standardwert (default)I args = [’a’, ’b’, ’c’]


BS-Abstraktion: das os-Modul

import os

import os.path

dir = os.path.dirname(file)

name = os.path.basename(file)

altdir = os.path.join(dir, "alt")

if not os.path.isdir(altdir):

if os.path.exists(altdir):

raise Exception("\"alt\" kein Verzeichnis")

else: os.mkdir(altdir)

os.rename(file, os.path.join(altdir, name))

I betriebssystemunabhangige Pfadtools im Untermodul os.path : z.B.dirname , basename , join , exists , isdir

I os. system : Programme wie von der Shell aufrufen

I os. rename /os. remove : Dateien umbenennen / loschen

I os.mkdir /os. rmdir : erzeugen / entfernen von Verzeichnissen

I os.fork : Skript ab dieser Stelle zweimal ausfuhren


Documents

Computerphysik WS 2015/2016 - physik.fu-berlin.de · I Skriptsprache u.a. f ur Blender, Cinema 4D, GIMP, OpenO ce.org, PyMOL I Laufzeitkritische Skripts lassen sich relativ einfach