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

In [1]:

    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:

In [2]:

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

Out[2]:

    (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.

In [3]:

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

    Hello, World!

## Variablen

- Man kann einem Objekt einen Namen geben:

In [4]:

    a = 2
    b = 3

    a + b

Out[4]:

    5

In [5]:

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

In [6]:

    namen[1]

Out[6]:

    'bar'

In [7]:

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

In [8]:

    zahlen['zwei']

Out[8]:

    2

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

In [9]:

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

Out[9]:

    [1.1, 1.2, 1.3, 1.4]

Variablennamen können auch überschrieben werden:

In [10]:

    a = 42
    b = a

    a = 0
    b

Out[10]:

    42

## Rechenoperatoren

Es gibt:

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

Listen werden mit `+` zusammengeführt:

In [11]:

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

Out[11]:

    [1, 2, 3, 4, 5]

## Vergleichsoperatoren

geben `True` oder `False` zurück

- `==`, `!=`
- `>`, `<`, `>=`, `<=`

In [12]:

    'Test' == 42

Out[12]:

    False

## Logische Operatoren

- `and`, `or`, `not`, `in`

In [13]:

    True or False
    # True and False
    # False and False

Out[13]:

    True

In [14]:

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

Out[14]:

    True

## Funktionen aufrufen

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

In [15]:

    print('Hello!')

    Hello!

In [16]:

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

Out[16]:

    5

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

In [17]:

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

    1 2 3 4 5

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

In [18]:

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

    1, 2, 3

Objekte haben auch Funktionen (nennt man Methoden):

In [19]:

    'foo bar baz'.split()

Out[19]:

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

In [20]:

    s = 'test'
    s.upper()

Out[20]:

    'TEST'

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

In [21]:

    #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

In [22]:

    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.

In [23]:

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

    0
    1
    2
    3
    4

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

In [24]:

    data = [10, 42, -1]

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

    20
    84
    -2

In [25]:

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

    0
    1
    2
    3
    4

In [26]:

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

    2
    3
    4

In [27]:

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

    10
    9
    8
    7
    6
    5
    4

In [28]:

    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`

In [29]:

    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

In [30]:

    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.

In [31]:

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

    add(2, 2)

Out[31]:

    4

Man kann auch mehrere Werte zurückgeben:

In [32]:

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

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

    1
    2

In [33]:

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

    factorial(4)

Out[33]:

    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:

In [34]:

    import os

    os.listdir()

Out[34]:

    ['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:

In [35]:

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

Out[35]:

    '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

In [36]:

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

Den Modulen können mit `as` neue Namen gegeben werden

In [37]:

    import os.path as pa

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

Out[37]:

    '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`.

In [38]:

    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:

In [39]:

    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:

In [40]:

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

Out[40]:

    'Erster Wert: 42, Zweiter Wert: 0'

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

`format()` hat viele fortgeschrittene Funktionen:

In [41]:

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

Out[41]:

    '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!).

In [42]:

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

    Hällo, Wörld!

## Weiterführende Links:

- Offizielle Python-Dokumentation
- Offizielles Python-Tutorial
- Codecademy Python
- Dive into Python 3
- A Byte of Python