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:

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)

Variablen

Man kann einem Objekt einen Namen geben:

In [3]:

a = 2
b = 3

a + b

Out[3]:

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]:

Variablennamen können auch überschrieben werden:

In [8]:

a = 42
b = a

a = 0
b

Out[8]:

Rechenoperatoren

Es gibt:

+, -, *
** (Potenzieren: 2**3 → 8)
/ (3 / 2 → 1.5 mit __from__ future import division)
// (3 // 2 → 1)
% (Divisionsrest)

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

and, or, not, in

In [11]:

print('Hello!')

Hello!

In [12]:

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

Out[12]:

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:

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.

if/elif/else: Ablauf unter einer bestimmten Bedingung

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

while-Schleifen: Wiederholen, solange ein bestimmter Ausdruck True zurück gibt

In [20]:

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

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

In [21]:

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

In [22]:

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

2
3
4

In [23]:

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

Eigene Funktionen definieren mit `def`

In [24]:

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

add(2, 2)

Out[24]:

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]:

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

Python-Dateien haben die Endung .py
Startet man mit python2 programm.py

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:

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

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

Einfache Datentypen

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:

Einfache Datentypen

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`