Python Language
Ordbok

Syntax

• mydict = {}
• mydict [k] = värde
• värde = mydik [k]
• värde = mydict.get (k)
• value = mydict.get (k, "default_value")

parametrar

Anmärkningar

Få åtkomst till värden i en ordlista

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

Ovanstående kod kommer att skriva ut 1234 .

Strängen "Hello" i det här exemplet kallas en nyckel . Det används för att slå upp ett värde i dict genom att placera nyckeln i fyrkantiga parenteser.

Siffran 1234 ses efter respektive kolon i dict . Detta kallas värdet som "Hello" kartlägger i denna dict .

Att leta upp ett värde som detta med en nyckel som inte finns kommer att höja ett undantag från KeyError och stoppa exekveringen om den inte fångas. Om vi vill komma åt ett värde utan att riskera en KeyError kan vi använda metoden dictionary.get . Om nyckeln inte finns som standard kommer metoden att returnera None . Vi kan ge det ett andra värde att returnera istället för None i händelse av en misslyckad sökning.

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

I det här exemplet kommer w att få värdet None och x får värdet "nuh-uh" .

Den konstruktören ()

dict() kan användas för att skapa ordböcker från nyckelordargument, eller från en enda iterabel av nyckelvärdespar, eller från en enda ordbok och nyckelordargument.

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}

Undvika undantag från KeyError

En vanlig fallgrop när man använder ordböcker är att komma åt en icke-existerande nyckel. Detta resulterar vanligtvis i ett KeyError undantag

mydict = {}
mydict['not there']

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

Ett sätt att undvika nyckelfel är att använda metoden dict.get , som låter dig ange ett standardvärde som ska returneras vid en frånvarande nyckel.

value = mydict.get(key, default_value)

Vilket returnerar mydict[key] om det finns, men annars returnerar default_value . Observera att detta inte lägger till key till mydict . Så om du vill behålla det nyckelvärde paret bör du använda mydict.setdefault(key, default_value) , som lagrar nyckelvärdeparet.

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

Ett alternativt sätt att hantera problemet är att få undantaget

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

Du kan också kontrollera om nyckeln finns in ordboken.

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

Observera dock att det i flera gängade miljöer är möjligt för nyckeln att tas bort från ordboken efter att du har kontrollerat, vilket skapar ett rasvillkor där undantaget fortfarande kan kastas.

Ett annat alternativ är att använda en underklass av dict, samlingar.defaultdict, som har en standardfabrik för att skapa nya poster i dikten när en ny_nyckel ges.

Få åtkomst till nycklar och värden

När du arbetar med ordböcker är det ofta nödvändigt att komma åt alla nycklar och värden i ordboken, antingen i en for loop, en listaförståelse eller bara som en vanlig lista.

Får en ordbok som:

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

Du kan få en lista med nycklar med metoden keys() :

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

Om du istället vill ha en lista med värden använder du metoden values() :

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

Om du vill arbeta med både nyckeln och dess motsvarande värde kan du använda metoden items() :

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

OBS: Eftersom en dict är osorterad har keys() , values() och items() ingen sorteringsordning. Använd sort() , sorted() eller ett OrderedDict om du bryr dig om den ordning som dessa metoder returnerar.

Skillnad mellan Python 2/3: I Python 3 returnerar dessa metoder speciella iterbara objekt, inte listor, och är ekvivalenta med Python 2- iterkeys() , itervalues() och iteritems() -metoder. Dessa objekt kan användas som listor för det mesta, men det finns vissa skillnader. Se PEP 3106 för mer information.

Introduktion till ordbok

En ordlista är ett exempel på en nyckelvärdeslager, även känd som Mapping in Python. Det låter dig lagra och hämta element genom att hänvisa till en nyckel. Eftersom ordböcker refereras med nyckel har de mycket snabba uppslag. Eftersom de främst används för att referera objekt efter nyckel, sorteras de inte.

att skapa en dikt

Ordböcker kan initieras på många sätt:

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

dikt förståelse

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

se även: Förståelser

inbyggd klass: 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)         

modifiera en dikter

För att lägga till objekt i en ordlista, skapa helt enkelt en ny nyckel med ett värde:

d['newkey'] = 42

Det är också möjligt att lägga till list och dictionary som värde:

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

Om du vill ta bort ett objekt tar du bort nyckeln från ordboken:

del d['newkey']

Ordbok med standardvärden

Finns i standardbiblioteket som 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'

[*] Alternativt, om du måste använda den inbyggda dict , kan du using dict.setdefault() att skapa ett standard när du öppnar en nyckel som inte fanns tidigare:

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

Tänk på att om du har många värden att lägga till kommer dict.setdefault() att skapa en ny instans av det ursprungliga värdet (i det här exemplet en [] ) varje gång det heter - vilket kan skapa onödiga arbetsbelastningar.

[*] Python Cookbook, 3: e upplagan, av David Beazley och Brian K. Jones (O'Reilly). Copyright 2013 David Beazley och Brian Jones, 978-1-449-34037-7.

Skapa en ordnad ordbok

Du kan skapa en ordnad ordbok som kommer att följa en bestämd ordning när du itererar över tangenterna i ordboken.

Använd OrderedDict från collections modulen. Detta kommer alltid att returnera ordbokselementen i den ursprungliga infogningsordningen när den itereras över.

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

Packa upp ordböcker med ** -operatören

Du kan använda operatören för att packa upp nyckelordet ** att leverera nyckelvärdespar i en ordlista i en funktions argument. Ett förenklat exempel från den officiella dokumentationen :

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

Från Python 3.5 kan du också använda den här syntaxen för att slå samman ett godtyckligt antal dict objekt.

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

Som det här exemplet visar kartlägger dubbla nycklar till deras senast värde (till exempel åsidosätter "Clifford" "Nemo").

Sammanfogande ordböcker

Tänk på följande ordböcker:

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

Som det här exemplet visar kartlägger dubbla nycklar till deras senast värde (till exempel åsidosätter "Clifford" "Nemo").

Python 3.3+

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

Med denna teknik har det främsta värdet företräde för en given nyckel snarare än den sista ("Clifford" kastas ut till förmån för "Nemo").

Python 2.x, 3.x

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

Detta använder det sistnämnda värdet, som med den ** -baserade tekniken för sammanslagning ("Clifford" åsidosätter "Nemo").

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

dict.update använder den senare dikten för att skriva över den föregående.

Den efterföljande komma

Som listor och tupplar kan du inkludera ett släp komma i din ordlista.

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

PEP 8 dikterar att du ska lämna ett mellanrum mellan efterföljande komma och stängningsstöd.

Alla kombinationer av ordboksvärden

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

Givet en ordbok som den som visas ovan, där det finns en lista som representerar en uppsättning värden för att utforska för motsvarande nyckel. Anta att du vill utforska "x"="a" med "y"=10 , sedan "x"="a" med "y"=10 , och så vidare tills du har undersökt alla möjliga kombinationer.

Du kan skapa en lista som returnerar alla sådana värdekombinationer med följande kod.

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

Detta ger oss en lista nedan lagras i variabeln 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}]

Iterating Over a Dictionary

Om du använder en ordlista som en iterator (t.ex. i en for uttalande), går den igenom ordlistans nycklar . Till exempel:

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

Detsamma gäller när det används i en förståelse

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

Skapa en ordlista

Regler för att skapa en ordlista:

• Varje nyckel måste vara unik (annars kommer den att åsidosättas)
• Varje tangent måste vara hashbar (kan använda hash funktionen för att hash den; annars TypeError )
• Det finns ingen särskild ordning för nycklarna.

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

Exempel på ordböcker

Ordböcker kartlägger nycklar till värden.

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

Ordlista värden kan nås med deras nycklar.

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

Ordböcker kan också skapas i en JSON-stil:

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

Ordboksvärden kan itereras över:

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

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