Zahlen - EDV-Buchversand

First
Kapitel 4
KAPITEL 4
Zahlen
Mit diesem Kapitel beginnt unsere Reise durch Python. In Python existieren Daten in
Form von Objekten. Das sind entweder bereits in Python eingebaute Objekte oder solche,
die wir selbst mit Hilfe von Python und C erstellen. Da Objekte das wichtigste Konzept in
der Python-Programmierung darstellen, beginnen wir dieses Kapitel mit einem Überblick
über die in Python eingebauten Objekttypen, bevor wir uns speziell den Zahlen widmen.
Python-Programmstruktur
Wir versuchen, als Einführung zuerst ein klares Bild davon zu vermitteln, wie das, was
Sie in diesem Kapitel lernen, in das Gesamtbild von Python passt. Konkreter: PythonProgramme können in Module, Anweisungen, Ausdrücke und Objekte zerlegt werden:
1. Programme bestehen aus Modulen.
2. Module enthalten Anweisungen.
3. Anweisungen enthalten Ausdrücke.
4. Ausdrücke bilden und verarbeiten Objekte.
Die oberste Ebene dieser Hierarchie haben wir im Zusammenhang mit Modulen in
Kapitel 3 eingeführt. Die Kapitel dieses Buchteils fangen von unten an und untersuchen
dabei sowohl eingebaute Objekte als auch die Ausdrücke, die Sie damit codieren können.
Warum eingebaute Typen benutzen?
Max.
Linie
Wenn Sie bereits mit Sprachen auf niedrigerem Niveau, wie C oder C++, gearbeitet
haben, wissen Sie, dass sich ein Großteil Ihrer Arbeit darauf konzentriert, Objekte zu
implementieren, die man oft auch als Datenstrukturen bezeichnet, um die relevanten
“
Max.
Linie
Links
Komponenten Ihres Anwendungsbereichs darzustellen. Sie müssen Speicherstrukturen
anlegen, Speicherzuordnungen verwalten, Such- und Zugangsroutinen implementieren
usw. Diese Routineaufgaben sind genauso langweilig (und fehleranfällig), wie sie klingen,
und lenken meistens von den eigentlichen Zielen Ihres Programms ab.
In typischen Python-Programmen verschwindet ein Großteil dieser lästigen Arbeit. Weil
Python über mächtige Objekttypen als wesentlichen Teil der Sprache verfügt, ist es nicht
notwendig, Objekt-Implementierungen zu erstellen, bevor Sie anfangen, Ihre Probleme
zu lösen. Sie sind wirklich besser bedient, wenn Sie die eingebauten Objekte benutzen,
anstatt Ihre eigenen zu implementieren, es sei denn, Sie brauchen eine spezielle Art von
Beaarbeitung, die die eingebauten Typen nicht bieten. Hier sind einige Gründe dafür:
Eingebaute Objekttypen machen es einfach, Programme zu schreiben. Für einfache Aufgaben sind eingebaute Typen oft alles, was Sie brauchen, um die Struktur eines Problems darzustellen. Weil Dinge wie Sammlungen (z.B. Listen) und Suchtabellen
(Dictionaries) bereits zur Verfügung stehen, können Sie sie sofort benutzen. Allein
mit diesen eingebauten Objekttypen können Sie eine Menge Arbeit erledigen.
Python stellt Objekttypen zur Verfügung und unterstützt Erweiterungen. In gewisser
Weise macht Python Anleihen sowohl bei Sprachen, die sich auf eingebaute Werkzeuge verlassen (z.B. LISP), als auch bei Sprachen, die sich auf den Programmierer
verlassen, der eigene Werkzeug-Implementierungen oder Frameworks liefert (z.B.
C++). Obwohl Sie in Python anwendungsspezifische Objekttypen implementieren
können, müssen Sie das am Anfang nicht unbedingt tun. Darüber hinaus sind
Pythons eingebaute Typen immer gleich, während Frameworks sich in der Regel
unterscheiden.
Eingebaute Objekttypen sind Komponenten von Erweiterungen. Für komplexere Aufgaben müssen Sie vielleicht doch mit Hilfe von Python-Anweisungen oder Schnittstellen zur Sprache C eigene Objekttypen erstellen. Aber wie Sie in den folgenden Teilen
sehen werden, basieren selbst implementierte Objekte oft auf eingebauten Typen wie
Listen und Dictionaries. Eine Stapel-Datenstruktur kann z.B. als eine Klasse implementiert werden, die intern ein Objekt vom eingebauten Typ Liste verwaltet.
Eingebaute Objekttypen sind oft effizienter als eigene Datenstrukturen. Die in Python
eingebauten Typen wenden bereits optimierte Datenstruktur-Algorithmen an, die
wegen der höheren Geschwindigkeit in C implementiert sind. Obwohl Sie selbst
ähnliche Objekttypen schreiben können, werden Sie normalerweise nur mit Mühe
die Performance von eingebauten Objekttypen erreichen können.
Mit anderen Worten: Eingebaute Objekttypen machen nicht nur das Programmieren einfacher, sie sind auch mächtiger und effizienter als fast alles, was von Grund auf neu
erstellt wird. Unabhängig davon, ob Sie neue Objekttypen implementieren oder nicht,
bilden die eingebauten Objekttypen den Kern eines jeden Python-Programms.
Max.
Linie
Max.
Linie
58 | Kapitel 4: Zahlen
“
Rechts
Tabelle 4-1 bietet eine Vorschau auf die eingebauten Objekttypen und ein wenig Syntax
für die Codierung ihrer Literale, d.h. der Ausdrücke, die Objekte generieren.1 Einige
davon werden Ihnen vermutlich bekannt vorkommen, wenn Sie schon mit anderen Sprachen gearbeitet haben. Zum Beispiel stellen Zahlen und Strings numerische Werte bzw.
Textwerte dar, und Dateien bieten eine Schnitttelle für die Bearbeitung von Dateien, die
auf Ihrem Rechner gespeichert sind.
Tabelle 4-1: Vorschau auf eingebaute Objekte
Objekttyp
Beispiel-Literale/-Erzeugung
Zahlen
3.1415, 1234, 999L, 3+4j
Strings
'spam', "guido's"
Listen
[1, [2, 'three'], 4]
Dictionaries
{'food': 'spam', 'taste': 'yum'}
Tupel
(1,'spam', 4, 'U')
Dateien
text = open('eggs', 'r').read( )
Mengen
set([1, 2, 'three'])
frozenset([1, 2, 'three'])
Die Objekttypen in Tabelle 4-1 sind allgemeiner und mächtiger als das, was Sie vielleicht
gewohnt sind. Sie werden z.B. feststellen, dass Listen und Dictionaries einen Großteil der
Arbeit unnötig machen, die Sie in niedrigeren Sprachen auf Sammlungen und Suchvorgänge verwenden. Listen sind geordnete Sammlungen anderer Objekte, die über ihre Position mit Zahlen ab 0 indiziert werden. Und Dictionaries sind Sammlungen anderer
Objekte, die über einen Schlüssel statt über ihre Position indiziert werden. Sowohl Dictionaries als auch Listen können verschachtelt werden, können bei Bedarf wachsen oder
schrumpfen und dürfen Objekte beliebigen Typs enthalten. Die ganze Geschichte erfahren
Sie, wenn Sie weiterlesen.
Zahlen
Der erste Objekttyp auf unserer Reise sind Python-Zahlen. Im Allgemeinen werden Ihnen
Pythons Zahlentypen vertraut vorkommen, wenn Sie schon irgendeine andere Programmiersprache benutzt haben. Python unterstützt die üblichen numerischen Typen: Ganzzahlen (engl. Integer) und Fließkommazahlen, ebenso wie Literale für die Erzeugung von
Zahlen und Ausdrücke für ihre Verarbeitung.
Max.
Linie
1 In diesem Buch steht der Begriff Literal einfach für einen Ausdruck, dessen Syntax ein Objekt erzeugt, manchmal
auch eine Konstante genannt. Allerdings heißt das nicht, dass Objekte oder Variablen gemeint sind, die nicht
mehr geändert werden können (d.h., es gibt keinen Zusammenhang zu const in C++ oder zu etwas »Unveränderlichem« in Python, was später noch in diesem Buch erklärt wird).
Zahlen | 59
“
Max.
Linie
Links
Zusätzlich bietet Python eine anspruchsvollere numerische Programmierunterstützung,
inklusive eines komplexen Zahlentyps, einer Ganzzahl mit unbegrenzter Genauigkeit
und einer Vielzahl von numerischen Werkzeug-Bibliotheken. Die nächsten Abschnitte
geben einen Überblick über die numerische Unterstützung in Python.
Zahlen-Literale
Als Grundtypen unterstützt Python die üblichen Verdächtigen: sowohl Ganzzahlen als
auch Fließkommazahlen und die gesamte damit verbundene Syntax und Operationen. Wie
C erlaubt auch Python, Ganzzahlen mit hexadezimalen und oktalen Literalen zu schreiben. Anders als C hat Python aber auch einen komplexen Zahlentyp und einen langen
Ganzzahltyp mit unbegrenzter Genauigkeit (die Anzahl der maximal möglichen Ziffern
hängt nur von Ihrem Hauptspeicher ab). Tabelle 4-2 zeigt, wie die numerischen Typen von
Python aussehen, wenn sie in einem Programm verwendet werden (d.h. als Literale).
Tabelle 4-2: Numerische Literale
Literal
Bedeutung
1234, -24, 0
Normale Ganzzahlen (in C: long)
9999999999999999999L
Lange Ganzzahlen (unbegrenzt)
1.23, 3.14e-10, 4E210, 4.0e+210
Fließkommazahl (in C: double)
0177, 0x9ff, 0XFF
Oktale und hexadezimale Literale
3+4j, 3.0+4.0j, 3J
Komplexe Zahlenliterale
Im Großen und Ganzen sind die numerischen Typen von Python einfach, aber ein paar
Konzepte dabei sollen hier doch hervorgehoben werden:
Ganzzahl- und Fließkomma-Literale
Ganzzahlen werden als Folge von Dezimalziffern geschrieben. Fließkommazahlen
enthalten einen Dezimalpunkt und/oder einen optionalen, vorzeichenbehafteten
Exponenten, dem ein e oder E vorausgeht. Wenn Sie eine Zahl mit einem Dezimalpunkt oder Exponenten schreiben, macht Python daraus ein FließkommazahlObjekt und benutzt Fließkomma- (und nicht Ganzzahl-)Arithmetik, wenn sie in
einem Ausdruck verwendet wird. Die Regeln beim Schreiben von Fließkommazahlen
sind die gleichen wie in C.
Numerische Genauigkeit und lange Ganzzahlen
Einfache Ganzzahlen (Zeile 1 in Table 4-2) werden intern als C-»longs« implementiert
(d.h., es gibt mindestens 32 Bits), und Fließkommazahlen werden als C-»doubles«
implementiert. Python-Zahlen haben dieselbe Genauigkeit wie der C-Compiler, mit
dem der Python-Interpreter erstellt wurde.2
Max.
Linie
2 Das gilt für die Standardimplementierung, d.h. CPython. In Jython, der Java-basierten Implementierung, sind
Python-Typen tatsächlich Java-Klassen.
60 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
Lange Ganzzahl-Literale
Wenn auf der anderen Seite ein Ganzzahl-Literal mit einem l oder L endet, wird
daraus eine lange Python-Ganzzahl (nicht zu verwechseln mit einem C-long), und sie
kann so groß wie nötig werden. Ab Python 2.2 ist der Buchstable L streng genommen
nicht mehr nötig, da Ganzzahlen bei einem Überlauf zu langen Ganzzahlen konvertiert werden. Für zukünftige Python-Versionen könnte die Unterscheidung zwischen
Ganzzahlen und langen Ganzzahlen ganz wegfallen.
Hexadezimale und oktale Literale
Die Regeln beim Schreiben von hexadezimalen und oktalen Ganzzahlen (jeweils zur
Basis 16 bzw. 8) sind dieselben wie in C. Oktale Literale beginnen mit einer führenden Null (0), nach der eine Folge der Ziffern 0–7 kommt. Hexadezimale Literale
beginnen mit einem führenden 0x oder 0X, nach dem eine Folge der Hexadezimalziffern 0–9 und A–F kommt. In hexadezimalen Literalen dürfen hexadezimale Ziffern
mit kleinen und großen Buchstaben codiert sein.
Komplexe Zahlen
Komplexe Zahlenliterale werden in Python als realteil+imaginärteil geschrieben,
wobei der imaginärteil mit einem j oder J endet. Rein technisch ist der realteil
optional und der imaginärteil darf an erster Stelle stehen. Intern werden sie als Paar
von Fließkommazahlen implemeniert, aber alle numerischen Operationen führen
eine komplexe Arithmetik aus, wenn sie auf komplexe Zahlen angewendet werden.
Eingebaute Werkzeuge und Erweiterungen
Neben den eingebauten Zahlentypen, die in Tabelle 4-2 dargestellt sind, stellt Python
eine Reihe von Werkzeugen zum Bearbeiten numerischer Objekte zur Verfügung:
Ausdrucksoperatoren
+, *, >>, ** usw.
Eingebaute mathematische Funktionen
pow, abs usw.
Hilfsmodule
random, math usw.
Sie werden alle im weiteren Verlauf des Buchs kennenlernen. Und schließlich, wenn Sie
an wirklich rechenintensiven Aufgaben arbeiten (engl. »number-crunching«), dann bietet
eine optionale Erweiterung für Python namens NumPy (Numeric Python) zusätzliche
numerische Programmierwerkzeuge, wie einen Matrix-Datentyp und Bibliotheken für
ausgeklügelte Berechnungen. Viele Gruppen, die ernsthaft wissenschaftliches Rechnen
betreiben, z.B. in den Lawrence Livermore Labs (USA) und bei der NASA, setzen Python
und NumPy bei Problemen ein, die sie früher mit C++ oder FORTRAN gelöst haben.
Max.
Linie
Max.
Linie
Zahlen | 61
“
Links
Weil es so anspruchsvoll ist, gehen wir hier nicht weiter auf NumPy ein. (Beispiele finden
Sie in Kapitel 29.) Weitere Unterstützung für anspruchsvolle numerische Programmierung mit Python finden Sie auf der Vaults of Parnassus-Website. Beachten Sie, dass
NumPy eine optionale Erweiterung ist, die nicht in Python enthalten ist, sondern separat
installiert werden muss.
Python-Ausdrucksoperatoren
Das vielleicht elementarste Werkzeug zum Bearbeiten von Zahlen ist der Ausdruck: eine
Kombination aus Zahlen (oder anderen Objekten) und Operatoren, die einen Wert
berechnet, wenn sie von Python ausgeführt wird. In Python werden Ausdrücke unter Verwendung der üblichen mathematischen Notationen und Operatorensymbole geschrieben. Zum Beispiel: Um die Zahlen X und Y zu addieren, schreibt man X+Y, was Python
anweist, den Operator + auf die Werte X und Y anzuwenden. Das Ergebnis dieses Ausdrucks ist die Summe von X und Y, ein weiteres Zahlen-Objekt.
In Tabelle 4-3 sind alle in Python verfügbaren Operatoren-Ausdrücke aufgeführt. Viele
sind selbsterklärend; z.B. werden die üblichen mathematischen Operatoren unterstützt: +,
-, *, / usw. Einige werden Ihnen geläufig sein, wenn Sie bereits C benutzt haben: % berechnet einen Divisionsrest, << führt eine bitweise Linksverschiebung durch, & berechnet eine
bitweise UND-Verknüpfung usw. Andere sind mehr Python-spezifisch, und nicht alle
sind numerischer Natur: Der is-Operator testet auf Gleichheit per Objekt-Identität (d.h.
über die Adresse im Speicher), lambda erzeugt unbenannte Funktionen usw. Mehr zu einigen davon folgt an späterer Stelle.
Gemischte Operatoren: Operator-Vorrang
Wie in den meisten Sprachen werden komplexere Ausdrücke dadurch codiert, dass man
Operatorausdrücke aus Tabelle 4-3 aneinanderreiht. Zum Beispiel kann man die Summe
zweier Multiplikationen als Mischung von Variablen und Operatoren schreiben:
A * B + C * D
Wie soll Python nun wissen, welcher Operator zuerst ausgeführt werden soll? Die Antwort
lautet: mit Hilfe dessen, was man als Operator-Vorrang bezeichnet. Wenn Sie einen Ausdruck mit mehr als einem Operator schreiben, gruppiert Python dessen Bestandteile
gemäß der sogenannten Vorrangsregeln, und diese Gruppierung bestimmt die Reihenfolge,
in der die Bestandteile von Ausdrücken berechnet werden. In der Table 4-3 haben die Operatoren weiter unten höheren Vorrang und binden daher in gemischten Ausdrücken stärker.
Max.
Linie
Wenn Sie z.B. X + Y * Z eingeben, wertet Python zuerst die Multiplikation aus (Y * Z) und
addiert danach das Ergebnis zu X, weil * Vorrang vor + hat (* steht weiter unten in der
Tabelle). Entsprechend werden im ursprünglichen Beispiel beide Multiplikationen (A * B
und C * D) berechnet, bevor ihre Ergebnisse addiert werden.
62 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
Klammern gruppieren Unterausdrücke
Sie können die Vorrangsregeln vollständig vergessen, wenn Sie die Bestandteile von Ausdrücken sorgfältig mit Klammern gruppieren. Wenn Sie Unterausdrücke in Klammern setzen, überschreiben Sie Pythons Vorrangsregeln. Python wertet Ausdrücke in Klammern
immer zuerst aus und benutzt dann ihre Ergebnisse in den umschließenden Ausdrücken.
Tabelle 4-3: Ausdrucksoperatoren und Vorrang
Operatoren
Beschreibung
lambda args: expression
Erzeugen anonymer Funktionen
x or y
Logisches ODER (y wird nur ausgewertet, wenn x falsch ist)
x and y
Logisches UND (y wird nur ausgewertet, wenn x wahr ist)
not x
Logische Negation
x
x
x
x
Vergleichsoperatoren, Testoperatoren für Wertgleichheit, Objektidentität und
Enthaltensein
< y, x <= y, x > y, x >= y,
== y, x <> y, x != y,
is y, x is not y,
in y, x not in y
x | y
Bitweises ODER
x ^ y
Bitweises Entweder-Oder
x & y
Bitweises UND
x << y, x >> y
Verschiebe x nach links oder rechts um y Bits
-x + y, x – y
Addition/Verkettung, Subtraktion
x * y, x % y, x / y, x // y
Multiplikation/Wiederholung, Divisionsrest/Format, Divisiona
-x, +x, ~x, x ** y
Negation, Identität, bitweises Komplement, Exponentiation
x[i], x[i:j], x.attr, x(...)
Indizieren, Slicing, Qualifizierung, Funktionsaufruf
(...), [...], {...}, `...`
Tupel, Liste,b Dictionary, Konvertierung in Stringc
a
Restslose Division (X // Y), schneidet den Nachkommateil immer ab. Das wird ausführlicher im Abschnitt »Division: klassische, restlose und echte« beschrieben.
b
Die Listensyntax ([...]) stellt entweder ein Listen-Literal oder einen List Comprehension-Ausdruck dar. Letzterer führt eine implizite Schleife durch und sammelt die Ausdrucksergebnisse in einer neuen Liste. Mehr dazu im
Zusammenhang mit Funktionen in Kapitel 14.
c
Objekte können auch mit den besser lesbaren eingebauten Funktionen str und repr in Strings konvertiert werden, siehe Abschnitt »Numerische Darstellung.«
Schreiben Sie z.B. statt X + Y * Z einen der folgenden Ausdrücke, um Python zu zwingen,
die Ausdrücke in der gewünschten Reihenfolge auszuwerten:
(X + Y) * Z
X + (Y * Z)
Max.
Linie
Im ersten Fall wird zuerst + auf X und Y angewendet, weil es in Klammern steht. Im zweiten Fall wird zuerst * ausgeführt (als ob keine Klammern da wären). Im Allgemeinen ist
Python-Ausdrucksoperatoren | 63
“
Max.
Linie
Links
es eine sehr gute Idee, in langen Ausdrücken Klammern zu setzen. Das erzwingt nicht nur
die gewünschte Auswertungsreihenfolge, es erhöht auch die Lesbarkeit.
Gemischte Typen: Konvertierung nach oben
Außer Operatoren in Ausdrücken können Sie auch numerische Typen mischen. Zum
Beispiel können Sie eine Ganzzahl zu einer Fließkommazahl addieren:
40 + 3.14
Aber das führt zu einer weiteren Frage: Welchen Typ hat das Ergebnis: Ganzzahl oder
Fließkommazahl? Die Antwort ist einfach, insbesondere wenn Sie eine beliebige andere
Sprache kennen: In Ausdrücken mit gemischten Typen konvertiert Python zuerst Operanden zu dem Typ des kompliziertesten Operanden hoch und rechnet dann mit Operanden
desselben Typs. Das ist eine ganz ähnliche Typkonvertierung wie bei C, wenn Sie diese
Sprache kennen.
Python stuft die Komplexität numerischer Typen wie folgt ein: Ganzzahlen sind einfacher
als lange Ganzzahlen, die ihrerseits einfacher als Fließkommazahlen sind, die wiederum
einfacher als komplexe Zahlen sind. Wenn also eine Ganzzahl mit einer Fließkommazahl
gemischt wird, wird die Ganzzahl zuerst zu einer Fließkommazahl hochkonvertiert, und
die Fließkommazahl-Berechnung ergibt das Fließkommazahl-Ergebnis. Analog dazu
wird in jedem Ausdruck gemischten Typs, in dem ein Operand eine komplexe Zahl ist,
der andere Operand in eine komplexe Zahl hochkonvertiert, was wiederum ein komplexes Ergebnis hervorbringt.
Außerdem konvertiert Python ab Version 2.2 normale Ganzzahlen automatisch in lange
Ganzzahlen, sobald ihr Wert zu groß für eine normale Ganzzahl wird. Beachten Sie, dass
all diese Konvertierungen bei gemischten Typen nur bei numerischen Typen um einen
Operator oder einen Vergleich herum erfolgen (z.B. eine Ganzzahl und eine Fließkommazahl). Im Allgemeinen führt Python keine Konvertierung zwischen anderen Typen durch.
So führt z.B. die Addition eines Strings zu einer Ganzzahl zu einem Fehler, es sei denn,
Sie konvertieren den einen oder anderen Wert manuell. Ein Beispiel dafür werden Sie in
Kapitel 5 sehen.
Vorschau: Operator-Überladung
Obwohl wir uns gerade auf eingebaute Zahlen konzentrieren, sollten Sie nicht vergessen,
dass Python-Operatoren durch Python-Klassen und C-Erweiterungen überladen (d.h.
implementiert) werden können, um mit Objekten zu arbeiten, die Sie selbst implementieren. Sie werden später sehen, dass durch Klassen codierte Objekte mit +-Ausdrücken
addiert, mit [i]-Ausdrücken indiziert werden usw.
Max.
Linie
Darüber hinaus sind einige Operatoren bereits durch Python selbst überladen. Je nach
Typ der eingebauten Objekte führen sie verschiedene Aktionen auf den jeweils betroffe-
64 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
nen eingebauten Objekten aus. Zum Beispiel führt der +-Operator eine Addition aus,
wenn er auf Zahlen angewendet wird, aber eine Verkettung, wenn er auf Sequenzobjekte
wie Strings und Listen angewendet wird.3
Zahlen in Aktion
Vielleicht versteht man numerische Objekte und Ausdrücke am besten dann, wenn man
sie in Aktion sieht. Starten Sie also eine interaktive Kommandozeile, und geben Sie einige
einfache, anschauliche Operationen ein.
Basis-Operationen und -Variablen
Lassen Sie uns als Erstes ein wenig elementare Mathematik üben. In der folgenden Sitzung weisen wir zunächst zwei Variablen (a und b) jeweils eine Ganzzahl zu, damit wir
sie später in einem längeren Ausdruck benutzen können. Variablen sind einfach Namen
(von Ihnen oder Python erzeugt), mit deren Hilfe Sie Informationen in Ihrem Programm
verwalten. Wir werden später noch mehr darüber sagen. Vorläufig aber nur so viel über
Variablen in Python:
• Variablen werden dann erzeugt, sobald ihnen erstmals ein Wert zugewiesen wird.
• Variablen werden durch ihre Werte ersetzt, wenn sie in Ausdrücken benutzt werden.
• Variablen müssen einen zugewiesenen Wert haben, bevor sie in Ausdrücken benutzt
werden können.
• Variablen verweisen auf Objekte und werden niemals vorab deklariert.
Mit anderen Worten: Variablen werden durch Zuweisungen automatisch erzeugt.
% python
>>> a = 3
>>> b = 4
# Name erzeugt
Hierbei haben wir auch einen Kommentar benutzt. In Python-Code wird Text ab einem
#-Zeichen bis zum Zeilenende als Kommentar betrachtet, den der Python-Interpreter
ignoriert. Kommentare sind für Dokumentation in Ihrem Code gedacht, die von Menschen gelesen werden soll. Da interaktiv geschriebener Code temporär ist, würden Sie hier
aber normalerweise keine Kommentare schreiben. Wir haben sie nur zur Beschreibung
des Codes beigefügt.4 Im nächsten Teil dieses Buches werden Sie ein ähnliches Merkmal
finden, Dokumentations-Strings, die Kommentartexte zu Objekten hinzufügen.
3 Das wird üblicherweise Polymorphie genannt, d.h., die Bedeutung einer Operation hängt vom Typ der Objekte
ab, auf die sie angewendet wird. Wir werden in Kapitel 12 darauf zurück kommen, wo es um Funktionen geht,
weil das Konzept dort viel offensichtlicher ist.
Max.
Linie
4 Während Sie diesen Code eingeben, können Sie die Kommentartexte von # bis zum Zeilenende weglassen. Kommentare werden von Python ignoriert und sind für die Anweisungen, die Sie eingeben, nicht notwendig.
Zahlen in Aktion | 65
“
Max.
Linie
Links
Nun wollen wir die Ganzzahl-Objekte in Ausdrücken benutzen. An dieser Stelle haben a
und b immer noch die Werte 3 bzw. 4. Solche Variablen werden durch ihren Wert ersetzt,
wenn sie in einem Ausdruck benutzt werden, und das Ergebnis eines Ausdrucks wird in
der interaktiven Kommandozeile einfach ausgegeben:
>>> a + 1, a – 1
(4, 2)
# Addition (3+1), Subtraktion (3-1)
>>> b * 3, b / 2
(12, 2)
# Multiplikation (4*3), Division (4/2)
>>> a % 2, b ** 2
(1, 16)
# Modulus (Rest), Exponentiation
>>> 2 + 4.0, 2.0 ** b
(6.0, 16.0)
# Konvertierung gemischter Typen
Genau genommen sind die hier ausgegebenen Ergebnisse zweistellige Tupel, weil die eingegebenen Zeilen zwei durch ein Komma getrennte Ausdrücke enthalten. Deswegen werden die Ergebnisse in Klammern dargestellt (später mehr über Tupel). Beachten Sie, dass
die Ausdrücke funktionieren, weil den Variablen a und b darin Werte zugewiesen wurden.
Wenn Sie eine andere Variable verwenden, der kein Wert zugewiesen wurde, gibt Python
einen Fehler aus und verwendet nicht etwa irgendeinen Vorgabewert:
>>> c * 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'c' is not defined
In Python müssen Sie keine Variablen vorab deklarieren, aber es muss ihnen mindestens
einmal ein Wert zugewiesen worden sein, bevor Sie sie benutzen können. Es folgen zwei
etwas längere Ausdrücke, in denen Operatoren gruppiert und Konvertierungen vorgenommen werden:
>>> b / 2 + a
5
>>> print b / (2.0 + a)
0.8
# dasselbe wie ((4 / 2) + 3)
# dasselbe wie (4 / (2.0 + 3))
Im ersten Ausdruck kommen keine Klammern vor, sodass Python die Komponenten
automatisch entsprechend der Vorrangsregeln gruppiert. Da / in Tabelle 4-3 weiter unten
steht als +, bindet es stärker und wird somit zuerst ausgewertet. Das Ergebnis ist so, als
hätten wir den Ausdruck so eingeklammert, wie er im Kommentar rechts vom Code
angezeigt ist. Beachten Sie auch, dass alle Zahlen im ersten Ausdruck Ganzzahlen sind
und Python daher eine Ganzzahl-Division und -Addition durchführt.
Max.
Linie
Im zweiten Ausdruck setzen wir den +-Teil in Klammern, um Python zu zwingen, ihn als
Ersten (d.h. vor dem /) auszuwerten. Zusätzlich haben wir einen der Operanden durch
Hinzufügen eines Dezimalpunktes zu einer Fließkommazahl gemacht: 2.0. Aufgrund dieser gemischten Typen konvertiert Python die durch a dargestellte Ganzzahl in einen Fließ-
66 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
komma-Wert (3.0), bevor das + ausgeführt wird. Ebenso wird b zu einem FließkommaWert (4.0) hochkonvertiert und dann eine Fließkomma-Division durchgeführt: (4.0/5.0)
resultiert in einem Fließkomma-Ergebnis von 0.8. Wären alle Zahlen in diesem Ausdruck
Ganzzahlen, würde eine Ganzzahl-Division durchgeführt (4/5), und das Ergebnis wäre
die abgeschnittete Ganzzahl 0 (jedenfalls bis Python 2.5, siehe dazu auch die Erläuterungen zur echten Division weiter unten).
Numerische Darstellung
Beachten Sie übrigens, dass wir im zweiten Beispiel eine print-Anweisung benutzt haben.
Ohne dieses print käme Ihnen die Anzeige auf den ersten Blick vielleicht etwas merkwürdig vor:
>>> b / (2.0 + a)
0.80000000000000004
# Automatische Ausgabe: mehr Ziffern
>>> print b / (2.0 + a)
0.8
# print rundet die Ziffern weg.
Der Grund dahinter hat mit den Beschränkungen von Fließkomma-Hardware zu tun, die
prinzipiell nicht fähig ist, einige Wert exakt darzustellen. Weil aber das Thema Rechnerarchitektur weit über den Rahmen dieses Buches hinausgeht, sagen wir an dieser Stelle
nur, dass alle Ziffern in der ersten Ausgabe tatsächlich in der Fließkomma-Hardware
Ihres Computers vorhanden sind. Es ist nur so, dass Sie sie normalerweise nicht sehen.
Wir benutzen dieses Beispiel, um Unterschiede beim Formatieren der Ausgabe zu
demonstrieren. Das Ergebnis der automatischen Ausgabe bei der interaktiven Eingabeaufforderung zeigt mehr Ziffern an als die print-Anweisung. Wenn Sie nicht alle Ziffern
haben möchten, verwenden Sie einfach print.
Anzeigeformate mit Str und Repr
Rein technisch betrachtet, entspricht der Unterschied zwischen der automatischen interaktiven Echo-Ausgabe und print-Anweisungen dem Unterschied zwischen den eingebauten
Funktionen repr und str:
>>> repr(num)
'0.33333333333333331'
>>> str(num)
'0.333333333333'
# In Echos: als Code-Form
# In print: als anwenderfreundliche Form
Beide konvertieren beliebige Objekte in ihre String-Darstellung: repr (und die interaktive
Eingabeaufforderung) produziert Ergebnisse, die so aussehen, als ob sie Code wären, während str (und die print-Anweisung) in ein üblicherweise anwenderfreundlicheres Format
konvertiert. Dieses Konzept wird später nochmal beim Thema Strings auftauchen.
Max.
Linie
Max.
Linie
Zahlen in Aktion | 67
“
Links
Beachten Sie, dass nicht bei allen Werten so viele Ziffern angezeigt werden:
>>> 1 / 2.0
0.5
Und es gibt noch mehr Möglichkeiten, die Bits einer Zahl in Ihrem Rechner darzustellen
als mit print und der automatischen Echo-Ausgabe:
>>> num = 1 / 3.0
>>> num
0.33333333333333331
>>> print num
0.333333333333
>>> "%e" % num
'3.333333e-001'
>>> "%2.2f" % num
'0.33'
# Automatische Echo-Ausgabe
# Print rundet
# String-Formatierung
# String-Formatierung
Die beiden letzten davon verwenden die String-Formatierung, d.h. Ausdrücke, die flexiblere Formate ermöglichen und im Kapitel über Strings erläutert werden.
Division: klassische, restlose und echte
Da Sie nun gesehen haben, wie die Division funktioniert, sollten Sie wissen, dass sie in
einer zukünftigen Python-Version eine leichte Änderung erfahren wird (vermutlich in
3.0, die wohl erst ein paar Jahre nach Erscheinen dieses Buches veröffentlicht werden
wird). In Python 2.5 funktioniert alles wie beschrieben, aber tatsächlich gibt es zwei verschiedene Divisionsoperatoren, von denen einer sich verändern wird:
X / Y
Klassische Division. In Python 2.5 und davor schneidet dieser Operator im Ergebnis
den Rest bei Ganzzahlen ab, behält ihn aber bei Fließkommazahlen, wie hier
beschrieben. Dieser Operator wird in einer zukünftigen Version von Python (man
spricht von 3.0) eine echte Division liefern, d.h., dann wird die Division unabhängig
vom Typ der Operanden immer eine Fließkommazahl ergeben, die den Rest enthält.
X // Y
Restlose Division (engl. floor division). Diesen Operator gibt es ab Python 2.2. Er
schneidet den Divisionsrest immer ab, egal welchen Typ die Operanden haben.
Die restlose Division wurde hinzugefügt, um der Tatsache Rechnung zu tragen, dass im
aktuellen klassischen Divisionsmodell das Ergebnis von den Operandentypen abhängt
und somit in einer dynamisch typisierten Sprache wie Python gelegentlich schwer vorherzusehen ist.
Max.
Linie
Wegen möglicher Probleme mit der Rückwärtskompatibilität wird diese Veränderung
heute noch diskutiert. In der Version 2.5 funktioniert die Division mit / standardmäßig
wie hier beschrieben, und die restlose Division mit // wurde hinzugefügt, um den Divisionsrest unabhängig von den Operandentypen abzuschneiden:
68 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
>>> (5 / 2), (5 / 2.0), (5 / -2.0), (5 / -2)
(2, 2.5, -2.5, -3)
>>> (5 // 2), (5 // 2.0), (5 // -2.0), (5 // -2)
(2, 2.0, -3.0, -3)
>>> (9 / 3), (9.0 / 3), (9 // 3), (9 // 3.0)
(3, 3.0, 3, 3.0)
In einer zukünftigen Python-Version wird die Division mit / vermutlich so geändert, dass
sie ein echtes Divisionsergebnis liefert, das immer den Rest enthält, sogar bei Ganzzahlen.
Zum Beispiel wird dann 1/2 den Wert 0.5 ergeben und nicht 0, und 1//2 wird immer noch
0 ergeben.
Solange diese Änderung nicht vollständig vollzogen ist, können Sie sehen, wie / wahrscheinlich in Zukunft funktionieren wird, indem Sie einen speziellen Import der folgenden Art ausführen: from _ _future_ _ import division. Das macht aus dem Operator /
eine echte Division (die Reste erhält), lässt // aber unverändert. Sehen Sie selbst, wie sich
/ verhalten wird:
>>> from _ _future_ _ import division
>>> (5 / 2), (5 / 2.0), (5 / -2.0), (5 / -2)
(2.5, 2.5, -2.5, -2.5)
>>> (5 // 2), (5 // 2.0), (5 // -2.0), (5 // -2)
(2, 2.0, -3.0, -3)
>>> (9 / 3), (9.0 / 3), (9 // 3), (9 // 3.0)
(3.0, 3.0, 3, 3.0)
Suchen Sie ein einfaches Beispiel für eine Primzahlen-while-Schleife in Kapitel 10 und
eine entsprechende Aufgabe am Ende von Teil IV, die die Art von Code illustrieren, der
von dieser Änderung von / betroffen sein wird. Im Allgemeinen könnte jeder Code
betroffen sein, der davon ausgeht, dass / den Rest in einem ganzzahligen Ergebnis
abschneidet (verwenden Sie dann das neue //). Im Augenblick ist diese Änderung für
Python 3.0 geplant, aber Sie sollten diese Ausdrücke unbedingt in Ihrer Version ausprobieren, um zu sehen, welches Verhalten bei Ihnen vorliegt. Und achten Sie auf weitere
Erklärungen in Kapitel 18 zu der hier verwendeten speziellen Form der from-Anweisung.
Bitweise Operationen
Neben den normalen numerischen Operationen (Addition, Subtraktion usw.) unterstützt
Python die meisten der in der Sprache C verfügbaren numerischen Ausdrücke. Hier
sehen Sie zum Beispiel eine bitweise Verschiebung und zwei Boolesche Operationen:
Max.
Linie
>>> x = 1
>>> x << 2
4
# 0001
# verschiebe nach links um 2 Bits: 0100
Max.
Linie
Zahlen in Aktion | 69
“
Links
>>> x | 2
3
>>> x & 1
1
# bitweises ODER: 0011
# bitweises UND: 0001
Im ersten Ausdruck wird eine binäre 1 (zur Basis 2, 0001) um zwei Stellen nach links verschoben, um eine binäre 4 zu erzeugen (0100). Die beiden letzten Operationen führen ein
binäres ODER (0001|0010 = 0011) und ein binäres UND (0001&0001 = 0001) aus. Mit Hilfe
solcher Bit-Maskierungen können Sie mehrere Schalter und andere Werte in einer einzigen Ganzzahl kodieren.
Wir werden hier nicht viel mehr auf die Details von »Bit-Spielereien« eingehen. Es wird
unterstützt, wenn Sie es benötigen, aber seien Sie sich bewusst, dass es in einer Hochsprache wie Python oftmals nicht so wichtig ist wie in einer niederen Sprache wie C. Als
Faustregel gilt: Wenn Sie feststellen, dass Sie in Python gerne Bits vertauschen möchten,
sollten Sie gründlich darüber nachdenken, welche Sprache Sie eigentlich benutzen. Im
Allgemeinen gibt es in Python oft bessere Wege, Informationen zu kodieren als mit BitStrings.5
Lange Ganzzahlen
Nun zu etwas Exotischerem: Hier können Sie lange Ganzzahlen in Aktion sehen. Wenn
ein Ganzzahl-Literal mit dem Buchstaben L (oder kleinem l) endet, bildet Python eine
lange Ganzzahl. In Python darf eine lange Ganzzahl beliebig lang sein und kann so viele
Ziffern haben, wie Sie Platz im Hauptspeicher haben:
>>> 9999999999999999999999999999999999999L + 1
10000000000000000000000000000000000000L
Das L am Ende der Ziffernfolge sagt Python, dass es ein langes Ganzzahlobjekt mit unbeschränkter Genauigkeit erzeugen soll. Ab Python 2.2 ist sogar der Buchstabe L größtenteils optional, denn Python konvertiert normale Ganzzahlen automatisch in lange Ganzzahlen, wann immer es zu einem Überlauf der normalen Genauigkeit von Ganzzahlen
kommt (üblicherweise bei 32 Bits):
>>> 9999999999999999999999999999999999999 + 1
10000000000000000000000000000000000000L
Lange Ganzzahlen sind ein praktisches Werkzeug. Sie können damit z.B. die Staatsverschuldung in Cent direkt in Python angeben (wenn Sie möchten und Ihr Rechner über so
viel Hauptspeicher verfügt). Sie sind auch der Grund dafür, dass wir eine Exponentialberechnung mit so großen Exponenten von 2 in den Beispielen von Kapitel 3 durchführen
konnten:
>>> 2L ** 200
1606938044258990275541962092341162602522202993782792835301376L
Max.
Linie
5 Wie bei allen Regeln gibt es auch hier Ausnahmen. Beispiel: Wenn Sie eine Schnittstelle mit C-Bibliotheken
haben, die Bit-Strings erwarten, gilt diese Regel nicht.
70 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
>>>
>>> 2 ** 200
1606938044258990275541962092341162602522202993782792835301376L
Aber weil Python Extraarbeit leisten muss, um deren erweiterte Genauigkeit zu unterstützen, ist die Langzahl-Arithmetik üblicherweise um einiges langsamer als die normale
Ganzzahl-Arithmetik (die in der Regel direkt auf die Hardware abgebildet wird). Wenn
Sie die Genauigkeit benötigen, so ist sie eingebaut und für Sie verfügbar. Aber es ist ein
Performance-Nachteil damit verbunden.
Eine Bemerkung zu verschiedenen Python-Versionen: Vor Python 2.2 wurden Ganzzahlen
nicht automatisch bei einem Überlauf zu langen Ganzzahlen hochkonvertiert, d.h., Sie
mussten den Buchstaben L tatsächlich benutzen, um die erweiterte Genauigkeit zu erhalten:
>>> 9999999999999999999999999999999999999 + 1
OverflowError: integer literal too large
# vor 2.2
>>> 9999999999999999999999999999999999999L + 1
10000000000000000000000000000000000000L
# vor 2.2
Ab Version 2.2 ist das L zum Großteil optional. In Zukunft kann es sein, dass bei Verwendung des Buchstabens L Python eine Warnung ausgibt. Deswegen fahren Sie vermutlich
am besten, wenn Sie das L weglassen und es Python überlassen, automatisch für Sie bei
Bedarf hochzukonvertieren.
Komplexe Zahlen
Komplexe Zahlen sind ein eigenständiger Objekttyp im Python-Kern. Falls Sie wissen,
was sie sind, wissen Sie auch, weshalb sie nützlich sind. Falls nicht, ist es Ihnen freigestellt, diesen Abschnitt zu lesen. Komplexe Zahlen werden als zwei Fließkomma-Zahlen
dargestellt, einem Real- und einem Imaginärteil, und werden mit einem zusätzlichen j
oder J als Endung des Imaginärteils codiert. Man kann komplexe Zahlen auch mit einem
Realteil ungleich null schreiben, indem man die beiden Teile mit einem + verbindet. Zum
Beispiel wird die komplexe Zahl mit dem Realteil 2 und dem Imaginärteil -3 als 2 + -3j
geschrieben. Hier ein paar Beispiele für komplexe Arithmetik in Aktion:
>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2+1j)*3
(6+3j)
Max.
Linie
Bei komplexen Zahlen kann man auf beide Anteile als Attribute zugreifen. Komplexe
Zahlen unterstützen alle üblichen mathematischen Ausdrücke und können mit den
Werkzeugen des Moduls cmath in der Standardbibliothek (der komplexen Version des
Moduls math) bearbeitet werden. Komplexe Zahlen finden typischerweise Anwendung in
ingineurswissenschaftlichen Programmen. Da sie etwas anspruchsvoller sind, sollten Sie
das Python Language Reference-Handbuch für weitere Details lesen.
Zahlen in Aktion | 71
“
Max.
Linie
Links
Hexadezimale und oktale Notation
Wie am Anfang dieses Abschnitts erwähnt, können Python-Ganzzahlen zusätzlich zur
normalen Codierung (zur Basis 10) auch in hexadezimaler (zur Basis 16) und oktaler (zur
Basis 8) Notation codiert werden:
• Oktale Literale haben eine führende 0, gefolgt von einer Folge von oktalen Ziffern 0–7,
in der jede drei Bits darstellt.
• Hexadezimale Literale haben ein führendes 0x oder 0X, gefolgt von einer Folge von
hexadezimalen Ziffern 0–9 und A–F (Klein- oder Großbuchstaben), in der jede Ziffer
vier Bits darstellt.
Bedenken Sie, dass das einfach nur eine alternative Syntax für die Angabe des Wertes
eines Ganzzahl-Objektes darstellt. So produzieren z.B. die folgenden oktalen und hexadezimalen Literale normale Ganzzahlen mit dem jeweils angegebenen Wert:
>>>
(1,
>>>
(1,
01, 010, 0100
8, 64)
0x01, 0x10, 0xFF
16, 255)
# oktale Literale
# hexadezimale Literale
Hierbei ist der oktale Wert 0100 dezimal 64, und der hexadezimale Wert 0xFF ist dezimal
255. Python gibt seine Ausgaben standardmäßig dezimal aus, bietet aber eingebaute
Funktionen, mit denen Sie Ganzzahlen in Ziffern-Strings mit deren oktaler und hexadezimaler Darstellung konvertieren können:
>>> oct(64), hex(64), hex(255)
('0100', '0x40', '0xff')
Die Funktionen oct und hex konvertieren dezimal nach oktal bzw. nach hexadezimal. In
umgekehrter Richtung konvertiert die eingebaute Funktion int einen Ziffern-String in
eine Ganzzahl, wobei Sie in einem optionalen zweiten Argument die numerische Basis
angeben können:
>>> int('0100'), int('0100', 8), int('0x40', 16)
(100, 64, 64)
Die Funktion eval, die Sie später in diesem Buch noch kennenlernen werden, behandelt
Strings so, als ob sie Python-Code wären. Daher hat sie einen ähnlichen Effekt (sie läuft
aber normalerweise langsamer ab, denn sie kompiliert den String und führt ihn als Programmstück aus):
>>> eval('100'), eval('0100'), eval('0x40')
(100, 64, 64)
Und schließlich können Sie Ganzzahlen auch mit einem String-Formatierungsausdruck
in oktale und hexadezimale Strings konvertieren:
Max.
Linie
>>> "%o %x %X" % (64, 64, 255)
'100 40 FF'
Max.
Linie
Das wird noch in Kapitel 4 behandelt.
72 | Kapitel 4: Zahlen
“
Rechts
Eine Warnung, bevor wir weitermachen: Achten Sie in Python darauf, dass Sie eine Ziffernfolge nicht mit einer führenden Null beginnen, es sei denn, Sie möchten wirklich
einen oktalen Wert codieren. Python wird ihn als Wert zur Basis 8 behandeln, was vielleicht nicht so funktionieren wird, wie Sie es erwarten. 010 ist immer dezimal 8, nicht
dezimal 10 (auch wenn Sie das anders sehen!).
Weitere numerische Werkzeuge
Python stellt sowohl eingebaute Funktionen als auch Module für die numerische Verarbeitung zur Verfügung. Es folgen ein paar Beispiele mit dem eingebauten Modul math und
einigen eingebauten Funktionen:
>>> import math
>>> math.pi, math.e
(3.1415926535897931, 2.7182818284590451)
>>> math.sin(2 * math.pi / 180)
0.034899496702500969
>>> abs(-42), 2**4, pow(2, 4)
(42, 16, 16)
>>> int(2.567), round(2.567), round(2.567, 2)
(2, 3.0, 2.5699999999999998)
Das math-Modul enthält die meisten der Werkzeuge, die in der mathematischen Bibliothek von C enthalten sind. Wie schon erwähnt, würde die letzte Ausgabezeile hier 2.57
enthalten, wenn Sie print verwenden.
Beachten Sie, dass eingebaute Module wie math importiert werden müssen, aber eingebaute Funktionen wie abs immer ohne Import verfügbar sind. Tatsächlich sind Module
externe Komponenten, aber eingebaute Funktionen befinden sich in einem implizierten
Namensraum, den Python automatisch absucht, um die in Ihrem Programm benutzten
Namen zu finden. Dieser Namensraum entspricht einem Modul, das _ _builtin_ _
genannt wird. In Teil IV, Funktionen, werden Sie noch viel mehr über die Auflösung von
Namen erfahren. Vorläufig sollten Sie bei dem Wort »Modul« an »importieren« denken.
Intermezzo: Dynamische Typisierung
Max.
Linie
Falls Sie sich mit kompilierten oder statisch typisierten Sprachen wie C, C++ oder Java
auskennen, könnten Sie an dieser Stelle evtl. leicht verwirrt sein. Bisher haben wir Variablen verwendet, ohne ihren Typ zu deklarieren, und irgendwie funktioniert das auch noch.
Wenn wir a = 3 in einer interaktiven Sitzung oder in einer Programmdatei eingeben,
woher weiß dann Python, dass a für eine Ganzzahl steht? Woher weiß Python eigentlich,
was a überhaupt sein soll?
Intermezzo: Dynamische Typisierung | 73
“
Max.
Linie
Links
Dezimalzahlen ab Python 2.4
Fließkomma-Zahlen in Python werden intern mit Hilfe des Typs double in C implementiert. Damit unterliegen sie den gleichen fundamentalen Beschränkungen, was die darstellbare Genauigkeit angeht. Viele Dezimalzahlen können daher nicht exakt dargestellt
werden, auch wenn der Unterschied nicht immer sichtbar ist, weil er bei der Ausgabe versteckt wird:
>>> 1.1
1.1000000000000001
>>> print 1.1
1.1
# Nicht exakt darstellbar
# Ungenauigkeit wird versteckt
Für viele Anwendungen spielt das keine Rolle. Für die anderen, in denen sich die Fehler
meist mit der Anzahl der Operationen addieren, ist das ein Problem. Dafür gibt es seit
Python 2.4 das Modul decimal in der Standardbibliothek, das echte Dezimalzahlen bietet.
Für diese Dezimalzahlen können Sie Genauigkeit und Rundung beliebig angeben. Sie können mit ihnen rechnen, Spezialwerte wie Unendlich benutzen und sie konvertieren. Weil
diese Dezimalzahlen kein eingebauter Zahlentyp in Python sind, gehen wir hier nicht weiter auf sie ein. Weitere Details dazu finden Sie im Python-Bibliothekshandbuch.
Sobald Sie anfangen, solche Fragen zu stellen, landen Sie bei Pythons Modell der dynamischen Typisierung. In Python werden Typen automatisch zur Laufzeit bestimmt, und
nicht als Reaktion auf Deklarationen in Ihrem Code. Für Sie bedeutet das, dass Sie zu
keinem Zeitpunkt Variablen vorab deklarieren. Dieses Konzept ist vielleicht einfacher zu
verdauen, wenn Sie vorher noch nicht in anderen Sprachen programmiert haben. Aber
weil das sehr wahrscheinlich das wichtigste Konzept der Sprache Python ist, gehen wir
hier detailliert darauf ein.
Wie Zuweisungen funktionieren
Wenn wir a = 3 schreiben, dann werden Sie feststellen, dass das funktioniert, obwohl wir
Python niemals gesagt haben, dass es a als Variable benutzen soll. Außerdem scheint
auch die Zuweisung von 3 an a zu funktionieren, obwohl wir Python nicht gesagt haben,
dass a für ein Objekt vom Typ Ganzzahl stehen soll. In Python lösen sich diese Fragen
auf natürliche Weise wie folgt:
Erzeugung
Eine Variable, z.B. a, wird dann erzeugt, wenn sie in Ihrem Code erstmals einen Wert
zugewiesen bekommt. Spätere Zuweisungen ändern den Wert eines bereits erzeugten Namens. Ganz streng genommen werden die Variablen jedesmal erzeugt, egal ob
sie bereits da waren oder nicht.
Max.
Linie
Max.
Linie
74 | Kapitel 4: Zahlen
“
Rechts
Typen
Eine Variable, z.B. a, ist nie mit irgendeiner Typinformation oder -beschränkung verbunden. Stattdessen werden Typen immer mit Objekten verbunden und nicht mit
Namen. Variablen verweisen einfach immer nur zu einer bestimmten Zeit auf ein
bestimmtes Objekt.
Benutzung
Sobald eine Variable in einem Ausdruck erscheint, wird sie sofort mit dem Objekt
ersetzt, auf das sie gerade verweist, was auch immer das sein mag. Außerdem muss
allen Variablen explizit ein Wert zugewiesen worden sein, bevor sie benutzt werden
können. Die Benutzung von Variablen ohne zugewiesenen Wert führt zu einem Fehler.
Dieses Modell unterscheidet sich erheblich von jenem in traditionellen Sprachen, und es
ist der Grund für einen Großteil der Kürze und Flexibilität von Python-Code. Am Anfang
werden Sie die dynamische Typisierung leichter verstehen, wenn Sie eine klare Trennlinie
zwischen Namen und Objekten ziehen. Betrachten Sie diese Anweisung als Beispiel:
>>> a = 3
Um diesen Befehl auszuführen, führt Python zumindest im Prinzip drei verschiedene
Schritte aus, was so für alle Zuweisungsoperationen gilt:
1. Erzeuge ein Objekt, das den Wert 3 darstellt.
2. Erzeuge die Variable a, falls sie noch nicht existiert.
3. Verbinde die Variable a mit dem neuen Objekt 3.
Als Endergebnis entsteht eine Struktur in Python, wie sie in Abbildung 4-1 abgebildet ist.
Wie angedeutet wurde, werden Variablen und Objekte in verschiedenen Teilen des
Hauptspeichers gespeichert und mit Verbindungen assoziiert, die hier als Pfeile gezeigt
werden. Variablen verweisen immer auf Objekte (und nie auf andere Variablen), aber
größere Objekte können auf andere Objekte verweisen.
Diese Verbindungen von Variablen zu Objekten werden in Python Verweise (engl. references) genannt, eine Art Assoziation.6 Immer, wenn eine Variable später benutzt wird
(d.h. wenn der Verweis verfolgt wird), wird die Verbindung von der Variablen zum
Objekt von Python automatisch verfolgt. All das ist einfacher, als es durch diese Terminologie vielleicht erscheinen mag. Konkret gilt:
• Variablen sind einfach Einträge in einer Suchtabelle, die Verbindungen zu Objekten
enthält.
Max.
Linie
6 Für Leser mit C-Kenntnissen werden Python-Verweise C-Zeigern (Speicheradressen) sehr ähnlich sehen. Tatsächlich sind Verweise als Zeiger implementiert und haben oftmals den gleichen Zweck, besonders bei Objekten,
die sich an Ort und Stelle ändern können (mehr dazu später). Weil Verweise bei ihrer Benutzung allerdings
immer automatisch verfolgt werden, können Sie nie irgendetwas Sinnvolles mit einem Verweis allein machen.
Das ist so gewollt und eliminiert eine riesige Kategorie von Fehlern in C. Aber Sie können sich Python-Verweise
als »void*«-Zeiger in C vorstellen, die bei ihrer Benutzung automatisch verfolgt werden.
Intermezzo: Dynamische Typisierung | 75
“
Max.
Linie
Links
• Objekte sind einfach Teile von belegtem Hauptspeicher, die genügend Raum für die
Darstellung ihres Wertes und einer Typinformation bieten.
Abbildung 4-1: Namen und Objekte nach der Zuweisung a = 3
Jedes Mal, wenn Sie in Ihrem Skript einen neuen Wert erzeugen, erzeugt Python, jedenfalls im Prinzip, ein neues Objekt (d.h. einen Speicherbereich), der diesen Wert darstellt.
Bestimmte Arten unveränderlicher Objekte wie kleine Ganzzahlen und Strings legt
Python zur Optimierung in einen Pufferspeicher und verwendet sie wieder (nicht alle
Nullen belegen eigenen Speicherplatz), aber das funktioniert so, als ob jeder Wert ein
eigenständiges Objekt wäre. Wir werden später im Abschnitt »Vergleiche und Gleichheit« in Kapitel 7 erneut auf dieses Konzept stoßen, wenn es um Vergleiche mit == und is
geht.
Erweitern wir diese Sitzung und beobachten wir, was mit den Namen und Objekten
darin passiert:
>>> a = 3
>>> b = a
Nach Eingabe dieser beiden Anweisungen ergibt sich das Bild in Abbildung 4-2. Wie
zuvor erzeugt Python mit der zweiten Zeile die Variable b. Dabei wird die Variable a
benutzt, d.h., ihr wird nichts zugewiesen, also wird sie durch das Objekt ersetzt, auf das
sie verweist (3), und b wird zu einem Verweis auf dieses Objekt. Im Endergebnis verweisen beide Variablen, a und b, auf dasselbe Objekt (d.h., sie zeigen auf denselben
Speicherbereich). In Python wird das ein gemeinsamer Verweis (engl. shared reference)
genannt, d.h., mehrere Namen verweisen auf dasselbe Objekt.
Max.
Linie
Abbildung 4-2: Namen und Objekte nach der Zuweisung b = a
76 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
Angenommen, wir erweitern die Sitzung um eine weitere Anweisung:
>>> a = 3
>>> b = a
>>> a = 'spam'
Wie alle Python-Zuweisungen erzeugt auch diese einfach ein neues Objekt, das den
String-Wert »spam« darstellt, und setzt a als Verweis auf dieses neue Objekt. Allerdings
ändert sie nicht den Wert von b. Nach wie vor verweist b auf das ursprüngliche Objekt,
die Ganzzahl 3. Es ergibt sich also die Verweisstruktur in Abbildung 4-3.
Abbildung 4-3: Namen und Objekte nach der Zuweisung a = 'spam'
Das Gleiche würde passieren, wenn wir stattdessen b auf »spam« gesetzt hätten: Die
Zuweisung würde nur b ändern, aber nicht a. Dieses Beispiel sieht besonders für ehemalige C-Programmierer sehr sonderbar aus, sieht es doch so aus, als ob der Typ von a sich
von einer Ganzzahl in einen String geändert hätte, wenn man a = 'spam' sagt. Das stimmt
nicht ganz. In Python funktionieren die Dinge etwas einfacher: Typen gehören zu Objekten, nicht zu Namen. Wir ändern nur a so, dass es auf ein anderes Objekt verweist.
Dieses Verhalten ist auch dann genau gleich, wenn die Typen gar nicht verschieden sind.
Betrachten Sie z.B. die folgenden drei Anweisungen:
>>> a = 3
>>> b = a
>>> a = 5
Max.
Linie
Bei dieser Abfolge geschieht das Gleiche: Python macht aus der Variablen a einen Verweis auf das Objekt 3 und aus b einen Verweis auf dasselbe Objekt, auf das a verweist,
wie in Abbildung 4-2 abgebildet ist. Wie schon zuvor setzt die letzte Zuweisung nur a als
Verweis auf ein völlig anderes Objekt, nämlich die Ganzzahl 5. Sie hat nicht den Seiteneffekt, auch b zu verändern. Tatsächlich gibt es keine Möglichkeit, den Wert des Objektes
3 zu überschreiben (Ganzzahlen können niemals an Ort und Stelle verändert werden,
eine Eigenschaft, die als Unveränderlichkeit, engl. immutability, bezeichnet wird).
Anders als in manchen anderen Sprachen sind in Python Variablen immer Zeiger auf
Objekte, nicht Etiketten für veränderbare Speicherbereiche.
Intermezzo: Dynamische Typisierung | 77
“
Max.
Linie
Links
Verweise und veränderliche Objekte
Wie Sie später in diesem Teil des Buchs sehen werden, gibt es aber Objekte und Operationen, die Objekte an Ort und Stelle verändern. Zum Beispiel verändern Zuweisungen an
Positionen in Listen tatsächlich das Listenobjekt selbst (an Ort und Stelle), anstatt ein
brandneues Objekt zu erzeugen. Bei Objekten, die solche Änderungen an Ort und Stelle
unterstützen, müssen Sie über gemeinsame Verweise besser Bescheid wissen, da eine
Änderung bei einem Namen Auswirkungen auf andere haben kann. Zum Beispiel unterstützen Listenobjekte die Zuweisung an Einzelpositionen an Ort und Stelle:
>>> L1 = [2,3,4]
>>> L2 = L1
Wie am Anfang dieses Kapitels erwähnt wurde, sind Listen einfache Sammlungen anderer Objekte und werden mit eckigen Klammern codiert. Also ist L1 hier eine Liste mit den
Objekten 2, 3 und 4 darin. Auf die Elemente in einer Liste wird über ihre Position zugegriffen, d.h., L1[0] steht für das Objekt 2, das erste Element in der Liste L.
Listen sind für sich genommen auch Objekte, ebenso wie Ganzzahlen und Strings. Nach
Ausführung der obigen zwei Zuweisungen verweisen L1 und L2 auf dasselbe Objekt,
genau wie im vorherigen Beispiel (siehe Abbildung 4-2). Ebenso gilt auch jetzt, dass nach
der Anweisung
>>> L1 = 24
L1 einfach auf ein anderes Objekt und L2 immer noch auf die ursprüngliche Liste verweist. Falls wir aber die Syntax dieser Anweisung leicht ändern, hat das einen völlig
anderen Effekt:
>>> L1[0] = 24
>>> L2
[24, 3, 4]
Hierbei haben wir eine Komponente des Objekts verändert, auf das L1 verweist, statt L1
selbst zu verändern. Diese Art von Änderung überschreibt einen Teil des Listenobjekts an
Ort und Stelle. Als Konsequenz tritt der gleiche Effekt auch in L2 auf, weil es auf dasselbe
Objekt wie L1 verweist.
Normalerweise ist es das, was Sie wollen, aber Sie sollten sich darüber im Klaren sein,
wie das funktioniert. Außerdem ist es das Standardverhalten: Wenn Sie ein anderes Verhalten möchten, können Sie verlangen, dass Python Kopien von Objekten statt Verweise
darauf erzeugt. Mehr Details über Listen, gemeinsame Verweise und Kopien erfahren Sie
in den Kapiteln 6 und 7.7
Max.
Linie
7 Objekte, die an Ort und Stelle verändert werden können, werden als veränderlich (engl. mutable) bezeichnet.
Dazu gehören Listen und Dictionaries, d.h., sie sind von Seiteneffekten durch Änderungen an Ort und Stelle
betroffen.
78 | Kapitel 4: Zahlen
“
Max.
Linie
Rechts
Verweise und Speicherbereinigung
Wenn Namen erzeugt werden, um auf neue Objekte zu verweisen, holt sich Python das
alte Objekt zurück, falls kein anderer Name (oder kein anderes Objekt) darauf verweist.
Diese automatische Rückforderung des Speicherplatzes, den ein Objekt belegt, wird als
Speicherbereinigung (engl. garbage collection) bezeichnet. Das bedeutet, Sie können
Objekte freizügig einsetzen, ohne jemals in Ihrem Skript Speicherplatz freigeben zu müssen. In der Praxis eliminiert das erhebliche Mengen an Verwaltungscode, die in niederen
Sprachen wie C und C++ notwendig sind.
Betrachten Sie das folgenden Beispiel, das bei jeder Zuweisung den Namen x auf ein
anderes Objekt setzt. Beachten Sie erstens, wie der Name x jedes Mal auf einen anderen
Typ von Objekt gesetzt wird. Es ist, als ob der Typ von x sich mit der Zeit verändert. Das
stimmt aber nicht ganz, denn in Python sind Typen mit Objekten verbunden, nicht mit
Namen. Weil Namen einfach nur generische Verweise auf Objekte sind, ist diese Art von
Code völlig natürlich:
>>>
>>>
>>>
>>>
x
x
x
x
=
=
=
=
42
'shrubbery'
3.1415
[1,2,3]
# holt nun 42 zurück (?)
# holt nun 'shrubbery' zurück (?)
# holt nun 3.1415 zurück (?)
Beachten Sie zweitens, dass Verweise auf Objekte dabei weggeworfen werden. Jedes Mal,
wenn ein neues Objekt an x zugewiesen wird, holt Python das vorherige Objekt zurück.
Wenn z.B. x auf den String 'shrubbery' gesetzt wird, wird das Objekt 42 sofort zurückgeholt, sofern es keinen anderen Verweis darauf gibt. Der Speicherplatz des Objekts wird
automatisch freigegeben und zum restlichen freien Speicherplatz hinzugefügt, damit er
für ein zukünftiges Objekt wiederverwendet werden kann.
Bei einigen Typen wird dieses Prinzip, technisch betrachtet, nicht ganz eingehalten. Weil
Python kleine Ganzzahlen und Strings in einen Pufferspeicher legt und wiederverwendet,
wird das Objekt 42 wahrscheinlich nicht wirklich zurückgeholt. Stattdessen bleibt es für
den Fall bestehen, dass Sie in Ihrem Code noch einmal eine 42 erzeugen. Aber die meisten
Arten von Objekten werden sofort zurückgeholt, sobald es keinen Verweis mehr darauf
gibt. Und bei den anderen ist der Pufferspeicher-Mechanismus irrelevant für Ihren Code.
Natürlich müssen Sie keine Namen/Objekt-Diagramme mit Kreisen und Pfeilen zeichnen, um Python zu benutzen. Aber am Anfang kann es manchmal hilfreich sein, um
einige Sonderfälle besser zu verstehen, wenn Sie die Verweisstruktur nachverfolgen können. Weil außerdem alles in Python aus Zuweisungen und Verweisen zu bestehen scheint,
ist ein Grundverständnis dieses Modells in vielen Kontexten hilfreich. Wie Sie z.B. noch
sehen werden, funktioniert es auf die gleiche Weise in Zuweisungsanweisungen, forSchleifenvariablen, Funktionsargumenten, Modulimporten usw.
Max.
Linie
Max.
Linie
Intermezzo: Dynamische Typisierung | 79
“
First
Index
Symbole
%-Operator (Rest/Format) 63
&-Operator (bitweises Und) 63
*-Operator (Multiplikation) 63, 338
+-Operator (Addition/Verkettung) 338
... Eingabeaufforderung 179
/-Operator (Division) 63
: (Doppelpunkt) 160
== (Vergleichsoperator) 131
>> (Shift-Operator) 63
>>> (Eingabeaufforderung) 30
^-Operator (bitweises Exklusiv-Oder) 63
_ _add_ _-Methode 352
_ _dict_ _-Attribute 283–284
_ _getattr_ _-Methode 357
_ _getitem_ _-Methode 353
_ _init_ _.py-Dateien 293
_ _init_ _-Konstruktor 338, 344, 349
_ _repr_ _-Methode 358
{ } (geschwungene Klammern) 112
|-Operator (bitweises Oder) 63
’ (Anführungszeichen) für Strings 81
A
Max.
Linie
Abbildung 111
Funktionen 242
abfangen
Ausnahmen 453, 456
benutzerdefinierte Ausnahmen 430
eingebaute Ausnahmen 426
Abfangen von Beschränkungen 432
Ablaufverfolgung 26
abs-Funktion 471
abstrakte Oberklassen 350
allgemeine Mengen-Funktionen 232
Allgemeingültigkeit, Qualifikation 285
and-Operator 63, 164
Anpassung
Dictionaries 114
IDLE 48
Klassen 334–337
Sortierung 483
Texteditoren 52
Vererbung 320
Anweisungen
assert 431
Ausdrücke 151
Begrenzungszeichen 162
definierte 143
Fehlersuche 196
if 157–160
print 32, 152–155
raise 429–431
Reihenfolge der 310
Syntax 160–164
try/except/else 421–428
try/finally 427
try/finally-Endebehandlung 428
Verbund- 32
verpacken 451
Wahrheitstests 164
while 167–169
Zusammenfassung 144
Zuweisung 144, 149, 151, 281
Anwendungen, Internationalisierung von 87
“
Max.
Linie
Links
Max.
Linie
append-Methode 109, 114, 485
apply-Funktion 239–241
Architektur 268–271
Argumente 206
Änderungen an veränderlichen 223
apply-Funktion 239–241
gemeinsame Verweise 223
Matching 225, 233
Standardwerte 260
Übergabe 222, 232, 234, 241
Argumentübergabe beim Referenzaufruf 225
argv-Attribut (sys-Modul) 93
Arrays 107
Aspektorientierte Programmierung 26
assert-Anweisung 431
Attribute 41
Architektur 269
Klassen 404
Konstruktion 347
pseudoprivate Klasse 394–396
Qualifikation 285
Suche bei der Vererbung 321
Aufgaben, Lösungen zu den 572
Aufrufe
apply-Funktion 241
einbetten 50–51
eingebaute String-Methoden 98
Funktionen 207
indirekte 257
Instanzen 360
Klassen 332
Listenmethoden 109
Methoden 346
Oberklassen-Konstruktoren 346
Signaturen 370
Ausdrücke 62–64, 151
Funktionen, Methoden 151
gemischte Typen 64
häufige 151
Klammern 63
Lambdas 236
List-Comprehension 245–249
Literale 59
Operatoren überladen 64
Werte ausgeben 151
Zahlen 65–73
ausführbare Skripte 36
eingefrorene Binärdateien 51
ausführen
interaktive Kodierung 29–32
Moduldateien 33–37
Ausführung 19–22
Code 505–508
innerhalb des Prozesses 450
Modellvariationen 22
Moduldateien 276
PVM 21
Sequenzen 160
Texteditoren 52
Ausgabe
Funktionen 204–211
Ausgabeströme
modifizieren 494
umlenken 154
Ausnahmen 415–421
abfangen 453, 456
assert-Anweisung 431
äußeres try 449
benutzerdefinierte (Beispiel) 430
eingebaute abfangen (Beispiel) 426
Fehlersuche 448–451
Klassen 434–442
Matching 455
raise-Anweisung 429–431
raw_input 448
Strings 433
Suchroutine 448
testen 452
Text 439
try/except/else-Anweisung 421–428
try/finally-Anweisung 427
verschachteln 444–448, 451–455
zusätzliche Daten übergeben 430
auspackende Zuweisungen 145
äußere try-Anweisungen 449
Auswahl von Modulen 274
automatische Erweiterungen, Windows 35
automatische Speicherverwaltung 14
B
Backslash 83, 163
Bäume 324, 347
Begrenzungszeichen
Anweisungen 162
Blöcke 161
“
Max.
Linie
Rechts
benutzerdefinierte Ausnahmen abfangen 430
benutzerdefinierte Dokumentations-Strings 186
benutzerdefinierte Iteratoren 355
Bereiche
Schleifen 178
Zeichenlisten 181
Berichte, PyDoc 189, 192
Beschränkungen 7
abfangen 432
Icon-Klicks 40
betrachten 40
Betrachtung 67
Betriebssysteme, automatische Erweiterungen
35
Beziehungen, Vererbung/OOP 372–378
Bildschirm löschen in IDLE 48
Binärdateien 499
bitweise Operatoren 63, 69
bitweises Shift, Zahlen 69
Blöcke
Begrenzungszeichen 161
-Strings 86
Blockgröße auswählen 497
Boolesche Operatoren 164
Zahlen 69
break-Anweisung 169
Bytecode 7
Escape-Sequenzen 82
kompilieren 20
C
C
Max.
Linie
Integration mit 14
Zuweisungen 173
C++ 10, 14
Callback-Funktionen 240
gebundene Methoden 388
CGI (Common Gateway Interface)
Module 501
Skripte 514, 532
chr-Funktion 471, 473
class-Anweisung 341
close-Funktion 125
cmp-Funktion 472
Code
Architektur 268–271
ausführen 505–508
Ausnahmen 433–442
C, Python und 196
Dokumentation 184–195
einbetten 50–51
Endebehandlung 428
Escape-Sequenzen 82
Fehlersuche 196
Funktionen 204–211
hello world 153
hexadezimale Notation 72
IDLE 47
interaktiver 29–32
Klassenbäume 324
Kommentare 65
kompilieren 20
Modell für dyn. Typisierung 74–79
Module 268, 278–282
Namen 212–218
oktale Notation 72
OOP 321–329
Spalte 1 196
Strings 94–97
testen 31
Unterausdrücke 63
Verwendungshinweise 44
Werkzeuge 243
Wiederverwendung 203, 326
(siehe auch Module)
COM (Microsoft Common Object Model) 474,
481
COM-Framework 513, 521
formletter.py 521
Information finden über 525
Common Gateway Interface (siehe CGI)
compile-Funktion 505
complex-Funktion 473
Constraint-basierte Programmierung 26
continue-Anweisung 169
CPython 22
csh-Shell 569
D
Dateien 124–126
ausführen 19
auswählen 274
Erweiterungen 35
Gültigkeitsbereich 216
“
Max.
Linie
Links
Max.
Linie
kopieren 490
Matching 492
Namensänderungen an mehreren 282
print-Anweisungen in 35
Scanner-Schleifen 177
verarbeiten 125
Verarbeitung 495
Dateimanipulation
glob-Modul 492
Menge von Dateien, Kommandozeile 498
open- und close-Funktionen 124
temporäre Dateien 493
Dateinamensmanipulation 491
Daten in Modulen verbergen 301–304
Datenbanken 10
Datenkapselung 301–304
Datensätze
Dictionaries 118
Klassen als 371–372
Datenstrom-Prozessoren 376
Datenstrukturmanipulation 479–485
def-Anweisung 204–205
zur Laufzeit 206
Deklaratoren 249
del-Anweisung 105, 110, 114, 138
Delegation und OOP 378
Destruktoren 361
diamantförmige Vererbung 397
Dictionaries 111–112
an Indices zuweisen
Datensätze 371–372
erzeugen 183, 485
häufige Konstanten, Operationen 112
kopieren 480
Namensräume 364
Operationen 112–115
Schlüssel 116
Sequenzoperationen 116
Sprachtabellen 115
sys.modules 306
sys.path 304
verändern 114
Verwendungshinweise 116
dir-Funktion 185, 466
Division 68
Dokumentation 184–195
COM 525
Strings 387, 388
Dokumentations-Strings 186
eingebaute 188
Standards 188
Doppelpunkte, Verbundanweisungen 196
dynamische Typisierung 12, 13, 74–79
E
Edit/Runscript-Option (IDLE) 48
editieren (siehe Texteditoren)
Effizienz eingebauter Objekte 58
einbetten
Objekte 390
Python in C 10
Sequenzen 82
einfache Variablen 285
Eingabe modifizieren 494
Eingabeaufforderungen
... 32
>>> 30
Dateierweiterungen 35
einrücken 32
interaktive 32
Verbundanweisungen 32
eingebaute apply-Funktionen 239
eingebaute Ausnahmen
abfangen 426
Klassen 438
eingebaute Dokumentations-Strings 188
eingebaute Funktionen 508
Zahlwerkzeuge 73
eingebaute Module
Binärdateien 499
cgi-Modul 501
Fehlerbeseitigung 508
Internet-Datenverarbeitung 503
Internet-Protokolle 503
Laufzeitprofil 510
string-Funktionen 474
string-Konstanten 474
time-Modul 509
urllib 502
urlparse 503
eingebaute Objekttypen 59
eingebaute String-Methoden 98
eingebaute Typen 57–59
erweitern 390–394
Fehlersuche 135–137
Hierarchien 133–134
“
Max.
Linie
Rechts
Max.
Linie
Iteratoren 254
Kategorien 126
eingebaute Werkzeuge 61
eingebauter Gültigkeitsbereich 217
eingefrorene Binärdateien 27
ausführbare 51
Einrückung 161, 196
interaktive Eingabeaufforderungen 32
einstellige Operatoren 63
elif-Klausel 157
else (Schleifen) 157, 168–169, 174
else-Anweisung 421
Endebehandlung 416, 418, 428
Endungen
komplexe Zahlen 71
(siehe auch Erweiterungen)
Entwickler-Produktivität 5
Entwicklung 21
Entwicklungsgeschwindigkeit 5
Entwurf
Ausnahmen 444–455
Entwurfsmuster 329
Funktionen 255–258
Module 305–308
OOP 369
Ereignismeldung 416
erneutes Modul-Laden 288
allgemeine Form 288
Attribute 42–44
Auswirkung auf Importe 312
Beispiel 289
Verwendungshinweise 44
erweiterte Zuweisungsanweisungen 149
Erweiterungen 7
automatische (Windows) 35
Bytecode 20
eingebaute Objekte 58
Importe als 304
Klassen neuen Stils 400
print-Anweisungen 154
Zahlen 61
Escape-Sequenzen 82
eval-Funktion 505
exec-Anweisung 505
execfile-Funktion 505–506
explizite Konfliktauflösung 398
extending
Python mit C 14
Extensible Markup Language (siehe XML)
F
Fabriken 383
feedback.py-Programm 514–520
Fehlerbehandlung 416
Fehlerbeseitigung 425, 448, 508–511
äußere try-Anweisungen 449
IDLE 48
Module 508
(siehe auch Fehlersuche)
Fehlersuche 508–511
Änderungen an veränderlichen Argumente
223
Ausnahmen 415–421, 429–431, 448–451
Code 196
explizite Konfliktauflösung 398
Funktionen 258–262
Icon-Klicks 40
if-Anweisugnen 158
Klassen 404–407
Module 308–315
Objekte 135–137
Wahrheitswerte 164
Fenster, IDLE 47
Fließkomma-Literale 60
Fließkommazahlen 59
float-Funktion 470, 473
Formatierung 212–218
Dictionaries 183, 485
for-Schleifen 173
Funktionen 204–211, 255–258
if-Anweisungen 157
Listen 485
Module 305–308
Schleifen 169–173
Strings 94–97
FormEditor-Program
Vergleich mit feedback.py 532
FormEditor-Programm 526
add_variable 530
Code 527
for-Schleifenblock 529
load_data-Funktion 530–531
select-Methode 531
formletter.py-Programm 521
Formulare, print-Anweisungen 152
for-Schleife 172–177
Variationen 178–183
Frameworks 329, 513
“
Max.
Linie
Links
COM 520–525
Entwurfsüberlegungen 532
PIL 553
Swing Java GUI 534–541
Freeware 12
from-Anweisung 279, 281
allgemeine Form 288
for-Zuweisungen 281
interaktives Testen 312
Module 309
Pakete 296
Zuweisungen 281
Funktionen 203, 235
Abbildung 242
allgemeine Menge 232
apply-Funktion 239–241
Argumentübergabe 222, 234
Aufrufe 207
Aufrufsyntax 197
Callback 240
Code 204–211
Code-Wiederverwendung 203
dir 185
eingebaute 508
Entwurf 255–258
Ergebnisse 197
Fehlersuche 258–262
Generatoren 251–255
global-Anweisung 205, 218
Gültigkeitsregeln in 212
indirekte Aufrufe 257
Iteratoren 251–255
Lambdas 235–239
map-Funktion 242
partielle Anwendung 244
Python-Code ausführen 505–508
raw_input 39, 448
return-Anweisung 205
reversed-Funktion 180
Typkonvertierungen 472
überladen 370
überschneidende Elemente 209
umgebende 214
verschachteln 219–222
Werte 231
Zahlwerkzeuge 73
Max.
Linie
G
Ganzzahlen 60, 70
lange 70
Literale 60
Zuweisungen 74
gebundene Instanzmethoden 385
gemeinsame Objektverweise 128
gemeinsame Verweise 128–130, 223
gemischte Operatoren 62
gemischte Typen, Ausdrucksoperatoren 64
gemischte Verwendungsarten, Module 303
Generator-Ausdrücke 254
Generatoren 251–255
Generierung
mehrerer Instanzobjekte 330–334
von Instanzen 371
generische Datenstrom-Prozessoren 376
Gleichheit, testen auf 131–133
global deklariert 214
global-Anweisung 205, 218
globaler Gültigkeitsbereich 213
glob-Modul 492
grapher.py 535, 540
Graphical User Interface (siehe GUI)
Groß-/Kleinbuchstaben-Unterscheidung
Namen 147
Größe von Objekten 89
große Zeichenmengen kodieren 86
GUI (Graphical User Interface)
Entwurfsüberlegungen 532
Programmierung 9
Gültigkeitsbereich 179, 362, 379
eingebauter 217
importieren 286
Lambdas 238
LGB-Regel 214
Regeln 212–218
verschachteln 206
verschachtelte Funktionen 219–222
(siehe auch Namensräume)
H
Hammond, Mark 521
»hat-eine«-Beziehung 374
hello world ausgeben 153
hexadezimale Konstanten 61
hexadezimale Literale 60
“
Max.
Linie
Rechts
hexadezimale Notation 72
hex-Funktion 473
Hierarchien
Klassen 334
Objekte 133–134
HTML (Hypertext Markup Language) 9, 515
PyDoc-Berichte 192
Hypertext Markup Language (siehe HTML)
I
Max.
Linie
Icons, Windows- 37–41
Identitätstests 131
IDLE 45–49
if-Anweisungen 157–160
imaginäre Zahlen 71
Implementation 22
import-Anweisung 505
allgemeine Form 288
als Zuweisung 281
importieren
Äquivalenz 282
Architektur 269
Attribute 42–44
Erweiterungen 304
Gültigkeitsbereich 286
Module 41–42, 271–277, 279–280
Namensstrings 308
Pakete 292–300
rekursiv 311
Verwendungshinweise 44
Zuweisungen 281
IndexError-Ausnahme 418
indirekte Aufrufe 257
indizieren 80, 90, 91
_ _getitem_ _-Methode 353
Dictionaries (siehe Dictionaries)
Klassen 353
Listen 104–110
in-Operator 63
Installation 18
Instanzen 371
Aufrufe 360
Klassen 322
mehrere -objekte 330–334
Slots 400
zusätzliche Daten schicken 440
Integration
mit C 10, 14, 51
Komponenten 10
Integrität, Tupel 123
interaktive Eingabeaufforderungen
einrücken 32
Kommandos 32
interaktive Kommandozeile, Python 29
interaktive Sitzungen 41
interaktives Testen 312
Internationalisierung von Anwendungen 87
Internet
cgi-Modul 501
Datenverarbeitung 503
Hilfsmodule 9
Protokolle 503
urllib-Modul 502
urlparse-Modul 503
Internet-Module 501–504
Interpreter nutzen 17
int-Funktion 470, 473
Introspektion 306
IronPython 23
is not-Operator 63
is-a-Relation 372
is-Operator 63, 131
Iteration 167–169, 242
benutzerdefinierte 355
Klassen 354
Strings 89
J
Java/Jython 533
Java-Bibliotheken 534
Java-Scripting 535
Nnstallation 533
Swing-Anwendung, grapher.py 535
Vergleich 540
Jython 23
K
Kanäle 495
Kapselung 369
Kategorien
Ausnahmen 434
Typen 126
KI-Programmierung 11
Klammern in Ausdrücken 63
Klassen
_ _add_ _-Methode 352
_ _getattr_ _-Methode 357
“
Max.
Linie
Links
Max.
Linie
_ _getitem_ _-Methode 353
_ _init_ _-Konstruktor 338, 344, 349
_ _repr_ _-Methode 358
aufrufen 332
Ausnahmen 434–442
Bäume 324
als Datensätze 371–372
Dokumentations-Strings 387
entwerfen mit OOP 369
Fehlersuche 404–407
generische Objektfabriken 383
Gründe für 320
Instanzen 322
Iteration 354
mehrfache Instanzobjekte 330
Methoden 344, 400
Module 336, 388
Namensräume 362–368
Namensverstümmelung 394
neuer Stil 396, 404
Oberklassen 334
Operatorüberladung 127, 337, 340, 351
Persistenz 379
Properties 401
pseudoprivate Attribute 394–396
Schnittstellen 349
Unterklassen 334–337
Vererbung 334–335, 383
Klassen neuen Stils 396, 404
klassifizierende Namen 363
Klauseln
try/else 424
try-Anweisung 422
Kommandos, interaktive Eingabeaufforderungen 32
Kommandozeilenargumente 29–32, 93
Kommentare 65, 160
Dokumentation 185
kommutative Operatoren 359
Komodo 50
kompilieren
Bytecode 20
Erweiterungen 7
Module 276
Psyco, Just-in-Time-Compiler 24
komplexe Zahlen 61, 71
Komponenten
Integration 10
mischen 27
Psyco, Just-in-Time-Compiler 24
PVM 21
Komposition 320, 374
Konfiguration
Ausnahmen 444–455
Dictionaries 112–115
Funktionen 255–258
Module 305–308
Suchpfad-Einstellungen 293
Konfliktauflösung 398
Konstanten
Listen 105
Tupel 121
Konstruktoren 326
Klassen 338, 344, 346, 349
Kontrollfluss
Anweisungen 160
ungewöhnlicher 417
verschachteln 445
Konventionen, Namens- 148, 485
Konvertierung, Strings 64, 92–95, 470–474
Konzepthierarchie 143
kopieren
copy-Modul 481
Dateien 490
Dictionaries 480
Objekte 128–130, 479
Vergleich mit verweisen 145
Verzeichnisse 490
Kopplung 255
ksh-Shell 569
Kurzschlussauswertung 165
L
Lambdas 235–239
Operatoren 63
lange Ganzzahlen 60, 70, 470
Laufzeit, def-Anweisungen 206
Laufzeitmessung 508–511
Laufzeitprofil 508–511
lazy evaluation 26
leere Sequenzen 132
leere Strings 80
Leerzeichen in Programmen 160
Leerzeilen 196
LEGB-Regel 214–215
leichte Bedienung 15
len-Funktion 89
“
Max.
Linie
Rechts
lesen von stdin 498
lexikalische Gültigkeitsbereiche 286
Links, Namensräume 367
List-Comprehension-Asdrücke 245–249
Listen
an Ort und Stelle ändern 108
Dictionaries 116
einfache Operationen auf 106
erzeugen 485
häufige Konstanten 105
Indizierung und Slicing 107
Methoden 109
Objekte 131–133
Operationen 106
sys.path 274
Tupel 123
Zeichen 181
list-Funktion 472
Literale 59
Dictionaries 112
Fließkomma 60
Listen 105
Strings 81–88
Tupel 121
Zahlen 60
logisch falsche Objekte 132
logische Operatoren 63
logische Programmierung 26
lokale Variablen 211
lokaler Gültigkeitsbereich 213
long, C 470
long-Funktion 473
Lösungen zu den Aufgaben 572
Lundh, Fredrik 553
M
Max.
Linie
Manuale (siehe Dokumentation)
map-Funktion 181, 242
Matching
Argumente 225, 233
Ausnahmen 455
Dateien 492
Matritzen 107
max-Funktion 474
mehrdimensionale Arrays 107
mehrere Instanzobjekte 320, 330–334
mehrfache Vererbung 405
Klassen 380
Reihenfolge 405
mehrfache Verzweigung 159
Werkzeuge 238
Mehrfachziel-Zuweisungen 146
mehrzeilige Block-Strings 86
Mengen-Objekte 123
Metaprogramme 306, 308
Methoden
Aufrufe 346
Dictionaries 115
Klassen 344
Listen 109
Operatorüberladung 352
Strings 97
Microsoft Common Object Model (siehe COM)
min-Funktion 473
Mischen von Komponenten 27
Mixins 381
Modelle
Ausführung 22
dynamische Typisierung 74–79
Modifikation
Ausgabe 494
Dictionaries 114
Eingabe 494
Strings 94, 98
veränderliche Typen 103
Module 57, 267, 316
_ _name_ _ und _ _main_ _ 303
Attribute 42–44
ausführen 276
auswählen 274
Code 268
copy 481
Dateien 33–37
Datenkapselungskonvention 301–304
definieren 278–282
Entwurf 305–308
erneut laden 312
Erweiterungen 304
Fehlersuche 308–315
gemischte Verwendungsarten 303
Gültigkeitsbereich 216
importieren 41–42, 271–277
Internet 501–504
Klassen 336, 388
kompilieren 276
Namensräume 283–287
Pakete 292, 300
“
Max.
Linie
Links
shutil 490
Standardbibliothek 271
suchen 272
Suchpfad ändern 304
Verwendungshinweise 44
Zahlwerkzeuge 73
(siehe auch erneutes Modul-Laden)
Module definieren 278–282
Muster
eingebaute String-Methoden 98
Entwurfs- 329
N
Namen
Änderungen an mehreren Dateien 282
Konventionen 148, 485, 487
Moduldateien 42–44
Qualifikation 285, 363
Typen 148
unqualifizierte Namen 362
Variablen-, Regeln 147
Verstümmelung 394
Verweis 145
Zuweisung 145
Namensänderungen an mehreren Dateien 282
Namensräume 212, 323, 362–368
Baumkonstruktion 347
class-Anweisung (Beispiel) 342
Dictionaries 364
LGB-Regel 214
Links 367
Module 268, 283–287
(siehe auch Gültigkeitsbereiche)
Negationsoperator 63
negative Abstände, Strings 90
None-Objekt 109, 133, 170, 197
not in-Operator 63
not-Operator 63, 164
numerische Genauigkeit 60
numerische Objekte
bitweise Operationen 69
lange Ganzzahlen 70
numerische Programmierung 11
NumPy, numerische Programmier-Erweiterung
11
Max.
Linie
O
Oberflächen
IDLE 45–49
Komodo 50
Programmierung 9
(siehe auch GUI)
Oberklassen 322, 334
abstrakte 350
Konstruktoren 346
oberste Ebene, Kopien auf 130
Objektänderung an Ort und Stelle 78
Objekte 57
Änderung an Ort und Stelle 78
einbetten 390
eingebaute 58
Fabriken 383
Fehlersuche 135–137
Funktionen 205
Gleichheitstests 131
Hierarchien 133–134
Klassifikation 126
kopieren 128–130, 479
Listen 104–106
Literale 59
mehrere Instanz- 330–334
Mengen 123
Namensräume 363
operations 106
Persistenz 10, 379
shared references 128–130
String-Methoden 97
veränderliche 260
Verbundtypen 126
Vergleiche 131–133
Wahrheitswerte 132
Zahlen 59–62, 65–73
objektorientierte Programmierung (siehe OOP)
Objektverweis
Erzeugung 145
Funktionen 205
oct-Funktion 473
offene Paar-Regel 163
öffnen von Windows-Icons 37–41
Oktalzahlen
Konstanten 61
Literale 60
Notation 72
“
Max.
Linie
Rechts
OOP (Object-Oriented Programming) 12
Delegation 378
entwerfen mit 369
Fabriken 383
Klassen (Beispiel) 330
Klassenobjekte 330, 334
Überblick 321–329
Vererbung 372–378
Open Source-Software 12
open-Funktion 124
Operationen
Dateien 124
Dictionaries 112–115
Listen 106
Tupel 121
Operatoren
Ausdrücke 62–64
Klassen 337
kommutative 359
Strings 88–94
überladen 64, 320
Überladung 127
Klassen 337, 340, 351
Vorrang 62
Optionen, Dictionaries 114
ord-Funktion 471, 473
or-Operator 63, 164
os.environ-Dictionary 488
os.error-Ausnahme 488
os.listdir-Funktion 491
os.name-Attribut 488
os.path-Modul, -Funktionen 489
os.rename-Funktion 491
os-Modul 486–490, 522
Attributdefinition 488
Funktionen (oft benutzte) 486
String-Attribute 489
Ousterhout, John 526
P
Max.
Linie
Pakete
importieren 292–300
Module 300
parallele Traversierungen 181
Parameter, Funktionen 206
parsen
Argumente 222, 234
raise-Anweisungen 430
Text 101
partielle Anwendung von Funktionen 244
pass-Anweisung 169
PATH-Umgebungsvariable 37, 530
Performance 21
Perl-Sprache 15
Persistenz 379
Pfade
Module 272
Qualifikation 285
Suche 304
suchen 293
pickle-Modul 10, 520, 522
PIL (Python Imaging Library) 513
Polymorphie 208, 210, 230, 369
portable Datenbank-APIs 10
portables ANSI-C 13
positive Abstände, Strings 90
POSIX-Konventionen 487
print-Anweisungen 32, 152–155
in Dateien 35
Zahlen 67
Produktivität 5
profile-Modul 511
Programmierung 9
Architektur 268–271
ausführen 505–508
Ausnahmen 433–442
Code-Wiederverwendung 204
Datenbanken 10
Dokumentation 184–195
Endebehandlung 428
Fehlersuche 196
Funktionen 204–211
GUI 9
hello world 153
Interpreter 17
KI 11
Klassenbäume 324
Kommentare 65
Modell für dyn. Typisierung 74–79
Module 268, 278–282
Namen 212–218
numerische 11
OOP 321–329
String-Methoden 97
Strings 94–97
“
Max.
Linie
Links
Struktur 57
Werkzeuge 243
Programmstruktur 269
Properties
Klassen 401
Listen 104–106
Syntaxregeln 160–164
Prototyp-Erstellung 11
pseudoprivate Klassenattribute 394–396
Psyco, Just-in-Time-Compiler 24
pth-Dateiverzeichnisse 273
PVM (Python Virtual Machine) 21
PyDev 50
PyDoc-Werkzeuge 189
HTML-Berichte 192
PyPy 25
Python ausführen
eingebetteter Code, Objekte 50–51
interaktive Kommandozeile 29–32
Interpreter 18
Moduldateien 33–37
Unix-artige Skripte 36
Python Imaging Library (PIL) 553
Python Virtual Machine (PVM) 21
Python.NET 23
PYTHONPATH-Variable 568
Verzeichnisse 273
PYTHONSTARTUP-Variable 568
PythonWin 50
Q
Qualifikation
_ _getattr_ _-Methode 357
Namen 285, 363
Qualität 4
Quellcode kompilieren 20
R
Max.
Linie
raise-Anweisung 429–431, 442
random-Modul 483
Rapid Prototyping 11
raw_input-Funktion 39, 448
re.compile( ) (Strings) 477
Rechte, ausführbare Skripte 36
Regeln
Gültigkeitsbereiche 212–218
LEGB 215
offene Paare 163
Syntax 160–164
reguläre Ausdrücke 474, 479
rekursiv importieren 311
re-Modul 474, 479
Repräsentationen, Strings 358
reservierte Wörter 147
Restoperator 63
return-Anweisungen 197, 205
reversed-Funktion 180
rohe Strings, Escapes unterdrücken 85
Rollen, Ausnahmen 416
RPython 25
S
Schleifen
Bereiche 178
Datei-Scanner 177
else 157, 169, 174
for 172–183
Formatierung 169–173
String-Iteration 89
verschachteln 246
while 167–169
Schlüsselwort-Argumente 226–234
Übergabe 241
Schnittstellen
Klassen 349
PyDoc 189
PythonWin 50
schreiben
auf sys.stdout 155
(siehe auch Code)
schreibweisenunabhängige Sortierung 483
Scripting 6, 9
Internet 9
PVM 21
Sprachen 13
umlenken 155
Unix-ähnliches 36
verpacken 451
Sequenzen 80
Ausführung 160
einbetten 82
Funktionen 242
Listen 106
überschneidende Elemente 209
unterdrücken 85
“
Max.
Linie
Rechts
Max.
Linie
Shell-Werkzeuge 6
shelve-Modul 379
Shift-Operatoren 63
shutil-Modul 490
Signaturen, Aufrufe 370
Slicing 80, 90–91
Listen 107
Zuweisungen 108
Slots, Instanzen 400
Software-Qualität 4
Sortierung anpassen 483
sort-Methode 109, 482
spärliche (sparse) Datenstrukturen, Dictionaries
für 117
Speicher, automatische Verwaltung von 14
Speicherbereinigung 14
Verweise 79
speichern, Text 33
Spezialfall, Behandlung 416
Spiele 11
Sprachen
Vergleiche mit 15
zukünftige Eigenschaften einschalten 302
Sprachtabellen, Dictionaries 115
Stackless Python-System 25
Stacks 444
Standardargumente 227, 229, 260
Standard-Ausnahmebehandler 418
Standard-Bibliotheksmodule 271
Standard-Manualsatz 193
Standards, Dokumentations-Strings 188
Startoptionen 52
Startverzeichnis 272
statisch verschachtelte Gültigkeitsbereiche 219–
222
statische lokale Funktionsvariablen 260
statische Methoden, Klassen neuen Stils 400
Stein, Greg 521
Steuersprache 6
str-Funktion 472
string-Modul 474
Ersetzungsoperation 478
Funktionen 474
Konstanten 474
Problem mit regulären Ausdrücken 476
Strings
ändern, formatieren 94
Ausnahmen 433
Block- 86
Codes 96
definierte 80
Dokumentation 387–388
einfache Operationen 88–94
Formatierung 94–97
indizieren 90–91
Konstanten, Operationen 81
Listen 106
Literale 81–88
Methoden 97
modifizieren 94, 98
Slicing 90–91
Typkategorien 102
zurückgeben 358
Strings in doppelten Anführungszeichen 82
Strings in dreifachen Anführungszeichen 86
Strings in einfache Anführungszeichen 82
Strom-Umlenkung 34
struct-Modul 499
Formatierungscodes 500
suchen
Ausnahmen 448
Module 272
Pakete 293
-Pfad ändern 304
Vererbung 321
Swing Java GUI-Toolkit 513
syntaktische Verschachtelung 446
Syntax
Anweisungen 160–164
apply-Funktion 241
Ausführungssequenzen 160
Backslash 163
offene Paare 163
Syntaxregeln
Anweisungs-Begrenzungszeichen 162
Blöcke 160–161
Leerzeichen, Kommentare 160
Variablennamen 147
Verbundanweisungen 160
sys.modules-Dictionary 306
sys.path-Dictionary 304
sys.path-Listen 274
sys.stdout, Schreiben auf 155
Systemprogrammierung 9
Max.
Linie
“
Links
T
Max.
Linie
Tabellen, Dictionaries 115
Tainting 26
tempfile-Modul 520
temporäre Dateien 493
Testen 508–511
testen
Ausnahmen 452
Code 31
Gleichheit 131–133
if-Anweisugnen 158
innerhalb des Prozesses ausführen 450
interaktiv 312
Wahrheitswerte 164–166
Tests hinzufügen 246
Tests innerhalb des Prozesses ausführen 450
Text 86
Ausnahmen 439
Dokumentations-Strings 188
Kommentare 65
parsen 101
speichern 33
String-Methoden 97
Strings modifizieren 94
umlenken 154
Texteditoren
Module 278–282
Startoptionen 52
time-Modul 509
Tk/Tkinter 9, 513, 526–532
GUI 513
Umgebungseinstellungen 569
Tracing 26
Traversierungen
parallele 181
Schleifen 180
try/except/else-Anweisung 421–428
try/finally-Anweisung 427
try-Anweisung 422
try/except/else-Anweisung 421
try/finally-Anweisung 427
Tupel
definierte 120–123
Eigenschaften 121
Funktionen 472
Inhalt sortieren 482
Zuweisung 145
Typen
Dateien 124–126
eingebaute 390–394
Einschränkungen 205
Fehlersuche 135–137
Gründe für eingebaute 57–59
Hierarchien 133–134
Iteratoren 254
Kategorien 102, 126
konvertieren 64, 472
Modell für dyn. Typisierung 74–79
Namen 148
Objekte 126
Sammlungstupel 120–123
veränderliche 103
Zahlen 59–62
U
Übergabe von Schlüsselwortargumenten 241
überladen von Operatoren 64, 127, 320
Klassen 340, 351
Übersetzung, Psyco, Just-in-Time-Compiler 24
umgebende
Ausdrücke 63
Funktionen 214
Umgebung 567
umlenken
Ausgabeströme 154
Skripte 155
ungebundene Klassenmethoden 385
Unicode-Strings 86
Unix-ähnliche System-Skripte 36
unqualifizierte Namen 362
Unterausdrücke 63
unterdrücken von Escape-Sequenzen 85
Unterklassen 322, 334, 391
unveränderliche Sequenzen 80
unveränderliche Typen ändern 137
urllib-Modul 502
urlparse-Modul 503
URLs, urllib-Modul 502
V
van Rossum, Guido 541
Variablen 43
einfache 285
lokale 211
“
Max.
Linie
Rechts
Max.
Linie
Namensregeln 147
Zahlen 65
Zuweisungen 74
Variationen, Ausführungsmodelle 22
veränderliche Argumente, Änderungen an 223
veränderliche Objekte 260
veränderliche Typen 103
Veränderlichkeit 80, 103, 137
Verarbeitung
Dateien 125, 495
Zahlobjekte 61
Zeilen 499
Verbergen von Objekten 26
Verbreitung von Ausnahmen 420, 431
Verbundanweisungen 32, 160
Verbundobjekttypen 126
Vererbung 320, 369
Anpassung 320
diamantförmig 397
Klassen 334, 383
Konstruktion von Namensraumbäumen 347
mehrfache 405
OOP 372–378
Spezialisierungsmethoden 348–350
Suche 321
Vergleiche 470–474
importieren/Gültigkeitsbereiche 286
Klassen/Module 388
Objekte 131–133
Operatoren 63
Sprachen 15
Zahlen 472
Verkettung 80
+ (Addition/Verkettung) 338
Strings 88–94
Verpacken von Anweisungen 451
verschachteln
Ausnahmen 444–448, 451–455
Blöcke 160
Funktionen 219–222
Gültigkeitsbereiche 154, 206, 366
Kontrollfluss 445
Lambdas 238
Listen 107
Namensräume 213, 287
Schleifen 246
syntaktisch 446
Verwaltung von Speicher, automatische 14
Verweise
Argumente 223
gemeinsame 128–130
Objektänderung an Ort und Stelle 78
Speicherbereinigung 79
Vergleich mit Kopien 145
Zuweisungen 135
Verwendungshinweise 44, 116
Verzeichnisse kopieren 490
verzögerte Auswertung 26
Vorrang
Ausdrücke 63
Regeln (Operatoren) 62
Vorwärtsverweise 310
W
Wahrheitswerte
Objekte 132
testen 164–166
Webseiten, cgi-Modul 501
Website-Ressourcen XXII
Werkzeuge
Ausdrücke 62–64
Dokumentation 185
eingebaute Funktionen 73
mehrfache Verzweigung 238
Programmierung 243
PyDoc 192
Shell 6
Zahlen 61
Werte
Funktionen 231
Standardargumente 260
Wahrheitswerte 164–166
Wahrheitswerte für Objekte 132
while-Schleife 167–169
Wide-Character-Strings 86
Wiederholung, eine Ebene tief 136
win32com 521
Dispatch-Funktion 522
formletter.py-Programm 521
Windows
automatische Erweiterungen 35
Icons 37–41
(siehe auch Oberflächen)
Wing IDE 50
Max.
Linie
“
Links
X
XML (Extensible Markup Language) 9, 11, 14
Z
Zahlen 59–62, 67, 470–474
Ausdrücke 62–64
Dezimalzahlen 74
einfache Operationen 65–73
eingebaute Typen 57–59
komplexe Zahlen 71
print-Anweisungen 67
Zuweisungen 74
Zählschleifen 167–169, 178
Zeichen
große Mengen kodieren 86
Listen 181
Zeilen, Verarbeitung 499
zip-Funktion 181, 183
Zope 559
Zusammenhalt 255
zusätzliche Daten an Instanzen schicken 440
Zuweisungen 74
C 173
Funktionen durch 205
Listen 108
Namen, klassifizierende 363
Objektänderung an Ort und Stelle 78
Verweise 135
Zuweisungsanweisungen 144, 149, 151, 281
Formen 145
implizite 145
Objektverweise 145
Regeln für Variablennamen 147
zyklische Datenstrukturen ausgeben 136
Max.
Linie
Max.
Linie
“