19.8    Eingebaute Funktionen 

Es war im Laufe des Buchs schon oft von eingebauten Funktionen oder Built-in Functions die Rede. Das sind vordefinierte Funktionen, die dem Programmierer jederzeit zur Verfügung stehen. Sie kennen zum Beispiel bereits die Built-in Functions len und range. Im Folgenden werden alle bisher relevanten Built-in Functions ausführlich beschrieben. Beachten Sie, dass es noch weitere eingebaute Funktionen gibt, die an dieser Stelle nicht besprochen werden können, da sie Konzepte der objektorientierten Programmierung voraussetzen. Eine vollständige Übersicht über alle in Python eingebauten Funktionen finden Sie im Anhang dieses Buchs (Abschnitt A.2).

Tabelle 19.1    Built-in Functions, die in diesem Abschnitt besprochen werden

 

19.8.1    abs(x) 

Die Funktion abs berechnet den Betrag von x. Der Parameter x muss dabei ein numerischer Wert sein, also eine Instanz der Datentypen int, float, bool oder complex.

>>> abs(1)
1
>>> abs(-12.34)
12.34
>>> abs(3 + 4j)
5.0

 

19.8.2    all(iterable) 

Die Funktion all gibt immer dann True zurück, wenn alle Elemente des als Parameter übergebenen iterierbaren Objekts, also beispielsweise einer Liste oder eines Tupels, den Wahrheitswert True ergeben. Sie wird folgendermaßen verwendet:

>>> all([True, True, False])
False
>>> all([True, True, True])
True

Das übergebene iterierbare Objekt muss nicht zwingend nur bool-Instanzen durchlaufen. Instanzen anderer Datentypen werden nach den Regeln aus Abschnitt 12.6.2, »Wahrheitswerte nicht-boolescher Datentypen«, in Wahrheitswerte überführt.

 

19.8.3    any(iterable) 

Die Funktion any arbeitet ähnlich wie all. Sie gibt immer dann True zurück, wenn mindestens ein Element des als Parameter übergebenen iterierbaren Objekts, also zum Beispiel einer Liste oder eines Tupels, den Wahrheitswert True ergibt. Sie wird folgendermaßen verwendet:

>>> any([True, False, False])
True
>>> any([False, False, False])
False

Das übergebene iterierbare Objekt muss nicht zwingend nur bool-Instanzen durchlaufen. Instanzen anderer Datentypen werden nach den Regeln aus Abschnitt 12.6.2, »Wahrheitswerte nicht-boolescher Datentypen«, in Wahrheitswerte überführt.

 

19.8.4    ascii(object) 

Die Funktion ascii gibt eine lesbare Entsprechung der Instanz object in Form eines Strings zurück. Im Gegensatz zu der für denselben Zweck existierenden Built-in Function repr enthält der von ascii zurückgegebene String ausschließlich Zeichen des ASCII-Zeichensatzes:

>>> ascii(range(0, 10))
'range(0, 10)'
>>> ascii("Püthon")
"'P\\xfcthon'"
>>> repr("Püthon")
"'Püthon'"

 

19.8.5    bin(x) 

Die Funktion bin gibt einen String zurück, der die für x übergebene ganze Zahl in ihrer Binärdarstellung enthält:

>>> bin(123)
'0b1111011'
>>> bin(-12)
'-0b1100'
>>> bin(0)
'0b0'

 

19.8.6    bool([x]) 

Hiermit wird eine Instanz des Datentyps bool mit dem Wahrheitswert der Instanz x erzeugt. Der Wahrheitswert von x wird nach den in Abschnitt 12.6.2, »Wahrheitswerte nicht-boolescher Datentypen«, festgelegten Regeln bestimmt.

Wenn kein Parameter übergeben wurde, gibt die Funktion bool den booleschen Wert False zurück.

 

19.8.7    bytearray([source, encoding, errors]) 

Die Funktion bytearray erzeugt eine Instanz des Datentyps bytearray, der eine Sequenz von Byte-Werten darstellt, also ganzen Zahlen im Zahlenbereich von 0 bis 255. Beachten Sie, dass bytearray im Gegensatz zu bytes ein veränderlicher Datentyp ist.

Der Parameter source wird zum Initialisieren des Byte-Arrays verwendet und kann verschiedene Bedeutungen haben:

Wenn für source ein String übergeben wird, wird dieser mithilfe der Parameter encoding und errors in eine Byte-Folge codiert und dann zur Initialisierung des Byte-Arrays verwendet. Die Parameter encoding und errors haben die gleiche Bedeutung wie bei der Built-in Function str.

Wenn für source eine ganze Zahl übergeben wird, wird ein Byte-Array der Länge source angelegt und mit Nullen gefüllt.

Wenn für source ein iterierbares Objekt, beispielsweise eine Liste, übergeben wird, wird das Byte-Array mit den Elementen gefüllt, über die source iteriert. Beachten Sie, dass es sich dabei um ganze Zahlen aus dem Zahlenbereich von 0 bis 255 handeln muss.

Außerdem kann für source eine beliebige Instanz eines Datentyps übergeben werden, der das sogenannte Buffer-Protokoll unterstützt. Das sind beispielsweise die Datentypen bytes und bytearray selbst.

>>> bytearray("äöü", "utf-8")
bytearray(b'\xc3\xa4\xc3\xb6\xc3\xbc')
>>> bytearray([1,2,3,4])
bytearray(b'\x01\x02\x03\x04')
>>> bytearray(10)
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

Näheres zum Datentyp bytearray erfahren Sie in Abschnitt 13.4, »Strings – str, bytes, bytearray«.

 

19.8.8    bytes([source, encoding, errors]) 

Hiermit wird eine Instanz des Datentyps bytes[ 70 ](siehe Abschnitt 13.4.4, »Zeichensätze und Sonderzeichen« ) erzeugt, der, wie der Datentyp bytearray, eine Folge von Byte-Werten speichert. Im Gegensatz zu bytearray handelt es sich aber um einen unveränderlichen Datentyp, weswegen wir auch von einem bytes-String sprechen.

Die Parameter source, encoding und errors werden so wie bei der Built-in Function bytearray zur Initialisierung der Byte-Folge verwendet:

>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes([1,2,3])
b'\x01\x02\x03'
>>> bytes("äöü", "utf-8")
b'\xc3\xa4\xc3\xb6\xc3\xbc'

 

19.8.9    chr(i) 

Die Funktion chr gibt einen String der Länge 1 zurück, der das Zeichen mit dem Unicode-Codepoint i enthält:

>>> chr(65)
'A'
>>> chr(33)
'!'
>>> chr(8364)
'€'

 

19.8.10    complex([real, imag]) 

Hiermit wird eine Instanz des Datentyps complex[ 71 ](siehe Abschnitt 12.7, »Komplexe Zahlen – complex« ) zur Speicherung einer komplexen Zahl erzeugt. Die erzeugte Instanz hat den komplexen Wert real+imag⋅j. Fehlende Parameter werden als 0 angenommen.

Außerdem ist es möglich, der Funktion complex einen String zu übergeben, der das Literal einer komplexen Zahl enthält. In diesem Fall darf jedoch kein weiterer Parameter angegeben werden.

>>> complex(1, 3)
(1+3j)
>>> complex(1.2, 3.5)
(1.2+3.5j)
>>> complex("3+4j")
(3+4j)
>>> complex("3")
(3+0j)

Beachten Sie, dass ein eventuell übergebener String keine Leerzeichen um den +‐Operator enthalten darf:

>>> complex("3 + 4j")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

Leerzeichen am Anfang oder Ende des Strings sind aber kein Problem.

 

19.8.11    dict([source]) 

Hiermit wird eine Instanz des Datentyps dict[ 72 ](siehe Abschnitt 14.1, »Dictionary – dict« ) erzeugt. Wenn kein Parameter übergeben wird, wird ein leeres Dictionary erstellt. Durch einen der folgenden Aufrufe ist es möglich, das Dictionary beim Erzeugen mit Werten zu füllen:

• Wenn source ein Dictionary ist, werden die Schlüssel und Werte dieses Dictionarys in das neue übernommen. Beachten Sie, dass dabei keine Kopien der Werte entstehen, sondern diese weiterhin dieselben Instanzen referenzieren.

  >>> dict({"a" : 1, "b" : 2})
  {'a': 1, 'b': 2}

• Alternativ kann source ein über Tupel iterierendes Objekt sein, wobei jedes Tupel zwei Elemente enthalten muss: den Schlüssel und den damit assoziierten Wert. Die Liste muss die Struktur [("a", 1), ("b", 2)] haben:

  >>> dict([("a", 1), ("b", 2)])
  {'a': 1, 'b': 2}

• Zudem erlaubt es dict, Schlüssel und Werte als Keyword Arguments zu übergeben. Der Parametername wird dabei in einen String geschrieben und als Schlüssel verwendet. Beachten Sie, dass Sie damit bei der Namensgebung den Beschränkungen eines Bezeichners unterworfen sind:

  >>> dict(a=1, b=2)
  {'a': 1, 'b': 2} 

 

19.8.12    divmod(a, b) 

Die Funktion divmod gibt folgendes Tupel zurück: (a//b, a%b). Mit Ausnahme von complex können für a und b Instanzen beliebiger numerischer Datentypen übergeben werden:

>>> divmod(2.5, 1.3)
(1.0, 1.2)
>>> divmod(11, 4)
(2, 3)

 

19.8.13    enumerate(iterable) 

Die Funktion enumerate erzeugt ein iterierbares Objekt, das nicht allein über die Elemente von iterable iteriert, sondern über Tupel der Form (i, iterable[i]). Dabei ist i ein Schleifenzähler, der bei 0 beginnt. Die Schleife wird beendet, wenn i den Wert len(iterable)-1 hat. Diese Tupelstrukturen werden deutlich, wenn man das Ergebnis eines enumerate-Aufrufs in eine Liste konvertiert:

>>> list(enumerate(["a", "b", "c", "d"]))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

Damit eignet sich enumerate besonders für for-Schleifen, in denen ein numerischer Schleifenzähler mitgeführt werden soll. Innerhalb einer for-Schleife kann enumerate folgendermaßen verwendet werden:

>>> for i, wert in enumerate([1,2,3,4,5]):
...     print("Der Wert von iterable an", i, "ter Stelle ist:", wert)
Der Wert von iterable an 0 ter Stelle ist: 1
Der Wert von iterable an 1 ter Stelle ist: 2
Der Wert von iterable an 2 ter Stelle ist: 3
Der Wert von iterable an 3 ter Stelle ist: 4
Der Wert von iterable an 4 ter Stelle ist: 5

 

19.8.14    eval(expression, [globals, locals]) 

Die Funktion eval wertet den in Form eines Strings vorliegenden Python-Ausdruck expression aus und gibt dessen Ergebnis zurück:

>>> eval("1+1")
2

Beim Aufruf von eval können der gewünschte globale und lokale Namensraum, in denen der Ausdruck ausgewertet werden soll, über die Parameter globals und locals angegeben werden. Wenn diese Parameter nicht angegeben wurden, wird expression in der Umgebung ausgewertet, in der eval aufgerufen wurde:

>>> x = 12
>>> eval("x**2")
144

>>> eval(input("Geben Sie Python-Code ein: "))
Geben Sie Python-Code ein: 2**4
16

 

19.8.15    exec(object, [globals, locals]) 

Die Funktion exec führt einen als String vorliegenden Python-Code aus:

>>> code = """
... x = 12
... print(x**2)
... """
>>> exec(code)
144

Beim Aufruf von exec können der gewünschte globale und lokale Namensraum, in denen der Code ausgeführt werden soll, über die Parameter globals und locals angegeben werden. Wenn diese Parameter nicht angegeben wurden, wird der Code in der Umgebung ausgeführt, in der exec aufgerufen wurde.

 

19.8.16    filter(function, iterable) 

Die Funktion filter erwartet ein Funktionsobjekt als ersten und ein iterierbares Objekt als zweiten Parameter. Der Parameter function muss eine Funktion oder Lambda-Form (siehe Abschnitt 19.5, »Anonyme Funktionen«) sein, die einen Parameter erwartet und einen booleschen Wert zurückgibt.

Die Funktion filter ruft für jedes Element des iterierbaren Objekts iterable die Funktion function auf und erzeugt ein iterierbares Objekt, das alle Elemente von list durchläuft, für die function den Wert True zurückgegeben hat. Dies soll an folgendem Beispiel erklärt werden, in dem filter dazu verwendet wird, aus einer Liste von ganzen Zahlen die ungeraden Zahlen herauszufiltern:

>>> filterobj = filter(lambda x: x%2 == 0, range(21))
>>> print(list(filterobj))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

 

19.8.17    float([x]) 

Hiermit wird eine Instanz des Datentyps float[ 73 ](siehe Abschnitt 12.5, »Gleitkommazahlen – float« ) erzeugt. Wenn der Parameter x nicht angegeben wurde, wird der Wert der Instanz mit 0.0, andernfalls mit dem übergebenen Wert initialisiert. Mit Ausnahme von complex können Instanzen alle numerischen Datentypen für x übergeben werden.

>>> float()
0.0
>>> float(5)
5.0

Außerdem ist es möglich, für x einen String zu übergeben, der eine Gleitkommazahl enthält:

>>> float("1e30")
1e+30
>>> float("0.5")
0.5

 

19.8.18    format(value, [format_spec]) 

Die Funktion format gibt den Wert value gemäß der Formatangabe format_spec zurück. Beispielsweise lässt sich ein Geldbetrag bei der Ausgabe folgendermaßen auf zwei Nachkommastellen runden:

>>> format(1.23456, ".2f") + "€"
'1.23€'

Ausführliche Informationen zu Formatangaben finden Sie in Abschnitt 13.4.3 über String-Formatierungen.

 

19.8.19    frozenset([iterable]) 

Hiermit wird eine Instanz des Datentyps frozenset[ 74 ](siehe Abschnitt 15.1, »Die Datentypen set und frozenset« ) zum Speichern einer unveränderlichen Menge erzeugt. Wenn der Parameter iterable angegeben wurde, werden die Elemente der erzeugten Menge diesem iterierbaren Objekt entnommen. Wenn der Parameter iterable nicht angegeben wurde, erzeugt frozenset eine leere Menge.

Beachten Sie zum einen, dass ein frozenset keine veränderlichen Elemente enthalten darf, und zum anderen, dass jedes Element nur einmal in einer Menge vorkommen kann.

>>> frozenset()
frozenset()
>>> frozenset({1,2,3,4,5})
frozenset({1, 2, 3, 4, 5})
>>> frozenset("Pyyyyyyython")
frozenset({'t', 'P', 'n', 'y', 'h', 'o'})

 

19.8.20    globals() 

Die Built-in Function globals gibt ein Dictionary mit allen globalen Referenzen des aktuellen Namensraums zurück. Die Schlüssel entsprechen den Referenznamen als Strings und die Werte den jeweiligen Instanzen.

>>> a = 1
>>> b = {}
>>> c = [1,2,3]
>>> globals()
{..., 'a': 1, 'b': {}, 'c': [1, 2, 3]}

Das zurückgegebene Dictionary enthält neben den im Beispiel angelegten noch weitere Referenzen, die im globalen Namensraum existieren.

 

19.8.21    hash(object) 

Die Funktion hash berechnet den Hash-Wert der Instanz object und gibt ihn zurück. Bei einem Hash-Wert handelt es sich um eine ganze Zahl, die aus Typ und Wert der Instanz erzeugt wird. Ein solcher Wert wird verwendet, um effektiv zwei komplexere Instanzen auf Gleichheit prüfen zu können. So werden beispielsweise die Schlüssel eines Dictionarys intern durch ihre Hash-Werte verwaltet.

>>> hash(12345)
12345
>>> hash("Hallo Welt")
-1324507931790039535
>>> hash((1,2,3,4))
485696759010151909

Beachten Sie den Unterschied zwischen veränderlichen (mutablen) und unveränderlichen (immutablen) Instanzen. Aus Letzteren kann zwar formal auch ein Hash-Wert errechnet werden, dieser wäre aber nur so lange gültig, wie die Instanz nicht verändert wurde. Aus diesem Grund ist es nicht sinnvoll, Hash-Werte von veränderlichen Instanzen zu berechnen; veränderliche Instanzen sind »unhashable«:

>>> hash([1,2,3,4])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

 

19.8.22    help([object]) 

Die Funktion help startet die interaktive Hilfe von Python. Wenn der Parameter object ein String ist, wird dieser im Hilfesystem nachgeschlagen. Sollte es sich um eine andere Instanz handeln, wird eine dynamische Hilfeseite zu dieser generiert.

 

19.8.23    hex(x) 

Die Funktion hex erzeugt einen String, der die als Parameter x übergebene ganze Zahl in Hexadezimalschreibweise enthält. Die Zahl entspricht, wie sie im String erscheint, dem Python-Literal für Hexadezimalzahlen.

>>> hex(12)
'0xc'
>>> hex(0xFF)
'0xff'
>>> hex(-33)
'-0x21'

 

19.8.24    id(object) 

Die Funktion id gibt die Identität einer beliebigen Instanz zurück. Bei der Identität einer Instanz handelt es sich um eine ganze Zahl, die die Instanz eindeutig identifiziert.

>>> id(1)
134537016
>>> id(2)
134537004

Näheres zu Identitäten erfahren Sie in Abschnitt 7.1.3.

 

19.8.25    input([prompt]) 

Die Funktion input liest eine Eingabe vom Benutzer ein und gibt sie in Form eines Strings zurück. Der Parameter prompt ist optional. Hier kann ein String angegeben werden, der vor der Eingabeaufforderung ausgegeben werden soll.

>>> s = input("Geben Sie einen Text ein: ")
Geben Sie einen Text ein: Python ist gut
>>> s
'Python ist gut'

>>> eval(input("Prompt: "))
Prompt: 2+2
4

 

19.8.26    int([x, base]) 

Hiermit wird eine Instanz des Datentyps int[ 75 ](siehe Abschnitt 12.4, »Ganzzahlen – int« ) erzeugt. Die Instanz kann durch Angabe von x mit einem Wert initialisiert werden. Wenn kein Parameter angegeben wird, erhält die erzeugte Instanz den Wert 0.

Wenn der Parameter x als String übergeben wird, erwartet die Funktion int, dass dieser String den gewünschten Wert der Instanz enthält. Durch den optionalen Parameter base kann die Basis des Zahlensystems angegeben werden, in dem die Zahl geschrieben wurde.

>>> int(5)
5
>>> int("FF", 16)
255
>>> int(hex(12), 16)
12

 

19.8.27    len(s) 

Die Funktion len gibt die Länge bzw. die Anzahl der Elemente von s zurück. Für s können Sequenzen, Mappings oder Mengen übergeben werden.

>>> len("Hallo Welt")
10
>>> len([1,2,3,4,5])
5

 

19.8.28    list([sequence]) 

Hiermit wird eine Instanz des Datentyps list[ 76 ](siehe Abschnitt 13.2, »Listen – list« ) aus den Elementen von sequence erzeugt. Der Parameter sequence muss ein iterierbares Objekt sein. Wenn er weggelassen wird, wird eine leere Liste erzeugt.

>>> list()
[]
>>> list((1,2,3,4)) 
[1, 2, 3, 4] 
>>> list({"a": 1, "b": 2})
['a', 'b']

Die Funktion list kann dazu verwendet werden, ein beliebiges iterierbares Objekt in eine Liste zu überführen:

>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]

 

19.8.29    locals() 

Die Built-in Function locals gibt ein Dictionary mit allen lokalen Referenzen des aktuellen Namensraums zurück. Die Schlüssel entsprechen den Referenznamen als Strings und die Werte den jeweiligen Instanzen. Dies soll an folgendem Beispiel deutlich werden:

>>> def f(a, b, c):
...     d = a + b + c
...     print(locals())
...
>>> f(1, 2, 3)
{'d': 6, 'c': 3, 'b': 2, 'a': 1}

Der Aufruf von locals im Namensraum des Hauptprogramms ist äquivalent zum Aufruf von globals.

 

19.8.30    map(function, [*iterable]) 

Diese Funktion erwartet ein Funktionsobjekt als ersten und ein iterierbares Objekt als zweiten Parameter. Optional können weitere iterierbare Objekte übergeben werden, die aber die gleiche Länge wie das erste haben müssen. Die Funktion function muss genauso viele Parameter erwarten, wie iterierbare Objekte übergeben wurden, und aus den Parametern einen Rückgabewert erzeugen.

Die Funktion map ruft function für jedes Element von iterable auf und gibt ein iterierbares Objekt zurück, das die jeweiligen Rückgabewerte von function durchläuft. Sollten mehrere iterierbare Objekte übergeben werden, werden function die jeweils n-ten Elemente dieser Objekte übergeben.

Im folgenden Beispiel wird das Funktionsobjekt durch eine Lambda-Form erstellt. Es ist auch möglich, eine »echte« Funktion zu definieren und ihren Namen zu übergeben.

>>> f = lambda x: x**2
>>> ergebnis = map(f, [1,2,3,4])
>>> list(ergebnis)
[1, 4, 9, 16]

Hier wird map dazu verwendet, eine Liste mit den Quadraten der Elemente einer zweiten Liste zu erzeugen.

>>> f = lambda x, y: x+y
>>> ergebnis = map(f, [1,2,3,4], [1,2,3,4])
>>> list(ergebnis)
[2, 4, 6, 8]

Hier wird map dazu verwendet, aus zwei Listen eine zu erzeugen, die die Summen der jeweiligen Elemente beider Quelllisten enthält.

Das letzte Beispiel wird durch Abbildung 19.3 veranschaulicht. Die eingehenden und ausgehenden iterierbaren Objekte sind jeweils senkrecht dargestellt.

Abbildung 19.3    Arbeitsweise der Built-in Function map

In beiden Beispielen wurden Listen verwendet, die ausschließlich numerische Elemente enthielten. Das muss nicht unbedingt sein. Welche Elemente ein an map übergebenes iterierbares Objekt durchlaufen darf, hängt davon ab, welche Instanzen für function als Parameter verwendet werden dürfen.

 

19.8.31    max(iterable, {default, key}), max(arg1, arg2, [*args], {key}) 

Wenn keine zusätzlichen Parameter übergeben werden, erwartet max ein iterierbares Objekt und gibt sein größtes Element zurück.

>>> max([2,4,1,9,5])
9
>>> max("Hallo Welt")
't'

Wenn mehrere Parameter übergeben werden, verhält sich max so, dass der größte übergebene Parameter zurückgegeben wird:

>>> max(3, 5, 1, 99, 123, 45)
123
>>> max("Hallo", "Welt", "!")
'Welt'

Der Funktion max kann optional über den Schlüsselwortparameter key ein Funktionsobjekt übergeben werden. Das Maximum wird dann durch das Vergleichen der Rückgabewerte dieser Funktion bestimmt. Mit dem Parameter key lässt sich also eine eigene Ordnungsrelation festlegen. In folgendem Beispiel soll key dazu verwendet werden, die Funktion max für Strings case insensitive zu machen. Dazu zeigen wir zunächst den normalen Aufruf ohne key:

>>> max("a", "P", "q", "X")
'q'

Ohne eigene key-Funktion wird der größte Parameter unter Berücksichtigung von Groß- und Kleinbuchstaben ermittelt. Folgende key-Funktion konvertiert zuvor alle Buchstaben in Kleinbuchstaben:

>>> f = lambda x: x.lower()
>>> max("a", "P", "q", "X", key=f)
'X'

Durch die key-Funktion wird der größte Parameter anhand der durch f modifizierten Werte ermittelt, jedoch unmodifiziert zurückgegeben.

Über den letzten Schlüsselwortparameter default kann ein Wert festgelegt werden, der von max zurückgegeben wird, wenn iterable leer sein sollte.

 

19.8.32    min(iterable, {default, key}), min(arg1, arg2, [*args], {key}) 

Die Funktion min verhält sich wie max, ermittelt jedoch das kleinste Element einer Sequenz bzw. den kleinsten übergebenen Parameter.

 

19.8.33    oct(x) 

Die Funktion oct erzeugt einen String, der die übergebene ganze Zahl x in Oktalschreibweise enthält.

>>> oct(123)
'0o173'
>>> oct(0o777)
'0o777'

 

19.8.34    ord(c) 

Die Funktion ord erwartet einen String der Länge 1 und gibt den Unicode-Codepoint des enthaltenen Zeichens zurück.

>>> ord("P")
80
>>> ord("€")
8364

Näheres zu Unicode und Codepoints erfahren Sie in Abschnitt 13.4.4, »Zeichensätze und Sonderzeichen«.

 

19.8.35    pow(x, y, [z]) 

Berechnet x ** y oder, wenn z angegeben wurde, x ** y % z. Diese Berechnung ist unter Verwendung des Parameters z performanter als die Ausdrücke pow(x, y) % z bzw. x ** y % z.

>>> 7 ** 5 % 4
3
>>> pow(7, 5, 4)
3

 

19.8.36    print([*objects], {sep, end, file, flush}) 

Die Funktion print schreibt die Textentsprechungen der für objects übergebenen Instanzen in den Datenstrom file. Bislang haben wir print nur dazu verwendet, auf den Bildschirm bzw. in die Standardausgabe zu schreiben.

Hier sehen wir, dass print es über den Schlüsselwortparameter file ermöglicht, in ein beliebiges zum Schreiben geöffnetes Dateiobjekt zu schreiben:

>>> f = open("datei.txt", "w")
>>> print("Hallo Welt", file=f)
>>> f.close()

Über den Schlüsselwortparameter sep, der mit einem Leerzeichen vorbelegt ist, wird das Trennzeichen angegeben, das zwischen zwei auszugebenden Werten stehen soll:

>>> print("Hallo", "Welt")
Hallo Welt
>>> print("Hallo", "du", "schöne", "Welt", sep="-")
Hallo-du-schöne-Welt

Über den zweiten Schlüsselwortparameter end wird bestimmt, welches Zeichen print als Letztes, also nach erfolgter Ausgabe aller übergebenen Instanzen, ausgeben soll. Vorbelegt ist dieser Parameter mit einem Newline-Zeichen.

>>> print("Hallo", end=" Welt\n")
Hallo Welt
>>> print("Hallo", "Welt", end="AAAA")
Hallo WeltAAAA>>>

Im letzten Beispiel befindet sich der Eingabeprompt des Interpreters direkt hinter der von print erzeugten Ausgabe, weil im Gegensatz zum Standardverhalten von print am Ende kein Newline-Zeichen ausgegeben wurde.

Mithilfe des letzten Parameters flush können Sie ein Leeren des Datenstrompuffers nach der Ausgabe erzwingen.

 

19.8.37    range([start], stop, [step]) 

Die Funktion range erzeugt ein iterierbares Objekt über fortlaufende, numerische Werte. Dabei wird mit start begonnen, vor stop aufgehört und in jedem Schritt der vorherige Wert um step erhöht. Sowohl start als auch step sind optional und mit 0 bzw. 1 vorbelegt.

Beachten Sie, dass stop eine Grenze angibt, die nicht erreicht wird. Die Nummerierung beginnt also bei 0 und endet einen Schritt, bevor stop erreicht würde.

Bei dem von range zurückgegebenen iterierbaren Objekt handelt es sich um ein sogenanntes range-Objekt. Dies wird bei der Ausgabe im interaktiven Modus folgendermaßen angezeigt:

>>> range(10)
range(0, 10)

Um zu veranschaulichen, über welche Zahlen das range-Objekt iteriert, wurde es in den folgenden Beispielen mit list in eine Liste überführt:

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

Es ist möglich, eine negative Schrittweite anzugeben:

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

 

19.8.38    repr(object) 

Die Funktion repr gibt einen String zurück, der eine druckbare Repräsentation der Instanz object enthält. Für viele Instanzen versucht repr, den Python-Code in den String zu schreiben, der die entsprechende Instanz erzeugen würde. Für manche Instanzen ist dies jedoch nicht möglich bzw. nicht praktikabel. In einem solchen Fall gibt repr zumindest den Typ der Instanz aus.

>>> repr([1,2,3,4])
'[1, 2, 3, 4]'
>>> repr(0x34)
'52'
>>> repr(set([1,2,3,4]))
'{1, 2, 3, 4}'
>>> repr(open("datei.txt", "w"))
"<_io.TextIOWrapper name='datei.txt' mode='w' encoding='UTF-8'>"

 

19.8.39    reversed(sequence) 

Mit reversed kann eine Instanz sequence eines sequenziellen Datentyps effizient rückwärts durchlaufen werden.

>>> for i in reversed([1, 2, 3, 4, 5, 6]):
...    print(i)
6
5
4
3
2
1

 

19.8.40    round(x, [n]) 

Die Funktion round rundet die Gleitkommazahl x auf n Nachkommastellen. Der Parameter n ist optional und mit 0 vorbelegt.

>>> round(-0.5)
0
>>> round(0.5234234234234, 5)
0.52342
>>> round(0.5, 4)
0.5

 

19.8.41    set([iterable]) 

Hiermit wird eine Instanz des Datentyps set[ 77 ](siehe Abschnitt 15.1, »Die Datentypen set und frozenset« ) erzeugt. Wenn angegeben, werden alle Elemente des iterierbaren Objekts iterable in das Set übernommen. Beachten Sie, dass ein Set keine Dubletten enthalten darf, jedes in iterable mehrfach vorkommende Element also nur einmal eingetragen wird.

>>> set()
set()
>>> set("Hallo Welt")
{'t', 'e', 'a', 'l', ' ', 'W', 'H', 'o'}
>>> set({1,2,3,4})
{1, 2, 3, 4}

 

19.8.42    sorted(iterable, [key, reverse]) 

Die Funktion sorted erzeugt aus den Elementen von iterable eine sortierte Liste:

>>> sorted([3,1,6,2,9,1,8])
[1, 1, 2, 3, 6, 8, 9]
>>> sorted("Hallo Welt")
[' ', 'H', 'W', 'a', 'e', 'l', 'l', 'l', 'o', 't']

Die Funktionsweise von sorted ist identisch mit der Methode sort der sequenziellen Datentypen, die in Abschnitt 13.2.4, »Methoden von list-Instanzen«, erklärt wird.

 

19.8.43    str([object, encoding, errors]) 

Hiermit wird ein String erzeugt,[ 78 ](siehe Abschnitt 13.4.4, »Zeichensätze und Sonderzeichen« ) der eine lesbare Beschreibung der Instanz object enthält. Wenn object nicht übergeben wird, erzeugt str einen leeren String.

>>> str(None)
'None'
>>> str()
''
>>> str(12345)
'12345'
>>> str(str)
"<class 'str'>"

Die Funktion str kann dazu verwendet werden, einen bytes-String oder eine bytearray-Instanz in einen String zu überführen. Dieser Prozess wird Decodieren genannt, und es muss dazu mindestens der Parameter encoding angegeben worden sein:

>>> b = bytearray([1,2,3])
>>> str(b, "utf-8")
'\x01\x02\x03'
>>> b = bytes("Hallö Wölt", "utf-8", "strict")
>>> str(b)
"b'Hall\\xc3\\xb6 W\\xc3\\xb6lt'"
>>> str(b, "utf-8")
'Hallö Wölt'

Dabei muss für den Parameter encoding ein String übergeben werden, der das Encoding enthält, mit dem der bytes-String codiert wurde, in diesem Fall utf-8. Der Parameter errors wurde im Beispiel oben nicht angegeben und bestimmt, wie mit Decodierungsfehlern zu verfahren ist. Tabelle 19.2 listet die möglichen Werte für errors und ihre Bedeutung auf.

errors	Beschreibung
"strict"	Bei einem Decodierungsfehler wird eine ValueError-Exception geworfen.
"ignore"	Fehler bei der Decodierung werden ignoriert.
"replace"	Ein Zeichen, das nicht decodiert werden konnte, wird durch das Unicode-Zeichen U+FFFD (), auch Replacement Character genannt, ersetzt.

Tabelle 19.2    Mögliche Werte des Parameters errors

 

19.8.44    sum(iterable, [start]) 

Die Funktion sum berechnet die Summe aller Elemente des iterierbaren Objekts iterable und gibt das Ergebnis zurück. Wenn der optionale Parameter start angegeben wurde, fließt dieser als Startwert der Berechnung ebenfalls in die Summe mit ein.

>>> sum([1,2,3,4])
10
>>> sum({1,2,3,4}, 2)
12
>>> sum({4,3,2,1}, 2)
12

 

19.8.45    tuple([iterable]) 

Hiermit wird eine Instanz des Datentyps tuple[ 79 ](siehe Abschnitt 13.3, »Unveränderliche Listen – tuple« ) aus den Elementen von iterable erzeugt.

>>> tuple()
()
>>> tuple([1,2,3,4])
(1, 2, 3, 4)

 

19.8.46    type(object) 

Die Funktion type gibt den Datentyp der übergebenen Instanz object zurück.

>>> type(1)
<class 'int'>
>>> type("Hallo Welt") == str
True
>>> type(sum)
<class 'builtin_function_or_method'>

 

19.8.47    zip([*iterables]) 

Die Funktion zip nimmt beliebig viele, gleich lange iterierbare Objekte als Parameter. Sollten nicht alle die gleiche Länge haben, werden die längeren nur bis zur Länge des kürzesten dieser Objekte betrachtet.

Als Rückgabewert wird ein iterierbares Objekt erzeugt, das über Tupel iteriert, die im i-ten Iterationsschritt die jeweils i-ten Elemente der übergebenen Sequenzen enthalten.

>>> ergebnis = zip([1,2,3,4], [5,6,7,8], [9,10,11,12])
>>> list(ergebnis)
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
>>> ergebnis = zip("Hallo Welt", "HaWe")
>>> list(ergebnis)
[('H', 'H'), ('a', 'a'), ('l', 'W'), ('l', 'e')]

Bei der bereits besprochenen Funktion enumerate handelt es sich um einen Spezialfall der zip-Funktion:

>>> s = "Python"
>>> list(zip(range(len(s)), s))
[(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')] 

Damit haben wir den ersten Teil der eingebauten Funktionen besprochen. In Kapitel 21, in dem die Konzepte der objektorientierten Programmierung besprochen werden, finden Sie in Abschnitt 21.5, »Built-in Functions für Objektorientierung«, die Beschreibung der eingebauten Funktionen mit objektorientiertem Hintergrund.