Python Language
толковый словарь

Синтаксис

• mydict = {}
• mydict [k] = значение
• value = mydict [k]
• value = mydict.get (k)
• value = mydict.get (k, "default_value")

параметры

замечания

Доступ к значениям словаря

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

Вышеприведенный код напечатает 1234 .

Строка "Hello" в этом примере называется ключом . Он используется для поиска значения в dict , помещая ключ в квадратные скобки.

Число 1234 видно после соответствующего двоеточия в определении dict . Это называется значением, которое "Hello" отображает в этом dict .

Поиск такого значения с помощью ключа, который не существует, приведет к KeyError исключения KeyError , прекратив выполнение, если он не сфотографирован. Если мы хотим получить доступ к значению без риска использования KeyError , мы можем использовать метод dictionary.get . По умолчанию, если ключ не существует, метод возвращает None . Мы можем передать ему второе значение для возврата вместо None в случае неудачного поиска.

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

В этом примере w получит значение None а x получит значение "nuh-uh" .

Конструктор dict ()

Конструктор dict() может использоваться для создания словарей из аргументов ключевого слова или из одного итерабельного из пар ключ-значение или из одного словаря и аргументов ключевого слова.

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

Одной из распространенных ошибок при использовании словарей является доступ к несуществующему ключу. Обычно это KeyError исключению KeyError

mydict = {}
mydict['not there']

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

Один из способов избежать ключевых ошибок - использовать метод dict.get , который позволяет указать значение по умолчанию для возврата в случае отсутствующего ключа.

value = mydict.get(key, default_value)

Что возвращает mydict[key] если он существует, но в противном случае возвращает значение default_value . Обратите внимание, что это не добавляет key к mydict . Так что если вы хотите сохранить эту ключевую пару значений, вы должны использовать mydict.setdefault(key, default_value) , который не хранить пару ключей значения.

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

Альтернативный способ решения этой проблемы - уловка исключения

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

Вы также можете проверить, находится ли ключ in словаре.

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

Однако обратите внимание, что в многопоточных средах ключ может быть удален из словаря после проверки, создавая условие гонки, в котором все еще может быть выбрано исключение.

Другой вариант - использовать подкласс dict, collection.defaultdict, который имеет свойство default_factory для создания новых записей в dict при задании new_key.

Доступ к ключам и значениям

При работе со словарями часто необходимо получить доступ ко всем ключам и значениям в словаре, либо в цикле for , либо в понимании списка, либо просто в виде простого списка.

Учитывая словарь, например:

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

Вы можете получить список ключей с помощью метода keys() :

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

Если вместо этого вы хотите получить список значений, используйте метод values() :

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

Если вы хотите работать как с ключом, так и с его соответствующим значением, вы можете использовать метод items() :

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

ПРИМЕЧАНИЕ. Поскольку dict unsorted, keys() , values() и items() имеют порядка сортировки. Используйте sort() , OrderedDict sorted() или OrderedDict если вам OrderedDict порядок, возвращаемый этими методами.

Python 2/3 Difference: в Python 3 эти методы возвращают специальные итеративные объекты, а не списки, и эквивалент методов Python 2 iterkeys() , itervalues() и iteritems() . Эти объекты могут использоваться как списки по большей части, хотя есть некоторые отличия. Подробнее см. PEP 3106 .

Введение в словарь

Словарь - это пример хранилища значений ключей, также известный как Mapping в Python. Он позволяет хранить и извлекать элементы, ссылаясь на ключ. Поскольку словари ссылаются на ключ, у них очень быстрый поиск. Поскольку они в основном используются для ссылки на элементы по ключу, они не сортируются.

создание диктата

Словари могут быть инициированы по-разному:

литеральный синтаксис

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}

понимание диктата

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

Смотри также: Понимание

встроенный класс: 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)         

изменение диктата

Чтобы добавить элементы в словарь, просто создайте новый ключ со значением:

d['newkey'] = 42

Также можно добавить list и dictionary качестве значения:

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

Чтобы удалить элемент, удалите ключ из словаря:

del d['newkey']

Словарь со значениями по умолчанию

Доступно в стандартной библиотеке как 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'

[*] В качестве альтернативы, если вы должны использовать встроенный класс dict , using dict.setdefault() позволит вам создавать по умолчанию всякий раз, когда вы получаете доступ к ключу, который раньше не существовал:

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

Имейте в виду, что если у вас есть много значений для добавления, dict.setdefault() создаст новый экземпляр начального значения (в этом примере a [] ) при каждом его вызове - что может создать ненужные рабочие нагрузки.

[*] Python Cookbook, 3-е издание, Дэвид Бэйсли и Брайан К. Джонс (O'Reilly). Copyright 2013 Дэвид Бэйсли и Брайан Джонс, 978-1-449-34037-7.

Создание упорядоченного словаря

Вы можете создать упорядоченный словарь, который будет следовать определенному порядку при итерации по клавишам в словаре.

Используйте OrderedDict из модуля collections . Это всегда будет возвращать элементы словаря в исходном порядке вставки при повторении.

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

Распаковка словарей с использованием оператора **

Вы можете использовать оператор распараллеливания аргументов аргументов ** для доставки пар ключ-значение в словаре в аргументы функции. Упрощенный пример из официальной документации :

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

С Python 3.5 вы также можете использовать этот синтаксис для слияния произвольного количества объектов 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'}

Как показывает этот пример, дубликаты ключей сопоставляются с их последним значением (например, «Клиффорд» переопределяет «Немо»).

Слияние словарей

Рассмотрим следующие словари:

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

Как показывает этот пример, дубликаты ключей сопоставляются с их последним значением (например, «Клиффорд» переопределяет «Немо»).

Python 3.3+

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

При таком методе главное значение имеет приоритет для данного ключа, а не последнего («Клиффорд» выбрасывается в пользу «Немо»).

Python 2.x, 3.x

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

Это использует последнее значение, как с использованием метода ** для объединения («Клиффорд» переопределяет «Немо»).

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

dict.update использует последний dict для перезаписывания предыдущего.

Задняя запятая

Подобно спискам и кортежам, вы можете включить запятую в ваш словарь.

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

PEP 8 диктует, что вы должны оставить пробел между конечной запятой и закрывающей скобкой.

Все комбинации значений словаря

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

Для словаря, такого как показанный выше, где есть список, представляющий набор значений для изучения соответствующего ключа. Предположим, вы хотите изучить "x"="a" с "y"=10 , затем "x"="a" с "y"=10 и т. Д., Пока вы не изучите все возможные комбинации.

Вы можете создать список, который возвращает все такие комбинации значений, используя следующий код.

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

Это дает нам следующий список, хранящийся в 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}]

Итерация по словарю

Если вы используете словарь как итератор (например, в инструкции for ), он перемещает ключи словаря. Например:

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

То же самое верно при использовании в понимании

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

Создание словаря

Правила создания словаря:

• Каждый ключ должен быть уникальным (иначе он будет отменен)
• Каждый ключ должен быть хешируемым (может использовать hash функцию для хеширования, иначе TypeError будет выброшен)
• Для ключей нет особого порядка.

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

Примеры словарей

Словари сопоставляют ключи со значениями.

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

Значения словаря могут быть доступны по их ключам.

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

Словари также могут быть созданы в стиле JSON:

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

Значения словаря можно повторить:

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

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