Python Language
Woordenboek

Syntaxis

• mydict = {}
• mydict [k] = waarde
• waarde = mydict [k]
• value = mydict.get (k)
• value = mydict.get (k, "default_value")

parameters

Opmerkingen

Toegang tot waarden van een woordenboek

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

Bovenstaande code zal 1234 afdrukken.

De tekenreeks "Hello" in dit voorbeeld een sleutel genoemd . Het wordt gebruikt om een waarde in het dict op te zoeken door de sleutel tussen vierkante haken te plaatsen.

Het nummer 1234 wordt gezien na de respectieve dubbele punt in de dict definitie. Dit is de waarde die de naam "Hello" kaarten in deze dict .

Het opzoeken van een waarde zoals deze met een sleutel die niet bestaat, zal een KeyError uitzondering KeyError , waardoor de uitvoering wordt gestopt als deze niet wordt opgevangen. Als we toegang willen krijgen tot een waarde zonder een KeyError te riskeren, kunnen we de methode dictionary.get gebruiken. Als de sleutel niet bestaat, retourneert de methode standaard None . We kunnen het een tweede waarde geven om terug te keren in plaats van None in het geval van een mislukte zoekopdracht.

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

In dit voorbeeld krijgt w de waarde None en krijgt x de waarde "nuh-uh" .

De dict () constructor

De constructor dict() kan worden gebruikt om woordenboeken te maken op basis van trefwoordargumenten, of van een enkele iterabele sleutel / waarde-paren, of van een enkel woordenboek en trefwoordargumenten.

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}

KeyError-uitzonderingen vermijden

Een veel voorkomende valkuil bij het gebruik van woordenboeken is toegang krijgen tot een niet-bestaande sleutel. Dit resulteert meestal in een KeyError uitzondering

mydict = {}
mydict['not there']

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

Een manier om sleutelfouten te voorkomen, is door de methode dict.get gebruiken, waarmee u een standaardwaarde kunt opgeven die moet worden geretourneerd in het geval van een ontbrekende sleutel.

value = mydict.get(key, default_value)

Die mydict[key] retourneert als deze bestaat, maar anders default_value retourneert. Merk op dat dit geen key toevoegt aan mydict . Dus als u dat sleutelwaardepaar wilt behouden, moet u mydict.setdefault(key, default_value) , waarmee het sleutelwaardepaar wel wordt opgeslagen.

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

Een alternatieve manier om het probleem aan te pakken, is de uitzondering opvangen

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

U kunt ook controleren of de sleutel in het woordenboek staat.

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

Houd er echter rekening mee dat in multi-threaded omgevingen de sleutel uit het woordenboek kan worden verwijderd nadat u hebt gecontroleerd, waardoor een raceconditie wordt gecreëerd waarin de uitzondering nog kan worden geworpen.

Een andere optie is het gebruik van een subklasse van dict, collections.defaultdict, met een default_factory om nieuwe items in het dict te maken wanneer een new_key wordt gegeven.

Toegang tot sleutels en waarden

Wanneer u met woordenboeken werkt, is het vaak nodig om toegang te krijgen tot alle sleutels en waarden in het woordenboek, hetzij in een for lus, een lijstbegrip, of gewoon als een gewone lijst.

Gegeven een woordenboek als:

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

U kunt een lijst met sleutels krijgen met de methode keys() :

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

Als u in plaats daarvan een zoeklijst wilt, gebruikt u de methode values() :

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

Als u met zowel de sleutel als de bijbehorende waarde wilt werken, kunt u de methode items() gebruiken:

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

OPMERKING: Omdat een dict ongesorteerd is, hebben keys() , values() en items() geen sorteervolgorde. Gebruik sort() , sorted() , of een OrderedDict als je de zorg over de volgorde dat deze methoden terug te keren.

Python 2/3 Verschil: in Python 3 retourneren deze methoden speciale iterabele objecten, geen lijsten, en zijn het equivalent van de iterkeys() Python 2 iterkeys() , itervalues() en iteritems() . Deze objecten kunnen grotendeels als lijsten worden gebruikt, hoewel er enkele verschillen zijn. Zie PEP 3106 voor meer details.

Inleiding tot woordenboek

Een woordenboek is een voorbeeld van een sleutelwaardeopslag ook bekend als Mapping in Python. Hiermee kunt u elementen opslaan en ophalen door naar een sleutel te verwijzen. Aangezien naar woordenboeken wordt verwezen met een sleutel, kunnen ze zeer snel worden opgezocht. Omdat ze voornamelijk worden gebruikt om naar items te verwijzen per sleutel, worden ze niet gesorteerd.

een dictaat maken

Woordenboeken kunnen op vele manieren worden gestart:

letterlijke syntaxis

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}

dict begrip

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

zie ook: Begrip

ingebouwde 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)         

een dict wijzigen

Om items aan een woordenboek toe te voegen, maakt u eenvoudig een nieuwe sleutel met een waarde:

d['newkey'] = 42

Het is ook mogelijk om list en dictionary als waarde toe te voegen:

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

Om een item te verwijderen, verwijdert u de sleutel uit het woordenboek:

del d['newkey']

Woordenboek met standaardwaarden

Beschikbaar in de standaardbibliotheek 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'

[*] Als alternatief, als u de ingebouwde dict klasse moet using dict.setdefault() , kunt u using dict.setdefault() een standaard maken wanneer u een sleutel using dict.setdefault() die nog niet bestond:

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

Houd er rekening mee dat als u veel waarden moet toevoegen, dict.setdefault() een nieuwe instantie van de initiële waarde (in dit voorbeeld een [] ) maakt wanneer deze wordt aangeroepen - wat onnodige werklasten kan veroorzaken.

[*] Python Cookbook, 3e editie, door David Beazley en Brian K. Jones (O'Reilly). Copyright 2013 David Beazley en Brian Jones, 978-1-449-34037-7.

Een geordend woordenboek maken

U kunt een geordend woordenboek maken dat een bepaalde volgorde volgt wanneer u de toetsen in het woordenboek herhaalt.

Gebruik OrderedDict uit de collections . Dit retourneert altijd de woordenboekelementen in de oorspronkelijke invoegvolgorde wanneer deze wordt herhaald.

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])

Uitpakken van woordenboeken met de ** operator

U kunt de ** uitpakkende operator ** trefwoordargument gebruiken om de sleutel / waarde-paren in een woordenboek om te zetten in de argumenten van een functie. Een vereenvoudigd voorbeeld uit de officiële documentatie :

>>>
>>> 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 !

Vanaf Python 3.5 kunt u deze syntaxis ook gebruiken om een willekeurig aantal dict objecten samen te voegen.

>>> 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'}

Zoals dit voorbeeld laat zien, worden dubbele sleutels toegewezen aan hun laatste waarde (bijvoorbeeld "Clifford" vervangt "Nemo").

Woordenboeken samenvoegen

Overweeg de volgende woordenboeken:

>>> 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'}

Zoals dit voorbeeld laat zien, worden dubbele sleutels toegewezen aan hun laatste waarde (bijvoorbeeld "Clifford" vervangt "Nemo").

Python 3.3+

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

Bij deze techniek heeft de belangrijkste waarde voorrang op een gegeven sleutel in plaats van de laatste ("Clifford" wordt weggegooid ten gunste van "Nemo").

Python 2.x, 3.x

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

Dit gebruikt de laatste waarde, zoals bij de ** -gebaseerde techniek voor samenvoegen ("Clifford" vervangt "Nemo").

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

dict.update gebruikt het laatste dict om het vorige te overschrijven.

De volgkomma

Net als lijsten en tupels, kunt u een volgkomma in uw woordenboek opnemen.

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

PEP 8 dicteert dat je een spatie moet laten tussen de volgende komma en de sluitende haak.

Alle combinaties van woordenboekwaarden

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

Gegeven een woordenboek zoals hierboven weergegeven, waar er een lijst is die een reeks waarden voor de bijbehorende sleutel vertegenwoordigt. Stel dat u "x"="a" wilt verkennen met "y"=10 , dan "x"="a" met "y"=10 , enzovoort totdat u alle mogelijke combinaties hebt onderzocht.

U kunt een lijst maken die al dergelijke combinaties van waarden retourneert met behulp van de volgende code.

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

Dit geeft ons de volgende lijst die is opgeslagen in de variabele 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}]

Een woordenboek herhalen

Als u een woordenboek als iterator gebruikt (bijvoorbeeld in een for instructie), doorloopt het de sleutels van het woordenboek. Bijvoorbeeld:

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

Hetzelfde is waar wanneer gebruikt in een begrip

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

Een woordenboek maken

Regels voor het maken van een woordenboek:

• Elke sleutel moet uniek zijn (anders wordt deze overschreven)
• Elke sleutel moet hashable zijn (kan de hash om deze te TypeError ; anders wordt TypeError gegenereerd)
• Er is geen specifieke volgorde voor de sleutels.

# 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}

Woordenboeken Voorbeeld

Woordenboeken wijzen sleutels toe aan waarden.

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

Woordenboekwaarden zijn toegankelijk met hun toetsen.

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

Woordenboeken kunnen ook in een JSON-stijl worden gemaakt:

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

Woordenboekwaarden kunnen worden herhaald:

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

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