Programmieren in Python - Grundlagen

Programmieren in Python - Grundlagen
Klaus Rheinberger
2017
Inhaltsverzeichnis
Vorwort
1 Installation
1.1 Anaconda . . .
1.2 Pakete . . . . .
1.3 Updates . . . .
1.4 Zusatzsoftware
2
.
.
.
.
3
3
4
4
4
2 Hilfe
2.1 Links . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Python Cheat Sheet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
4
5
3 Jupyter Notebooks
3.1 Starten . . . . . . . . . . . . . . .
3.2 Beenden . . . . . . . . . . . . . . .
3.3 Zellen . . . . . . . . . . . . . . . .
3.4 Exportieren . . . . . . . . . . . . .
3.5 Navigationsbefehle im Dateisystem
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
5
6
7
7
4 Datentypen
4.1 Überblick über Standardtypen
4.2 Boolean . . . . . . . . . . . . .
4.3 Numeric Types . . . . . . . . .
4.4 Sequences . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
8
8
9
5 Matrizenrechnung
5.1 Vektoralgebra: 1-dimensionale arrays . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Matrixalgebra: 2-dimensionale arrays . . . . . . . . . . . . . . . . . . . . . . . . .
11
12
13
6 Grafiken
6.1 Passive Grafiken: matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Interaktive Grafiken: ipywidgets . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
15
17
7 Funktionen
7.1 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Beispiel 1: Hello . . . ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.3 Beispiel 2: Fahrzeug auf ebener Fahrbahn . . . . . . . . . . . . . . . . . . . . . .
17
17
17
17
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8 Kontrollstrukturen
8.1 if else Abfrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 for Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3 while Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
19
20
21
9 Daten-IO
9.1 NumPy Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2 Pickle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
22
23
10 Literatur und Links
10.1 Leitfaden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2 Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
24
24
Vorwort
Folgende Lehrveranstaltungen im Masterstudiengang Energietechnik und Energiewirtschaft
verwenden die Programmiersprache Python zusammen mit ausgewählten Paketen (insbesondere
SciPy) und der webbasierten Oberfläche Jupyter:
•
•
•
•
•
Angewandte Mathematik
Aufbaukurs
Data Science
Erneuerbare Energien
Technische Mathematik
In Masterarbeiten wird Python ebenfalls oft verwendet.
Python:
Python ist eine leicht zu erlernende, effiziente Programmiersprache, die folgende weitere Vorteile
bietet:
• plattformunabhängig: Python-Programme laufen unter Linux, Windows und Mac OS, BSD
etc.
• frei erhältlich: siehe z. B. Python Software Foundation License FAQ
• weit verbreitet: Es gibt sehr viele Tutorials, Videos, Foren, Bücher etc.
• viele Pakete: Der Python Package Index umfasst derzeit (2017-09-06) 116307 Pakete. “Es
gibt kaum etwas, das man mit Python nicht bauen könnte - solange es Software ist natürlich.”
(Zitat Franz Geiger, FHV)
Der Name bezieht sich übrigens auf die englische Komikergruppe Monty Python.
SciPy:
SciPy umfasst die Pakete
• NumPy: Matrizenrechnung, lineare Algebra
• SciPy library: Integralrechnung, Optimierung, Interpolation, Fourier, Signalanalyse, lineare
Algebra, Statistik, Bilderverarbeitung
• Matplotlib: 2D-Grafiken
• IPython: interaktives Programmieren mit Python
• Sympy: symbolische Mathematik (im Gegensatz zu numerischer Mathematik)
• Pandas: Datenanalyse
2
SciPy stellt dadurch eine attraktive Alternative zu kommerziellen Produkten wie Matlab und
Mathematica dar.
Jupyter:
Jupyter ist eine Webapplikation, die das Arbeiten mit sogenannten Jupyter Notebooks ermöglicht.
In Jupyter Notebooks können Sie neben Code (nicht nur Python) auch formatierten Text, Links,
Bilder, Videos und interaktive Widgets generieren, laufen lassen und exportieren.
Neben der modernen Jupyter-Umgebung kann man Python auch im klassichen Interface “Editor
+ Command Line” verwenden, z. B. mit Spyder.
Inhalte:
Grundlagen:
•
•
•
•
•
•
•
•
Installation und Hilfe
Juypter Notebooks
Datentypen
Matrizenrechnung
Grafiken
Funktionen
Kontrollstrukturen
Daten-IO
Vertiefende Themen:
• Lineare Optimierung
• Datenmanagement mit Pandas
zusätzliche Unterlagen: Auf der Webseite finden Sie zusätzliche Unterlagen: Abbildungen,
Daten, Code.
Notation:
• Als Dezimaltrennzeichen wird der englische Punkt statt dem deutschen Komma verwendet, da dies auch in der verwendeten Programmiersprache der Fall ist und zu keinen
Verwechslungen mit Kommas bei der Angabe von Vektoren und Intervallen führt.
• Python-Code ist wie folgt formatiert:
r = sqrt(t)
phi = pi*t
1 Installation
1.1 Anaconda
Es gibt einige Möglichkeiten, Python und Python-Pakete zu installieren. Wir verwenden die
Python-Distribution Anaconda. Laden Sie unter www.anaconda.com/download Anaconda für
Ihre Plattform (Linux, Mac, Windows) die Python-Version >=3.6 herunter, und installieren Sie
diese wie in der Installationshilfe angegeben.
3
1.2 Pakete
Zusätzliche (zu den bereits mitinstallierten) Pakete können Sie mit Anaconda in einem SystemTerminal oder dem Anaconda Command Prompt (=Anaconda-Kommandozeile) mit dem Befehl
conda install <Paketname>
installieren, wobei <Paketname> durch den Namen des Pakets zu ersetzen ist. Alternativ können
Sie die Anaconda Navigator Oberfläche verwenden.
Eine Auflistung aller Python Pakete finden Sie im Python Package Index.
1.3 Updates
Sie können die in Anaconda installierten Pakete in einem System-Terminal oder auf der AnacondaKommandozeile mit dem Befehl
conda update --all
updaten. Alternativ können Sie die Anaconda Navigator Oberfläche verwenden.
1.4 Zusatzsoftware
Zum Konvertieren von Jupyter Notebooks zu pdf-Dateien müssen auf Ihrem Computer
• eine TeX-Distribution, z. B. TeX Live, und
• Pandoc
installiert sein.
2 Hilfe
2.1 Links
Im Internet finden Sie viele Unterlagen. Die folgende Liste ist nur eine kleine und persönliche
Auswahl:
•
•
•
•
•
•
•
•
•
•
•
A Crash Course in Python for Scientists
SciPy Lecture Notes
Notebook Gallery
www.tutorialspoint.com/python
PythonLearn: textbook, exercises, code, videos etc.
video2brain: Python 3 - Grundlagen: Zugang via FHV-Login
Zur Formatierung der Markdown-Zellen im Jupyter-Notebook: Markdown-Cheatsheet
NumPy for Matlab users
IPython
Jupyter
Jupyter Docs
4
2.2 Python Cheat Sheet
Da man sich nicht alle Befehle merken kann oder will, gibt es zu Programmiersprachen oft
sogenannte cheat sheets. Für unsere Zwecke enthält das folgende Python Cheat Sheet einige oft
gebrauchte Befehle: python_cheat_sheet_v3.pdf
3 Jupyter Notebooks
3.1 Starten
Unter Windows und Mac können Sie Jupyter Notebook aus dem Start-Menü oder dem
Anaconda Navigator starten. Ein Notebook Server startet anschließend in einem neu geöffneten
System-Terminal.
Auf allen Betriebssystemen können Sie im Anaconda Command Prompt oder einem SystemTerminal den Befehl
jupyter notebook
direkt zum Start eines Notebook Servers verwenden.
Ihr Default-Browser öffnet sich, falls er nicht schon geöffnet war, und das Jupyter-Dashboard
erscheint in einem neuen Browser-Tab. Sie können nun z.B.
•
•
•
•
•
•
das Arbeitsverzeichnis ändern
neue Notebooks erstellen und starten
Notebooks herunterfahren
Ordner erstellen und löschen
Textdateien editieren
Dateien löschen
Achtung: Verwenden Sie generell für Ordner- und und Dateinamen keine Umlaute, keine
Sonderzeichen und keine Leerzeichen!
Wenn Sie ein (neues) IPython-Notebook - das ist eine ipynb-Datei - starten, öffnet sich ein neuer
Tab und ein IPython-Kernel wird gestartet. Der Kernel führt Ihre Befehle aus und beeinhaltet
alle verwendeten Objekte (Variablen, Funktionen, Pakete etc.).
Starten Sie zum Einstieg unter dem Menüeintrag Help die User Interface Tour.
3.2 Beenden
Um Ihre Arbeit in einem Notebook zu beenden,
1. speichern Sie zuerst das Notebook mit Strg-S oder dem Save-Icon in der Toolbar und
2. verwenden Sie danach unter File den Befehl Close and Halt. Dadurch werden
• der Kernel heruntergefahren und somit alle Variablenwerte gelöscht
• der Browser-Tab geschlossen.
Achtung: Sollten Sie den Tab des Notebooks ohne Close and Halt geschlossen haben, dann
läuft der Kernel weiter, und Sie können im Jupyter-Dashboard das Notebook durch Anklicken
wieder in einem Tab öffnen oder im Reiter Running des Jupyter-Dashboards den noch laufenden
den Kernel herunterfahren.
5
Um das Jupyter-Dashboard zu beenden, drücken Sie Strg-C zweimal im anfangs geöffneten
System-Terminal.
3.3 Zellen
Das Notebook besteht aus einer Liste von Zellen (engl. cells).
Modi: Zellen können im Command Mode (blau umrandet) oder im Edit Mode (grün umrandet)
bearbeitet werden.
Bearbeiten: Über die Menüeinträge Edit, Insert, Cell und über die Toolbar können Sie Zellen
ausführen, verschieben, zusammenfügen, splitten, löschen etc.
Tastenkürzel: Im Menüeintrag Help finden Sie unter Keyboard shortcuts eine Liste von vielen
Tastenkürzeln, deren Verwendung Ihre Arbeit sehr beschleunigen können!
Die wichtigsten zwei Zelltypen sind Code und Markdown. Sie können den Typ einer Zelle über
die Toolbar oder ein Tastenkürzel ändern.
Code-Zellen: Hier können Sie
•
•
•
•
•
Variablen definieren
Pakete importieren
deren Funktionen(=Befehle) aufrufen
neue Funktionen definieren
weitere Programmierstrukturen verwenden: for-Schleifen, if-Abfragen etc.
Code-Kommentare beginnen mit dem Rautezeichen #.
Der letzte Befehl einer Code-Zelle wird in einem folgenden Output-Zelle ausgegeben. Sie können
die Ausgabe mit einem Strichpunkt am Ende des letzten Befehls unterdrücken.
Funktionen haben immer runde Klammern! Hilfe z. B. zur Funktion print erhalten Sie durch
• help(print) oder
• print? oder
• (öfter) SHIFT-Enter drücken, wenn der Cursor nach der ersten runden Klammer steht.
Variablen: Eine Liste der von Ihnen definierten Variablen erhalten Sie mit dem magic command
%whos. Löschen einzelner Variablen, hier z. B. der Variable x, erfolgt mit dem Befehl del(x).
Löschen aller selber definierten Variablen erfolgt mit dem Befehl %reset -s
Das Importieren der Numpy und Matplotlib Befehle erfolgt z. B. mit dem magic command %pylab
inline. Als optionalen Parameter kann man inline angeben, sodass Abbildungen im Notebook
und nicht in einem eigenen Fenster dargestellt werden.
Tipp: Tabulator-Vervollständigung verwenden!
Markdown-Zellen: Markdown ist eine vereinfachte Auszeichnungssprache, die bereits in der
Ausgangsform ohne weitere Konvertierung leicht lesbar ist. Sie können in Markdown sehr leicht
folgenden strukturierten Text erstellen:
•
•
•
•
•
Überschirften: Rautesymbol(e) vor der Überschrift
Listen: mit Minus- oder Pluszeichen
Links: z. B. ETW, Syntax [Name](URL)
Bilder: mit Syntax ![Name](Pfad-zu-Bilddatei)
2
Mathematische Formeln via LaTeX, z. B. K = mv
2
Tipp: Cheatsheet
6
3.4 Exportieren
Sie könne Notebooks über den Menüeintrag File/Download as oder über Systembefehle in
andere Dateiformate exportieren. Systembefehle können Sie auf folgende Weisen ausführen:
• in einem System-Terminal
• im Anaconda Command Prompt
• in einer Codezelle, wenn Sie ein Rufezeichen vor den Systembefehl setzen.
HTML: Systembefehl !jupyter-nbconvert Mein_Notebook.ipynb
PDF: Zur Konvertierung von Jupyter-Notebook zu pdf müssen eine TeX-Distribution, z.
B. TeX Live, und Pandoc installiert sein. Systembefehl: jupyter-nbconvert --to pdf
Mein_Notebook.ipynb
LaTeX: Systembefehl jupyter-nbconvert --to latex Mein_Notebook.ipynb
Python-Script: Systembefehl jupyter-nbconvert --to script Mein_Notebook.ipynb
Slides: inkl. Präsentation via Webserver. Bevor Sie den Systembefehl jupyter-nbconvert --to
slides --post serve Mein_Notebook.ipynb in einem System-Terminal oder im Anaconda
Command Prompt aufrufen, müssen Sie zuerst in der Toolbar unter Cell Toolbar die Option
Slideshow einstellen und anschließend Ihre Zellen zu Slides, Sub-Slides, Fragements, Skip oder
Notes definieren. Beenden Sie den gestarteten Webserver nach der Präsentation durch Strg-C
im Terminal bzw. im Anaconda Command Prompt.
Link: nbconvert.readthedocs.io/en/latest/usage.html
3.5 Navigationsbefehle im Dateisystem
Für die Arbeit in einem System-Terminal, dem Anaconda Command Prompt oder in einer Codezelle
sind oft folgende Navigationsbefehle nützlich:
•
•
•
•
pwd: print working/current directory
ls oder dir: list files in current directory
cd DIR: change into absolute or relative directory DIR
cd ..: change to parent directory
4 Datentypen
In Python stehen Ihnen, wie auch in anderen Programmiersprachen, für unterschiedliche Zwecke
entsprechende Datentypen zur Verfügung. Jedes Objekt ist von einem bestimmten (Daten)Typ.
4.1 Überblick über Standardtypen
Wir verwenden die englischen Namen der Standardtypen, da Sie diese auch so in der (interaktiven)
Hilfe und beim Suchen im Internet finden.
• Boolean: die logischen Wahrheitswerte True und False
• Numeric Types: Integers (ganze, auch negative Zahlen), Floats (Dezimalzahlen), komplexe Zahlen
• Sequences: Lists (Listen von anderen Daten), Tuples (unveränderbare Listen), Strings
(Wörter inkl. Leerzeichen, Zeilenumbruch und Sonderzeichen)
7
•
•
•
•
Sets: Mengen
Dictionaries: Schlüssel-Objekt-Paare wie z. B. {“AT”: 1, “CH”:2, “DE”:3}
Functions: Input zu Output Transformationen
...
Link: Python standard types documentation
4.2 Boolean
Eine Abfrage über größer (gleich), (un)gleich oder kleiner (gleich) liefert als Ergebnis ein Objekt
vom Typ Boolean:
3 > 2 # greater
True
3 > 3
False
3 >= 3 # greater or equal
True
3 == 3.0 # equal
True
42 != 42 # not equal
False
Auch Wörter (Strings, siehe weiter unten) können verglcihen werden:
"Emil" == "emil"
False
Von welchem Typ ein Objejekt ist, können Sie mit der eingebauten Funktion type bestimmen:
type(True)
bool
4.3 Numeric Types
Ganze Zahlen: . . . , -3, -2, -1, 0, 1, 2, 3, . . . sind vom Typ int.
n = 12
type(n)
int
Fließkommazahlen (=Dezimalzahlen) sind von Typ float.
x = 12.3
type(x)
float
Komplexe Zahlen bestehen aus einen Realteil (int oder float) und einem Imaginärteil. Die
imaginäre Einheit wird mit j geschrieben und ohne Malzeichen * an den Imaginärteil multipliziert.
8
z = 12.4 + 3.7j
type(z)
complex
Rechenoperationen:
x + 2*n
36.3
x - z
(-0.09999999999999964-3.7j)
12/5
2.4
vgl. Modulo-Rechnung
12//5
2
Achtung: Potenzieren mit ** und nicht mit ˆ
x**2
151.29000000000002
4.4 Sequences
• können Daten unterschiedlichen Typs enthalten
• haben geordnete Elemente, Indizierung:
–
–
–
–
mit eckigen Klammern
beginnend bei 0
von Index a inklusive bis b exklusive mit a:b
der letzte Eintrag hat den Index -1, der vorletzte Eintrag hat den Index -2, . . .
Lists:
• verwenden eckige Klammern
• sind veränderbar
numbers = [12, 12.3, 5, -8, 23]
numbers
[12, 12.3, 5, -8, 23]
type(numbers)
list
len(numbers) # Länge = Anzahl an Elementen
5
numbers[0] # erstes Element
12
9
numbers[-1] # letztes Element
23
# erstes Element neu setzen:
numbers[0] = 10
numbers
[10, 12.3, 5, -8, 23]
Slicing: nicht nur einzelne Elemente, sondern ganze Unterlisten “herausschneiden”
numbers[2:4]
[5, -8]
Achtung: Oben wars das Element mit Index 2 (das dritte Element) inklusive und das Element
mit Index 4 (das fünfte Element) exklusive!
numbers[1:] # open end
[12.3, 5, -8, 23]
numbers[:3] # beginning from start
[10, 12.3, 5]
Anfügen ans Ende der Liste:
numbers.append(-3)
numbers
[10, 12.3, 5, -8, 23, -3]
Sortieren:
numbers.sort() # aufsteigend sortieren, mit Option reverse=True absteigend
numbers
[-8, -3, 5, 10, 12.3, 23]
Achtung: + und * bewirken Aneinanderkettung
numbers + numbers
[-8, -3, 5, 10, 12.3, 23, -8, -3, 5, 10, 12.3, 23]
3*numbers
[-8, -3, 5, 10, 12.3, 23, -8, -3, 5, 10, 12.3, 23, -8, -3, 5, 10, 12.3, 23]
Sie können überprüfen, ob ein Objekt in einer Liste vorkommt.
7 in [2, 3, 4, 5, 6, 7, 8, 9, 7]
# incuded in
True
Tipp: list comprehension
[x**2 for x in numbers if x > 0]
[25, 100, 151.29000000000002, 529]
Tuples:
• verwenden runde Klammern
10
• sind nicht veränderbar
t = (3, 2, 5)
type(t)
tuple
# results in TypeError: 'tuple' object does not support item assignment
# t[1] = 10
Strings:
Wörter, Buchstaben und Wortketten, inkl. Sonderzeichen
• einfache oder doppelte Anführungszeichen, dieselben zu Beginn und am Ende
• veränderbar
• Zeilenumbruch mit \n
s1 = 'Hello \n'
s2 = "World!"
s1 + s2
'Hello \nWorld!'
print(s1 + s2)
Hello
World!
Formatierte Ausgabe:
n = 12
print("Die Wurzel aus {:d} ist circa {:8.5f}".format(n, n**0.5))
# Variante:
print("Die Wurzel aus %d ist circa %8.5f" %(n, n**0.5))
Die Wurzel aus 12 ist circa
Die Wurzel aus 12 ist circa
3.46410
3.46410
5 Matrizenrechnung
Um mit Vektoren und Matrizen nach den Regeln der Mathemaik zu arbeiten, gibt es das Paket
NumPy. das den Datentyp numpy.ndarray, kurz array, bereitstellt:
• Die Indizierung erfolgt analog zu Sequences
• Import: Wir imporieren die NumPy-Funktionen in den Haupt-Namespace mit %pylab
inline. Oft wird NumPy auch als Namespace np durch import numpy as np importiert,
um den Haupt-Namespace nicht zu überladen.
%pylab inline
%config InlineBackend.figure_format = 'svg'
import seaborn as sns
Populating the interactive namespace from numpy and matplotlib
11
5.1 Vektoralgebra: 1-dimensionale arrays
• nur eine Klammerung, z. B. beim Inputs der array-Funktion und bei der Indizierung
• Achtung: keine Unterscheidung in Spalten- oder Zeilenvektoren!
v = array([3, 2.1, -5])
v
array([ 3. ,
2.1, -5. ])
type(v)
numpy.ndarray
# Vektoren sind 1-dimensional
ndim(v)
1
Die Anzahl der Elemente wird als Länge (engl. length) bezeichnet. Achtung, das ist nicht die
geometrische Länge des Vektors!
len(v)
3
Viele Funktionen lassen sich alternativ als Methoden der Objekte mit Punkt-Notation aufrufen:
print(v.dtype) # data type: Type der Einträge
print(v.ndim)
print(v.mean())
float64
1
0.0333333333333
Rechnoperationen: Achtung! +, -, *, ** und / sind nun elementweise Operationen.
3*v # Skalarmultiplikation
array([
9. ,
6.3, -15. ])
v + v # Vektoraddition
array([
6. ,
4.2, -10. ])
Das innere Produkt wird im Englischen oft “dot product” genannt.
dot(v, v)
38.409999999999997
# alternativ mit dem @ Operator:
v@v
38.409999999999997
cross(v, v) # Kreuzprodukt
array([ 0.,
0.,
0.])
v*v # Achtung elementweise!
array([
9.
,
4.41,
25.
])
12
v/v # elementweise!
array([ 1.,
1.,
1.])
v**3 # elementweise!
array([
27.
,
9.261, -125.
])
5.2 Matrixalgebra: 2-dimensionale arrays
Zwei Dimensionen und daher auch zwei Klammeren:
• erste Dimension: wievielte Zeile = Zeilenindex
• zweite Dimension: wievielte Spalte = Spaltenindex
A = array([[1, 2, sqrt(4)],
[4, -3,
pi]])
A
array([[ 1.
[ 4.
, 2.
, -3.
,
,
2.
],
3.14159265]])
A.shape # 2x3 Matrix
(2, 3)
dot(A, v) # Matrix-Vektor-Produkt
array([ -2.8
, -10.00796327])
# alternativ mit dem @ Operator:
A@v
array([ -2.8
, -10.00796327])
dot(v[:2], A) # Vektor-Matrix-Produkt
array([ 11.4
,
-0.3
,
12.59734457])
,
12.59734457])
# alternativ mit dem @ Operator:
v[:2]@A
array([ 11.4
,
-0.3
w = array([[1, 2, 3]])
w.shape
(1, 3)
# dot(A, w) gibt einen Fehler. Warum?
w.T # Transponieren
array([[1],
[2],
[3]])
w.T.shape
(3, 1)
dot(A, w.T) # oder [email protected]
13
array([[ 11.
],
[ 7.42477796]])
Slicing:
A[:,0] # Ergebnis: 1-dim array
array([ 1.,
4.])
A[:,[0]] # Ergebnis: 2-dim array
array([[ 1.],
[ 4.]])
A = array([[3, -2],
[0, 12]])
b = array([1, 2])
# Lösen des quadratischen Gleichungssystems Ax=b
x = solve(A, b)
x # Ergebnis: 1-dim array, wie b
array([ 0.44444444,
0.16666667])
c = b.reshape(2,1)
c # 2-dim array
array([[1],
[2]])
Lösen eines Gleichungssystems:
x = solve(A, c)
x # Ergebnis: 2-dim array, wie c
array([[ 0.44444444],
[ 0.16666667]])
flattening of a 2-dim array into a 1-dim array:
A.ravel()
array([ 3, -2,
0, 12])
# vergleiche:
A
array([[ 3, -2],
[ 0, 12]])
Aufgabe:
Welche Funktionalitäten bieten folgende Befehle?
•
•
•
•
•
•
•
linspace
arange
eye
ones
zeros
diag
vstack
14
•
•
•
•
hstack
column_stack
row_stack
reshape
Experimentieren Sie mit den Befehlen!
6 Grafiken
6.1 Passive Grafiken: matplotlib
Wir werden nur zwei Beispiele in diesem Abschnitt aufzeigen. Die fast unüberschaubare Vielfalt
an grafischen Darstellungsmöglichkeiten mit dem Python-Paket Matplotlib finden Sie z. B. unter
Matplotlib Gallery
# Importieren der der Numpy und Matplotlib Befehle:
%pylab inline
Populating the interactive namespace from numpy and matplotlib
# Bilder werden im SVG-Format erstellt:
%config InlineBackend.figure_format = 'svg'
# Durch den Import des seaborn Paketes wird die Default-Darstellung von Abbildungen geändert
import seaborn as sns
Beispiel 1: 2D-Plot
Wir plotten einen Vektor x gegen einen Vektor y:
x = linspace(-1, 3, num = 11)
x
array([-1. , -0.6, -0.2,
0.2,
0.6,
1. ,
1.4,
1.8,
2.2,
2.6,
3. ])
# Typ des Objekts x:
type(x)
numpy.ndarray
%whos
Variable
Type
Data/Info
------------------------------sns
module
<module 'seaborn' from '/<...>ges/seaborn/__init__.py'>
x
ndarray
11: 11 elems, type `float64`, 88 bytes
y = -x**2 + 8
figure(figsize=(5,3))
plot(x, y, 'o-r', label='Parabel')
xlabel('Weite')
ylabel('Höhe')
ylim(-2, 10)
title('Wurfparabel')
legend(numpoints=1, loc='best')
grid(True)
15
savefig('abbildungen/Wurfparabel.pdf')
Beispiel 2: Sankey-Diagramm
Nach dem Import der Sankey Funktion erstellen wir ein Sankey-Diagramm.
from matplotlib.sankey import Sankey
fig = figure(figsize=(6,4))
ax = fig.add_subplot(1,1,1)
axis('off')
Sankey(flows=[0.25, 0.15, 0.60, -0.20, -0.15, -0.05, -0.50, -0.10], ax = ax,
labels=['', '', '', 'First', 'Second', 'Third', 'Fourth', 'Fifth'],
orientations=[-1, 1, 0, 1, 1, 1, 0, -1]).finish();
savefig('abbildungen/Sankey.pdf')
16
6.2 Interaktive Grafiken: ipywidgets
Link: ipywidgets.readthedocs.io/en/stable/
from ipywidgets import interact
x = linspace(-2, 2, num= 100)
def my_f(k):
y = k*x
plot(x, y)
ylim((-2, 2))
xlim((-2, 2))
grid(True)
show()
interact(my_f, k=(-1, 1, 0.1));
7 Funktionen
7.1 Syntax
def my_function(x, y, a = 1):
""""
Hilfetext
""" "
z = 3*x + 5*sin(y) + a
return z
7.2 Beispiel 1: Hello . . . !
def my_hello(what):
"""
returns the string "Hello" concatenated with the input string
"""
text = "Hello, " + what + "!"
return text
my_hello("world")
'Hello, world!'
7.3 Beispiel 2: Fahrzeug auf ebener Fahrbahn
Wir verwenden mit dem Befehl linspace die Datenstruktur array, um die Strömungswiderstandskraft für unterschiedliche Geschwindigkeiten zu berechnen. Auf nicht ebener Strecke kommt die
Gravitationskraft noch dazu.
Links:
• Strömungswiderstandkraft
• Rollwiderstandskraft
17
%pylab inline
Populating the interactive namespace from numpy and matplotlib
Paramterwerte:
# Massse in kg
m = 110
# Erdbeschleunigung in m/s^2
g = 9.81
# Rollwiderstandsbeiwert
cr = 0.0055
# Strömungswiderstandskoeffizient
cw = 0.076
# Bezugsfläche in m^2
A = 0.41
# verschiedene Anströmgeschwindigkeiten in m/s
v = linspace(0, 20, num=20)
Strömungswiderstandkraft:
def F_Stroemung(cw, A, v, rho = 1.2041):
"""
Strömungswiderstandskraft in Abhängigkeit von
-
Strömungswiderstandskoeffizient: cw
Bezugsfläche: A in m^2
Anströmgeschwindigkeit: v in m/s
Dichte: rho in kg/m^3, Default= 1.2041 (Luft)
ist gegeben durch
F = cw*A*1/2*rho*v**2
"""
F = cw*A*0.5*rho*v**2
return F
F_S = F_Stroemung(cw, A, v, rho = 1.2)
F_S
array([ 0.
,
0.51789474,
2.07157895,
4.66105263,
0.02071579,
0.74576842,
2.50661053,
5.30324211,
0.08286316,
1.01507368,
2.98307368,
5.98686316,
Rollwiderstandskraft:
F_R = cr*m*g
F_R
18
0.18644211,
1.32581053,
3.50096842,
6.71191579,
0.33145263,
1.67797895,
4.06029474,
7.4784
])
5.93505
figure(figsize=(5,3))
plot(v, F_S, 'b', label='Strömung')
hlines(F_R, min(v), max(v), color= 'r', label='Roll')
xlabel('Geschwindigkeit [m/s]')
ylabel('Strömungswiderstandskraft [N]')
legend(loc='best')
grid(True)
8 Kontrollstrukturen
Die wichtigsten Typen von Kontrollstrukturen sind:
• if else Abfrage
• for Schleife
• while Schleife
%pylab inline
%config InlineBackend.figure_format = 'svg'
import seaborn as sns
Populating the interactive namespace from numpy and matplotlib
8.1 if else Abfrage
Beispiel: Determinante und inverse Matrix
Falls eine Matrix eine Determinante nicht Null hat, ist sie invertierbar.
A = array([[1, 2],
[3, 4]])
print(A)
[[1 2]
[3 4]]
19
if det(A) != 0:
B = 1/det(A)*array([ [ A[1,1], -A[0,1] ],
[-A[1,0], A[0,0] ] ])
print(B)
print(inv(A))
else:
print("Matrix ist nicht invertierbar.")
[[-2.
1. ]
[ 1.5 -0.5]]
[[-2.
1. ]
[ 1.5 -0.5]]
# Probe:
dot(A, B) # oder A@B
array([[ 1.,
[ 0.,
0.],
1.]])
8.2 for Schleife
Beispiel: Arrhenius-Gleichung
Die Arrhenius-Gleichung, benannt nach Svante Arrhenius, beschreibt näherungsweise eine quantitative Temperaturabhängigkeit bei physikalischen und vor allem chemischen Prozessen, bei
denen auf molekularer Ebene eine Aktivierungsenergie überwunden werden muss. Die ArrheniusGleichung ist eine phänomenologische Beziehung und gilt für sehr viele chemische Reaktionen.
Unter anderem wird auch das Alterungsverhalten von Lithium-Ionen-Akkumulatoren damit
beschreibbar.
Die Arrhenius-Gleichung beschreibt in der chemischen Kinetik für den Spezialfall monomolekularer
Reaktionen die quantitative Abhängigkeit der Reaktionsgeschwindigkeitskonstanten k von der
Temperatur:
−EA
k = Ae RT
mit
•
•
•
•
A . . . präexponentieller oder Frequenzfaktor
EA . . . Aktivierungsenergie (Einheit: J mol−1 )
R . . . universelle Gaskonstante (8,314 J K−1 mol−1 )
T . . . absolute (thermodynamische) Temperatur (Einheit: K)
Quelle: https://de.wikipedia.org/wiki/Arrhenius-Gleichung
A = 1
EA_values = arange(10, 200, 50)
R = 8.314
T = linspace(1, 500, num = 100)
figure(figsize=(6,4))
for EA in EA_values:
k = A*exp(-EA/(R*T))
plot(T, k, label="EA = {:d} J/mol".format(EA), linewidth=2)
legend(loc='best')
xlabel('T')
20
ylabel('k')
grid(True)
8.3 while Schleife
Beispiel: Collatz-Problem
Das Collatz-Problem, auch als (3n+1)-Vermutung bezeichnet, ist ein ungelöstes mathematisches
Problem, das 1937 von Lothar Collatz gestellt wurde. Bei dem Problem geht es um Zahlenfolgen,
die nach einem einfachen Bildungsgesetz konstruiert werden:
•
•
•
•
Beginne mit irgendeiner natürlichen Zahl n > 0.
Ist n gerade, so nimm als Nächstes n/2,
Ist n ungerade, so nimm als Nächstes 3n + 1.
Wiederhole die Vorgehensweise mit der erhaltenen Zahl.
So erhält man zum Beispiel für die Startzahl n = 19 die Folge 19, 58, 29, 88, 44, 22, 11, 34, 17, 52,
26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, . . . Anscheinend mündet jede Folge mit n > 0 in den Zyklus
4, 2, 1, unabhängig davon, welche Startzahl n man probiert hat. Die Collatz-Vermutung lautet:
Jede so konstruierte Zahlenfolge mündet in den Zyklus 4, 2, 1, egal, mit welcher natürlichen Zahl
n > 0 man beginnt.
Trotz zahlreicher Anstrengungen gehört diese Vermutung noch immer zu den ungelösten Problemen der Mathematik. Mehrfach wurden Preise für eine Lösung ausgelobt.
Quelle: https://de.wikipedia.org/wiki/Collatz-Problem
n = 70
while True:
if n % 2 == 0:
n = n/2
else:
n = 3 * n + 1
# Der Modulo Operator % liefert den Rest der Division.
21
print(n)
if n == 1:
break
35.0
106.0
53.0
160.0
80.0
40.0
20.0
10.0
5.0
16.0
8.0
4.0
2.0
1.0
9 Daten-IO
Daten laden und speichern
9.1 NumPy Befehle
Link: docs.scipy.org/doc/numpy/reference/routines.io.html
%pylab inline
Populating the interactive namespace from numpy and matplotlib
Daten aus Textdatei einlesen:
A = genfromtxt('daten/AustriaW-o.csv', delimiter=",", skip_header=1)
A
array([[ 47.235154
[ 47.23515
[ 47.23451
...,
[ 47.94042
[ 47.94034
[ 47.94011
,
,
,
,
,
,
9.59921836,
9.59921
,
9.59925
,
17.06803
17.06798
17.06859
,
,
,
467.
466.
465.
],
],
],
142.
142.
140.
],
],
]])
elevation = A[:,2]
figure(figsize=(8,3))
plot(elevation)
xlabel('Datenpunkt')
ylabel('elevation')
grid(True)
22
Matrix von Zufallszahlen:
B = randn(10, 3)
B
array([[ 0.69647387,
[ 0.5511336 ,
[-0.18151827,
[-0.04850343,
[ 0.89181773,
[-0.34304204,
[-0.40687218,
[ 0.91194416,
[-0.58071868,
[ 0.58517214,
0.92849206,
0.89693122,
-0.98037619,
0.14501138,
-0.07503731,
0.61168174,
-0.37346573,
-0.4345603 ,
-0.75033516,
-1.28535455,
0.04061399],
-1.18229411],
-0.47596028],
0.88081873],
0.93466913],
-0.74506326],
-0.21545588],
0.14213569],
1.25259673],
-0.39639893]])
Speichern als CSV-Datei:
savetxt('daten/Zufallszahlenmatrix.csv', B, delimiter=',')
9.2 Pickle
Speichern und Laden von Objekten jeglichen Datentyps. Siehe z. B. wiki.python.org/moin/UsingPickle
import pickle
my_object = ['Ich', 'und', 7]
pickle.dump( my_object, open( "daten/save.p", "wb" ) )
del my_object
%whos
Variable
Type
Data/Info
-------------------------------A
ndarray
9398x3: 28194 elems, type `float64`, 225552 bytes (220.265625 kb)
B
ndarray
10x3: 30 elems, type `float64`, 240 bytes
elevation
ndarray
9398: 9398 elems, type `float64`, 75184 bytes
my_object
list
n=3
pickle
module
<module 'pickle' from '/u<...>lib/python3.6/pickle.py'>
23
my_object = pickle.load( open( "daten/save.p", "rb" ) )
my_object
['Ich', 'und', 7]
10 Literatur und Links
10.1 Leitfaden
Einführungen und Grundlagen:
• IPython Notebook Essentials (Martins 2014)
• IPython Interactive Computing and Visualization Cookbook (Rossant 2014)
• Introduction to Computation and Programming Using Python (Guttag 2013)
Fortgeschrittene Bücher und Vertiefungen:
• Numerical Python - A Practical Techniques Approach for Industry (Johansson 2015)
• Python for Data Analysis (McKinney 2012), PDF-Download im FHV-Campusnetz, deutsche
Übersetzung: Datenanalyse mit Python (McKinney 2015)
• Introduction to Machine Learning with Python: A Guide for Data Scientists (Müller; Guido 2016)
10.2 Literaturverzeichnis
Guttag, John V. (2013): Introduction to Computation and Programming Using Python. Revised
and Exp. Mit Pr, S. 296.
Johansson, Robert (2015): Numerical Python: A Practical Techniques Approach for Industry. 1st
ed. Apress, S. 512.
Martins, L. Felipe (2014): IPython Notebook Essentials. Packt Publishing, S. 190.
McKinney, Wes (2015): Datenanalyse Mit Python: Auswertung von Daten Mit Pandas, NumPy
Und IPython. 1., Auflage. O’Reilly, S. 478.
McKinney, Wes (2012): Python for Data Analysis. 1. Aufl. O’Reilly Media, S. 452.
Müller, Andreas; Guido, Sarah (2016): Introduction to Machine Learning with Python: A Guide
for Data Scientists. 1. Aufl. O’Reilly UK Ltd., S. 400.
Rossant, Cyrille (2014): IPython Interactive Computing and Visualization Cookbook. Packt
Publishing, S. 512.
24