Python

Python

In [1]:
# encoding: utf-8
from __future__ import (print_function,
                        division,
                        unicode_literals,
                        absolute_import)

Einfachstes Beispiel:

In [2]:
print('Hello, World!')
Hello, World!

Zum Vergleich: C++

#include <iostream>

using namespace std;

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

Einfache Datentypen

Python stellt bereit:

In [2]:

Variablen

In [3]:
a = 2
b = 3

a + b
Out[3]:
5
In [4]:
namen = ['foo', 'bar', 'baz']
In [5]:
namen[1]
Out[5]:
u'bar'
In [6]:
zahlen = { 'eins': 1, 'zwei': 2, 'drei': 3 }
In [7]:
zahlen['zwei']
Out[7]:
2

Variablennamen können auch überschrieben werden:

In [8]:
a = 42
b = a

a = 0
b
Out[8]:
42

Rechenoperatoren

Es gibt:

In [8]:
In [9]:
[1, 2, 3] + [4, 5]
Out[9]:
[1, 2, 3, 4, 5]

Vergleichsoperatoren

geben True oder False zurück

In [10]:
'Test' == 42
Out[10]:
False

Logische Operatoren

In [10]:

Funktionen aufrufen

In [11]:
print('Hello!')
Hello!

In [12]:
len([1, 2, 3, 4, 5])
Out[12]:
5
In [13]:
from math import cos

cos(1.0)
Out[13]:
0.5403023058681398

Viele Funktionen können beliebig viele Argumente haben:

In [14]:
print(1, 2, 3, 4, 5)
1 2 3 4 5

Man kann auch sogenannte Keyword-Arguments übergeben:

In [15]:
print(1, 2, 3, sep=', ')
1, 2, 3

Objekte haben auch Funktionen (nennt man Methoden):

In [16]:
'foo bar baz'.split()
Out[16]:
[u'foo', u'bar', u'baz']
In [17]:
s = 'test'
s.upper()
Out[17]:
u'TEST'

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

In [18]:
print?

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

Kontrollstrukturen

Jede Zeile eines Python-Programms wird nacheinander durchlaufen.

Die Kontrollstrukturen erlauben mehr Kontrolle über den Ablauf.

In [19]:
# dies ist ein Kommentar

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

In [20]:
i = 0
while i < 5:
    print(i)
    i += 1
0
1
2
3
4

In [21]:
for i in range(5):
    print(i)
0
1
2
3
4

In [22]:
for i in range(2, 5):
    print(i)
2
3
4

In [23]:
for i in range(10, 3, -1):
    print(i)
10
9
8
7
6
5
4

Eigene Funktionen definieren mit def

In [24]:
def add(x, y):
    z = x + y
    return z

add(2, 2)
Out[24]:
4

Man kann auch mehrere Werte zurückgeben:

In [25]:
def divide(x, y):
    return x // y, x % y

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

In [26]:
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

factorial(4)
Out[26]:
24

Module und import

In Python kann man Programme in einzelne Module portionieren.

Braucht man etwas aus einem anderen Modul, importiert man es:

In [27]:
import math

math.sin(math.pi)
Out[27]:
1.2246467991473532e-16
In [28]:
from math import cos, pi

cos(2 * pi)
Out[28]:
1.0
In [29]:
from math import *

log(e)
Out[29]:
1.0
In [30]:
import math as m

m.exp(10)
Out[30]:
22026.465794806718

Schauen wir mal, was alles in math definiert wurde:

In [31]:
import math
dir(math)
Out[31]:
['__doc__',
 '__file__',
 '__name__',
 '__package__',
 'acos',
 'acosh',
 'asin',
 'asinh',
 'atan',
 'atan2',
 'atanh',
 'ceil',
 'copysign',
 'cos',
 'cosh',
 'degrees',
 'e',
 'erf',
 'erfc',
 'exp',
 'expm1',
 'fabs',
 'factorial',
 'floor',
 'fmod',
 'frexp',
 'fsum',
 'gamma',
 'hypot',
 'isinf',
 'isnan',
 'ldexp',
 'lgamma',
 'log',
 'log10',
 'log1p',
 'modf',
 'pi',
 'pow',
 'radians',
 'sin',
 'sinh',
 'sqrt',
 'tan',
 'tanh',
 'trunc']

Einzelne Python-Dateien (Endung .py) kann man als Module benutzten.

Liegt eine Datei test.py im selben Ordner, so kann man import test ausführen.

Auslagern in Python-Dateien

Es folgt ein fertiges Python-Programm.

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

In [32]:
# encoding: utf-8

from __future__ import (print_function,
                        division,
                        unicode_literals,
                        absolute_import)

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:

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

In [33]:
print(r'\Huge\texttt{Python}')
\Huge\texttt{Python}

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

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

In [34]:
'Erster Wert: {}, Zweiter Wert: {}'.format(42, 0)
Out[34]:
u'Erster Wert: 42, Zweiter Wert: 0'

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

format() hat viele fortgeschrittene Funktionen:

In [35]:
'Das Ergebnis ist {:.2f}'.format(3.2211421)
Out[35]:
u'Das Ergebnis ist 3.22'

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

Bei Python 2 muss man eigentlich immer ein 'u' vor einen String setzen, der sie enthalten muss.

Alternativ kann man from __future__ import unicode_literals verwenden.

In [36]:
print(u'Hällo Wörld')


print('Hällo Wörld') # wir haben unicode_literals importiert
Hällo Wörld
Hällo Wörld