Словари в 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 познакомимся в следующей теме.