Anhang

Schlüsselwörter

In Python3 sind folgende Schlüsselwörter vordefiniert:

False assert del for in or while
None break elif from is pass with
True class else global lambda raise yield
and continue except if nonlocal return  
as def finally import not try  

Die in der obigen Tabelle angegebenen Wörter können nicht als Variablen- oder Funktionsnamen verwendet werden. Mittels der Funktion iskeyword() aus dem Modul keyword kann getestet werden, ob eine Zeichenkette ein Schlüsselwort ist:

from keyword import iskeyword()

iskeyword("lambda")
# Ergebnis: True

Standardfunktionen

Die im folgenden Abschnitt beschriebenen Funktionen (Builtin-Funktionen) sind standardmäßig in Python definiert, ohne dass ein zusätzliches Modul geladen werden muss.

abs()

Die Funktion abs(x) gibt den Absolutwert einer Zahl x als Ergebnis zurück.

Beispiel:

abs( -5.7 )
# Ergebnis: 5.7

abs( +5.7 )
# Ergebnis: 5.7

all()

Die Funktion all(sequenz) kann auf ein beliebiges iterierbares Objekt (Listen oder Mengen) angewendet werden. Als Ergebnis wird True zurückgegeben, wenn alle Elemente den Wahrheitswert True besitzen; andernfalls wird False als Ergebnis zurückgegeben.

Beispiel:

all( [1,3,5,0,7] )
# Ergebnis: False

all( [3,7,9,5,2] )
# Ergebnis: True

any()

Die Funktion any(sequenz) kann auf ein beliebiges iterierbares Objekt (Listen oder Mengen) angewendet werden. Als Ergebnis wird True zurückgegeben, wenn zumindest ein Element den Wahrheitswert True besitzt; andernfalls wird False als Ergebnis zurückgegeben.

Beispiel:

any( [0,0,0,0,0] )
# Ergebnis: False

any( [0,0,0,1,0] )
# Ergebnis: True

ascii()

Die Funktion ascii(objekt) gibt ebenso wie die Funktion repr() als Ergebnis eine Zeichenkette zurück, die eine kurze charakteristische Beschreibung des Objekts beinhaltet; häufig entspricht dies einer Angabe der Objekt-Klasse, des Objekt-Namens und der Speicheradresse.

Beispiel:

ascii(print)
# Ergebnis: '<built-in function print>'

Ist in der Klasse des angegebenen Objekts eine __repr__()-Methode definiert, so ist repr(objekt) identisch mit objekt.__repr__(). Als Zeichensatz wird für die Ausgabe des Strings allerdings der ASCII-Zeichensatz verwendet, so dass darin nicht enthaltene Symbole durch Zeichen mit vorangestelltem \x, \u oder \U gekennzeichnet werden.

bin()

Die Funktion bin(x) gibt eine Zeichenkette mit der Binärdarstellung einer einer Integer-Zahl als Ergebnis zurück. Eine solche Zeichenkette wird mit 0b eingeleitet, gefolgt von der eigentlichen Binärzahl.

Beispiel:

bin(42)
# Ergebnis: '0b101010'

bool()

Die Funktion bool(ausdruck) gibt den Wahrheitswert eines logischen Ausdrucks an; dieser kann entweder True oder False sein. Als Argument kann entweder ein mittels :ref`Vergleichsoperatoren <Operatoren>` erzeugter logischer Ausdruck oder auch ein einzelnes Objekt übergeben werden.

  • Listen, Tupel und Zeichenketten haben den Wahrheitswert True, wenn sie nicht leer sind beziehungsweise mindestens ein Zeichen enthalten.
  • Zahlen haben dann den Wahrheitswert True, wenn sie nicht gleich Null sind.
  • bool(None) liefert den Wahrheitswert False.

Beispiel:

bool(-3)
# Ergebnis: True

bytearray()

Die Funktion bytearray(string, encoding) erzeugt aus der angegebenen Zeichenkette eine neue Instanz eines bytearray-Objekts; als Encoding kann beispielsweise 'utf-8' oder 'ascii' angegeben werden. Dieser Datentyp besteht aus ganzzahligen Werten zwischen 0 und 255 und ist – ähnlich wie der Datentyp str zur Speicherung von Zeichenketten in Textdateien vorgesehen ist – zur Speicherung von binären Daten gedacht.

Beispiel:

bytearray("Hallo Welt!", 'utf-8')
# Ergebnis: bytearray(b'Hallo Welt!')

Die für bytes und bytearrays verfügbaren Methoden entsprechen im Wesentlichen den jeweiligen Methoden für Zeichenketten (siehe Abschnitt Bytes and Bytearray Operations der offiziellen Python-Dokumentation).

bytes()

Die Funktion bytes(string, encoding) erzeugt aus der angegebenen Zeichenkette eine neue Instanz eines bytes-Objekts; als Encoding kann beispielsweise 'utf-8' oder 'ascii' angegeben werden. Das bytes-Objekt entspricht im Wesentlichen einem bytearray-Objekt, ist aber nicht veränderlich (so wie ein Tupel eine unveränderliche Liste darstellt).

Beispiel:

bytes("Hallo Welt!", 'utf-8')
# Ergebnis: b'Hallo Welt!'

callable()

Die Funktion callable(objekt) gibt in Form eines booleschen Wahrheitswertes an, ob das als Argument übergebene Objekt (wie eine Funktion oder Methode) aufrufbar ist oder nicht.

Beispiel:

callable(5)
# Ergebnis: False

callable(print)
# Ergebnis: True

chr()

Die Funktion chr(zahl) gibt zu einem angegebenen Ganzzahl-Wert mit positivem Vorzeichen das entsprechende Unicode-Zeichen aus.

Beispiel:

chr(65)
# Ergebnis: 'A'

chr(97)
# Ergebnis: 'a'

Für viele Programme reichen die ASCII-Codes als Teilmenge des Unicode-Zeichensatzes bereits aus.

classmethod()

Die Funktion classmethod(methode) macht die angegebene Methode zu einer so genannten Klassen-Methode. Üblicherweise wird die classmethod()-Funktion als Funktionsdekorator verwendet:

class C():

    @classmethod
    def my_class_method(cls, arguments):

        pass

Bei einer so definierten Methode wird die als erstes Argument der Name der Klasse angegeben, von der aus die Methode aufgerufen wird. Die Klassen-Methode des obigen Beispiels kann dann wahlweise mittels C.my_class_method() oder ausgehend von einer Instanz der Klasse, also mittels C().my_class_method() aufgerufen werden; im letzteren Fall wird beim Aufruf nur der Name der Instanzklasse, nicht die Instanz selbst als erstes Argument an die Methode übergeben.

Wird eine Klassen-Methode von einer Instanz einer Klasse aufgerufen, welche die Methode lediglich über eine Vererbung erhalten hat, so wird beim Aufruf dennoch der Name der konkreten Instanzklasse (und nicht der Basis-Klasse) übergeben.

compile()

Die Funktion compile(code, file, mode) übersetzt den als erstes Argument angegebenen Code-String in ein ausführbares, in Maschinensprache geschriebenes Bytecode-Objekt. Als zweites Argument muss der Pfad einer Datei angegeben werden, in die gegebenenfalls auftretende Fehler geschrieben werden sollen. Als drittes Argument muss entweder zum Kompilieren genutzte Modus angegeben werden:

  • single, wenn es sich bei dem angegebenen Code um eine einzelne Aussage-Komponente (beispielsweise den Wert einer Variablen) handelt;
  • eval, wenn der angegebene Code eine einzelne Aussage darstellt;
  • exec, wenn der angegebene Code aus einer oder mehreren Aussagen besteht und als Ergebnis None liefern soll.

Der compilierte Bytecode kann anschließend mittels eval() beziehungsweise exec() ausgeführt werden.

Beispiel:

# Bytecode erzeugen:

a = 5

compile('a', 'tmp.txt', 'single')
# Ergebnis: <code object <module> at 0x7f38edc91f60, file "tmp.txt", line 1>

compile('print("Hallo Welt!")', 'tmp.txt', 'eval')
# Ergebnis: <code object <module> at 0x7f38edc91c00, file "tmp.txt", line 1>

compile('for i in range(3): print(i)', 'tmp.txt', 'exec')
# Ergebnis: <code object <module> at 0x7f38edc94780, file "tmp.txt", line 1>

# Bytecode ausführen:

eval( compile('a', 'tmp.txt', 'single') )
# Rückgabewert / Ergebnis: 5

eval( compile('print("Hallo Welt!")', 'tmp.txt', 'eval') )
# Rückgabewert / Ergebnis: Hallo Welt!

exec( compile('for i in range(3): print(i)', 'tmp.txt', 'exec') )
# Rückgabewert: None
# Ergebnis (auf dem Bildschirm):
# 0
# 1
# 2

complex()

Die Funktion complex() erstellt eine neue Instanz einer komplexen Zahl aus zwei angegebenen Zahlen oder einem angegebenen String.

Beispiel:

complex(1.5, 2)
# Ergebnis: (1.5+2j)

Wird ein String als Argument angegeben, so muss darauf geachtet werden, dass kein Leerzeichen zwischen dem Realteil, dem Pluszeichen und dem Imaginärteil steht; complex() löst sonst einen ValueError aus.

delattr()

Die Funktion delattr(objekt, attributname) löscht ein angegebenes Attribut beziehungsweise einen angegebenen Funktionsnamen (eine Zeichenkette) aus dem als erstes Argument angegebenen Objekt; dies ist formal identisch mit del objekt.attributname.

import math as m

# Attribut löschen:
delattr(m, 'cos')

# Test:
m.cos( m.pi/4 )
# Ergebnis: 'module' object has no attribute 'cos'

dict()

Die Funktion dict() erzeugt eine neue Instanz eines dict-Objekts, also ein Dictionary. Formal ist d = dict() somit identisch mit d = {}.

Beispiel:

# Neues dict erzeugen:
d = dict()

# Schlüssel-Wert-Paar hinzufügen:
d['test'] = 'Hallo Welt!'

d
# Ergebnis: {'test': 'Hallo Welt!'}

dir()

Die Funktion dir() gibt, wenn sie ohne ein angegebenes Argument aufgerufen wird, eine Liste mit den Namen aller in der aktuellen Python-Sitzung definierten Objekt-Namen (als Strings) zurück.

Wird als Argument ein beliebiges Objekt angegeben, so werden die Attribute und Methoden des jeweiligen Objekts in Form einer String-Liste ausgegeben.

Beispiel:

import math as m

dir(m)
# Ergebnis:
# ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos',
# 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign',
# 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial',
# 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf',
# 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi',
# 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

divmod()

Die Funktion divmod(zahl1, zahl2) dividiert die als erstes Argument angegebene Zahl durch die zweite Zahl. Als Ergebnis gibt die Funktion ein Tupel zweier Werte zurück, wobei der erste Wert das ganzzahlige Ergebnis der Division und der zweite Wert den Divisionsrest angibt.

Beispiel:

divmod(14,5)
# Ergebnis: (2, 4)

enumerate()

Die Funktion enumerate(sequenz) ermöglicht es, die Einträge einer Liste oder eines Tupels zu nummerieren. Damit lassen sich beispielsweise for-Schleifen über die Elemente einer Liste konstruieren, in denen beide Informationen verwendet werden.

Beispiel:

liste = [5, 6, 7, 8, 9]

for i, num in enumerate(liste):
    print( "Der {}. Eintrag in der Liste ist {}".format(i, num) )

# Ergebnis:
# Der 0. Eintrag in der Liste ist 5
# Der 1. Eintrag in der Liste ist 6
# Der 2. Eintrag in der Liste ist 7
# Der 3. Eintrag in der Liste ist 8
# Der 4. Eintrag in der Liste ist 9

eval()

Die Funktion eval(zeichenkette) erstellt aus der angegebenen Zeichenkette den entsprechenden Python-Ausdruck und wertet diesen aus; es darf sich dabei allerdings nur um einen einzelnen Ausdruck, nicht um ein aus vielen einzelnen Aussagen zusammengesetztes Code-Stück handeln.

Der Rückgabewert von eval() entspricht dabei dem Ergebnis des ausgewerteten Ausdrucks.

Beispiel:

x = 1

eval('x+1')
# Rückgabewert / Ergebnis: 2

eval('for i in range(3): print(i)')
# Ergebnis:
# for i in range(3): print(i)
#  ^
# SyntaxError: invalid syntax

Die Funktion eval() kann ebenso verwendet werden, um einen mittels compile() erzeugten Ausdruck auszuwerten. Wurde als Compilier-Modus hierbei 'single' oder eval angegeben, so entspricht der Rückgabewert wiederum dem Ergebnis des Ausdrucks; bei der Angabe von exec() als Compilier-Modus liefert eval() als Ergebnis stets den Wert None.

exec()

Die Funktion exec(zeichenkette) führt – ähnlich wie eval() – einen (beispielsweise mittels compile() konstruierten) Python-Ausdruck aus; es kann sich dabei auch um eine beliebig lange Zusammensetzung einzelner Python-Ausdrücke handeln. Als Ergebnis wird stets None zurückgegeben.

Beispiel:

exec('print("Hallo Welt!")')
# Rückgabewert: None
# Ergebnis (Auf dem Bildschirm):
# Hallo Welt!

exec('for i in range(3): print(i)')
# Rückgabewert: None
# Ergebnis (Auf dem Bildschirm):
# 0
# 1
# 2

exec('42')
# Rückgabewert / Ergebnis: None

Die Funktion exec() kann ebenso verwendet werden, um einen mittels compile() erzeugten Ausdruck auszuwerten; auch hierbei ist der Rückgabewert stets None.

filter()

Die Funktion filter(funktionsname, objekt) bietet die Möglichkeit, eine Filter-Funktion auf alle Elemente eines iterierbaren Objekts (beispielsweise einer Liste) anzuwenden. Als Ergebnis gibt die filter()-Funktion ein iterierbares Objekt zurück. Dieses kann beispielsweise für eine for-Schleife genutzt oder mittels list() in eine neue Liste umgewandelt werden.

Beispiel:

my_list = [1,2,3,4,5,6,7,8,9]

even_numbers = filter(lambda x: x % 2 == 0, my_list)

list(even_numbers)
# Ergebnis: [2,4,6,8]

Oftmals kann anstelle der filter()-Funktion allerdings auch eine (meist besser lesbare) List-Comprehension genutzt werden. Im obigen Beispiel könnte auch kürzer even_numbers = [x for x in my_list if x % 2 == 0] geschrieben werden.

float()

Die Funktion float() gibt, sofern möglich, die zur angegebenen Zeichenkette oder Zahl passende Gleitkomma-Zahl als Ergebnis zurück; wird eine int-Zahl als Argument übergeben, so wird die Nachkommastelle .0 ergänzt.

Beispiel:

float(5)
# Ergebnis: 5.0

float('3.2')
# Ergebnis: 3.2

float('1e3')
# Ergebnis: 1000.0

format()

Die Funktion format(wert, formatangabe) formatiert die Ausgabe des angegebenen Werts. Hierzu können als Format-Angabe die für die Formatierung von Zeichenketten üblichen Symbole verwendet werden. Wird kein Format angegeben, so wird die in der Objektklasse des Werts definierte Funktion wertklasse.__format__() aufgerufen.

Beispiel:

# Zeichenkette zentriert ausgeben (Gesamtbreite 20):
format('Hallo Welt!', '^20')
# Ergebnis: '    Hallo Welt!     '

# Zeichenkette rechtsbündig ausgeben (Gesamtbreite 20):
format('Hallo Welt!', '>20')
# Ergebnis: '         Hallo Welt!'

# Zahl Pi mit drei Stellen Genauigkeit ausgeben:
format(m.pi, '.3')
# Ergebnis: 3.14

frozenset()

Die Funktion frozenset(sequenz) erzeugt aus der angegebenen Sequenz (beispielsweise einer Liste oder einer Zeichenkette) eine neue Instanz eines frozenset-Objekts, also eine unveränderliche Menge.

Beispiel:

frozenset( [1, 3, 5, 7, 9, 9] )
# Ergebnis: frozenset({1, 3, 5, 7, 9})

frozenset( "Hallo Welt!" )
# Ergebnis: frozenset({' ', '!', 'H', 'W', 'a', 'e', 'l', 'o', 't'})

getattr()

Die Funktion getattr(objekt, attributname) gibt als Ergebnis den Wert von objekt.attributname zurück. Als drittes Argument kann optional ein Standard-Wert angegeben werden, der als Ergebnis zurück gegeben wird, wenn das angegebene Attribut nicht existiert.

Beispiel:

# Beispiel-Klasse:
class Point():

    x = 5
    y = 4

# Punkt-Objekt erzeugen:
p = Point()

getattr(p, 'x')
# Ergebnis: 5

getattr(p, 'y')
# Ergebnis: 4

getattr(p, 'z', 0)
# Ergebnis: 0

Wird kein Standard-Wert angegeben und das Attribut existiert nicht, so wird ein AttributeError ausgelöst.

globals()

Die Funktion globals() liefert als Ergebnis ein dict mit den Namen und den Werten aller zum Zeitpunkt des Aufrufs existierenden globalen, das heißt programmweit sichtbaren Variablen.

Beispiel:

globals()
# Ergebnis:
# {'__doc__': None, '__spec__': None, '__name__': '__main__',
# '__package__': None, # '__loader__': <class '_frozen_importlib.BuiltinImporter'>,
# '__builtins__': <module 'builtins' (built-in)>}

hasattr()

Die Funktion hasattr(objekt, attributname) gibt als Ergebnis den Wahrheitswert True zurück, falls für das angegebene Objekt ein Attribut mit dem angegebenen Namen existiert, andernfalls False.

Beispiel:

# Beispiel-Klasse:
class Point():

    x = 5
    y = 4

# Punkt-Objekt erzeugen:
p = Point()

hasattr(p, 'x')
# Ergebnis: True

hasattr(p, 'y')
# Ergebnis: True

getattr(p, 'z')
# Ergebnis: False

Mittels der Funktion hasattr() kann somit geprüft werden, ob die Funktion getattr() beim Aufruf einen AttributeError auslösen wird oder nicht.

hash()

Die Funktion hash(unveraenderliches-objekt) liefert zu beliebigen nicht veränderlichen Python-Objekten (beispielsweise Zeichenketten oder Tupeln) einen eindeutigen Integer-Wert als Ergebnis zurück; dieser ist nicht abhängig von der aktuellen Python-Sitzung. Identische Objekte werden durch die hash()-Funktion also auf identische ganzzahlige Werte abgebildet.

Beispiel:

hash("Hallo Welt!")
# Ergebnis: -2446188496090613429

hash( (1, 3, 5, 7, 9) )
# Ergebnis: -4331119994873071480

Die Umkehrung ist leider nicht zwingend eindeutig: Zu einem Hash-Wert können unterschiedliche Objekte gehören.

help()

Die Funktion help(objekt) blendet im Interpreter eine Hilfe-Seite zum angegebenen Objekt ein, sofern eine Dokumentation zum angegebenen Objekt vorhanden ist.

Beispiel:

# Hilfe zu Zeichenketten (str) anzeigen:
help(str)

# Hilfe zur Funktion print() anzeigen:
help(str)

hex()

Die Funktion hex(int-wert) gibt eine Zeichenkette mit der Hexadezimal-Darstellung einer Integer-Zahl als Ergebnis zurück. Eine solche Zeichenkette wird mit 0x eingeleitet, gefolgt von der eigentlichen Binärzahl.

Beispiel:

hex(42)
# Ergebnis: '0x2a'

id()

Die Funktion id(objekt) liefert für beliebige Python-Objekte, abhängig von der aktuellen Python-Sitzung, einen eindeutigen Integer-Wert als Ergebnis zurück; dieser Wert entspricht der Adresse, an der das Objekt im Speicher abgelegt ist.

Beispiel:

id("Hallo Welt!")
# Ergebnis: 139882484400688

Mittels der Funktion id() können somit zwei Objekte auf Gleichheit getestet werden.

input()

Die Funktion input() dient zum Einlesen einer vom Benutzer eingegebenen Zeichenkette. Beim Aufruf kann dabei optional ein String angegeben werden, der dem Benutzer vor dem Eingabe-Prompt angezeigt wird:

answer = input("Bitte geben Sie Ihren Namen an: ")

print("Ihr Name ist %s." % answer)

Soll eine Zahl eingelesen werden, so muss die Benutzerantwort mittels int() bzw. float() explizit von einem String in eine solche umgewandelt werden.

int()

Die Funktion int() gibt, sofern möglich, die zur angegebenen Zeichenkette oder Gleitkomma-Zahl passende Integer-Zahl als Ergebnis zurück; wird eine float-Zahl als Argument übergeben, so werden mögliche Nachkommastellen schlichtweg ignoriert, beispielsweise ergibt int(3.7) den Wert 3.

Beispiel:

int('5')
# Ergebnis: 5

int(3.14)
# Ergebnis: 3

isinstance()

Die Funktion isinstance(objekt, klassen-name) gibt als Ergebnis den Wahrheitswert True zurück, wenn das angegebene Objekt eine Instanz der als zweites Argument angegebenen Klasse (oder einer Subklasse) ist; ist dies nicht der Fall, wird False als Ergebnis zurückgegeben.

Beispiel:

isinstance("Hallo Welt", str)
# Ergebnis: True

issubclass()

Die Funktion issubclass(cls1, cls2) gibt als Ergebnis den Wahrheitswert True zurück, wenn die als erstes Argument angegebene Klasse eine Subklasse der als zweites Argument angegebenen Klasse ist; ist dies nicht der Fall, wird False als Ergebnis zurückgegeben.

Beispiel:

isinstance(str, object)
# Ergebnis: True

iter()

Die Funktion iter(sequenz) erstellt eine neue Instanz eines Iterator-Objekts aus einer listen-artigen Sequenz (genauer: einem Objekt mit einer __iter__()-Methode). Dieser Iterator kann beispielsweise verwendet werden, um eine for-Schleife über die in der Sequenz vorkommenden Elemente zu konstruieren:

Beispiel:

# Iterator generieren:
iterator = iter( ['Hallo', 'Welt'] )

# Elemente des Iterator-Objekts ausgeben:
for i in iterator:
    print(i)

# Ergebnis:
# Hallo
# Welt

Die einzelnen Elemente eines Iterator-Objekts können auch schrittweise mittels iteratorname.__next__() aufgerufen werden; ist man am Ende der Sequenz angekommen, so wird ein StopIteration-Error ausgelöst.

Eine zweite Verwendungsmöglichkeit der iter()-Funktion besteht darin, als erstes Objekt einen Funktions- oder Methodennamen und als zweites Argument eine Integer-Zahl als “Grenzwert” anzugeben. Wird ein solcher “aufrufbarer” Iterator mit iteratorname.__next__() aufgerufen, so wird die angegebene Funktion so lange aufgerufen, bis diese einen Rückgabewert liefert, der mit dem angegebenen Grenzwert identisch ist. Wird der Grenzwert nicht erreicht, so kann der Iterator beliebig oft aufgerufen werden.

Beispiel:

import random

# Aufrufbaren Iterator generieren:
iterator = iter( random.random, 1 )

# Zufallszahlen ausgeben:

iterator.__next__()
# Ergebnis: 0.17789467192460118

iterator.__next__()
# Ergebnis: 0.7501975823469289

len()

Die Funktion len() gibt die Länge einer Liste oder Zeichenkette als int-Wert an. Bei einer Liste wird die Anzahl an Elementen gezählt, bei einer Zeichenkette die einzelnen Textzeichen, aus denen die Zeichenkette besteht.

Beispiel:

len('Hallo Welt!')
# Ergebnis: 11

len( str(1000) )
# Ergebnis: 4

len( [1,2,3,4,5] )
# Ergebnis: 5

list()

Die Funktion list() erzeugt eine neue Instanz eines list-Objekts, also eine (veränderliche) Liste. Formal ist l = list() somit identisch mit l = [ ].

Wird beim Aufruf von list() eine Sequenz angegeben, so wird die Liste mit den in der Sequenz vorkommenden Einträgen gefüllt.

Beispiel:

# Leere Liste erzeugen:
l1 = list()

# Liste mit Zahlen 0 bis 9 erzeugen:
l2 = list( range(10) )

l2
# Ergebnis: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

locals()

Die Funktion locals() liefert als Ergebnis ein dict mit den Namen und den Werten aller zum Zeitpunkt des Aufrufs existierenden lokalen, das heißt im aktuellen Codeblock sichtbaren Variablen.

map()

Die Funktion map(function, object) wendet eine Funktion auf alle Elemente eines iterierbaren Objekts (beispielsweise einer Liste) an. Als Ergebnis liefert map() ein neues iterierbares Objekt, dessen Elemente den einzelnen Ergebniswerten entsprechen.

Beispiel:

my_list = [3, 5, -10.2, -7, 4.5]
map(abs, my_list)
# Ergebnis: [3, 5, 10.2, 7, 4.5]

Oftmals wird anstelle der map()-Funktion eine (meist besser lesbare) List-Comprehension genutzt. Im obigen Beispiel könnte auch [abs(x) for x in my_list] geschrieben werden.

max()

Die Funktion max() gibt das größte Element einer Liste als Ergebnis zurück.

Beispiel:

max( [5,1,3,9,7] )
# Ergebnis: 9

min()

Die Funktion min() gibt das kleinste Element einer Liste als Ergebnis zurück.

Beispiel:

min( [5,1,3,9,7] )
# Ergebnis: 1

object()

Die Funktion object() erzeugt eine Instanz eines neuen object-Objekts. Ein objekt ist die Basisklasse aller Objekte, hat allerdings keine besonderen Attribute oder Methoden.

Beim Aufruf von object() dürfen keine weiteren Argumente angegeben werden; zudem verfügt ein object-Objekt über kein __dict__, so dass der Instanz keine weiteren Attribute oder Methoden hinzugefügt werden können.

oct()

Die Funktion oct(int-wert) gibt eine Zeichenkette mit der Oktaldarstellung einer int-Zahl als Ergebnis zurück. Eine solche Zeichenkette wird mit 0o eingeleitet, gefolgt von der eigentlichen Oktalzahl.

Beispiel:

oct(42)
# Ergebnis: '0o52'

open()

Die Funktion open(dateiname) gibt ein zum angegebenen Pfad passendes Datei-Objekt als Ergebnis zurück, das zum Lesen oder Schreiben von Dateien verwendet wird.

Die Funktion open() ist im Abschnitt Dateien näher beschrieben.

ord()

Die Funktion ord(zeichen) gibt die Unicode-Zahl (ein int-Wert) eines angegebenen Zeichens (Buchstabe, Zahl, oder Sonderzeichen) aus.

Beispiel:

ord('A')
# Ergebnis: 65

ord('a')
# Ergebnis: 97

Für viele Programme reichen die ASCII-Codes als Teilmenge des Unicode-Zeichensatzes bereits aus.

pow()

Die Funktion pow(zahl1, zahl2) gibt beim Aufruf von pow(x,y) den Wert von x ** y, also x hoch y aus (Potenz).

Beispiel:

pow(10, 3)
# Ergebnis: 1000

pow(10, -3)
# Ergebnis: 0.001

print()

Die Funktion print(zeichenkette) gibt die angegebene Zeichenkette auf dem Bildschirm aus; dabei können unter anderem mittels einer geeigneten Formatierung auch Werte von Variablen ausgegeben werden.

Beispiel:

print("Die Antwort lautet %d.", % 42)
# Ergebnis: Die Antwort lautet 42.

property()

Die Funktion property() wird verwendet, um auf ein Attribut einer Klasse nicht direkt, sondern mittels einer Methode zuzugreifen. Hierzu wird in der Klasse des Objekts je eine Setter- und Getter-Methode definiert, die zum Zuweisen und Abrufen des Attributs verwendet werden. Anschließend kann mittels my_attribute = property(fget=getterfunction, fset=setterfunction) ein Property-Attribut erzeugt werden.

“Klassisch” kann die property()-Funktion folgendermaßen verwendet werden:

# Testklasse definieren:
class C():

    # Normales Klassen-Attribut anlegen:
    foo = 1

    # Getter-Funktion für 'bar' definieren:
    def get_bar(self):
        return self.foo

    # Setter-Funktion für 'bar' definieren:
    def set_bar(self, value):
        self.foo = value

    # 'bar' zu einer Property machen:
    bar = property(get_bar, set_bar)

Häufiger wird die property()-Funktion allerdings als Funktionsdekorator genutzt. Die Bedeutung bleibt dabei gleich, doch ist die Schreibweise etwas “übersichtlicher”:

# Testklasse definieren:
class C():

    # Normales Klassen-Attribut anlegen:
    foo = 1

    # Property 'bar' definieren:
    @property
    def bar(self):
        return self.foo

    # Setter für 'bar' definieren:
    @bar.setter
    def bar(self, value):
        self.foo = value

Erzeugt man mittels c = C() ein neues Objekt der obigen Beispielklasse, so kann auch mittels c.bar auf das Attribut c.foo zugegriffen werden:

# Instanz der Beispiel-Klasse erzeugen:
c = C()

c.bar
# Ergebnis: 1

# Wert der Property 'bar' ändern:
c.bar = 2

c.foo
# Ergebnis: 2

Üblicherweise erhält die Zielvariable, die von der Property verändert wird, den gleichen Namen wie die Property selbst, jedoch mit einem _ zu Beginn des Variablennamens. Hierdurch wird ausgedrückt, dass die Variable nicht direkt verändert werden sollte (obgleich dies möglich wäre). In der Setter-Funktion kann dann beispielsweise explizit geprüft werden, ob eine vorgenommene Wertzuweisung überhaupt zulässig ist.

range()

Die Funktion range() erzeugt eine Sequenz ganzzahliger Werte. Sie kann wahlweise in folgenden Formen benutzt werden:

range(stop)
range(start, stop)
range(start, stop, step)

Wird der range()-Funktion nur ein einziger Wert n als Argument übergeben, so wird eine Zahlensequenz von 0 bis n-1 generiert; Werden zwei Werte m und n übergeben, so wird eine Zahlensequenz von m bis n-1 erzeugt. Allgemein ist bei Verwendung von range() die untere Schranke im Zahlenbereich enthalten, die obere hingegen nicht.

Wird eine dritte Zahl i \ne 0 als Argument angegeben, so wird nur jede i-te Zahl im angegebenen Zahlenbereich in die Sequenz aufgenommen. Ist der Startwert des Zahlenbereichs größer als der Stopwert und i negativ, so wird eine absteigende Zahlensequenz generiert.

Beispiel:

range(10)
# Ergebnis: range(0,10)

list( range(0, 10) )
# Ergebnis: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list( range(0, 10, 2) )
# Ergebnis: [0, 2, 4, 6, 8]

list( range(10, 0, -1) )
# Ergebnis: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

repr()

Die Funktion repr(objekt) gibt als Ergebnis eine Zeichenkette zurück, die eine kurze charakteristische Beschreibung des Objekts beinhaltet; häufig entspricht dies einer Angabe der Objekt-Klasse, des Objekt-Namens und der Speicheradresse.

Beispiel:

repr(print)
# Ergebnis: '<built-in function print>'

Ist in der Klasse des angegebenen Objekts eine __repr__()-Methode definiert, so ist repr(objekt) identisch mit objekt.__repr__().

Als Zeichensatz wird für die Ausgabe des Strings Unicode verwendet, so dass beispielsweise auch Umlaute im Ausgabe-String enthalten sein können.

reversed()

Die Funktion reversed(sequenz) kann auf eine iterierbares Objekt (beispielsweise ein Tupel oder eine Liste) angewendet werden; sie gibt einen Iterator mit den gleichen Elementen, aber in der umgekehrten Reihenfolge zurück.

Beispiel

liste = [1,5,2,3]

liste_rev = reversed(liste)

liste_rev
# Ergebnis: <builtins.list_reverseiterator at 0x7f38edce2278>

for i in liste_rev:
    print(i)

# Ergebnis:
# 3
# 2
# 5
# 1

round()

Die Funktion round() rundet eine float-Zahl auf die nächste int-Zahl auf beziehungsweise ab und gibt diese als Ergebnis zurück. Wird zusätzlich zur Zahl eine zweite Integer-Zahl als Argument angegeben, also round(a, n), so wird die Zahl a auf n Stellen gerundet als Ergebnis zurück gegeben.

round(15.37)
#Ergebnis: 15

round(15.37, 1)
#Ergebnis: 15.4

set()

Die Funktion set() erzeugt ein neues set-Objekt, also eine Menge.

Wird optional beim Aufruf von set() eine Sequenz als Argument angegeben, so wird das Mengen-Objekt mit den Einträgen dieser Menge gefüllt (doppelte Einträge bleiben ausgeschlossen).

Beispiel:

# Leeres Set-Objekt erstellen:
s1 = set()

# Set-Objekt aus einer Liste erstellen:
s2 = set( [1, 3, 5, 7, 9, 9] )

s2
# Ergebnis: set({1, 3, 5, 7, 9})

# Set-Objekt aus einer Zeichenkette erstellen:
s3 = set( "Hallo Welt!" )

s3
# Ergebnis: set({' ', '!', 'H', 'W', 'a', 'e', 'l', 'o', 't'})

setattr()

Die Funktion setattr(objekt, attributname, wert) weist dem angegebenen Attribut des als erstes Argument angegebenen Objekts den als drittes Argument angegebenen Wert zu (sofern dies möglich ist); formal ist setattr(objekt, attributname, wert) somit identisch mit objekt.attributname = wert.

Beispiel:

# Beispiel-Klasse:
class Point():

    x = 5
    y = 4

# Punkt-Objekt erzeugen:
p = Point()

# Attribut ändern:
setattr(p, 'x', 3)

# Attribut abrufen:
getattr(p, 'x')
# Ergebnis: 3

# Attribut neu zuweisen:
setattr(p, 'z', 2)

# Attribut abrufen:
getattr(p, 'z')
# Ergebnis: 2

slice()

Die Funktion slice(startwert, stopwert, stepwert) erstellt eine neue Instanz eines Slice-Objekts. Dieses Objekt repräsentiert einen Satz an Indizes, der durch die angegebenen Werte unveränderbar festgelegt ist.

Beispiel

s = slice(0,10,2)

s.start
# Ergebnis:0

s.stop
# Ergebnis:10

s.step
# Ergebnis:2

Beim Aufruf von slice() kann als Wert für die Argumente start und stop auch None angegeben werden. Das Slice-Objekt enthält dann nur step als unveränderlichen Wert. Wird das Slice-Objekt mit s bezeichnet, so kann in diesem Fall beispielsweise mittels s.indices(100) ein neues Slice-Objekt als Ergebnis geliefert werden, das den angegebenen Wert als stop-Wert hat.

Slice-Objekte werden selten direkt verwendet. Allerdings werden bei Datentypen wie Zeichenketten oder Listen Slicings gerne zur Auswahl von Elementen genutzt; ebenso können bei Verwendung von Modulen wie numpy oder pandas Slicings eingesetzt werden, um mittels den dabei resultierenden Indizes Teilbereiche aus Zahlenlisten zu selektieren. Die Syntax lautet dabei etwa:

a = numpy.arange(10)

# Als Zahlenbereich die dritte bis zur siebten Zahl selektieren:

a[3:8]
# Ergebnis: array([3, 4, 5, 6, 7])

# Dabei nur jede zweite Zahl selektieren:

a[3:8:2]
# Ergebnis: array([3, 5, 7])

Verwendet man die gleichnamige Funktion slice() aus dem itertools-Modul, so wird als Ergebnis statt einem Slice ein entsprechendes Iterator-Objekt zurückgegeben.

sorted()

Die Funktion sorted(sequenz) kann auf eine iterierbares Objekt (beispielsweise ein Tupel oder eine Liste) angewendet werden; sie gibt eine Liste mit den entsprechenden Elementen in sortierter Reihenfolge zurück.

Beispiel

sorted([1,5,2,3])
# Ergebnis: [1, 2, 3, 5]

staticmethod()

Die Funktion staticmethod(methode) macht die angegebene Methode zu einer so genannten statischen Methode. Üblicherweise wird die staticmethod()-Funktion als Funktionsdekorator verwendet:

class C():

    @staticmethod
    def my_static_method(arguments):

        pass

Bei einer so definierten Methode wird weder der Name der Klasse noch der Name der Instanz angegeben, von der aus die Methode aufgerufen wird.

Die statische Methode des obigen Beispiels kann wahlweise mittels C.my_class_method() oder ausgehend von einer Instanz der Klasse, also mittels C().my_class_method() aufgerufen werden.

str()

Die Funktion str(objekt) gibt eine String-Version des als Argument angegebenen Objekts aus. Hierbei wird die Methode objekt.__str__() der jeweiligen Klasse aufgerufen.

Beispiel:

str( [1,2,3,4,5] )
# Ergebnis: '[1, 2, 3, 4, 5]'

sum()

Die Funktion sum(sequenz) gibt die Summe eines iterierbaren Objekts (beispielsweise einer Liste) als Ergebnis zurück.

Beispiel:

sum( [1,2,3,4,5] )
# Ergebnis: 15

sum( range(100) )
# Ergebnis: 4950

super()

Die Funktion super() gibt, ausgehend von der Klasse des aufrufenden Objekts, die in der Objekt-Hierarchie nächst höher liegende Klasse an; dies wird insbesondere bei der Vererbung von Methoden genutzt.

Die Objekt-Hierarchie gibt eine Art Stammbaum für die Klasse an. Über das Attribut __mro__ einer Klasse (“Method Resolution Order”) kann abgefragt werden, in welcher Reihenfolge Klassen bei einem Methodenaufruf nach einer entsprechend benannten Methode durchsucht werden.

Beispiel:

# Objekt-Hierarchie einer abgeleiteten Klasse anzeigen:

import enum

enum.OrderedDict.__mro__
# Ergebnis: (collections.OrderedDict, builtins.dict, builtins.object)

Wird beispielsweise beim Aufruf von obj.eine_methode() die Methode nicht im Namensraum des Objekts gefunden, so wird entlang der Method Resolution-Order geprüft, ob eine gleichnamige Methode in einer übergeordneten Klasse definiert ist. Ist dies der Fall, so wird die Methode dieser Klasse aufgerufen, da die konkrete Klasse des Objekts die Methoden “geerbt” und nicht überschrieben hat. Den Zugriff auf die jeweils nächste Klasse der Method Resolution Order bietet gerade die Funktion super().

Beim Programmieren kann die Funktion super(), die in Python3 fast immer ohne Argumente aufgerufen wird, genutzt werden, um eine Methode der übergeordneten Klasse aufzugreifen und gleichzeitig zu modifizieren.

tuple()

Die Funktion tuple(sequenz) erzeugt aus der angegebenen Sequenz (beispielsweise einer Liste oder einer Zeichenkette) eine neue Instanz eines tuple-Objekts, also eine unveränderliche Liste.

Beispiel:

tuple('Hallo Welt!')
# Ergebnis: ('H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't')

tuple( range(10) )
# Ergebnis: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

type()

Die Funktion type(objekt) gibt als Ergebnis den Namen der Klasse des angegebenen Objekts zurück; dies ist identisch mit einem Aufruf von objekt.__class__.

Beispiel:

type("Hallo Welt!")
# Ergebnis: builtins.str

Eine zweite Verwendungsmöglichkeit der type()-Funktion liegt darin, sie als type(objektname, basisklasse, attribute-dict) aufzurufen, um ein neues Objekt zu erstellen. Dieses erbt alle Eigenschaften der angegebenen Basisklasse (oder mehrerer als Liste angegebener Basisklassen); zudem können für das Objekt in form eines dict weitere Attribute definiert werden.

Die folgenden beiden Code-Varianten erzeugen jeweils ein Objekt mit gleichen Eigenschaften:

# Beispielklasse definieren:
class C(object):
    x = 1

# Beispiel-Objekt generieren:
c1 = C()

# Type-Objekt mit gleichen Eigenschaften generieren:
c2 = type('C', (object,), dict(x=1) )

vars()

Die Funktion vars() gibt, sofern sie ohne Argument aufgerufen wird, als Ergebnis ein dict mit den Namen und den Werten aller zum Zeitpunkt des Aufrufs existierenden lokalen, das heißt im aktuellen Codeblock sichtbaren Variablen zurück (ebenso wie locals()).

Wird beim Aufruf von vars() als Argument ein beliebiges Objekt angegeben, so wird der Inhalt von objekt.__dict__ als Ergebnis zurückgegeben.

zip()

Die Funktion zip() verbindet – ähnlich wie ein Reißverschluss – Elemente aus verschiedenen iterierbaren Objekten (beispielsweise Listen) zu einem neuen Iterator-Objekt, dessen Elemente Zusammensetzungen der ursprünglichen Elemente sind.

Beispiel:

zip( ['a', 'b', 'c'], [1, 2, 3, 4] )
# Ergebnis: <builtins.zip at 0x7f39027b22c8>

list( zip( ['a', 'b', 'c'], [1, 2, 3, 4] ) )
# Ergebnis: [('a', 1), ('b', 2), ('c', 3)]

Wichtige Standard-Module

Die im folgenden Abschnitt beschriebenen Module sind standardmäßig in Python enthalten, ohne dass zusätzliche Software-Pakete installiert werden müssen:

cmath – Mathe-Modul für komplexe Zahlen

Das cmath-Modul umfasst viele Funktionen des math-Moduls, die allerdings komplexe Zahlen als Argumente zulassen.

copy – Kopien von Objekten erstellen

Das copy-Modul stellt insbesondere die Funktion deepcopy() bereit, mit der 1:1-Kopien von existierenden Objekten gemacht werden können.

Erstellt man eine Kopie eines Objekts mittels objekt2 = objekt1.copy(), so wird genau genommen nur eine neue Referenz auf das bestehende Objekt angelegt. Hat objekt1 beispielsweise ein Attribut x mit dem Wert 5, so würde durch eine Eingabe von objekt2.x = 7 auch der Attribut-Wert von objekt1 geändert. Ein solches Verhalten ist beispielsweise bei der Übergabe von Objekten an Funktionen erwünscht, entspricht allerdings nicht der klassischen Vorstellung einer Kopie. Eine solche kann folgendermaßen erstellt werden:

import copy

# Kopie eines Objekts erzeugen:
objekt2 = copy.deepcopy(objekt1)

Werden nun die Attribut-Werte von objekt2 geändert, so bleiben die Werte des Original-Objekts unverändert.

cProfile – Profiler

Mittels des Pakets cProfile und der darin definierten Funktion run() kann ermittelt werden, wie viel Zeit für einen Aufruf einer Funktion benötigt wird. Bei einer Funktion, die weitere Unterfunktionen aufruft, wird zudem angezeigt, wie viel Zeit auf die einzelnen Schritte entfällt:

import cProfile
cProfile.run('sum( range(10000000) )')

# Ergebnis:
# 4 function calls in 0.321 seconds

# Ordered by: standard name

# ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#     1    0.000    0.000    0.321    0.321 <string>:1(<module>)
#     1    0.000    0.000    0.321    0.321 {built-in method exec}
#     1    0.321    0.321    0.321    0.321 {built-in method sum}
#     1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

Mit dem Profiler können in verschachtelten Funktionen schnell “Bottlenecks” gefunden werden, also Programmteile, die sehr rechenintensiv sind und daher bevorzugt optimiert werden sollten.

logging – Logger-Modul

Das logging-Modul stellt einfache Methoden bereit, mit denen ein einfaches Aufzeichnen verschiedener Informationen im Verlauf eines Programms ermöglicht wird.

Das logging-Modul ist im Abschnitt Arbeiten mit Logdateien näher beschrieben.

math – Mathematische Funktionen

Das math-Modul stellt eine Vielzahl häufig vorkommender mathematischer Funktionen bereit. Unter anderem sind folgende Funktionen nützlich:

  • Mit math.pi und math.e können die Naturkonstanten \pi =
3,1415\ldots und e = 2,7182\ldots ausgegeben werden.
  • Mit math.floor(zahl) wird der nächst kleinere int-Wert zur angegebenen Zahl ausgegeben, mit math.ceil(zahl) der nächst größere int-Wert.
  • Mit math.factorial(n) wird die Fakultät n!=n \cdot (n-1) \cdot
(n-2) \cdot \ldots \cdot 1 einer positiven ganzzahligen Zahl n ausgegeben.
  • Mit math.sqrt(zahl) wird die Wurzel einer positiven Zahl ausgegeben.
  • Mit math.pow(zahl, n) wird die n-te Potenz der angegebenen Zahl ausgegeben. Für n kann auch eine float-Zahl kleiner als 1 angegeben werden; beispielsweise wird durch math.pow(8, 1/3) die dritte Wurzel von 8 berechnet.
  • Mit math.exp(x) wird der Wert der Exponentialfunktion e^{x} ausgegeben.
  • Mit math.log(x, a) wird der Wert der Logarithmusfunktion \log_{a}{(x)} ausgegeben. Wird kein Basis-Wert angegeben, so wird der natürliche Logarithmus, also der Logarithmus zur Basis e berechnet.
  • Mit math.radians(winkelwert) kann der angegebene Winkel (im Gradmaß) ins Bogenmaß, mittels math.degrees(zahl) das angegebene Bogenmaß ins Gradmaß Winkelwert umgerechnet werden.
  • Mit math.sin(x), math.cos(x) und math.tan(x) können die trigonometrischen Funktionen Sinus, Cosinus und Tangens zu den angegeben Werten berechnet werden; diese müssen im Bogenmaß, also in rad angegeben werden.
  • Mit math.asin(x), math.acos(x) und math.atan(x) können die Umkehrfunktionen zu den jeweiligen trigonometrischen Funktionen berechnet werden; die Ergebnisse werden im Bogenmaß, also in rad angegeben.

Das math-Modul ist für die Berechnung einzelner Werte vorgesehen. Für die Berechnung von Zahlenreihen stellt das Zusatz-Modul numpy gleichnamige Funktionen bereit. Diese können jeweils nicht nur einen einzelnen Wert, sondern jeweils auch eine Liste von entsprechenden Zahlenwerten als Argument effizient auswerten.

os – Interaktion mit dem Betriebsystem

Das os-Modul stellt einige nützliche Funktionen und Konstanten bereit, um gewöhnliche Aufgaben auf der Ebene des Betriebsystems durchführen zu können.

  • Mit os.chdir(pfad) wird das als Argument angegebene Verzeichnis zum aktuellen Arbeitsverzeichnis.
  • Mit os.getcwd() wird der Pfad des aktuellen Arbeitsverzeichnisses ausgegeben.
  • Mit os.listdir(pfad) wird eine Liste aller Dateinamen des als Argument angegebenen Verzeichnisses ausgegeben.
  • Mit os.mkdir(verzeichnisname) wird das als Argument angegebene Verzeichnis neu erstellt.
  • Mit os.rmdir(verzeichnisname) wird das als Argument angegebene Verzeichnis gelöscht.
  • Mit os.remove(dateiname) wird die als Argument angegebene Datei gelöscht.
  • Mit os.rename(alt, neu) wird einer Datei oder einem Verzeichnis ein neuer Name zugewiesen.

Mit der Funktion os.popen() ist es zudem möglich, ein Programm in einer gewöhnlichen Shell aufzurufen. Hierzu wird der Funktion os.popen() als Argument eine Zeichenkette angegeben, deren Inhalt an den Shell-Interpreter weitergereicht wird. Die Ausgabe des Programms wird in eine Pipe geschrieben, die wie ein Datei-Objekt wahlweise zeilenweise mittels readline() oder als Ganzes mittels read() ausgelesen werden kann:

import os

# Shell-Anweisung festlegen:
command = 'ls -l'

# Shell-Anweisung ausführen:
# (Der Rückgabewert ist ein Filepointer auf die Pipe)
fp = os.popen(command)

# Das Ergebnis der Shellanweisung (Pipe) auslesen:
ergebnis = fp.read()

# Pipe schließen:
# (Status == None bedeutet fehlerfreies Schließen)
status = fp.close()

os.path – Pfadfunktionen

Das os.path-Modul stellt einige nützliche Funktionen bereit, die bei der Arbeit mit Datei- und Verzeichnisnamen hilfreich sind:

  • Mit os.path.exists(pfad) kann geprüft werden, ob der als Argument angegebene Dateiname als Pfad im Dateisystem existiert; als Ergebnis gibt die Funktion True oder False zurück.
  • Mit os.path.isdir(pfad) kann geprüft werden, ob der als Argument angegebene Pfad ein Verzeichnis ist; als Ergebnis gibt die Funktion True oder False zurück.
  • Mit os.path.isfile(pfad) kann geprüft werden, ob der als Argument angegebene Pfad eine Datei ist; als Ergebnis gibt die Funktion True oder False zurück.
  • Mit os.path.getsize(pfad) kann der vom als Argument angegebenen Pfad belegte Speicherplatz ausgegeben werden.

Um nicht nur relative, sondern auch absolute Pfadangaben nutzen zu können, kann die Funktion os.path.abspath(pfad) genutzt werden; diese gibt zu einem angegebenen (relativen) Dateinamen den zugehörigen absoluten Pfad an.

pickle – Speichern von Python-Objekten

Das pickle-Modul ermöglicht es, während einer Python-Sitzung existierende Objekte in Byte-Strings umzuwandeln und diese auf einer Festplatte zu speichern; ebenso können auf diese Art festgehaltene Daten mittels pickle zu einem späteren Zeitpunkt (sogar nach einem Neustart des Systems) auch wieder gelesen werden.

Um ein beliebiges Python-Objekt mittels pickle als Zeichenkette zu codieren, gibt man folgendes ein:

import pickle

liste_original = [1,2,3,4,5]

# Objekt als Byte-String ausgeben:
storage = pickle.dumps(liste_original)
b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.'

Hierbei steht dumps für “dump string”. Der erzeugte Byte-String ist zwar für Menschen nicht unmittelbar lesbar, kann aber vom Computer effizient geschrieben und auch mittels pickle.loads() (“load string”) wieder ausgelesen werden:

# Byte-String zurückübersetzen:
liste_neu = pickle.loads(storage)

liste_neu
# Ergebnis: [1,2,3,4,5]

Das wieder geladene Objekt ist inhaltlich mit dem Original identisch, wird vom Interpreter jedoch als neues Objekt gehandhabt.

Soll das Ablegen eines Objekts unmittelbar in eine Datei erfolgen, so kann anstelle von pickle.dumps() die Funktion pickle.dump() verwendet und dabei als Argument ein existierender File-Pointer angegeben werden. Umgekehrt kann mittels pickle.load() wieder unmittelbar aus dem als Argument angegebenen Datei-Objekt gelesen werden.

random – Zufallsgenerator

Das random-Modul stellt Funktion zum Erzeugen von Zufallszahlen, für das Auswählen eines zufälligen Elements aus einer Liste sowie für das Umsortieren von Listen bereit.

Zu Beginn sollte zunächst stets eine neue Basis für die Erzeugung von Zufallszahlen in der aktuellen Python-Sitzung erstellt werden:

import random

# Zufallszahlen initiieren:
random.seed()

Anschließend können folgende Funktionen genutzt werden:

  • Die Funktion random.random() liefert als Ergebnis eine Zufallszahl zwischen 0.0 und 1.0 (einschließlich dieser beiden Werte).
  • Die Funktion random.randint(min,max) liefert als Ergebnis eine ganzzahlige Zufallszahl zwischen min und max (einschließlich dieser beiden Werte).
  • Die Funktion random.choice(sequenz) wählt ein zufälliges Element aus einer Sequenz (beispielsweise einer Liste oder einem Tupel) aus.
  • Die Funktion random.shuffle(liste) ordnet die Elemente einer Liste auf zufällige Weise neu an; dabei wird das Original verändert.

Beispielsweise kann also mittels random.randint(1,6) das Verhalten eines gewöhnlichen sechsflächigen Würfels imitiert werden.

sys – Systemzugriff

Das sys-Modul stellt Variablen und Funktion bereit, die in unmittelbarem Zusammenhang mit dem Python-Interpreter selbst stehen. Hilfreich sind unter anderem:

  • Mit sys.exit() kann die aktuelle Interpreter-Sitzung beziehungsweise das aktuelle Programm beendet werden. Bei einem gewöhnlichen Beenden ohne Fehler wird dabei üblicherweise der Wert 0 als Argument angegeben, bei einem fehlerhaften Beenden der Wert 1.
  • Mit sys.modules erhält man eine Liste aller Module, die in der aktuellen Interpreter-Sitzung beziehungsweise im laufenden Programm bereits geladen wurden.
  • Mit sys.path erhält man eine Liste mit Pfadnamen, in denen beim Aufruf von import nach Modulen gesucht wird.
  • Mit sys.stdin, sys.stdout und sys.stderr hat man Zugriff zu den drei gewöhnlichen Shell-Kanälen (Eingabe, Ausgabe, Fehler). In Python werden diese wie gewöhnliche Datei-Objekte behandelt.
  • Mit sys.version wird die Versionsnummer des Python-Interpreters ausgegeben.

timeit – Laufzeitanalyse

Mittels des Moduls timeit und der gleichnamigen Funktion aus diesem Paket kann einfach ermittelt werden, wieviel Zeit eine Funktion für einen Aufruf benötigt:

import timeit

timeit.timeit("x = 2 ** 2")
# Ergebnis: 0.02761734207160771

ASCII-Codes

Dez ASCII Dez ASCII Dez ASCII Dez ASCII Dez ASCII Dez ASCII Dez ASCII Dez ASCII
0 NUL 16 DLE 32 SP 48 0 64 @ 80 P 96 ` 112 p
1 SOH 17 DC1 33 ! 49 1 65 A 81 Q 97 a 113 q
2 STX 18 DC2 34 " 50 2 66 B 82 R 98 b 114 r
3 ETX 19 DC3 35 # 51 3 67 C 83 S 99 c 115 s
4 EOT 20 DC4 36 $ 52 4 68 D 84 T 100 d 116 t
5 ENQ 21 NAK 37 % 53 5 69 E 85 U 101 e 117 u
6 ACK 22 SYN 38 & 54 6 70 F 86 V 102 f 118 v
7 BEL 23 ETB 39 ' 55 7 71 G 87 W 103 g 119 w
8 BS 24 CAN 40 ( 56 8 72 H 88 X 104 h 120 x
9 HT 25 EM 41 ) 57 9 73 I 89 Y 105 i 121 y
10 LF 26 SUB 42 * 58 : 74 J 90 Z 106 j 122 z
11 VT 27 ESC 43 + 59 ; 75 K 91 [ 107 k 123 {
12 FF 28 FS 44 , 60 < 76 L 92 \ 108 l 124 |
13 CR 29 GS 45 - 61 = 77 M 93 ] 109 m 125 }
14 SO 30 RS 46 . 62 > 78 N 94 ^ 110 n 126 ~
15 SI 31 US 47 / 63 ? 79 O 95 _ 111 o 127 DEL