Wörterbücher in Python

Python bietet ein weiteres zusammengesetztesdata type namensdictionary, das einer Liste insofern ähnlich ist, als es eine Sammlung von Objekten ist.

Here’s what you’ll learn in this tutorial: Sie werden die grundlegenden Eigenschaften von Python-Wörterbüchern behandeln und lernen, wie Sie auf Wörterbuchdaten zugreifen und diese verwalten. Wenn Sie dieses Lernprogramm abgeschlossen haben, sollten Sie genau wissen, wann und wie ein Wörterbuch für den Datentyp geeignet ist.

Wörterbücher und Listen weisen die folgenden Merkmale auf:

Beide sind veränderlich.
Beide sind dynamisch. Sie können nach Bedarf wachsen und schrumpfen.
Beide können verschachtelt werden. Eine Liste kann eine andere Liste enthalten. Ein Wörterbuch kann ein anderes Wörterbuch enthalten. Ein Wörterbuch kann auch eine Liste enthalten und umgekehrt.

Wörterbücher unterscheiden sich von Listen hauptsächlich darin, wie auf Elemente zugegriffen wird:

Auf Listenelemente wird über ihre Position in der Liste über die Indizierung zugegriffen.
Auf Wörterbuchelemente wird über Schlüssel zugegriffen.

__ Take the Quiz: Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python Dictionaries“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können:

Das Quiz machen "

Wörterbuch definieren

Wörterbücher sind Pythons Implementierung einer Datenstruktur, die allgemein als assoziatives Array bezeichnet wird. Ein Wörterbuch besteht aus einer Sammlung von Schlüssel-Wert-Paaren. Jedes Schlüssel-Wert-Paar ordnet den Schlüssel seinem zugeordneten Wert zu.

Sie können ein Wörterbuch definieren, indem Sie eine durch Kommas getrennte Liste von Schlüssel-Wert-Paaren in geschweiften Klammern ({}) einfügen. Ein Doppelpunkt (:) trennt jeden Schlüssel von seinem zugehörigen Wert:

d = {
    : ,
    : ,
      .
      .
      .
    : 
}

Im Folgenden wird ein Wörterbuch definiert, das einen Standort dem Namen des entsprechenden Major League Baseball-Teams zuordnet:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

Sie können auch ein Wörterbuch mit der integrierten Funktiondict()erstellen. Das Argument fürdict() sollte eine Folge von Schlüssel-Wert-Paaren sein. Eine Liste von Tupeln eignet sich gut dafür:

d = dict([
    (, ),
    (, , )
])

MLB_team kann dann auch folgendermaßen definiert werden:

>>>

>>> MLB_team = dict([
...     ('Colorado', 'Rockies'),
...     ('Boston', 'Red Sox'),
...     ('Minnesota', 'Twins'),
...     ('Milwaukee', 'Brewers'),
...     ('Seattle', 'Mariners')
... ])

Wenn die Schlüsselwerte einfache Zeichenfolgen sind, können sie als Schlüsselwortargumente angegeben werden. Hier ist noch eine andere Möglichkeit,MLB_team zu definieren:

>>>

>>> MLB_team = dict(
...     Colorado='Rockies',
...     Boston='Red Sox',
...     Minnesota='Twins',
...     Milwaukee='Brewers',
...     Seattle='Mariners'
... )

Sobald Sie ein Wörterbuch definiert haben, können Sie dessen Inhalt genauso anzeigen wie für eine Liste. Alle drei oben gezeigten Definitionen werden wie folgt angezeigt:

>>>

>>> type(MLB_team)


>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Die Einträge im Wörterbuch werden in der Reihenfolge angezeigt, in der sie definiert wurden. Aber das ist irrelevant, wenn es darum geht, sie abzurufen. Auf Wörterbuchelemente wird nicht über einen numerischen Index zugegriffen:

>>>

>>> MLB_team[1]
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team[1]
KeyError: 1

Zugriff auf Wörterbuchwerte

Natürlich müssen Wörterbuchelemente irgendwie zugänglich sein. Wenn Sie sie nicht nach Index erhalten, wie erhalten Sie sie dann?

Ein Wert wird aus einem Wörterbuch abgerufen, indem der entsprechende Schlüssel in eckigen Klammern ([]) angegeben wird:

>>>

>>> MLB_team['Minnesota']
'Twins'
>>> MLB_team['Colorado']
'Rockies'

Wenn Sie auf einen Schlüssel verweisen, der nicht im Wörterbuch enthalten ist, löst Python eine Ausnahme aus:

>>>

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team['Toronto']
KeyError: 'Toronto'

Das Hinzufügen eines Eintrags zu einem vorhandenen Wörterbuch besteht lediglich darin, einen neuen Schlüssel und Wert zuzuweisen:

>>>

>>> MLB_team['Kansas City'] = 'Royals'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners', 'Kansas City': 'Royals'}

Wenn Sie einen Eintrag aktualisieren möchten, können Sie einem vorhandenen Schlüssel einfach einen neuen Wert zuweisen:

>>>

>>> MLB_team['Seattle'] = 'Seahawks'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Seahawks', 'Kansas City': 'Royals'}

Verwenden Sie zum Löschen eines Eintrags die Anweisungdel und geben Sie den zu löschenden Schlüssel an:

>>>

>>> del MLB_team['Seattle']
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Kansas City': 'Royals'}

Beginnen Sie, Seahawks! Du bist ein NFL-Team.

Wörterbuchschlüssel vs. Listenindizes

Möglicherweise haben Sie bemerkt, dass der Interpreter dieselbe AusnahmeKeyError auslöst, wenn auf ein Wörterbuch entweder mit einem undefinierten Schlüssel oder über einen numerischen Index zugegriffen wird:

>>>

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> MLB_team[1]
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team[1]
KeyError: 1

Tatsächlich ist es der gleiche Fehler. Im letzteren Fall sieht[1] wie ein numerischer Index aus, ist es aber nicht.

Sie werden später in diesem Tutorial sehen, dass ein Objekt eines unveränderlichen Typs als Wörterbuchschlüssel verwendet werden kann. Dementsprechend gibt es keinen Grund, warum Sie keine ganzen Zahlen verwenden können:

>>>

>>> d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

>>> d[0]
'a'
>>> d[2]
'c'

In den AusdrückenMLB_team[1],d[0] undd[2] erscheinen die Zahlen in eckigen Klammern so, als wären sie Indizes. Sie haben jedoch nichts mit der Reihenfolge der Elemente im Wörterbuch zu tun. Python interpretiert sie als Wörterbuchschlüssel. Wenn Sie dasselbe Wörterbuch in umgekehrter Reihenfolge definieren, erhalten Sie immer noch dieselben Werte mit denselben Schlüsseln:

>>>

>>> d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d
{3: 'd', 2: 'c', 1: 'b', 0: 'a'}

>>> d[0]
'a'
>>> d[2]
'c'

Die Syntax sieht möglicherweise ähnlich aus, aber Sie können ein Wörterbuch nicht wie eine Liste behandeln:

>>>

>>> type(d)


>>> d[-1]
Traceback (most recent call last):
  File "", line 1, in 
    d[-1]
KeyError: -1

>>> d[0:2]
Traceback (most recent call last):
  File "", line 1, in 
    d[0:2]
TypeError: unhashable type: 'slice'

>>> d.append('e')
Traceback (most recent call last):
  File "", line 1, in 
    d.append('e')
AttributeError: 'dict' object has no attribute 'append'

Note: Obwohl der Zugriff auf Elemente in einem Wörterbuch nicht von der Reihenfolge abhängt, garantiert Python, dass die Reihenfolge der Elemente in einem Wörterbuch beibehalten wird. Bei der Anzeige werden die Elemente in der Reihenfolge angezeigt, in der sie definiert wurden, und die Iteration durch die Schlüssel erfolgt ebenfalls in dieser Reihenfolge. Zu einem Wörterbuch hinzugefügte Elemente werden am Ende hinzugefügt. Wenn Artikel gelöscht werden, bleibt die Reihenfolge der verbleibenden Artikel erhalten.

Mit dieser Ordnungserhaltung können Sie erst in jüngster Zeit rechnen. Es waradded as a part of the Python language specification in version 3.7. Dies galt jedoch auch ab Version 3.6 - zufällig als Ergebnis der Implementierung, jedoch nicht durch die Sprachspezifikation garantiert.

Inkrementelles Erstellen eines Wörterbuchs

Das Definieren eines Wörterbuchs mit geschweiften Klammern und einer Liste von Schlüssel-Wert-Paaren, wie oben gezeigt, ist in Ordnung, wenn Sie alle Schlüssel und Werte im Voraus kennen. Aber was ist, wenn Sie ein Wörterbuch im laufenden Betrieb erstellen möchten?

Sie können beginnen, indem Sie ein leeres Wörterbuch erstellen, das durch leere geschweifte Klammern angegeben wird. Anschließend können Sie nacheinander neue Schlüssel und Werte hinzufügen:

>>>

>>> person = {}
>>> type(person)


>>> person['fname'] = 'Joe'
>>> person['lname'] = 'Fonebone'
>>> person['age'] = 51
>>> person['spouse'] = 'Edna'
>>> person['children'] = ['Ralph', 'Betty', 'Joey']
>>> person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}

Sobald das Wörterbuch auf diese Weise erstellt wurde, wird auf seine Werte wie auf jedes andere Wörterbuch zugegriffen:

>>>

>>> person
{'fname': 'Joe', 'lname': 'Fonebone', 'age': 51, 'spouse': 'Edna',
'children': ['Ralph', 'Betty', 'Joey'], 'pets': {'dog': 'Fido', 'cat': 'Sox'}}

>>> person['fname']
'Joe'
>>> person['age']
51
>>> person['children']
['Ralph', 'Betty', 'Joey']

Zum Abrufen der Werte in der Unterliste oder im Unterwörterbuch ist ein zusätzlicher Index oder Schlüssel erforderlich:

>>>

>>> person['children'][-1]
'Joey'
>>> person['pets']['cat']
'Sox'

Dieses Beispiel zeigt eine weitere Funktion von Wörterbüchern: Die im Wörterbuch enthaltenen Werte müssen nicht vom gleichen Typ sein. Inperson sind einige der Werte Zeichenfolgen, einer eine Ganzzahl, einer eine Liste und einer ein anderes Wörterbuch.

So wie die Werte in einem Wörterbuch nicht vom gleichen Typ sein müssen, müssen die Schlüssel auch nicht:

>>>

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

>>> foo[42]
'aaa'
>>> foo[2.78]
'bbb'
>>> foo[True]
'ccc'

Hier ist einer der Schlüssel eine Ganzzahl, einer ein Float und einer ein Boolescher Wert. Es ist nicht klar, wie dies nützlich wäre, aber Sie wissen es nie.

Beachten Sie, wie vielseitig Python-Wörterbücher sind. InMLB_team wird dieselbe Information (der Name des Baseballteams) für jeden von mehreren verschiedenen geografischen Standorten gespeichert. person speichert dagegen unterschiedliche Datentypen für eine einzelne Person.

Sie können Wörterbücher für eine Vielzahl von Zwecken verwenden, da die zulässigen Schlüssel und Werte so wenig eingeschränkt sind. Aber es gibt einige. Weiter lesen!

Einschränkungen für Wörterbuchschlüssel

Fast jeder Werttyp kann in Python als Wörterbuchschlüssel verwendet werden. Sie haben gerade dieses Beispiel gesehen, in dem Integer-, Float- und Boolesche Objekte als Schlüssel verwendet werden:

>>>

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

Sie können sogar integrierte Objekte wie Typen und Funktionen verwenden:

>>>

>>> d = {int: 1, float: 2, bool: 3}
>>> d
{: 1, : 2, : 3}
>>> d[float]
2

>>> d = {bin: 1, hex: 2, oct: 3}
>>> d[oct]
3

Es gibt jedoch einige Einschränkungen, die Wörterbuchschlüssel einhalten müssen.

Erstens kann ein bestimmter Schlüssel nur einmal in einem Wörterbuch erscheinen. Doppelte Schlüssel sind nicht zulässig. Ein Wörterbuch ordnet jeden Schlüssel einem entsprechenden Wert zu. Daher ist es nicht sinnvoll, einen bestimmten Schlüssel mehr als einmal zuzuordnen.

Sie haben oben gesehen, dass beim Zuweisen eines Werts zu einem bereits vorhandenen Wörterbuchschlüssel der Schlüssel nicht ein zweites Mal hinzugefügt wird, sondern der vorhandene Wert ersetzt wird:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> MLB_team['Minnesota'] = 'Timberwolves'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Timberwolves',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Wenn Sie bei der ersten Erstellung eines Wörterbuchs ein zweites Mal einen Schlüssel angeben, überschreibt das zweite Vorkommen das erste:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Timberwolves',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners',
...     'Minnesota': 'Twins'
... }
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Begone, Timberwolves! Du bist ein NBA-Team. Art von.

Zweitens muss ein Wörterbuchschlüssel von einem unveränderlichen Typ sein. Sie haben bereits Beispiele gesehen, in denen mehrere der Ihnen bekannten unveränderlichen Typen - Ganzzahl, Gleitkomma, Zeichenfolge und Boolescher Wert - als Wörterbuchschlüssel gedient haben.

Ein Tupel kann auch ein Wörterbuchschlüssel sein, da Tupel unveränderlich sind:

>>>

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

(Erinnern Sie sich an die Diskussion übertuples, dass ein Grund für die Verwendung eines Tupels anstelle einer Liste darin besteht, dass es Umstände gibt, unter denen ein unveränderlicher Typ erforderlich ist. Dies ist einer von ihnen.)

Weder eine Liste noch ein anderes Wörterbuch können jedoch als Wörterbuchschlüssel dienen, da Listen und Wörterbücher veränderbar sind:

>>>

>>> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
Traceback (most recent call last):
  File "", line 1, in 
    d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
TypeError: unhashable type: 'list'

Technical Note: Warum wird in der Fehlermeldung "nicht verwischbar" angezeigt?

Technisch gesehen ist es nicht ganz richtig zu sagen, dass ein Objekt unveränderlich sein muss, um als Wörterbuchschlüssel verwendet zu werden. Genauer gesagt muss ein Objekthashable sein, was bedeutet, dass es an eine Hash-Funktion übergeben werden kann. Eine Hash-Funktion nimmt Daten beliebiger Größe und ordnet sie einem relativ einfacheren Wert fester Größe zu, der alshash value (oder einfach als Hash) bezeichnet wird und für die Tabellensuche und den Vergleich verwendet wird.

Die in Python integriertehash()-Funktion gibt den Hashwert für ein Objekt zurück, das hashbar ist, und löst eine Ausnahme für ein Objekt aus, das nicht:

>>>

>>> hash('foo')
11132615637596761

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

Alle integrierten unveränderlichen Typen, die Sie bisher kennengelernt haben, sind hashbar und die veränderlichen Containertypen (Listen und Wörterbücher) nicht. Für die gegenwärtigen Zwecke können Sie sich Hash oder unveränderlich als mehr oder weniger synonym vorstellen.

In zukünftigen Tutorials werden Sie auf veränderbare Objekte stoßen, die auch hashbar sind.

Einschränkungen für Wörterbuchwerte

Im Gegensatz dazu gibt es keine Einschränkungen für Wörterbuchwerte. Buchstäblich gar keine. Ein Wörterbuchwert kann ein beliebiger Objekttyp sein, den Python unterstützt, einschließlich veränderbarer Typen wie Listen und Wörterbücher sowie benutzerdefinierter Objekte, die Sie in den kommenden Tutorials kennenlernen werden.

Es gibt auch keine Einschränkung für einen bestimmten Wert, der mehrmals in einem Wörterbuch erscheint:

>>>

>>> d = {0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d[0] == d[1] == d[2]
True

Operatoren und integrierte Funktionen

Sie haben bereits viele Operatoren und integrierte Funktionen kennengelernt, die mitstrings,lists undtuples verwendet werden können. Einige davon funktionieren auch mit Wörterbüchern.

Beispielsweise geben die Operatorenin undnot inTrue oderFalse zurück, je nachdem, ob der angegebene Operand als Schlüssel im Wörterbuch vorkommt:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> 'Milwaukee' in MLB_team
True
>>> 'Toronto' in MLB_team
False
>>> 'Toronto' not in MLB_team
True

Sie können den Operatorinzusammen mit der Kurzschlussauswertung verwenden, um Fehler beim Zugriff auf einen Schlüssel zu vermeiden, der nicht im Wörterbuch enthalten ist:

>>>

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "", line 1, in 
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> 'Toronto' in MLB_team and MLB_team['Toronto']
False

Im zweiten Fall wird aufgrund der Kurzschlussauswertung der AusdruckMLB_team['Toronto'] nicht ausgewertet, sodass die AusnahmeKeyError nicht auftritt.

Die Funktionlen() gibt die Anzahl der Schlüssel-Wert-Paare in einem Wörterbuch zurück:

>>>

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }
>>> len(MLB_team)
5

Integrierte Wörterbuchmethoden

Wie bei Zeichenfolgen und Listen gibt es mehrere integrierte Methoden, die für Wörterbücher aufgerufen werden können. In einigen Fällen haben die Listen- und Wörterbuchmethoden denselben Namen. (In der Diskussion zur objektorientierten Programmierung werden Sie sehen, dass es für verschiedene Typen durchaus akzeptabel ist, Methoden mit demselben Namen zu haben.)

Im Folgenden finden Sie eine Übersicht über Methoden, die für Wörterbücher gelten:

`d.clear()`

Löscht ein Wörterbuch.

d.clear() leert das Wörterbuchd aller Schlüssel-Wert-Paare:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

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

`d.get([, ])`

Gibt den Wert für einen Schlüssel zurück, falls dieser im Wörterbuch vorhanden ist.

Die Methode des Python-Wörterbuchs.get()bietet eine bequeme Möglichkeit, den Wert eines Schlüssels aus einem Wörterbuch abzurufen, ohne vorher zu prüfen, ob der Schlüssel vorhanden ist, und ohne einen Fehler auszulösen.

d.get(<key>) durchsucht das Wörterbuchd nach<key> und gibt den zugehörigen Wert zurück, wenn er gefunden wird. Wenn<key> nicht gefunden wird, wirdNone zurückgegeben:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> print(d.get('b'))
20
>>> print(d.get('z'))
None

Wenn<key> nicht gefunden wird und das optionale Argument<default> angegeben wird, wird dieser Wert anstelle vonNone zurückgegeben:

>>>

>>> print(d.get('z', -1))
-1

`d.items()`

Gibt eine Liste von Schlüssel-Wert-Paaren in einem Wörterbuch zurück.

d.items() gibt eine Liste von Tupeln zurück, die die Schlüssel-Wert-Paare ind enthalten. Das erste Element in jedem Tupel ist der Schlüssel, und das zweite Element ist der Wert des Schlüssels:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.items())
[('a', 10), ('b', 20), ('c', 30)]
>>> list(d.items())[1][0]
'b'
>>> list(d.items())[1][1]
20

`d.keys()`

Gibt eine Liste der Schlüssel in einem Wörterbuch zurück.

d.keys() gibt eine Liste aller Schlüssel ind zurück:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.keys())
['a', 'b', 'c']

`d.values()`

Gibt eine Liste von Werten in einem Wörterbuch zurück.

d.values() gibt eine Liste aller Werte ind zurück:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.values())
[10, 20, 30]

Doppelte Werte ind werden so oft zurückgegeben, wie sie auftreten:

>>>

>>> d = {'a': 10, 'b': 10, 'c': 10}
>>> d
{'a': 10, 'b': 10, 'c': 10}

>>> list(d.values())
[10, 10, 10]

Technical Note: Die Methoden.items(),.keys() und.values() geben tatsächlich etwas zurück, das alsview object bezeichnet wird. Ein Wörterbuchansichtsobjekt ähnelt mehr oder weniger einem Fenster mit Schlüsseln und Werten. Aus praktischen Gründen können Sie sich diese Methoden als Rückgabelisten der Schlüssel und Werte des Wörterbuchs vorstellen.

`d.pop([, ])`

Entfernt einen Schlüssel aus einem Wörterbuch, falls vorhanden, und gibt seinen Wert zurück.

Wenn<key> ind vorhanden ist, entferntd.pop(<key>)<key> und gibt den zugehörigen Wert zurück:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('b')
20
>>> d
{'a': 10, 'c': 30}

d.pop(<key>) löst eineKeyError-Ausnahme aus, wenn<key> nicht ind enthalten ist:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('z')
Traceback (most recent call last):
  File "", line 1, in 
    d.pop('z')
KeyError: 'z'

Wenn<key> nicht ind ist und das optionale Argument<default> angegeben ist, wird dieser Wert zurückgegeben und keine Ausnahme ausgelöst:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z', -1)
-1
>>> d
{'a': 10, 'b': 20, 'c': 30}

`d.popitem()`

Entfernt ein Schlüssel-Wert-Paar aus einem Wörterbuch.

d.popitem() entfernt ein zufälliges, beliebiges Schlüssel-Wert-Paar ausd und gibt es als Tupel zurück:

>>>

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.popitem()
('c', 30)
>>> d
{'a': 10, 'b': 20}

>>> d.popitem()
('b', 20)
>>> d
{'a': 10}

Wennd leer ist, löstd.popitem() eine Ausnahme vonKeyErroraus:

>>>

>>> d = {}
>>> d.popitem()
Traceback (most recent call last):
  File "", line 1, in 
    d.popitem()
KeyError: 'popitem(): dictionary is empty'

`d.update()`

Führt ein Wörterbuch mit einem anderen Wörterbuch oder mit einer Iteration von Schlüssel-Wert-Paaren zusammen.

Wenn<obj> ein Wörterbuch ist, führtd.update(<obj>) die Einträge von<obj> ind zusammen. Für jeden Schlüssel in<obj>:

Wenn der Schlüssel ind nicht vorhanden ist, wird das Schlüssel-Wert-Paar von<obj> zud addiert.
Wenn der Schlüssel bereits ind vorhanden ist, wird der entsprechende Wert ind für diesen Schlüssel auf den Wert von<obj> aktualisiert.

Hier ist ein Beispiel, das zwei zusammengeführte Wörterbücher zeigt:

>>>

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d2 = {'b': 200, 'd': 400}

>>> d1.update(d2)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

In diesem Beispiel ist der Schlüssel'b' bereits ind1 vorhanden, sodass sein Wert auf200 aktualisiert wird, den Wert für diesen Schlüssel ausd2. Es gibt jedoch keinen Schlüssel'd' ind1, so dass das Schlüssel-Wert-Paar ausd2 addiert wird.

<obj> kann auch eine Folge von Schlüssel-Wert-Paaren sein, ähnlich wie wenn die Funktiondict() zum Definieren eines Wörterbuchs verwendet wird. Beispielsweise kann<obj> als Liste von Tupeln angegeben werden:

>>>

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update([('b', 200), ('d', 400)])
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Oder die zusammenzuführenden Werte können als Liste von Schlüsselwortargumenten angegeben werden:

>>>

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update(b=200, d=400)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Fazit

In diesem Tutorial haben Sie die grundlegenden Eigenschaften von Pythondictionarybehandelt und gelernt, wie Sie auf Wörterbuchdaten zugreifen und diese bearbeiten.

Lists unddictionaries sind zwei der am häufigsten verwendeten Python-Typen. Wie Sie gesehen haben, haben sie mehrere Ähnlichkeiten, unterscheiden sich jedoch darin, wie auf ihre Elemente zugegriffen wird. Auf Listenelemente wird über einen numerischen Index basierend auf der Reihenfolge zugegriffen, und auf Wörterbuchelemente wird über einen Schlüssel zugegriffen

Aufgrund dieses Unterschieds sind Listen und Wörterbücher in der Regel für unterschiedliche Umstände geeignet. Sie sollten jetzt ein gutes Gefühl haben, für das, wenn beides, für eine bestimmte Situation am besten geeignet ist.

Als nächstes lernen Sie Pythonsets kennen. Der Satz ist ein anderer zusammengesetzter Datentyp, unterscheidet sich jedoch erheblich von einer Liste oder einem Wörterbuch.

Das Quiz machen "

TOC

Wörterbücher in Python