Словари в Python: создание и работа с ключами

Обновлено:

Класс:

dict

представляет словарь — коллекцию пар:

ключ → значение

Например:

user = {
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

Здесь находятся три пары:

'name' → 'Alex'
'age'  → 30
'city' → 'Tbilisi'

1. Основные свойства dict

Словарь является:

  • изменяемым объектом;
  • итерируемым объектом;
  • упорядоченной коллекцией;
  • mapping type — отображением ключей на значения.

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

values[0]

а по ключам:

user['name']

2. Порядок элементов

Современный dict сохраняет порядок вставки элементов.

Например:

user = {
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

print(user)

Пары сохраняются в том порядке, в котором были добавлены.

Гарантией языка Python это стало начиная с:

Python 3.7

В CPython 3.6 такое поведение уже существовало как особенность реализации, но начиная с Python 3.7 сохранение порядка является частью спецификации языка.


3. dict основан на хеш-таблице

В предыдущей теме мы познакомились с:

hash()

Это непосредственно связано со словарями.

В CPython dict реализован с использованием хеш-таблицы.

Очень упрощённо:

ключ
↓
hash(key)
↓
поиск позиции в хеш-таблице
↓
ключ + значение

Поэтому поиск значения по ключу в среднем выполняется за:

O(1)

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

4. Пустой словарь

Самый короткий способ:

data = {}

Проверим:

print(
    type(data)
)

Результат:

<class 'dict'>

5. Через класс dict

Можно использовать сам класс:

data = dict()

print(data)

Результат:

{}

Литерал словаря

6. Словарь с данными

product = {
    'name': 'Laptop',
    'price': 1500,
    'available': True,
}

Синтаксис одной пары:

key: value

Пары разделяются запятыми:

{
    key_1: value_1,
    key_2: value_2,
    key_3: value_3,
}

Ключи

7. Ключи должны быть хешируемыми

Например, ключами могут быть:

data = {
    'name': 'Alex',
    10: 'ten',
    (1920, 1080): 'resolution',
}

Здесь используются:

str
int
tuple

Кортеж подходит только тогда, когда его элементы тоже хешируемы.


8. Список ключом быть не может

Такой код:

data = {
    [10, 20]: 'coordinates',
}

приведёт к:

TypeError: unhashable type: 'list'

Потому что list не является хешируемым объектом.


Значение может быть практически любым объектом

9. Например, списком

user = {
    'name': 'Alex',
    'skills': [
        'Python',
        'SQL',
        'Django',
    ],
}

Значение:

user['skills']

является обычным списком.

Значения словаря не обязаны быть хешируемыми.

Ограничение на хешируемость относится именно к ключам.


Dict comprehension

10. Вспоминаем list comprehension

Мы уже умеем:

squares = [
    number ** 2
    for number in range(5)
]

Результат:

[0, 1, 4, 9, 16]

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

Для словаря используются фигурные скобки и конструкция:

key: value

Например:

squares = {
    number: number ** 2
    for number in range(5)
}

print(squares)

Результат:

{
    0: 0,
    1: 1,
    2: 4,
    3: 9,
    4: 16,
}

Общий вид:

{
    key_expression: value_expression
    for element in iterable
}

Такая конструкция называется:

dict comprehension

Фигурные скобки и разные типы

12. Важно различать

С двоеточием:

{
    'name': 'Alex',
    'age': 30,
}

получаем:

dict

Без двоеточия:

{
    10,
    20,
    30,
}

получается другой тип данных:

set

с которым познакомимся позже.


dict() с именованными аргументами

13. Ещё один способ создания словаря

user = dict(
    name='Alex',
    age=30,
    city='Tbilisi',
)

print(user)

Результат:

{
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

Здесь:

name='Alex'

является именованным аргументом.

Как, например:

print(
    'Python',
    'SQL',
    sep=' | ',
)

14. Имена аргументов становятся строковыми ключами

При:

user = dict(
    name='Alex',
    age=30,
)

получаем:

{
    'name': 'Alex',
    'age': 30,
}

То есть имена аргументов:

name
age

превратились в строковые ключи:

'name'
'age'

Ограничения этого синтаксиса

15. Именованный аргумент должен иметь допустимое имя

Например:

dict(
    first_name='Alex',
)

работает.

Но нельзя напрямую написать:

dict(
    1name='Alex',
)

или:

dict(
    first-name='Alex',
)

или ключ с пробелом:

'first name'

через обычный синтаксис именованного аргумента.

Почему?

Потому что слева от:

=

здесь находится именно имя именованного аргумента, поэтому на него распространяются правила идентификаторов Python.


16. Через литерал таких ограничений нет

user = {
    '1name': 'Alex',
    'first-name': 'Brown',
    'first name': 'Alex Brown',
    '123': 'number',
}

Такие строковые ключи совершенно допустимы.

Поэтому:

dict(
    name='Alex',
    age=30,
)

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

А литерал:

{
    key: value,
}

намного универсальнее.


Переменная как ключ и имя аргумента

17. Важное различие

Например:

field_name = 'technology'
value = 'Python'

Литерал:

data = {
    field_name: value,
}

print(data)

Результат:

{
    'technology': 'Python'
}

Почему?

Потому что выражение:

field_name

вычисляется.

Его значение:

'technology'

становится ключом.


А:

data = dict(
    field_name=value,
)

print(data)

даст:

{
    'field_name': 'Python'
}

Потому что:

field_name=value

здесь является именованным аргументом.

Ключом становится имя аргумента:

'field_name'

а не значение переменной field_name.


Создание dict из итерируемого объекта

18. Пары из двух элементов

dict() можно передать итерируемый объект, элементы которого сами содержат по два значения:

pairs = [
    (
        'name',
        'Alex',
    ),
    (
        'age',
        30,
    ),
    (
        'city',
        'Tbilisi',
    ),
]

user = dict(pairs)

print(user)

Результат:

{
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

Первое значение каждой пары становится:

ключом

второе:

значением

19. Необязательно использовать кортежи

Например:

pairs = [
    ['Python', 10],
    ['SQL', 8],
    ['Django', 7],
]

ratings = dict(pairs)

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

ключ
значение

Ключи уникальны

20. Двух одинаковых ключей одновременно быть не может

Например:

user = {
    'name': 'Alex',
    'age': 30,
    'name': 'Emma',
}

print(user)

Получим:

{
    'name': 'Emma',
    'age': 30,
}

Первое:

'name': 'Alex'

было заменено более поздним:

'name': 'Emma'

21. Последнее значение побеждает

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

Поэтому:

{
    'status': 'new',
    'status': 'active',
    'status': 'deleted',
}

в итоге содержит:

{
    'status': 'deleted',
}

Так писать не следует: повторяющиеся ключи в литерале обычно означают ошибку в коде.


Получение значения

22. Обращение по ключу

user = {
    'name': 'Alex',
    'age': 30,
}

print(
    user['name']
)

Результат:

Alex

KeyError

23. Несуществующий ключ

Если обратиться:

print(
    user['email']
)

а ключа:

'email'

нет, получим:

KeyError

Например:

KeyError: 'email'

24. Аналогия с IndexError

У списка:

numbers[100]

может возникнуть:

IndexError

потому что такого индекса нет.

У словаря:

user['email']

может возникнуть:

KeyError

потому что такого ключа нет.


Добавление новой пары

25. Новый ключ

user = {
    'name': 'Alex',
    'age': 30,
}

user['city'] = 'Tbilisi'

print(user)

Получим:

{
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

Если такого ключа раньше не было, создаётся новая пара.


Изменение значения

26. Существующий ключ

user['age'] = 31

Теперь:

print(user)

даст:

{
    'name': 'Alex',
    'age': 31,
    'city': 'Tbilisi',
}

Существующая пара не дублируется.

Меняется значение по ключу:

'age'

Удаление через del

27. Удаляем пару

user = {
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

del user['age']

print(user)

Результат:

{
    'name': 'Alex',
    'city': 'Tbilisi',
}

Удаляется вся пара:

ключ + значение

28. Несуществующий ключ

del user['email']

если такого ключа нет, приведёт к:

KeyError

Словари нельзя складывать

29. Оператор +

first = {
    'a': 1,
}

second = {
    'b': 2,
}

print(
    first + second
)

Получим:

TypeError

Для dict оператор:

+

не определён.


30. Умножение тоже не работает

data = {
    'a': 1,
}

print(
    data * 3
)

тоже приведёт к:

TypeError

Словарь не поддерживает повторение через:

*

как это делают:

str
list
tuple

Порядок и сравнение

31. У списка порядок влияет на равенство

first = [
    1,
    2,
    3,
]

second = [
    3,
    2,
    1,
]

print(
    first == second
)

Результат:

False

Элементы одинаковые, но порядок различается.


32. То же самое с tuple

first = (
    1,
    2,
    3,
)

second = (
    3,
    2,
    1,
)

print(
    first == second
)

Результат:

False

Для dict порядок вставки не влияет на ==

33. Два словаря

first = {
    1: 'one',
    2: 'two',
    3: 'three',
}

second = {
    2: 'two',
    3: 'three',
    1: 'one',
}

print(
    first == second
)

Результат:

True

Хотя пары были добавлены в разном порядке.


34. Почему словари равны

Для равенства обычных словарей важно:

  • одинаковое количество пар;
  • одинаковые ключи;
  • каждому ключу соответствует равное значение.

Порядок вставки при:

==

не учитывается.


Учебный алгоритм сравнения

35. Приблизительная модель

Можно написать свою функцию:

def dictionaries_equal(
    first,
    second,
):
    if len(first) != len(second):
        return False

    for key in first:
        if key not in second:
            return False

        if first[key] != second[key]:
            return False

    return True

Проверим:

first = {
    1: 'one',
    2: 'two',
    3: 'three',
}

second = {
    3: 'three',
    1: 'one',
    2: 'two',
}

print(
    dictionaries_equal(
        first,
        second,
    )
)

Результат:

True

Это учебный пример логики сравнения.

Он не означает, что CPython буквально реализует сравнение словарей именно таким Python-кодом.


Почему dict настолько важен

36. Словари используются постоянно

dict — один из самых распространённых типов данных в Python.

Он встречается:

  • в backend-разработке;
  • при работе с API;
  • в автоматизации;
  • в тестировании;
  • при обработке конфигураций;
  • при анализе данных;
  • при работе с JSON;
  • во множестве библиотек и фреймворков.

Сама идея:

ключ → значение

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


JSON

37. Обмен структурированными данными

Веб-приложения часто обмениваются данными через формат:

JSON

Например, сервер условного сервиса может вернуть данные о криптовалюте:

{
    "data": {
        "symbol": "BTC",
        "name": "Bitcoin",
        "price": {
            "USD": 64000.5,
            "EUR": 59000.2
        }
    },
    "success": true
}

Это JSON, а не Python-код.

Но после преобразования JSON в Python очень похожая структура обычно представляется через:

dict
list
str
int
float
bool
None

38. JSON и dict похожи, но это не одно и то же

Например, в JSON:

{
    "active": true,
    "error": null
}

А соответствующие значения Python:

{
    'active': True,
    'error': None,
}

Также ключи JSON-объекта являются строками.

Поэтому визуально JSON очень похож на Python-словарь, но это отдельный формат данных.

Позже познакомимся со специальным модулем:

json

Вложенные словари

39. Словарь внутри словаря

Представим ответ некоторого API:

market_data = {
    'data': {
        'symbol': 'BTC',
        'price': {
            'USD': 64_000.5,
            'EUR': 59_000.2,
        },
    },
    'success': True,
}

Чтобы получить:

64_000.5

нужно постепенно пройти через ключи.

Сначала:

market_data['data']

Получаем:

{
    'symbol': 'BTC',
    'price': {
        'USD': 64_000.5,
        'EUR': 59_000.2,
    },
}

Затем:

market_data[
    'data'
]['price']

И наконец:

usd_price = (
    market_data[
        'data'
    ][
        'price'
    ][
        'USD'
    ]
)

print(usd_price)

Результат:

64000.5

Смешанная вложенность

40. dict → list → dict

Например:

response = {
    'users': [
        {
            'name': 'Alex',
            'age': 30,
        },
        {
            'name': 'Emma',
            'age': 27,
        },
    ],
}

Нужно получить имя второго пользователя.

Сначала ключ:

response['users']

получаем список.

Затем индекс:

response['users'][1]

получаем второй словарь.

Затем ключ:

response['users'][1]['name']

Получаем:

Emma

41. Можно комбинировать ключи и индексы

В реальных структурах может встречаться:

dict
↓
list
↓
dict
↓
list
↓
dict

Тогда обращение может выглядеть:

data[
    'users'
][0][
    'orders'
][2][
    'price'
]

Каждая следующая пара:

[]

применяется к объекту, который вернул предыдущий шаг.


Обход dict

42. Обычный for обходит ключи

Возьмём:

user = {
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

Напишем:

for key in user:
    print(key)

Результат:

name
age
city

Важно запомнить:

При обычном обходе dict цикл получает ключи.


43. Получаем значение через ключ

Раз у нас есть ключ:

key

значение можно получить:

user[key]

Например:

for key in user:
    print(
        key,
        user[key],
    )

Результат:

name Alex
age 30
city Tbilisi

Пока для этого не нужны никакие методы словаря.


Передача dict в другие конструкции

44. list(dict)

user = {
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

print(
    list(user)
)

Результат:

['name', 'age', 'city']

Получили именно ключи.


45. tuple(dict)

print(
    tuple(user)
)

Результат:

('name', 'age', 'city')

Снова только ключи.


46. sorted(dict)

numbers = {
    30: 'thirty',
    10: 'ten',
    20: 'twenty',
}

print(
    sorted(numbers)
)

Результат:

[10, 20, 30]

Функция сортирует ключи.


47. max() и min()

numbers = {
    30: 'thirty',
    10: 'ten',
    20: 'twenty',
}

print(
    max(numbers)
)

print(
    min(numbers)
)

Результат:

30
10

Потому что функции получают ключи словаря.


Общее правило

48. dict как итерируемый объект

Когда мы просто итерируем словарь:

for key in dictionary:

или передаём его туда, где ожидается итерируемый объект:

list(dictionary)

tuple(dictionary)

sorted(dictionary)

max(dictionary)

итерация происходит по:

ключам

Изменение значений во время обхода

49. Значение по существующему ключу менять можно

prices = {
    'apple': 100,
    'banana': 80,
    'orange': 120,
}

for product in prices:
    prices[product] *= 2

print(prices)

Результат:

{
    'apple': 200,
    'banana': 160,
    'orange': 240,
}

Мы не меняли количество ключей.

Мы только заменяли значения по уже существующим ключам.


50. Ещё один пример

users = {
    'Alex': 'active',
    'Emma': 'active',
    'Daniel': 'active',
}

for user in users:
    users[user] = (
        users[user].upper()
    )

print(users)

Результат:

{
    'Alex': 'ACTIVE',
    'Emma': 'ACTIVE',
    'Daniel': 'ACTIVE',
}

Нельзя бездумно менять размер словаря во время обхода

51. Добавление или удаление ключей

Например, такой код проблемный:

for key in user:
    user['new_key'] = 100

или:

for key in user:
    del user[key]

Потому что во время итерации изменяется размер словаря.

Python обычно прервёт такой обход ошибкой:

RuntimeError: dictionary changed size during iteration

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

Подробные способы изучим позже.


Объединение словарей

Оператор |

Начиная с Python 3.9 словари можно объединять с помощью оператора:

|

Например:

user = {
    'name': 'Alex',
    'age': 30,
}

contacts = {
    'email': 'alex@example.com',
    'city': 'Tbilisi',
}

result = user | contacts

print(result)

Результат:

{
    'name': 'Alex',
    'age': 30,
    'email': 'alex@example.com',
    'city': 'Tbilisi',
}

Создаётся новый словарь.

Исходные:

user
contacts

не изменяются.


Можно объединить несколько словарей

first = {
    'name': 'Alex',
}

second = {
    'age': 30,
}

third = {
    'city': 'Tbilisi',
}

result = (
    first
    | second
    | third
)

print(result)

Результат:

{
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
}

Что происходит с одинаковыми ключами

Ключи словаря должны быть уникальными.

Поэтому:

first = {
    'name': 'Alex',
    'age': 30,
}

second = {
    'age': 31,
    'city': 'Tbilisi',
}

result = first | second

print(result)

Получим:

{
    'name': 'Alex',
    'age': 31,
    'city': 'Tbilisi',
}

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

first | second
        ↑
значения второго словаря
перезаписывают совпадающие
значения первого

Старый способ через **

Оператор:

|

для словарей появился в Python 3.9.

До него словари часто объединяли через распаковку:

first = {
    'name': 'Alex',
    'age': 30,
}

second = {
    'city': 'Tbilisi',
    'language': 'Python',
}

result = {
    **first,
    **second,
}

print(result)

Результат:

{
    'name': 'Alex',
    'age': 30,
    'city': 'Tbilisi',
    'language': 'Python',
}

Такой синтаксис распаковки словарей появился в Python 3.5.

Можно распаковать сразу несколько словарей:

result = {
    **first,
    **second,
    **third,
}

При повторяющихся ключах действует тот же принцип: более позднее значение перезаписывает более раннее.


В современном Python для обычного объединения словарей чаще всего удобно использовать:

result = first | second

а конструкция:

{
    **first,
    **second,
}

остаётся полезной и также продолжает работать.


Кратко о создании dict

Литерал:

user = {
    'name': 'Alex',
    'age': 30,
}

Пустой:

user = {}

Через класс:

user = dict()

Через именованные аргументы:

user = dict(
    name='Alex',
    age=30,
)

Из пар:

user = dict(
    [
        ('name', 'Alex'),
        ('age', 30),
    ]
)

Dict comprehension:

squares = {
    number: number ** 2
    for number in range(5)
}

Главное по теме

dict — это:

изменяемая
итерируемая
упорядоченная
mapping-коллекция

которая хранит:

ключ → значение

Сохранение порядка вставки гарантировано начиная с:

Python 3.7

Но порядок не влияет на сравнение словарей через:

==

Ключи должны быть:

hashable

Например:

str
int
float
подходящий tuple

А:

list

ключом быть не может.


Значение может быть практически любым Python-объектом:

{
    'numbers': [10, 20, 30],
}

Получение значения:

dictionary[key]

Добавление:

dictionary[new_key] = value

Изменение:

dictionary[existing_key] = new_value

Удаление:

del dictionary[key]

Если при обращении через:

dictionary[key]

или удалении через:

del dictionary[key]

такого ключа нет, возникает:

KeyError

Обычный обход словаря:

for key in dictionary:
    ...

даёт именно ключи.

Значение можно получить:

dictionary[key]

Поэтому:

list(dictionary)
tuple(dictionary)
sorted(dictionary)
max(dictionary)

тоже работают с ключами.


Во время обхода можно менять значения существующих ключей:

for key in dictionary:
    dictionary[key] = ...

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


dict особенно важен при работе со структурированными данными и API.

Вложенные структуры могут содержать одновременно:

dict
list
dict
list
...

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

data['key'][0]['another_key']

С методами класса dict познакомимся в следующей теме.