Python Language
Słownik

Składnia

• mydict = {}
• mydict [k] = wartość
• wartość = mydict [k]
• wartość = mydict.get (k)
• wartość = mydict.get (k, „default_value”)

Parametry

Uwagi

Dostęp do wartości słownika

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

Powyższy kod wydrukuje 1234 .

Ciąg "Hello" w tym przykładzie nazywa się kluczem . Służy do wyszukiwania wartości w dict poprzez umieszczenie klucza w nawiasach kwadratowych.

Liczba 1234 jest widoczna po odpowiednim dwukropku w definicji dict . Jest to tak zwana wartość odwzorowana przez "Hello" w tym dict .

Wyszukanie takiej wartości z kluczem, który nie istnieje, wywoła wyjątek KeyError , zatrzymując wykonanie, jeśli nie zostanie przechwycony. Jeśli chcemy uzyskać dostęp do wartości bez ryzyka KeyError , możemy użyć metody dictionary.get . Domyślnie, jeśli klucz nie istnieje, metoda zwróci None . Możemy przekazać mu drugą wartość do zwrócenia zamiast None w przypadku nieudanego wyszukiwania.

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

W tym przykładzie w otrzyma wartość None a x otrzyma wartość "nuh-uh" .

Konstruktor dict ()

Konstruktor dict() może być używany do tworzenia słowników z argumentów słów kluczowych lub z pojedynczej iterowalnej pary klucz-wartość lub z pojedynczego słownika i argumentów słów kluczowych.

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}

Unikanie wyjątków KeyError

Częstą pułapką przy korzystaniu ze słowników jest dostęp do nieistniejącego klucza. Zwykle powoduje to wyjątek KeyError

mydict = {}
mydict['not there']

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

Jednym ze sposobów uniknięcia błędów klucza jest użycie metody dict.get , która pozwala określić domyślną wartość zwracaną w przypadku braku klucza.

value = mydict.get(key, default_value)

Który zwraca mydict[key] jeśli istnieje, ale w przeciwnym razie zwraca wartość default_value . Zauważ, że to nie dodaje key do mydict . Więc jeśli chcesz zachować tę parę klucz wartość, należy użyć mydict.setdefault(key, default_value) , który ma przechowywać parę kluczową wartością.

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

Alternatywnym sposobem rozwiązania problemu jest wyłapanie wyjątku

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

Możesz także sprawdzić, czy klucz znajduje się in słowniku.

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

Należy jednak pamiętać, że w środowiskach wielowątkowych klucz można usunąć ze słownika po sprawdzeniu, tworząc warunek wyścigu, w którym wyjątek może być nadal zgłaszany.

Inną opcją jest użycie podklasy dict, collections.defaultdict, która ma default_factory do tworzenia nowych wpisów w dict po otrzymaniu new_key.

Dostęp do kluczy i wartości

Podczas pracy ze słownikami często konieczne jest uzyskanie dostępu do wszystkich kluczy i wartości w słowniku, w pętli for , ze zrozumieniem listy lub po prostu jako zwykła lista.

Biorąc pod uwagę słownik taki jak:

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

Możesz uzyskać listę kluczy za pomocą metody keys() :

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

Jeśli zamiast tego chcesz uzyskać listę wartości, użyj metody values() :

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

Jeśli chcesz pracować zarówno z kluczem, jak i odpowiadającą mu wartością, możesz użyć metody items() :

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

UWAGA: Ponieważ dict jest nieposortowane, keys() , values() i items() nie mają kolejności sortowania. Użyj sort() , sorted() lub OrderedDict jeśli zależy ci na kolejności zwracania tych metod.

Różnica w Pythonie 2/3: W Pythonie 3 metody te zwracają specjalne iterowalne obiekty, nie listy, i są odpowiednikiem metod iterkeys() , itervalues() i iteritems() w Pythonie 2. Obiekty te mogą być używane w większości jak listy, choć istnieją pewne różnice. Aby uzyskać więcej informacji, zobacz PEP 3106 .

Wprowadzenie do słownika

Słownik jest przykładem magazynu wartości klucza znanego również jako Mapowanie w Pythonie. Pozwala na przechowywanie i wyszukiwanie elementów poprzez odniesienie do klucza. Ponieważ słowniki są przywoływane za pomocą klucza, mają one bardzo szybkie wyszukiwanie. Ponieważ są one głównie używane do odwoływania się do elementów według klucza, nie są sortowane.

tworzenie dykt

Słowniki można inicjować na wiele sposobów:

dosłowna składnia

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}

rozumieć dyktando

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

patrz także: Rozumienie

klasa wbudowana: 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)         

modyfikacja dyktanda

Aby dodać elementy do słownika, po prostu utwórz nowy klucz o wartości:

d['newkey'] = 42

Możliwe jest również dodanie list i dictionary jako wartości:

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

Aby usunąć element, usuń klucz ze słownika:

del d['newkey']

Słownik z wartościami domyślnymi

Dostępne w standardowej bibliotece jako 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'

[*] Alternatywnie, jeśli musisz użyć wbudowanej klasy dict , using dict.setdefault() pozwoli ci stworzyć wartość domyślną za każdym razem, gdy uzyskasz dostęp do klucza, który wcześniej nie istniał:

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

Należy pamiętać, że jeśli masz wiele wartości do dodania, dict.setdefault() utworzy nowe wystąpienie wartości początkowej (w tym przykładzie a [] każdym razem, gdy zostanie wywołane - co może powodować niepotrzebne obciążenia.

[*] Python Cookbook, wydanie trzecie, David Beazley i Brian K. Jones (O'Reilly). Prawa autorskie 2013 David Beazley i Brian Jones, 978-1-449-34037-7.

Tworzenie uporządkowanego słownika

Możesz utworzyć uporządkowany słownik, który będzie postępował zgodnie z ustaloną kolejnością podczas iteracji po klawiszach w słowniku.

Użyj polecenia OrderedDict z modułu collections . To zawsze zwróci elementy słownika w oryginalnej kolejności wstawiania po iteracji.

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

Rozpakowywanie słowników za pomocą operatora **

Możesz użyć operatora ** rozpakowywania argumentów słowa kluczowego, aby dostarczyć pary klucz-wartość ze słownika do argumentów funkcji. Uproszczony przykład z oficjalnej dokumentacji :

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

Począwszy od języka Python 3.5, możesz także użyć tej składni do scalenia dowolnej liczby obiektów dict .

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

Jak pokazuje ten przykład, zduplikowane klucze są mapowane do ich ostatniej wartości (na przykład „Clifford” zastępuje „Nemo”).

Scalanie słowników

Rozważ następujące słowniki:

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

Jak pokazuje ten przykład, zduplikowane klucze są mapowane do ich ostatniej wartości (na przykład „Clifford” zastępuje „Nemo”).

Python 3.3+

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

Dzięki tej technice najważniejsza wartość ma pierwszeństwo dla danego klucza zamiast ostatniego („Clifford” jest wyrzucany na korzyść „Nemo”).

Python 2.x, 3.x

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

Wykorzystuje ostatnią wartość, jak w przypadku techniki scalania opartej na ** („Clifford” zastępuje „Nemo”).

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

dict.update używa tego ostatniego do zastąpienia poprzedniego.

Końcowy przecinek

Podobnie jak listy i krotki, w słowniku można wstawić przecinek końcowy.

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

PEP 8 nakazuje pozostawienie odstępu między przecinkiem końcowym a nawiasem zamykającym.

Wszystkie kombinacje wartości słownikowych

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

Biorąc pod uwagę słownik, taki jak ten pokazany powyżej, w którym znajduje się lista reprezentująca zestaw wartości do zbadania dla odpowiedniego klucza. Załóżmy, że chcesz eksplorować "x"="a" pomocą "y"=10 , a następnie "x"="a" z "y"=10 i tak dalej, aż odkryjesz wszystkie możliwe kombinacje.

Możesz utworzyć listę, która zwraca wszystkie takie kombinacje wartości przy użyciu następującego kodu.

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

To daje nam następującą listę przechowywaną w combinations zmiennych:

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

Iteracja po słowniku

Jeśli użyjesz słownika jako iteratora (np. W instrukcji for ), przejdzie on przez klawisze słownika. Na przykład:

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

To samo jest prawdą, gdy jest używane w rozumieniu

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

Tworzenie słownika

Zasady tworzenia słownika:

• Każdy klucz musi być unikalny (w przeciwnym razie zostanie zastąpiony)
• Każdy klucz musi być hashable (można użyć hash funkcji hash to, inaczej TypeError zostanie wyrzucony)
• Nie ma określonej kolejności kluczy.

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

Słowniki Przykład

Słowniki odwzorowują klucze na wartości.

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

Do wartości słownika można uzyskać dostęp po ich kluczach.

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

Słowniki można również tworzyć w stylu JSON:

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

Wartości słownika można iterować:

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

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