Python

aktuelle Version: Python 3.4

Hier soll es hingehen: Auswertung von Praktikumsversuchen:

Plot

Fortgeschrittenen Praktikum, Lebensdauer kosmischer Myonen

Python

Eine Programmiersprache wie Python lässt sich nicht an einem Tag lernen.

Hier geben wir einen kurzen Überblick über die wichtigsten Konzepte.

Keine Angst: Zum Erstellen von Plots und für einfache Auswertungen muss man nicht viel Python können!

Einfachstes Beispiel

print('Hello, World!')

Hello, World!

Zum Vergleich: C++

#include <iostream>

int main(int argc, char *argv[])
{
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Einfache Datentypen

Python stellt bereit:

Booleans: True, False
Ganze Zahlen (Integer): 42
Floating-Point-Zahlen: 3.14
Strings (Zeichenketten, Textausschnitte): 'Test' oder "Test"
Listen: [1, 2, 3]
Dictionaries: { 'eins': 1, 'zwei': 2, 'drei': 3 }
Tupel: ('test', 1)

Python ist eine dymanisch typisierte Sprache, das heißt, es werden Variablen automatisch Typen zugewiesen. Welchen Typ eine Variable gerade habt erfahrt ihr mit:

type(True), type(1), type(1.0), type([1,2,3])

(bool, int, float, list)

Kommentare

Sehr wichtig für die Leute, die mit euch Arbeiten und für euch zwei Wochen später, sind Kommentare, die erklären, was euer Code tut. Alles was in Python hinter einem # steht, wird nicht als Code betrachtet und dient als Kommentar.

# this just prints "hello World" on the console
print("Hello, World!")

Hello, World!

Variablen

Man kann einem Objekt einen Namen geben:

a = 2
b = 3

a + b

5

# Eine Liste:
namen = ['foo', 'bar', 'baz']

namen[1]

'bar'

# Ein Dictionary:
zahlen = { 'eins': 1, 'zwei': 2, 'drei': 3 }

zahlen['zwei']

2

Dictionarys sind extrem hilfreich, zum Beispiel um die gleiche Analyse für verschiedene Datensätze durchzuführen:

data = {"Cu":[1.1, 1.2, 1.3, 1.4], "Fe":[0.7, 0.8, 0.9, 1.0]}
data["Cu"]

[1.1, 1.2, 1.3, 1.4]

Variablennamen können auch überschrieben werden:

a = 42
b = a

a = 0
b

42

Rechenoperatoren

Es gibt:

+, -, *
** (Potenzieren: 2**3 → 8)
/ (3 / 2 → 1.5)
// (3 // 2 → 1)
% (Modulo-Operation, Divisionsrest)

Listen werden mit + zusammengeführt:

[1, 2, 3] + [4, 5]

[1, 2, 3, 4, 5]

Vergleichsoperatoren

geben True oder False zurück

==, !=
>, <, >=, <=

'Test' == 42

False

Logische Operatoren

and, or, not, in

True or False
# True and False
# False and False

True

weekdays = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
"Mo" in weekdays

True

Funktionen aufrufen

Mit Funktionen lässt sich Code leicht wiederverwenden. Eine Funktion nimmt Parameter, verarbeitet sie und gibt Ergebnisse zurück.

print('Hello!')

Hello!

len([1, 2, 3, 4, 5])

5

Viele Funktionen haben mehrere Parameter, einige können sogar beliebig viele haben:

print(1, 2, 3, 4, 5)

1 2 3 4 5

Viele Funktionen haben optionale Parameter mit eigenem Namen, sogenannte "keyword arguments":

print(1, 2, 3, sep=', ')

1, 2, 3

Objekte haben auch Funktionen (nennt man Methoden):

'foo bar baz'.split()

['foo', 'bar', 'baz']

s = 'test'
s.upper()

'TEST'

In IPython kann man wie folgt auf die Dokumentation einer Funktion zugreifen:

#print?

Ansonsten findet man ausführliche Erklärungen in der offiziellen Dokumentation.

Kontrollstrukturen

Die Zeilen eines Python-Programms werden nacheinander ausgeführt.

Sogennante Kontrollstrukturen erlauben es, den Ablauf zu steuern.

if/elif/else: Je nach Bedingung unterschiedliche Befehle ausführen

a = 3

if a == 1:
    # muss eingerückt werden, 4 spaces:
    print('foo')
elif a == 2:
    print('bar')
else:
    print('baz')

baz

while-Schleifen: Wiederholen, solange ein bestimmter Ausdruck erfüllt ist.

i = 0
while i < 5:
    print(i)
    i += 1

for-Schleifen: Wiederholen für jedes Element (z.B. einer Liste)

data = [10, 42, -1]

for x in data:
    # Wir können auf das jetztige Element als "x" zugreifen
    print(2 * x)

20
84
-2

for i in range(5):
    print(i)

for i in range(2, 5):
    print(i)

2
3
4

for i in range(10, 3, -1):
    print(i)

10
9
8
7
6
5
4

for day in weekdays:
    print("Heute ist", day)

Heute ist Mo
Heute ist Di
Heute ist Mi
Heute ist Do
Heute ist Fr
Heute ist Sa
Heute ist So

Zwei sehr nützliche Funktionen sind enumerate und zip

for i, day in enumerate(weekdays):
    print(day, " ist der ", i+1, ". Tag der Woche", sep="")

Mo ist der 1. Tag der Woche
Di ist der 2. Tag der Woche
Mi ist der 3. Tag der Woche
Do ist der 4. Tag der Woche
Fr ist der 5. Tag der Woche
Sa ist der 6. Tag der Woche
So ist der 7. Tag der Woche

english = ["foot", "ball", "goal"]
deutsch = ["Fuß", "Ball", "Tor"]

for a, b in zip(english, deutsch):
    print(a, b)

foot Fuß
ball Ball
goal Tor

Eigene Funktionen definieren mit `def`

Bevor man eine Funktion verwenden kann, muss sie erst definiert werden. Das wird wie folgt gemacht. Mit dem Keyword return kann man die Funktion beenden und Ergebnisse zurückgeben.

def add(x, y):
    z = x + y
    return z

add(2, 2)

4

Man kann auch mehrere Werte zurückgeben:

def divide(x, y):
    return x // y, x % y

n, rest = divide(5, 3)
print(n)
print(rest)

1
2

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

factorial(4)

24

Module und `import`

In Python kann man Programme in einzelne Module portionieren.

Es stehen bereits unglaublich viele Module für Python zur Verfügung. Gerade fürs wissenschaftliche Arbeiten ist eigentlich alles da was man braucht und noch viel mehr. Braucht man etwas aus einem anderen Modul, importiert man es:

import os

os.listdir()

['muon_plot.py',
 'example_data.txt',
 'Python.ipynb',
 'test.txt',
 'muon_data.txt',
 '.gitignore',
 'muon_plot.png',
 'Matplotlib.ipynb',
 'example2.txt',
 'plot.pdf',
 'ScientificPython.ipynb',
 'matplotlibrc',
 'uncertainties.ipynb',
 'README.md',
 'test_T.txt',
 'build',
 '.ipynb_checkpoints']

Man kann auch nur einzelne Funktionen importieren:

from os.path import join
outputpath = "Plots"
join(outputpath, "fig1.pdf")

'Plots/fig1.pdf'

from module import * importiert jede Funktion eines Moduls. Sollte auf Grund von möglichen Mehrfachbelegungen nicht in größeren Programmen verwendet werden

from os.path import *
outputpath = "Plots"
if exists(outputpath):
    print("Plots exists!")

Den Modulen können mit as neue Namen gegeben werden

import os.path as pa

pa.join(outputpath, "fig1.pdf")

'Plots/fig1.pdf'

Auslagern in Python-Dateien

Python-Dateien haben die Endung .py
Startet man mit python programm.py
Einzelne Python-Dateien (Endung .py) kann man als Module benutzen. Liegt eine Datei test.py im selben Ordner, so kann man import test ausführen.

Es folgt ein fertiges Python-Programm.

Speichert es als primes.py ab und startet es aus dem Terminal mit python primes.py.

def primes(max_num):
    # Es werden nur Primzahlen kleiner max_num berechnet
    is_prime = max_num * [True]
    is_prime[0] = False
    is_prime[1] = False

    primes = []

    # Sieb von Erathosthenes:
    for i in range(2, max_num):
        if is_prime[i]:
            for j in range(2 * i, max_num, i):
                # Alle Vielfachen sind keine Primzahl
                is_prime[j] = False
            primes.append(i)
    
    return primes

print(primes(100))

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Besonderheiten bei Strings

Mit \ kann man in Strings besondere Anweisungen setzen:

'\n' -> Zeilenumbruch
'\t' -> Tab
'\\' -> normales '\'

Wenn man viele '\' schreiben muss (z.B. in LaTeX-Code), lohnt es sich diese Funktion mit dem Prefix r auszuschalten:

print(r'\Huge\texttt{Python}')

\Huge\texttt{Python}

Oft will man Werte oder andere Strings in einen String einsetzen.

Dafür stellt Python die mächtige format()-Methode bereit:

'Erster Wert: {}, Zweiter Wert: {}'.format(42, 0)

'Erster Wert: 42, Zweiter Wert: 0'

Die {}-Markierungen werden durch die Parameter von format() ersetzt.

format() hat viele fortgeschrittene Funktionen:

'Das Ergebnis ist {:.2f}'.format(3.2291421)

'Das Ergebnis ist 3.23'

Ausführliche Beispiele zur Benutzung von Format findet man z.B. in der offiziellen Dokumentation:

https://docs.python.org/3.1/library/string.html#format-examples

Mit Python 3 kann man standardmäßig beliebige (Unicode-)Schriftzeichen in Strings verwenden (Umlaute!).

print('Hällo, Wörld!')

Hällo, Wörld!

Python

Einfachstes Beispiel

Einfache Datentypen

Kommentare

Variablen

Rechenoperatoren

Vergleichsoperatoren

Logische Operatoren

Funktionen aufrufen

Kontrollstrukturen

Eigene Funktionen definieren mit def

Module und import

Auslagern in Python-Dateien

Besonderheiten bei Strings

Weiterführende Links:

Eigene Funktionen definieren mit `def`

Module und `import`