Python Language
Wörterbuch

Syntax

• mydict = {}
• meinDict [k] = Wert
• Wert = Mydict [k]
• value = meinedict.get (k)
• value = mydict.get (k, "default_value")

Parameter

Bemerkungen

Zugriff auf Werte eines Wörterbuchs

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

Der obige Code wird 1234 drucken.

Die Zeichenfolge "Hello" in diesem Beispiel als Schlüssel bezeichnet . Es wird verwendet, um einen Wert im dict indem der Schlüssel in eckige Klammern gesetzt wird.

Die Nummer 1234 steht hinter dem jeweiligen Doppelpunkt in der dict . Dies ist der Wert, genannt "Hello" Karten in diesem dict .

Wenn Sie einen KeyError Wert mit einem nicht vorhandenen Schlüssel KeyError , wird eine KeyError Ausnahme KeyError , die die Ausführung KeyError , wenn sie nicht KeyError . Wenn wir auf einen Wert zugreifen möchten, ohne einen KeyError zu riskieren, können wir die dictionary.get Methode verwenden. Wenn der Schlüssel nicht vorhanden ist, gibt die Methode standardmäßig None . Im Falle eines fehlgeschlagenen Suchvorgangs können Sie einen zweiten Wert übergeben, der anstelle von None .

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

In diesem Beispiel erhält w den Wert None und x den Wert "nuh-uh" .

Der dict () -Konstruktor

Der dict() kann zum Erstellen von Wörterbüchern aus Schlüsselwortargumenten oder aus einem einzigen iterierbaren Schlüsselpaar oder aus einem einzelnen Wörterbuch und Schlüsselwortargumenten verwendet werden.

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

Vermeiden von KeyError-Ausnahmen

Bei der Verwendung von Wörterbüchern besteht häufig die Gefahr, auf einen nicht vorhandenen Schlüssel zuzugreifen. Dies führt normalerweise zu einer KeyError Ausnahme

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

Eine Möglichkeit, Schlüsselfehler zu vermeiden, ist die Verwendung der Methode dict.get , mit der Sie einen Standardwert angeben können, der im Falle eines fehlenden Schlüssels zurückgegeben werden soll.

value = mydict.get(key, default_value)

mydict[key] falls vorhanden, ansonsten default_value . Beachten Sie, dass dies keinen key zu mydict hinzufügt. Also , wenn Sie diesen Schlüssel Wertpaar beibehalten möchten, sollten Sie mydict.setdefault(key, default_value) , die den Schlüssel Wertpaar speichert.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

Eine alternative Möglichkeit, mit dem Problem umzugehen, ist die Ausnahme

try:
    value = mydict[key]
except KeyError:
    value = default_value

Sie können auch überprüfen, ob der Schlüssel in Wörterbuch enthalten ist.

if key in mydict:
    value = mydict[key]
else:
    value = default_value

Beachten Sie jedoch, dass es in Umgebungen mit mehreren Threads möglich ist, dass der Schlüssel nach der Überprüfung aus dem Wörterbuch entfernt wird, wodurch eine Race-Bedingung erstellt wird, bei der die Ausnahme immer noch ausgelöst werden kann.

Eine andere Option ist die Verwendung einer Unterklasse von dict, Collections.defaultdict, die über eine default_factory verfügt, um neue Einträge im dict zu erstellen, wenn ein neuer_key gegeben wird.

Zugriff auf Schlüssel und Werte

Wenn Sie mit Wörterbüchern arbeiten, ist es häufig erforderlich, auf alle Schlüssel und Werte im Wörterbuch zuzugreifen, entweder in einer for Schleife, einem Listenverständnis oder einfach als einfache Liste.

Gegeben ein Wörterbuch wie:

mydict = {
    'a': '1',
    'b': '2'
}

Sie können eine Liste der Schlüssel mit der keys() -Methode erhalten:

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

Wenn Sie stattdessen eine Liste mit Werten wünschen, verwenden Sie die Methode values() :

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

Wenn Sie sowohl mit dem Schlüssel als auch mit dem entsprechenden Wert arbeiten möchten, können Sie die Methode items() verwenden:

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

HINWEIS: Da ein dict unsortiert ist, haben keys() , values() und items() keine Sortierreihenfolge. Verwenden Sie sort() , OrderedDict sorted() oder OrderedDict wenn Sie die Reihenfolge OrderedDict , die diese Methoden zurückgeben.

Python-2/3-Unterschied: In Python 3 geben diese Methoden spezielle iterierbare Objekte und keine Listen zurück. Sie entsprechen den Python-2- iterkeys() , itervalues() und iteritems() . Diese Objekte können größtenteils wie Listen verwendet werden, es gibt jedoch einige Unterschiede. Weitere Informationen finden Sie in PEP 3106 .

Einführung in das Wörterbuch

Ein Wörterbuch ist ein Beispiel für einen Schlüsselwertspeicher, der auch als Mapping in Python bezeichnet wird. Sie können Elemente speichern und abrufen, indem Sie auf einen Schlüssel verweisen. Da Wörterbücher über Schlüssel referenziert werden, können sie sehr schnell nachschlagen. Da sie hauptsächlich zur Referenzierung von Artikeln nach Schlüssel verwendet werden, werden sie nicht sortiert.

ein dikt erstellen

Wörterbücher können auf verschiedene Arten initiiert werden:

wörtliche Syntax

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

Diktierverständnis

d = {k:v for k,v in [('key', 'value',)]}

siehe auch: Verständnis

eingebaute Klasse: dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

ein dikt ändern

Um einem Wörterbuch Elemente hinzuzufügen, erstellen Sie einfach einen neuen Schlüssel mit einem Wert:

d['newkey'] = 42

Es ist auch möglich, list und dictionary als Wert hinzuzufügen:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

Um ein Element zu löschen, löschen Sie den Schlüssel aus dem Wörterbuch:

del d['newkey']

Wörterbuch mit Standardwerten

Verfügbar in der Standardbibliothek als defaultdict

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] Wenn Sie die integrierte dict Klasse using dict.setdefault() müssen, können Sie alternativ bei using dict.setdefault() einen Standardwert erstellen, wenn Sie auf einen Schlüssel zugreifen, der zuvor nicht vorhanden war:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

Wenn Sie viele Werte hinzufügen müssen, erstellt dict.setdefault() bei dict.setdefault() eine neue Instanz des Anfangswerts (in diesem Beispiel ein [] ). Dies kann zu unnötigen Workloads führen.

[*] Python Cookbook, 3. Auflage, von David Beazley und Brian K. Jones (O'Reilly). Copyright 2013 David Beazley und Brian Jones, 978-1-449-34037-7.

Ein geordnetes Wörterbuch erstellen

Sie können ein geordnetes Wörterbuch erstellen, das beim Iterieren über die Tasten im Wörterbuch einer festgelegten Reihenfolge folgt.

Verwenden Sie OrderedDict aus dem collections Modul. Dadurch werden die Wörterbuchelemente immer in der ursprünglichen Einfügereihenfolge zurückgegeben, wenn sie wiederholt werden.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

Wörterbücher mit dem Operator ** auspacken

Sie können den Operator zum Entschlüsseln des Schlüsselworts ** , um die Schlüssel-Wert-Paare in einem Wörterbuch in die Argumente einer Funktion zu übermitteln. Ein vereinfachtes Beispiel aus der offiziellen Dokumentation :

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Ab Python 3.5 können Sie diese Syntax auch verwenden, um eine beliebige Anzahl von dict Objekten zusammenzuführen.

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Wie dieses Beispiel zeigt, werden Schlüssel auf den letzten Wert kopiert (z. B. überschreibt "Clifford" "Nemo").

Wörterbücher zusammenführen

Betrachten Sie die folgenden Wörterbücher:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5+

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Wie dieses Beispiel zeigt, werden Schlüssel auf den letzten Wert kopiert (z. B. überschreibt "Clifford" "Nemo").

Python 3.3+

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

Bei dieser Technik hat der vorderste Wert für einen bestimmten Schlüssel Vorrang vor dem letzten ("Clifford" wird zugunsten von "Nemo" verworfen).

Python 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Dies verwendet den letzten Wert, wie bei der ** -basierten Technik zum Zusammenführen ("Clifford" überschreibt "Nemo").

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update verwendet das letzte Diktat, um das vorherige zu überschreiben.

Das nachfolgende Komma

Wie Listen und Tupel können Sie in Ihr Wörterbuch ein nachfolgendes Komma einfügen.

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8 schreibt vor, dass zwischen dem nachgestellten Komma und der schließenden Klammer ein Leerzeichen stehen soll.

Alle Kombinationen von Wörterbuchwerten

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

Angenommen, ein Wörterbuch wie das oben gezeigte, bei dem es eine Liste gibt, die einen Satz von Werten darstellt, um nach dem entsprechenden Schlüssel zu suchen. Angenommen, Sie möchten "x"="a" mit "y"=10 erkunden, dann "x"="a" mit "y"=10 usw., bis Sie alle möglichen Kombinationen untersucht haben.

Sie können eine Liste erstellen, die alle derartigen Wertekombinationen mithilfe des folgenden Codes zurückgibt.

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

Dies gibt uns die folgende Liste in den Variablen gespeichert combinations :

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

Iteration über ein Wörterbuch

Wenn Sie ein Wörterbuch als Iterator verwenden (z. B. in einer for Anweisung), werden die Schlüssel des Wörterbuchs durchsucht. Zum Beispiel:

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

Dasselbe gilt, wenn es in einem Verständnis verwendet wird

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

Wörterbuch erstellen

Regeln zum Erstellen eines Wörterbuchs:

• Jeder Schlüssel muss eindeutig sein (sonst wird er überschrieben)
• Jeder Schlüssel muss hashbar sein (kann mit der hash Funktion TypeError werden; andernfalls wird TypeError ausgelöst)
• Es gibt keine besondere Reihenfolge für die Schlüssel.

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

Wörterbücher Beispiel

Wörterbücher ordnen Schlüssel zu Werten zu.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

Auf die Wörterbuchwerte kann über ihre Schlüssel zugegriffen werden.

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

Wörterbücher können auch in einem JSON-Stil erstellt werden:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

Wörterbuchwerte können wiederholt werden:

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette