Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
1 Einleitung
2 Überblick über Python
3 Die Arbeit mit Python
4 Der interaktive Modus
5 Grundlegendes zu Python-Programmen
6 Kontrollstrukturen
7 Das Laufzeitmodell
8 Basisdatentypen
9 Benutzerinteraktion und Dateizugriff
10 Funktionen
11 Modularisierung
12 Objektorientierung
13 Weitere Spracheigenschaften
14 Mathematik
15 Strings
16 Datum und Zeit
17 Schnittstelle zum Betriebssystem
18 Parallele Programmierung
19 Datenspeicherung
20 Netzwerkkommunikation
21 Debugging
22 Distribution von Python-Projekten
23 Optimierung
24 Grafische Benutzeroberflächen
25 Python als serverseitige Programmiersprache im WWW mit Django
26 Anbindung an andere Programmiersprachen
27 Insiderwissen
28 Zukunft von Python
A Anhang
Stichwort

Download:
- ZIP, ca. 4,8 MB
Buch bestellen
Ihre Meinung?

Spacer
 <<   zurück
Python von Peter Kaiser, Johannes Ernesti
Das umfassende Handbuch - Aktuell zu Python 2.5
Buch: Python

Python
gebunden, mit CD
819 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1110-9
Pfeil 10 Funktionen
  Pfeil 10.1 Schreiben einer Funktion
  Pfeil 10.2 Funktionsparameter
    Pfeil 10.2.1 Optionale Parameter
    Pfeil 10.2.2 Schlüsselwortparameter
    Pfeil 10.2.3 Beliebige Anzahl von Parametern
    Pfeil 10.2.4 Seiteneffekte
  Pfeil 10.3 Zugriff auf globale Variablen
  Pfeil 10.4 Lokale Funktionen
  Pfeil 10.5 Anonyme Funktionen
  Pfeil 10.6 Rekursion
  Pfeil 10.7 Vordefinierte Funktionen


Galileo Computing - Zum Seitenanfang

10.7 Vordefinierte Funktionen  topZur vorigen Überschrift

Es war im Laufe des Buches schon oft von sogenannten Built-in Functions die Rede. Das sind vordefinierte Funktionen, die dem Programmierer jederzeit zur Verfügung stehen. Üblicherweise handelt es sich dabei um Hilfsfunktionen, die das Programmieren in Python erheblich erleichtern. Sie kennen bereits die Built-in Functions len und range. Im Folgenden werden alle bisher relevanten Built-in Functions ausführlich beschrieben. Im Anhang finden Sie eine vollständige tabellarische Übersicht.

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, long, float, bool oder complex.

>>> abs(1) 
1 
>>> abs(-12.34) 
12.34 
>>> abs(3 + 4j) 
5.0
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
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
bool([x])

Gibt den Wahrheitswert der Instanz x zurück. Wenn kein Parameter übergeben wurde, gibt die Funktion bool den booleschen Wert False zurück.

chr(i)

Die Funktion chr gibt einen String der Länge 1 zurück, der das Zeichen mit dem ASCII-Code i enthält. Der Parameter i repräsentiert ein Byte, muss also eine ganze Zahl zwischen 0 und 255 sein.

>>> chr(65) 
'A' 
>>> chr(33) 
'!'
cmp(x, y)

Die Funktion cmp vergleicht zwei beliebige, aber vergleichbare Instanzen miteinander. Das Ergebnis ist negativ, wenn x < y, null, wenn x == y, und positiv, wenn x > y. Beachten Sie, dass nicht nur Zahlen untereinander vergleichbar sind, sondern beispielsweise auch Strings oder Listen.

>>> cmp("A", "B") 
-1 
>>> cmp(999, 99) 
1 
>>> cmp([1,2], [1,2]) 
0
complex([real[, imag]])

Dies erzeugt eine Instanz des Datentyps complex zur Speicherung einer komplexen Zahl. 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.

dict([source])

Erzeugt eine Instanz des Datentyps dict. 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 eine Liste von Tupeln sein, wobei jedes Tupel zwei Elemente enthalten kann: Den Schlüssel und den damit assoziierten Wert. Die Liste muss also folgende Struktur haben: [("a", 1), ("b", 2)]:
>>> 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}
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)
enumerate(iterable)

Die Funktion enumerate erzeugt ein iterierbares Objekt, das nicht allein über die Elemente von iterable iteriert, sondern über Tupel der folgenden 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.

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(iterable): 
    print "Der Wert von iterable an", i, "ter Stelle ist:", wert

Angenommen, der obige Code würde für eine Liste iterable = [1,2,3,4,5] ausgeführt, so käme folgende Ausgabe zustande:

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
file(filename[, mode[, bufsize]])

Konstruiert ein Dateiobjekt. Die Funktion file verfügt über die gleiche Schnittstelle wie die in Abschnitt 9.3 besprochene Built-in Function open und bewirkt das Gleiche. Dennoch sollten Sie zum Öffnen einer Datei stets open verwenden, anstatt den Konstruktor des Dateiobjekts direkt aufzurufen.

filter(function, list)

Die Funktion filter erwartet ein Funktionsobjekt als ersten und eine Liste als zweiten Parameter. Der Parameter function muss eine Funktion oder Lambda-Form sein, die einen Parameter erwartet und einen booleschen Wert zurückgibt.

Die Funktion filter ruft für jedes Element der Liste list die Funktion function auf und erzeugt eine neue Liste, die alle Elemente von list enthält, für die function True zurückgegeben hat. Dies soll an folgendem Beispiel erklärt werden, in dem filter dazu verwendet wird, um aus einer Liste von ganzen Zahlen die ungeraden Zahlen herauszufiltern:

def fun(prm): 
    return (prm%2 == 0) 
print filter(fun, [1,2,3,4,5,6,7,8,9,10])

Die Ausgabe des Beispiels lautet:

[2, 4, 6, 8, 10]
float([x])

Erzeugt eine Instanz des Datentyps float. 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
frozenset([iterable])

Erzeugt eine Instanz des Datentyps frozenset zum Speichern einer unveränderlichen Menge. Wenn der Parameter iterable angegeben wurde, so werden die Elemente der erzeugten Menge diesem iterierbaren Objekt entnommen. Wenn der Parameter iterable nicht angegeben wurde, ist der Funktionsaufruf äquivalent zu frozenset([]). 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(['h', 'o', 'n', 'P', 't', 'y'])
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, 'c': [1, 2, 3], 'b': {}, '__builtins__': <module '__builtin__'
(built-in)>, '__name__': '__main__', '__doc__': None}

Das zurückgegebene Dictionary enthält neben den vorher angelegten noch weitere Instanzen, die im globalen Namensraum existieren. Diese vordefinierten Referenzen haben wir bisher noch nicht besprochen, lassen Sie sich davon also nicht stören.

hash(object)

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") 
-962533610 
>>> hash((1,2,3,4)) 
89902565

Beachten Sie den Unterschied zwischen veränderlichen (mutable) und unveränderlichen (immutable) 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: list objects are unhashable
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.

hex(x)

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'
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
input([prompt])

Liest einen Python-Ausdruck vom Benutzer ein und evaluiert ihn. Das Ergebnis der Evaluation wird zurückgegeben. Der Parameter prompt ist optional. Hier kann ein String angegeben werden, der vor der Eingabeaufforderung ausgegeben werden soll.

>>> input() 
2+2 
4 
>>> input("Geben Sie einen Ausdruck ein: ") 
Geben Sie einen Ausdruck ein: (12 + 14)*9 
234
int([x[, radix]])

Erzeugt eine Instanz des Datentyps int. 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, so erwartet die Funktion int, dass dieser String den gewünschten Wert der Instanz enthält. Durch den optionalen Parameter radix 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
len(s)

Gibt die Länge bzw. die Anzahl der Elemente von s zurück.

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

Erzeugt eine Instanz des Datentyps list aus den Elementen von sequence. 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']
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 lokals() 
f(1, 2, 3)

Dieses Beispiel erzeugt folgende Ausgabe:

{'a': 1, 'c': 3, 'b': 2, 'd': 6}

Beachten Sie, dass der Aufruf von locals im Namensraum des Hauptprogramms äquivalent ist zum Aufruf von globals.

long([x[, radix]])

Erzeugt eine Instanz des Datentyps long. Die Funktionsschnittstelle kann verwendet werden wie die von int.

>>> long(123) 
123L
map(function, list …)

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

Die Funktion map ruft function für jedes Element der übergebenen Liste auf und gibt eine neue Liste zurück, die die jeweiligen Rückgabewerte von function enthält. Sollten mehrere Listen übergeben werden, so werden function die jeweils n-ten Elemente aller Listen übergeben. Beachten Sie, dass function aus diesem Grund unbedingt genau so viele Parameter erwarten muss, wie Listen übergeben werden, und dass alle übergebenen Listen gleich viele Elemente enthalten müssen.

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 
>>> map(f, [1,2,3,4]) 
[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 
>>> map(f, [1,2,3,4], [1,2,3,4]) 
[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.

In beiden Beispielen wurden Listen verwendet, die ausschließlich numerische Elemente enthielten. Das muss nicht unbedingt sein. Welche Elemente eine Liste enthalten darf, hängt davon ab, welche Instanzen für function als Parameter verwendet werden dürfen.

Das obige Beispiel soll durch Abbildung 10.2 anschaulich erklärt werden.

Abbildung 10.2  Arbeitsweise der Built-in Function map

Die eingehenden und ausgehenden Listen sind jeweils senkrecht dargestellt.

max(s[, args...][key])

Wenn keine zusätzlichen Parameter übergeben werden, erwartet max eine Sequenz und gibt ihr größtes Element zurück. Die übergebene Instanz eines sequenziellen Datentyps muss Elemente enthalten:

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

Wenn mehrere Parameter übergeben werden, so 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'

Für beide Verwendungsarten von max kann eine optionale Funktion als Schlüsselwortparameter übergeben werden, die für jedes Element der übergebenen Sequenz bzw. jeden Parameter aufgerufen wird, bevor das größte Element festgestellt wird. So ist es mit key möglich, aus den übergebenen Datensätzen eine für die Ordnungsrelation relevante Information zu extrahieren.

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.

min(s[, args...][key])

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

oct(x)

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

>>> oct(123) 
'0173' 
>>> oct(0777) 
'0777'
open(filename[, mode[, bufsize]])

Öffnet eine Datei im gewünschten Modus und gibt das erzeugte Dateiobjekt zurück. Eine vollständige Beschreibung der Funktion finden Sie im Abschnitt 9.3.4, »Verwendung des Dateiobjekts«.

ord(c)

Die Funktion ord erwartet einen String der Länge 1 und gibt den ASCII-Code des enthaltenen Zeichens zurück. Wenn es sich um einen Unicode-String handelt, wird der Unicode-Code des Zeichens zurückgegeben.

>>> ord("P") 
80
pow(x, y[, z])

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

>>> 7 ** 5  % 4 
3 
>>> pow(7, 5, 4) 
3
range([start, ]stop[, step])

Die Funktion range erzeugt eine Liste mit fortlaufenden, numerischen Elementen. Dabei beginnen die Elemente der Liste mit start, enden vor stop, und jedes Element ist um step größer als das vorherige. Sowohl start als auch step sind optional und mit 0 bzw. 1 vorbelegt.

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

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

Es ist möglich, eine negative Schrittweite anzugeben:

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

In allen bisherigen Beispielen des Buches, in denen eine Zählschleife benötigt wurde, wurde dafür range in Kombination mit einer for-Schleife verwendet. Dazu ist zu sagen, dass es in nahezu allen Fällen performanter ist, stattdessen die Built-in Function xrange zu verwenden, auf die wir in diesem Kapitel noch zu sprechen kommen werden.

raw_input([prompt])

Liest eine Eingabe vom Benutzer ein und gibt diese als String zurück. Durch den optionalen Parameter prompt kann ein String angegeben werden, der vor der Eingabeaufforderung ausgegeben wird.

>>> raw_input() 
2+2 
'2+2' 
>>> s = raw_input("Ihre Eingabe bitte: ") 
Ihre Eingabe bitte: Oh, kein Thema, bitte sehr 
>>> s 
'Oh, kein Thema, bitte sehr'

Beachten Sie, dass raw_input im Gegensatz zu input die Eingabe nicht als Python-Ausdruck interpretiert, sondern als String zurückgibt. Damit ist raw_input in den meisten Fällen eine bessere Wahl als input, da der Input so im Programm ankommt, wie er von der Tastatur eingegeben wurde.

reduce(function, sequence[, initializer])

Die Funktion reduce erwartet ein Funktionsobjekt als ersten und eine Sequenz als zweiten Parameter. Die Funktion function muss zwei Parameter akzeptieren und aus ihnen einen Rückgabewert bestimmen.

Die Funktion reduce ruft function für die ersten beiden Elemente der Sequenz sequence auf und ersetzt beide Elemente durch den Rückgabewert von function. Diese Prozedur wiederholt sich so lange, bis sequence nur noch ein Element enthält. Dieses wird zurückgegeben.

Beachten Sie, dass die Funktion frei von Nebeneffekten ist, an sequence selbst also nichts geändert wird. Insofern ist reduce ein unglücklich gewählter Name, denn an der übergebenen Sequenz wird nichts geändert.

Bei der Liste [a, b, c, d] wäre der Aufruf von reduce gleichbedeutend mit:

function(function(function(a, b), c), d)

Im folgenden Beispiel wird reduce dazu verwendet, das Produkt aller Elemente von sequence zu errechnen.

>>> f = lambda x, y: x * y 
>>> reduce(f, [5,9,27,3,11]) 
40095

Abbildung 10.3 soll die dem Ergebnis zugrunde liegende Berechnung verdeutlichen.

Abbildung 10.3  Funktionsweise von reduce

Wenn der optionale Parameter initializer angegeben wurde, so wird die hier übergebene Instanz als Startwert der Berechnung angenommen. Man kann sich das so vorstellen, dass die übergebene Instanz gedanklich als erstes Element in sequence eingefügt wird. Das bedeutet unter anderem, dass das Übergeben einer leeren Liste nur dann erlaubt ist, wenn der Parameter initializer angegeben wurde.

>>> f = lambda x, y: x * y 
>>> reduce(f, []) 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
TypeError: reduce() of empty sequence with no initial value 
>>> reduce(f, [], 100) 
100
repr(object)

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])) 
'set([1, 2, 3, 4])' 
>>> repr(open("datei.txt", "w")) 
"<open file 'datei.txt', mode 'w' at 0xb7bea0f8>"
reversed(seq)

Mit reversed kann eine Sequenz seq sehr effizient rückwärts durchlaufen werden: [Die Built-in-Function reversed ist nicht auf Sequenzen beschränkt, sondern funktioniert für jedes beliebige iterierbare Objekt. Was es mit iterierbaren Objekten auf sich hat, erfahren Sie in Abschnitt 13.5. ]

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

Rundet die Gleitkommazahl x auf n Nachkommastellen. Der Parameter n ist optional und mit 0 vorbelegt.

>>> round(0.5, 4) 
0.5 
>>> round(-0.5) 
-1.0 
>>> round(0.5234234234234, 5) 
0.52342
set([iterable])

Erzeugt eine Instanz des Datentyps set. 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") 
set(['a', ' ', 'e', 'H', 'l', 'o', 't', 'W']) 
>>> set([1,2,3,4]) 
set([1, 2, 3, 4])
sorted(iterable[, cmp[, 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 Funktion akzeptiert drei weitere Schlüsselwortparameter, um das Sortieren der Elemente zu beeinflussen:

  • Durch den Schlüsselwortparameter cmp kann eine eigene Vergleichsfunktion angegeben werden. Diese muss über die gleiche Schnittstelle und das gleiche Verhalten verfügen wie die Built-in Function cmp. Im Beispiel wurde eine Vergleichsfunktion geschrieben, die das negative Ergebnis der Built-in Function cmp zurückgibt. Dadurch wird die Liste umgekehrt sortiert:
>>> f = lambda x, y: -cmp(x, y) 
>>> sorted([3,1,6,2,9,1,8], cmp=f) 
[9, 8, 6, 3, 2, 1, 1]
  • Durch den Schlüsselwortparameter key kann eine Funktion übergeben werden, die die für den Vergleich wichtige Information aus den Elementen extrahiert. Die Funktion muss einen Parameter akzeptieren und einen Rückgabewert zurückgeben. Wie die Built-in Function max verfügt sorted ebenfalls über einen Parameter key, über den eine Funktion gleicher Schnittstelle und gleicher Bedeutung übergeben werden muss.
>>> f = lambda x: x.lower() 
>>> sorted("Hallo Welt", key=f) 
[' ', 'a', 'e', 'H', 'l', 'l', 'l', 'o', 't', 'W']
  • Der Schlüsselwortparameter reverse muss ein boolescher Wert sein und ist mit False vorbelegt. Wird er auf True gesetzt, so veranlasst dies sorted, die Sortierreihenfolge umzukehren.
>>> sorted([3,1,6,2,9,1,8], reverse=True) 
[9, 8, 6, 3, 2, 1, 1]

Die obigen Schlüsselwortparameter können selbstverständlich nicht nur isoliert, sondern auch gemeinsam übergeben werden.

Es ist in den meisten Fällen schneller, eine Liste durch Angabe von key und reverse in einer bestimmten Weise zu sortieren, als den gleichen Effekt durch cmp zu erreichen, da cmp für jedes Element mehrfach aufgerufen werden muss.

str([object])

Erzeugt eine Instanz des Datentyps str. Wenn der optionale Parameter object übergeben wird, so wird eine lesbare Repräsentation der Instanz in den String geschrieben. Der Unterschied zu repr besteht darin, dass str nicht immer versucht, die Ausgabe als gültigen Python-Code zu formulieren.

>>> str(None) 
'None' 
>>> str() 
'' 
>>> str(None) 
'None' 
>>> str(str) 
"<type 'str'>"
sum(sequence[, start])

Die Funktion sum berechnet die Summe aller Elemente von sequence und gibt das Ergebnis zurück. Wenn der optionale Parameter start angegeben wurde, so 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
tuple([sequence])

Erzeugt eine Instanz des Datentyps tuple und überträgt dabei, wenn angegeben, alle Elemente von sequence in diese neue Instanz.

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

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

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

Die Funktion unichr erzeugt einen Unicode-String der Länge 1, der das Zeichen mit dem Unicode-Code i enthält:

>>> unichr(64) 
u'@' 
>>> unichr(99) 
u'c'
unicode([object[, encoding[, errors]]])

Erzeugt eine Instanz des Datentyps unicode, die, sofern angegeben, eine lesbare Repräsentation der Instanz object enthält.

Wenn object eine Instanz des Datentyps str ist, können zusätzlich die Parameter encoding und errors angegeben werden, die das Konvertieren des 8-Bit-Strings in einen Unicode-String beeinflussen. Der Parameter encoding muss ein String sein, der den Namen des Encodings enthält, das zum Decodieren des 8-Bit-Strings verwendet werden soll. Der Parameter errors muss ein String sein und regelt, wie verfahren werden soll, wenn ein Zeichen auftritt, das nicht decodiert werden kann. Wenn errors den Wert "strict", mit dem der Parameter vorbelegt ist, hat, wird ein ValueError erzeugt. Wenn errors den Wert "ignore" hat, werden Fehler beim Dekodieren ignoriert.

>>> unicode() 
u'' 
>>> unicode("Hallo Welt") 
u'Hallo Welt' 
>>> unicode("Hallo Welt", "utf16") 
u'\u6148\u6c6c\u206f\u6557\u746c'
xrange([start, ]stop[, step])

Die Funktion xrange verfügt über die gleiche Schnittstelle wie die Funktion range und ist für ähnliche Zwecke gedacht. Jedoch gibt xrange keine vollständige Liste zurück, sondern ein sogenanntes XRange-Objekt. Das ist ein iterierbares Objekt, das sich wie eine Liste verhält, aber das nächste Element erst bei Bedarf erzeugt. Die Funktion ist dazu gedacht, range bei der Verwendung in einer for-Schleife abzulösen. Dort ist xrange, gerade wenn sonst sehr große Listen erzeugt werden müssten, schneller und effizienter.

Beachten Sie aber, dass es zwar möglich ist, auf beliebige Elemente des XRange-Objekts zuzugreifen, dass dies aber sehr langsam ist. Sollten solche Operationen gefordert sein, muss zu range gegriffen werden.

zip([iterable, …])

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

Als Rückgabewert wird eine neue Liste erzeugt, die als Element i ein Tupel enthält, das seinerseits die i-ten Elemente der übergebenen Listen enthält.

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

Dies waren noch nicht alle Built-in Functions, da einige für Themen gedacht sind, die bisher noch nicht behandelt wurden. Im Anhang finden Sie eine tabellarische Übersicht über alle Built-in Functions, inklusive eines Verweises, wo die jeweilige Funktion detailliert besprochen wird.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






 <<   zurück
  
  Zum Katalog
Zum Katalog: Python






Python
bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Linux






 Linux


Zum Katalog: Ubuntu GNU/Linux






 Ubuntu GNU/Linux


Zum Katalog: Praxisbuch Web 2.0






 Praxisbuch Web 2.0


Zum Katalog: UML 2.0






 UML 2.0


Zum Katalog: Praxisbuch Objektorientierung






 Praxisbuch Objektorientierung


Zum Katalog: Einstieg in SQL






 Einstieg in SQL


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für Fachinformatiker


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo





Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de