Словари Python

23 августа, 2020

Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python. Там выходят задачи, полезные советы и сливы платных курсов - перейти

Python предоставляет еще один составной тип данных, называемый словарем, который похож на список в том, что представляет собой набор объектов.

Вот что вы узнаете из этого руководства: вы узнаете об основных характеристиках словарей Python и то, как получить доступ к данным словаря и управлять ими. После того, как вы закончите это руководство, вы должны хорошо понимать, когда словарь является подходящим типом данных для использования и как это реализовать.

Словари и списки имеют следующие характеристики:

  • Оба непостоянны.
  • Оба динамичны. Они могут увеличиваться и уменьшаться по мере необходимости.
  • Оба могут быть вложенными. Список может содержать другой список. Словарь может содержать другой словарь. Словарь также может содержать список, и наоборот.

Словари отличаются от списков в первую очередь способом доступа к элементам:

  • Доступ к элементам списка осуществляется по их положению в списке посредством индексации.
  • Доступ к элементам словаря осуществляется с помощью ключей.

Определение словаря

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

Вы можете определить словарь, заключив список пар ключ-значение, разделенных запятыми, в фигурные скобки ({}). Двоеточие (:) отделяет каждый ключ от связанного с ним значения:

d = {
    <key>: <value>,
    <key>: <value>,
      .
      .
      .
    <key>: <value>
}

Следующее определяет словарь, который сопоставляет местоположение с названием соответствующей команды Высшей бейсбольной лиги:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }
Python dictionary (illustration)
Сопоставление местоположения словаря с командой MLB

Вы также можете создать словарь с помощью встроенной функции dict(). Аргумент dict() должен быть последовательностью пар ключ-значение. Для этого хорошо подходит список кортежей:

d = dict([
    (<key>, <value>),
    (<key>, <value),
      .
      .
      .
    (<key>, <value>)
])

MLB_team также можно определить следующим образом:

>>> MLB_team = dict([
...     ('Colorado', 'Rockies'),
...     ('Boston', 'Red Sox'),
...     ('Minnesota', 'Twins'),
...     ('Milwaukee', 'Brewers'),
...     ('Seattle', 'Mariners')
... ])

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

>>> MLB_team = dict(
...     Colorado='Rockies',
...     Boston='Red Sox',
...     Minnesota='Twins',
...     Milwaukee='Brewers',
...     Seattle='Mariners'
... )

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

>>> type(MLB_team)
<class 'dict'>

>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Записи в словаре отображаются в том порядке, в котором они были определены. Но когда дело доходит до их получения, это не имеет значения. Доступ к элементам словаря не осуществляется по числовому индексу:

>>> MLB_team[1]
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    MLB_team[1]
KeyError: 1

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

Конечно, элементы словаря должны быть как-то доступны. Если вы не получите их по индексу, то как их получить?

Значение извлекается из словаря путем указания соответствующего ключа в квадратных скобках ([]):

>>> MLB_team['Minnesota']
'Twins'
>>> MLB_team['Colorado']
'Rockies'

Если вы ссылаетесь на ключ, которого нет в словаре, Python вызывает исключение:

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    MLB_team['Toronto']
KeyError: 'Toronto'

Добавление записи в существующий словарь – это просто вопрос назначения нового ключа и значения:

>>> MLB_team['Kansas City'] = 'Royals'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners', 'Kansas City': 'Royals'}

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

>>> MLB_team['Seattle'] = 'Seahawks'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Seahawks', 'Kansas City': 'Royals'}

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

>>> del MLB_team['Seattle']
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Kansas City': 'Royals'}

Беги, Сихокс! Ты команда НФЛ.

Ключи словаря и индексы списка

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

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> MLB_team[1]
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    MLB_team[1]
KeyError: 1

По сути, это та же ошибка. В последнем случае [1] выглядит как числовой индекс, но это не так.

Позже в этом руководстве вы увидите, что объект любого неизменяемого типа может использоваться как ключ словаря. Соответственно, нет причин, по которым вы не можете использовать целые числа:

>>> d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

>>> d[0]
'a'
>>> d[2]
'c'

В выражениях MLB_team [1], d [0] и d [2] числа в квадратных скобках выглядят так, как если бы они могли быть индексами. Но они не имеют ничего общего с порядком пунктов в словаре. Python интерпретирует их как ключи словаря. Если вы определите этот же словарь в обратном порядке, вы все равно получите те же значения, используя те же ключи:

>>> d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d
{3: 'd', 2: 'c', 1: 'b', 0: 'a'}

>>> d[0]
'a'
>>> d[2]
'c'

Синтаксис может быть похожим, но словарь нельзя рассматривать как список:

>>> type(d)
<class 'dict'>

>>> d[-1]
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    d[-1]
KeyError: -1

>>> d[0:2]
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    d[0:2]
TypeError: unhashable type: 'slice'

>>> d.append('e')
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    d.append('e')
AttributeError: 'dict' object has no attribute 'append'

Примечание. Хотя доступ к элементам в словаре не зависит от порядка, Python гарантирует, что порядок элементов в словаре сохраняется. При отображении элементы будут отображаться в том порядке, в котором они были определены, и повторение ключей также будет происходить в этом порядке. Элементы, добавленные в словарь, добавляются в конце. Если элементы удаляются, порядок остальных элементов сохраняется.

На такое сохранение порядка можно рассчитывать лишь совсем недавно. Он был добавлен как часть спецификации языка Python в версии 3.7. Однако это было верно и для версии 3.6 – случайно, в результате реализации, но не гарантированной спецификацией языка.

Постепенное создание словаря

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

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

>>> person = {}
>>> type(person)
<class 'dict'>

>>> person['fname'] = 'Joe'
>>> person['lname'] = 'Fonebone'
>>> person['age'] = 51
>>> person['spouse'] = 'Edna'
>>> person['children'] = ['Ralph', 'Betty', 'Joey']
>>> person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}

После создания словаря таким образом доступ к его значениям осуществляется так же, как и к любому другому словарю:

>>> person
{'fname': 'Joe', 'lname': 'Fonebone', 'age': 51, 'spouse': 'Edna',
'children': ['Ralph', 'Betty', 'Joey'], 'pets': {'dog': 'Fido', 'cat': 'Sox'}}

>>> person['fname']
'Joe'
>>> person['age']
51
>>> person['children']
['Ralph', 'Betty', 'Joey']

Для получения значений в подсписке или подсловаре требуется дополнительный индекс или ключ:

>>> person['children'][-1]
'Joey'
>>> person['pets']['cat']
'Sox'

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

Точно так же, как значения в словаре не обязательно должны быть одного типа, ключи также не должны:

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

>>> foo[42]
'aaa'
>>> foo[2.78]
'bbb'
>>> foo[True]
'ccc'

Здесь один из ключей – целое число, один – число с плавающей запятой, а третий – логическое. Неизвестно, насколько это может быть полезно, но мало ли.

Обратите внимание, насколько универсальны словари Python. В MLB_team одна и та же информация (название бейсбольной команды) хранится для каждого из нескольких различных географических мест. person, с другой стороны, хранит различные типы данных для одного человека.

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

Ограничения для ключей словаря

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

>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

Вы даже можете использовать встроенные объекты, такие как типы и функции:

>>> d = {int: 1, float: 2, bool: 3}
>>> d
{<class 'int'>: 1, <class 'float'>: 2, <class 'bool'>: 3}
>>> d[float]
2

>>> d = {bin: 1, hex: 2, oct: 3}
>>> d[oct]
3

Однако есть пара ограничений, которым должны соответствовать словарные ключи.

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

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

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> MLB_team['Minnesota'] = 'Timberwolves'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Timberwolves',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Точно так же, если вы укажете ключ во второй раз во время первоначального создания словаря, второе вхождение заменит первое:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Timberwolves',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners',
...     'Minnesota': 'Twins'
... }
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Прочь, Timberwolves! Вы команда НБА. Вроде, как бы, что-то вроде того.

Во-вторых, ключ словаря должен иметь неизменяемый тип. Вы уже видели примеры, в которых несколько знакомых вам неизменяемых типов – integer, float, string и Boolean – служили ключами словаря.

Кортеж также может быть ключом словаря, потому что кортежи неизменяемы:

>>> d = {(1, 1): 'a', (1, 2): 'b', (2, 1): 'c', (2, 2): 'd'}
>>> d[(1,1)]
'a'
>>> d[(2,1)]
'c'

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

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

>>> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
TypeError: unhashable type: 'list'

Техническое примечание. Почему в сообщении об ошибке написано «unhashable»?

Технически не совсем правильно говорить, что объект должен быть неизменным, чтобы его можно было использовать в качестве словарного ключа. Точнее, объект должен быть хешируемым, что означает, что его можно передать хеш-функции. Хэш-функция принимает данные произвольного размера и сопоставляет их с относительно более простым значением фиксированного размера, называемым хеш-значением (или просто хешем), которое используется для поиска и сравнения в таблице.

Встроенная функция Python hash() возвращает хеш-значение для объекта, который можно хэшировать, и вызывает исключение для объекта, который не является:

>>> hash('foo')
11132615637596761

>>> hash([1, 2, 3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Все встроенные неизменяемые типы, о которых вы уже узнали, являются хешируемыми, а изменяемые типы контейнеров (списки и словари) – нет. Итак, для настоящих целей вы можете думать о хэшируемом и неизменяемом как о более или менее синонимах.

В будущих уроках вы встретите изменяемые объекты, которые также могут быть хешированы.


Ограничения на значения словаря

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

Также нет ограничений на то, чтобы определенное значение появлялось в словаре несколько раз:

>>> d = {0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d[0] == d[1] == d[2]
True

Операторы и встроенные функции

Вы уже познакомились со многими операторами и встроенными функциями, которые можно использовать со строками, списками и кортежами. Некоторые из них также работают со словарями.

Например, операторы in и not in возвращают True или False в зависимости от того, встречается ли указанный операнд как ключ в словаре:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }

>>> 'Milwaukee' in MLB_team
True
>>> 'Toronto' in MLB_team
False
>>> 'Toronto' not in MLB_team
True

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

>>> MLB_team['Toronto']
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    MLB_team['Toronto']
KeyError: 'Toronto'

>>> 'Toronto' in MLB_team and MLB_team['Toronto']
False

Во втором случае из-за оценки короткого замыкания выражение MLB_team['Toronto'] не оценивается, поэтому исключение KeyError не возникает.

Функция len() возвращает количество пар ключ-значение в словаре:

>>> MLB_team = {
...     'Colorado' : 'Rockies',
...     'Boston'   : 'Red Sox',
...     'Minnesota': 'Twins',
...     'Milwaukee': 'Brewers',
...     'Seattle'  : 'Mariners'
... }
>>> len(MLB_team)
5

Встроенные словарные методы

Как и в случае со строками и списками, есть несколько встроенных методов, которые можно вызывать в словарях. Фактически, в некоторых случаях методы списка и словаря имеют одно и то же имя. (При обсуждении объектно-ориентированного программирования вы увидите, что для разных типов вполне приемлемо иметь методы с одинаковыми именами.)

Ниже приводится обзор методов, применимых к словарям:

d.clear()

Очищает словарь.

d.clear() очищает словарь d от всех пар ключ-значение:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> d.clear()
>>> d
{}

d.get(<key>[, <default>])

Возвращает значение ключа, если он существует в словаре.

Метод Python dictionary .get() предоставляет удобный способ получения значения ключа из словаря без предварительной проверки существования ключа и без возникновения ошибки.

d.get(<key>) ищет в словаре d <key> и возвращает связанное значение, если оно найдено. Если <key> не найден, возвращается None:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> print(d.get('b'))
20
>>> print(d.get('z'))
None

Если <key> не найден и указан необязательный аргумент <default>, вместо None возвращается это значение:

>>> print(d.get('z', -1))
-1

d.items()

Возвращает список пар ключ-значение в словаре.

d.items() возвращает список кортежей, содержащих пары ключ-значение в d. Первый элемент в каждом кортеже – это ключ, а второй элемент – значение ключа:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.items())
[('a', 10), ('b', 20), ('c', 30)]
>>> list(d.items())[1][0]
'b'
>>> list(d.items())[1][1]
20

d.keys()

Возвращает список ключей в словаре.

d.keys() возвращает список всех ключей в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.keys())
['a', 'b', 'c']

d.values()

Возвращает список значений в словаре.

d.values() возвращает список всех значений в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.values())
[10, 20, 30]

Любые повторяющиеся значения в d будут возвращаться столько раз, сколько они встречаются:

>>> d = {'a': 10, 'b': 10, 'c': 10}
>>> d
{'a': 10, 'b': 10, 'c': 10}

>>> list(d.values())
[10, 10, 10]

Техническое примечание: методы .items(), .keys() и .values() на самом деле возвращают нечто, называемое объектом представления. Объект представления словаря более или менее похож на окно с ключами и значениями. Для практических целей эти методы можно рассматривать как возвращающие списки ключей и значений словаря.

d.pop(<key>[, <default>])

Удаляет ключ из словаря, если он присутствует, и возвращает его значение.

Если <key> присутствует в d, d.pop (<key>) удаляет <key> и возвращает связанное с ним значение:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('b')
20
>>> d
{'a': 10, 'c': 30}

d.pop(<key>) вызывает исключение KeyError, если <key> не находится в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('z')
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    d.pop('z')
KeyError: 'z'

Если <key> не находится в d, и указан необязательный аргумент <по умолчанию>, то возвращается это значение, и исключение не возникает:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z', -1)
-1
>>> d
{'a': 10, 'b': 20, 'c': 30}

d.popitem()

Удаляет пару ключ-значение из словаря

d.popitem() удаляет последнюю пару ключ-значение, добавленную из d, и возвращает ее как кортеж:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.popitem()
('c', 30)
>>> d
{'a': 10, 'b': 20}

>>> d.popitem()
('b', 20)
>>> d
{'a': 10}

Если в d пусто, d.popitem() вызывает исключение KeyError:

>>> d = {}
>>> d.popitem()
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    d.popitem()
KeyError: 'popitem(): dictionary is empty'

Примечание. В версиях Python менее 3.6 popitem () будет возвращать произвольную (случайную) пару ключ-значение, поскольку словари Python были неупорядоченными до версии 3.6.

d.update(<obj>)

Объединяет словарь с другим словарем или с итерацией пар ключ-значение.

Если <obj> – словарь, d.update(<obj>) объединяет записи из <obj> в d. Для каждого ключа в <obj>:

  • Если ключ отсутствует в d, пара ключ-значение из <obj> добавляется к d.
  • Если ключ уже присутствует в d, соответствующее значение в d для этого ключа обновляется до значения из <obj>.

Вот пример объединения двух словарей:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d2 = {'b': 200, 'd': 400}

>>> d1.update(d2)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

В этом примере ключ ‘b’ уже существует в d1, поэтому его значение обновляется до 200, значение для этого ключа из d2. Однако в d1 нет ключа ‘d’, поэтому эта пара “ключ-значение” добавляется из d2.

<obj> также может быть последовательностью пар ключ-значение, подобно тому, как функция dict() используется для определения словаря. Например, <obj> можно указать как список кортежей:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update([('b', 200), ('d', 400)])
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Или значения для объединения можно указать в виде списка аргументов ключевого слова:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update(b=200, d=400)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Вывод

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

Списки и словари – два наиболее часто используемых типа Python. Как вы видели, они имеют несколько общих черт, но отличаются способом доступа к их элементам. Доступ к элементам списков осуществляется по числовому индексу в зависимости от порядка, а к элементам словаря – по ключу

Из-за этой разницы списки и словари подходят для разных ситуаций. Теперь вы должны хорошо почувствовать, что лучше всего подходит для данной ситуации.


Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram