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 8 Basisdatentypen
  Pfeil 8.1 Operatoren
  Pfeil 8.2 Das Nichts – NoneType
  Pfeil 8.3 Numerische Datentypen
    Pfeil 8.3.1 Ganze Zahlen – int, long
    Pfeil 8.3.2 Gleitkommazahlen – float
    Pfeil 8.3.3 Boolesche Werte – bool
    Pfeil 8.3.4 Komplexe Zahlen – complex
  Pfeil 8.4 Methoden und Parameter
  Pfeil 8.5 Sequenzielle Datentypen
    Pfeil 8.5.1 Listen – list
    Pfeil 8.5.2 Unveränderliche Listen – tuple
    Pfeil 8.5.3 Strings – str, unicode
  Pfeil 8.6 Mappings
    Pfeil 8.6.1 Dictionary – dict
  Pfeil 8.7 Mengen
    Pfeil 8.7.1 Mengen – set
    Pfeil 8.7.2 Unveränderliche Mengen – frozenset


Galileo Computing - Zum Seitenanfang

8.6 Mappings  Zur nächsten ÜberschriftZur vorigen Überschrift

Die Kategorie Mappings (dt. Zuordnungen) enthält Datentypen, die eine Zuordnung zwischen verschiedenen Objekten herstellen.


Galileo Computing - Zum Seitenanfang

8.6.1 Dictionary – dict  topZur vorigen Überschrift

Der einzige Datentyp der Kategorie Mappings ist das Dictionary, wofür in Python der Name dict verwendet wird. Der Name des Datentyps gibt dabei schon einen guten Hinweis darauf, was sich dahinter verbirgt. Ein Dictionary enthält beliebig viele Schlüssel/Wert-Paare (engl. key/value pairs), wobei der Schlüssel nicht unbedingt, wie bei einer Liste, eine ganze Zahl sein muss. Vielleicht ist Ihnen dieser Datentyp schon von einer anderen Programmiersprache her bekannt, wo er als assoziatives Array (u. a. in PHP), Map (u. a. in C++) oder Hash (u. a. in Perl) bezeichnet wird. Der Datentyp dict ist mutable, also veränderlich.

Im folgenden Beispiel wird erklärt, wie ein dict mit mehreren Schlüssel/Wert-Paaren innerhalb von geschweiften Klammern erzeugt wird. Außerdem wird die Assoziation mit einem Wörterbuch ersichtlich:

woerterbuch = {"Germany" : "Deutschland", "Spain" : "Spanien"}

In diesem Fall wurde ein dict mit zwei Einträgen angelegt, die durch ein Komma getrennt werden. Beim ersten wurde dem Schlüssel "Germany" der Wert "Deutschland" zugewiesen. Schlüssel und Wert werden durch einen Doppelpunkt voneinander getrennt. Beachten Sie, dass Sie nicht gezwungen sind, alle Paare in eine Zeile zu schreiben. Innerhalb der geschweiften Klammern können Sie Ihren Quellcode beliebig formatieren:

woerterbuch = { 
              "Germany" : "Deutschland", 
              "Spain" : "Spanien", 
              "France" : "Frankreich" 
              }

Hinter dem letzten Schlüssel/Wert-Paar kann ein weiteres Komma stehen, es wird aber nicht benötigt. Jeder Schlüssel muss im Dictionary eindeutig sein, es darf also kein zweiter Schlüssel mit demselben Namen existieren. Formal ist folgendes zwar möglich, es bewirkt aber nur, dass das erste Schlüssel/Wert-Paar überschrieben wird.

d = { 
    "Germany" : "Deutschland", 
    "Germany" : "Pusemuckel" 
    }

Im Gegensatz dazu brauchen die Werte eines Dictionarys nicht eindeutig sein, dürfen also ruhig mehrfach vorkommen:

d = { 
    "Germany" : "Deutschland", 
    "Allemagne" : "Deutschland" 
    }

In den bisherigen Beispielen waren bei allen Paaren sowohl der Schlüssel als auch der Wert ein String. Das muss nicht unbedingt sein:

mapping = { 
          0 : 1, 
          "abc" : 0.5, 
          1.2e22 : [1,2,3,4], 
          (1,3,3,7) : "def" 
          }

In einem Dictionary können beliebige Instanzen, seien sie mutable oder immutable, als Werte verwendet werden. Bei dem Schlüssel ist zu beachten, dass nur Instanzen unveränderlicher (immutable) Datentypen verwendet werden dürfen. Dabei handelt es sich um alle bisher besprochenen Datentypen mit Ausnahme der Listen und der Dictionarys selbst. Versuchen wir beispielsweise, ein Dictionary zu erstellen, in dem eine Liste als Schlüssel verwendet wird, so meldet sich der Interpreter mit einem entsprechenden Fehler:

>>> d = {[1,2,3] : "abc"} 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
TypeError: list objects are unhashable

Diese Beschränkung rührt daher, dass die Schlüssel eines Dictionarys anhand eines aus ihrem Wert errechneten Hash-Werts verwaltet werden. Prinzipiell lässt sich aus jedem Objekt ein Hash-Wert berechnen, bei veränderlichen Objekten macht dies jedoch wenig Sinn, da sich der Hash-Wert bei Veränderung des Objekts ebenfalls ändern würde. Eine solche Veränderung würde beispielsweise die Schlüsselverwaltung eines Dictionarys zerstören. Aus diesem Grund sind veränderliche Objekte »unhashable«, wie in der obigen Fehlermeldung gesagt wird.

Bei einem Dictionary handelt es sich um ein iterierbares Objekt. Es ist daher möglich, ein Dictionary in einer for-Schleife zu durchlaufen. Dabei wird nicht über das komplette Dictionary iteriert, sondern nur über alle Schlüssel. Im folgenden Beispiel durchlaufen wir alle Schlüssel unseres Wörterbuchs und geben sie mittels print aus:

for key in woerterbuch: 
    print key

Die Ausgabe des Codes sieht erwartungsgemäß folgendermaßen aus:

Germany 
Spain 
France

Selbstverständlich kann in einer solchen Schleife auch auf die Werte des Dictionarys zugegriffen werden. Dazu bedient man sich des Zugriffsoperators, den wir im Folgenden unter anderem behandeln werden. Beachten Sie, dass Sie die Größe des Dictionarys nicht verändern dürfen, während es in einer Schleife durchlaufen wird. Die Größe des Dictionarys würde zum Beispiel durch das Hinzufügen oder Löschen eines Schlüssel/Wert-Paares beeinflusst. Sollten Sie es dennoch versuchen, bekommen Sie folgende Fehlermeldung angezeigt:

Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
RuntimeError: dictionary changed size during iteration

Diese Beschränkung gilt ausschließlich für Operationen, die die Größe des Dictionarys beeinflussen, also beispielsweise das Hinzufügen und Entfernen von Einträgen. Sollten Sie in einer Schleife lediglich den korrelierenden Wert eines Schlüssels ändern, tritt keinerlei Fehler auf.

Operatoren

Bisher haben Sie gelernt, was ein Dictionary ist und wie es erzeugt wird. Außerdem sind wir auf einige Besonderheiten eingegangen. Nachfolgend besprechen wir die für Dictionarys verfügbaren Operatoren.


Tabelle 8.26  Operatoren eines Dictionarys
Operator Beschreibung

len(s)

Liefert die Anzahl aller im Dictionary s enthaltenen Elemente.

d[k]

Zugriff auf den Wert mit dem Schlüssel k

del d[k]

Löschen des Schlüssels k und seines Wertes

k in d

True, wenn sich der Schlüssel k in d befindet

k not in d

True, wenn sich der Schlüssel k nicht in d befindet


Nachfolgend besprechen wir die Operatoren eines Dictionarys im Detail. Die meisten der Operatoren werden anhand des Dictionarys woerterbuch erklärt, das wir zu Beginn dieses Kapitels eingeführt haben.

Länge eines Dictionarys

Um die Länge eines Dictionarys zu bestimmen, wird die eingebaute Funktion len verwendet. Die Länge entspricht dabei der Anzahl von Schlüssel/Wert-Paaren:

>>> len(woerterbuch) 
3
Zugriff auf einen Wert

Um in einem Dictionary auf einen Wert zugreifen zu können, wird der entsprechende Schlüssel in eckigen Klammern hinter den Namen des Dictionarys geschrieben. Bei dem im zweiten Beispiel angelegten Wörterbuch könnte ein solcher Zugriff folgendermaßen aussehen:

>>> woerterbuch["Germany"] 
'Deutschland'

Dabei erfolgt der Zugriff, indem Werte miteinander verglichen werden und nicht Identitäten. Das liegt daran, dass die Schlüssel eines Dictionarys intern durch ihren Hash-Wert repräsentiert werden, der ausschließlich anhand des Wertes einer Instanz gebildet wird. In der Praxis bedeutet dies, dass beispielsweise die Zugriffe d[1] und d[1.0] äquivalent sind.

Zu guter Letzt werfen wir noch einen Blick darauf, was passiert, wenn auf einen Wert zugegriffen werden soll, der nicht existiert. Der Interpreter antwortet mit einer Fehlermeldung:

>>> d = {} 
>>> d[100] 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
KeyError: 100
Löschen eines Schlüssel/Wert-Paares

Um in einem Dictionary einen Eintrag zu löschen, kann das Schlüsselwort del in Kombination mit dem Zugriffsoperator verwendet werden. Im folgenden Beispiel wird der Eintrag "Germany" : "Deutschland" aus dem Dictionary entfernt werden.

del woerterbuch["Germany"]

Das Dictionary selbst existiert auch dann noch, wenn es durch Entfernen des letzten Eintrags leer geworden ist.

Auf bestimmte Schlüssel testen

Um ein Dictionary auf bestimmte Schlüssel zu testen, werden die Operatoren in und not in verwendet. Sie prüfen, ob sich ein Schlüssel im Dictionary befindet oder nicht, und geben das entsprechende Ergebnis als Wahrheitswert zurück:

>>> "France" in woerterbuch 
True 
>>> "Spain" not in woerterbuch 
False

Methoden

Neben den Operatoren sind für Dictionarys eine ganze Reihe von Methoden definiert, die die Arbeit mit Dictionarys erleichtern. Parameter in eckigen Klammern können, je nach Verwendung der Methode, weggelassen werden.


Tabelle 8.27  Methoden eines Dictionarys
Methode Beschreibung

d.clear()

Löscht den Inhalt des Dictionarys d. Das Dictionary selbst bleibt bestehen.

d.copy()

Erzeugt eine Kopie von d. Beachten Sie, dass nur das Dictionary selbst kopiert wird. Alle Werte bleiben Referenzen auf dieselben Instanzen.

d.has_key(k)

Äquivalent zu k in d. Bitte nicht benutzen.

d.items()

Erzeugt eine Liste, die alle Schlüssel/Wert-Paare von d als Tupel enthält.

d.keys()

Erzeugt eine Liste aller Schlüssel von d.

d.values()

Erzeugt eine Liste aller Werte von d.

d.update(d2)

Fügt ein Dictionary d2 zu d hinzu und überschreibt gegebenenfalls die Werte von bereits vorhandenen Schlüsseln.

d.fromkeys(seq[, value])

Erstellt ein neues Dictionary mit den Werten der Liste seq als Schlüssel und setzt jeden Wert initial auf value.

Beachten Sie, dass diese Methode nichts am Dictionary d ändert.

d.get(k[, x])

Liefert d[k], wenn der Schlüssel k vorhanden ist, ansonsten x.

d.setdefault(k[, x])

Das Gegenteil von get. Setzt d[k] = x, wenn der Schlüssel k nicht vorhanden ist.

d.popitem()

Gibt ein willkürliches Schlüssel/Wert-Paar von d zurück und entfernt es aus dem Dictionary.

d.iteritems()

Erlaubt es, in einer for-Schleife alle Schlüssel/Wert-Paare von d zu durchlaufen.

d.iterkeys()

Erlaubt es, in einer for-Schleife alle Schlüssel von d zu durchlaufen.

d.itervalues()

Erlaubt es, in einer for-Schleife alle Werte von d zu durchlaufen.


Jetzt möchten wir alle Methoden detailliert und jeweils mit einem kurzen Beispiel im interaktiven Modus erläutern. Alle Beispiele werden dabei in folgendem Kontext erklärt:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}

Es ist also in jedem Beispiel ein Dictionary d mit drei Schlüssel/Wert-Paaren vorhanden. In den Beispielen werden wir das Dictionary verändern und uns vom Interpreter seinen Wert ausgeben lassen. Die Ausgabe des unveränderten Dictionarys sieht folgendermaßen aus:

>>> d 
{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}

Sie können dabei jedes Beispiel für sich betrachten und von diesen Grundvoraussetzungen ausgehen. Änderungen, die in einem Beispiel an dem Dictionary d durchgeführt werden, wirken sich nicht auf die Folgebeispiele aus.

d.clear()

Die Methode clear löscht alle Schlüssel/Wert-Paare von d. Sie hat dabei nicht den gleichen Effekt wie del d, da das Dictionary selbst nicht gelöscht, sondern nur geleert wird:

>>> d.clear() 
>>> d 
{}
d.copy()

Die Methode copy erzeugt eine Kopie des Dictionarys d. Beachten Sie, dass zwar das Dictionary selbst kopiert wird, es sich bei den Werten aber nach wie vor um Referenzen auf dieselben Objekte handelt.

>>> e = d.copy() 
{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}
d.has_key(k)

Die Methode has_key prüft, ob ein bestimmter Schlüssel im Dictionary d enthalten ist, und gibt das Ergebnis als booleschen Wert zurück. Der Schlüssel, nach dem gesucht wird, wird der Methode als Parameter übergeben:

>>> d.has_key("k3") 
True 
>>> d.has_key(123)
False

Die Methode has_key kann damit als äquivalent zum Operator in betrachtet werden. Sie sollten die Verwendung des Operators bevorzugen, da has_key in zukünftigen Versionen von Python entfernt werden könnte.

d.items()

Die Methode items erzeugt eine Liste, die alle Schlüssel/Wert-Paare des Dictionarys d enthält. Jedes Paar wird dabei in einem Tupel gespeichert. Diese Liste ist, wie das Dictionary selbst, nicht sortiert:

>>> d.items() 
[('k3', 'v3'), ('k2', 'v2'), ('k1', 'v1')]
d.keys()

Die Methode keys funktioniert ähnlich wie items, mit dem Unterschied, dass die erzeugte Liste nicht die Schlüssel/Wert-Paare enthält, sondern nur die Schlüssel:

>>> d.keys() 
['k3', 'k2', 'k1']
d.values()

Die Methode values ist das Gegenstück zu keys. Statt der Schlüssel enthält die erzeugte Liste alle Werte des Dictionarys:

>>> d.values() 
['v3', 'v2', 'v1']
d.update(d2)

Die Methode update erweitert das Dictionary d um die Schlüssel und Werte des Dictionarys d2, das der Methode als Parameter übergeben wird:

>>> d.update({"k4" : "v4"}) 
>>> d 
{'k3': 'v3', 'k2': 'v2', 'k1': 'v1', 'k4': 'v4'}

Sollten beide Dictionarys über einen gleichen Schlüssel verfügen, so wird der mit diesem Schlüssel verbundene Wert in d mit dem aus d2 überschrieben:

>>> d.update({"k1" : "python rulez"}) 
{'k3': 'v3', 'k2': 'v2', 'k1': 'python rulez'}
d.fromkeys(seq[, value])

Die Methode fromkeys erzeugt ein neues Dictionary und verwendet dabei die Einträge der Liste seq als Schlüssel. Der Parameter value ist optional. Sollte er jedoch angegeben werden, so wird er als Wert eines jeden Schlüssel/Wert-Paars verwendet:

>>> d.fromkeys([1,2,3], "python") 
{1: 'python', 2: 'python', 3: 'python'}

Wird der Parameter value ausgelassen, so wird stets None als Wert eingetragen:

>>> d.fromkeys([1,2,3]) 
{1: None, 2: None, 3: None}
d.get(k[, x])

Die Methode get ermöglicht den Zugriff auf einen Wert des Dictionarys. Im Gegensatz zum Zugriffsoperator wird aber keine Exception erzeugt, wenn der Schlüssel nicht vorhanden ist. Stattdessen wird in diesem Fall der optionale Parameter x zurückgegeben. Sollte x nicht angegeben worden sein, so wird er als None angenommen. Die Methode get kann also als Ersatz für folgenden Code gesehen werden:

if k in d: 
    wert = k[d] 
else: 
    wert = x

Die Methode get kann folgendermaßen verwendet werden:

>>> d.get("k2", 1337) 
'v2' 
>>> d.get("k5", 1337) 
1337
d.setdefault(k[, x])

Die Methode setdefault fügt das Schlüssel/Wert-Paar {k : x} zum Dictionary d hinzu, sollte der Schlüssel k nicht vorhanden sein:

>>> d.setdefault("k2", 1337) 
'v2' 
>>> d.setdefault("k5", 1337) 
1337 
>>> d 
{'k3': 'v3', 'k2': 'v2', 'k1': 'v1', 'k5': 1337}
d.popitem()

Die Methode popitem gibt ein willkürliches Schlüssel/Wert-Paar als Tupel zurück und entfernt es aus dem Dictionary. Beachten Sie, dass das zurückgegebene Paar zwar willkürlich, aber nicht zufällig ist:

>>> d.popitem() 
('k3', 'v3') 
>>> d 
{'k2': 'v2', 'k1': 'v1'}

Sollte d leer sein, so wird eine entsprechende Exception erzeugt:

Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
KeyError: 'popitem(): dictionary is empty'
d.iteritems()

Die Methode iteritems erlaubt es, in einer for-Schleife über alle Schlüssel/Wert-Paare zu iterieren. Das könnte zum Beispiel folgendermaßen aussehen:

for paar in d.iteritems(): 
    print paar

In jedem Schleifendurchlauf enthält die Variable paar das jeweilige Schlüssel/Wert-Paar als Tupel. Dementsprechend sieht die Ausgabe des Beispiels aus:

('k3', 'v3') 
('k2', 'v2') 
('k1', 'v1')
d.iterkeys()

Die Methode iterkeys erlaubt es, in einer for-Schleife alle Schlüssel zu durchlaufen. Im folgenden Beispiel werden alle Schlüssel mittels print ausgegeben:

for key in d.iterkeys(): 
    print key

Wir haben eingangs gesagt, dass es keiner speziellen Methode bedarf, um alle Schlüssel eines Dictionarys zu durchlaufen. Die Methode iterkeys kann problemlos durch folgenden Code umgangen werden:

for key in d: 
    print key

Beide Beispiele sind äquivalent und erzeugen folgende Ausgabe:

k3 
k2 
k1
d.itervalues()

Die Methode itervalues verhält sich ähnlich wie iterkeys, mit dem Unterschied, dass sie es ermöglicht, alle Werte zu durchlaufen:

for value in d.itervalues(): 
    print value

Das Beispiel erzeugt folgende Ausgabe:

v3 
v2 
v1


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