Методы словарей в Python

Обновлено:

Мы уже умеем:

  • создавать словари;
  • получать значения по ключам;
  • добавлять и изменять пары;
  • удалять пары через del;
  • обходить словарь в цикле for.

Теперь рассмотрим основные методы класса:

dict

1. Метод get()

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

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

print(
    user['name']
)

Результат:

Alex

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

get()
print(
    user.get('name')
)

Результат:

Alex

Если ключ существует, эти две конструкции дают одинаковый результат.


2. Главное отличие get()

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

print(
    user['city']
)

возникнет:

KeyError

А:

print(
    user.get('city')
)

вернёт:

None

и программа продолжит работать.


3. Значение по умолчанию

В get() можно передать второй аргумент:

dictionary.get(
    key,
    default,
)

Он определяет, что вернуть, если ключ отсутствует.

Например:

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

city = user.get(
    'city',
    'Не указан',
)

print(city)

Результат:

Не указан

Сам словарь при этом не изменяется:

print(user)
{'name': 'Alex'}

4. Когда использовать квадратные скобки, а когда get()

Если отсутствие ключа является ошибкой программы:

user['name']

может быть подходящим вариантом.

Если ключ может отсутствовать и это нормальная ситуация:

user.get(
    'middle_name',
    'Не указано',
)

часто удобнее использовать get().


Практический пример get()

5. Дни недели вместо большого if / elif

Раньше подобную задачу можно было решить:

day = 3

if day == 1:
    result = 'Monday'
elif day == 2:
    result = 'Tuesday'
elif day == 3:
    result = 'Wednesday'
elif day == 4:
    result = 'Thursday'
elif day == 5:
    result = 'Friday'
elif day == 6:
    result = 'Saturday'
elif day == 7:
    result = 'Sunday'
else:
    result = 'Такого дня недели нет'

print(result)

Для сопоставления одного значения другому отлично подходит словарь:

weekdays = {
    1: 'Monday',
    2: 'Tuesday',
    3: 'Wednesday',
    4: 'Thursday',
    5: 'Friday',
    6: 'Saturday',
    7: 'Sunday',
}

day = 3

result = weekdays.get(
    day,
    'Такого дня недели нет',
)

print(result)

Результат:

Wednesday

Если:

day = 10

получим:

Такого дня недели нет

Подсчёт количества элементов

6. Алгоритм через if / else

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

text = 'banana'

Можно создать словарь:

counter = {}

for char in text:
    if char not in counter:
        counter[char] = 1
    else:
        counter[char] += 1

print(counter)

Получим:

{
    'b': 1,
    'a': 3,
    'n': 2,
}

7. Тот же алгоритм через get()

text = 'banana'

counter = {}

for char in text:
    counter[char] = (
        counter.get(char, 0)
        + 1
    )

print(counter)

Результат тот же:

{
    'b': 1,
    'a': 3,
    'n': 2,
}

8. Как это работает

На первом символе:

'b'

ключа ещё нет.

Поэтому:

counter.get(
    'b',
    0,
)

возвращает:

0

Затем:

0 + 1 = 1

и выполняется:

counter['b'] = 1

Когда позже снова встречается:

'a'

метод:

counter.get(
    'a',
    0,
)

уже возвращает текущее значение:

2

Выполняется:

2 + 1 = 3

и значение обновляется:

counter['a'] = 3

9. Подсчёт слов

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

words = [
    'python',
    'sql',
    'python',
    'django',
    'python',
    'sql',
]

counter = {}

for word in words:
    counter[word] = (
        counter.get(word, 0)
        + 1
    )

print(counter)

Результат:

{
    'python': 3,
    'sql': 2,
    'django': 1,
}

Метод update()

10. Обновление словаря другим словарём

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

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

user.update(new_data)

print(user)

Получим:

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

Здесь произошли две вещи.

Ключ:

'age'

уже существовал, поэтому его значение изменилось.

Ключа:

'city'

не было, поэтому появилась новая пара.


11. update() изменяет существующий словарь

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

old_id = id(user)

user.update(
    {
        'age': 30,
    }
)

print(
    id(user) == old_id
)

Результат:

True

Метод изменяет существующий объект dict.

Он не создаёт новый словарь вместо него.


12. update() возвращает None

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

result = user.update(
    {
        'age': 30,
    }
)

print(result)

Результат:

None

Как и многие методы, изменяющие объект на месте:

list.append()
list.extend()
list.sort()
dict.update()

update() возвращает None.


Именованные аргументы в update()

13. Можно написать так

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

user.update(
    age=30,
    city='Tbilisi',
)

print(user)

Получим:

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

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

age  → 'age'
city → 'city'

14. Итерируемый объект с парами

Как и класс:

dict()

метод update() может принимать итерируемый объект, содержащий пары:

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

new_data = [
    (
        'age',
        30,
    ),
    (
        'city',
        'Tbilisi',
    ),
]

user.update(new_data)

print(user)

Результат:

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

Каждый вложенный элемент должен предоставлять пару:

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

update() и |=

15. Похожее действие

С Python 3.9 словари поддерживают:

|=

Например:

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

user |= {
    'age': 30,
    'city': 'Tbilisi',
}

print(user)

Результат:

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

16. Сравниваем | и |=

Обычный:

result = first | second

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

А:

first |= second

изменяет существующий:

first

По смыслу это очень похоже на:

first.update(second)

Метод setdefault()

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

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

result = user.setdefault(
    'name'
)

print(result)

Результат:

Alex

Если ключ уже существует, setdefault() просто возвращает его значение.

Словарь не меняется.


18. Отсутствующий ключ

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

result = user.setdefault(
    'city'
)

print(result)
print(user)

Получим:

None

и:

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

Вот здесь и появляется главное отличие от:

get()

get() и setdefault()

19. get() не изменяет словарь

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

user.get(
    'city',
    'Unknown',
)

print(user)

Результат:

{'name': 'Alex'}

20. setdefault() добавляет отсутствующий ключ

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

user.setdefault(
    'city',
    'Unknown',
)

print(user)

Результат:

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

21. Если ключ уже существует

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

result = user.setdefault(
    'city',
    'Batumi',
)

print(result)
print(user)

Получим:

Tbilisi

и:

{
    'city': 'Tbilisi',
}

setdefault() не заменяет существующее значение.


Практическое использование setdefault()

22. Изменяем структуру данных

Представим телефонную книгу:

contacts = [
    (
        'Alex Brown',
        '+995111111111',
    ),
    (
        'Emma Wilson',
        '+995222222222',
    ),
    (
        'Alex Brown',
        '+995333333333',
    ),
    (
        'Alex Brown',
        '+995444444444',
    ),
]

У одного человека может быть несколько номеров.

Хотим получить:

{
    'Alex Brown': [
        '+995111111111',
        '+995333333333',
        '+995444444444',
    ],
    'Emma Wilson': [
        '+995222222222',
    ],
}

23. Решение без setdefault()

phone_book = {}

for full_name, phone in contacts:
    if full_name not in phone_book:
        phone_book[full_name] = [
            phone
        ]
    else:
        phone_book[
            full_name
        ].append(phone)

print(phone_book)

Алгоритм работает.


24. Решение через setdefault()

phone_book = {}

for full_name, phone in contacts:
    phone_book.setdefault(
        full_name,
        [],
    ).append(phone)

print(phone_book)

Получаем тот же результат.


25. Как это работает

На первом:

Alex Brown

такого ключа ещё нет.

Поэтому:

phone_book.setdefault(
    'Alex Brown',
    [],
)

создаёт:

{
    'Alex Brown': [],
}

и возвращает созданный список.

После этого сразу вызывается:

.append(phone)

Получаем:

{
    'Alex Brown': [
        '+995111111111',
    ],
}

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

phone_book.setdefault(
    'Alex Brown',
    [],
)

возвращает существующий список.

После этого новый телефон добавляется именно в него.


Метод pop()

26. Удаление по ключу

Мы уже умеем:

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

del user['age']

После этого пара удаляется.

Но del ничего нам не возвращает.


27. pop() удаляет и возвращает значение

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

age = user.pop(
    'age'
)

print(age)
print(user)

Результат:

30

Словарь:

{
    'name': 'Alex',
}

То есть:

pop()

одновременно:

  1. удаляет пару;
  2. возвращает её значение.

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

user.pop(
    'city'
)

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

KeyError

29. Значение по умолчанию

Можно передать второй аргумент:

result = user.pop(
    'city',
    'Не найдено',
)

print(result)

Если ключа нет:

Не найдено

Ошибки уже не будет.


del и pop()

30. Разница

del dictionary[key]

просто удаляет пару.

Если ключа нет:

KeyError

dictionary.pop(key)

удаляет пару и возвращает значение.

Если ключа нет:

KeyError

dictionary.pop(
    key,
    default,
)

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

default

без ошибки.


Метод popitem()

31. Удаление последней пары

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

Метод:

popitem()

удаляет последнюю добавленную пару.

Например:

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

result = user.popitem()

print(result)
print(user)

Результат:

('city', 'Tbilisi')

Словарь:

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

32. popitem() возвращает tuple

Результат:

(
    'city',
    'Tbilisi',
)

является кортежем из двух элементов:

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

33. Можно сразу распаковать

key, value = user.popitem()

print(key)
print(value)

Например:

city
Tbilisi

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

Если:

data = {}

вызвать:

data.popitem()

возникнет:

KeyError

Потому что удалять уже нечего.


Метод fromkeys()

35. Создание словаря из ключей

Метод:

fromkeys()

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

Например:

fields = (
    'name',
    'age',
    'city',
)

user = dict.fromkeys(
    fields
)

print(user)

Результат:

{
    'name': None,
    'age': None,
    'city': None,
}

По умолчанию значением для всех ключей становится:

None

36. Указываем общее начальное значение

products = (
    'laptop',
    'mouse',
    'keyboard',
)

inventory = dict.fromkeys(
    products,
    0,
)

print(inventory)

Получим:

{
    'laptop': 0,
    'mouse': 0,
    'keyboard': 0,
}

37. Пример склада

Теперь можно изменять остатки:

inventory[
    'laptop'
] += 10

inventory[
    'mouse'
] += 25

print(inventory)

Получим:

{
    'laptop': 10,
    'mouse': 25,
    'keyboard': 0,
}

Для подобных неизменяемых значений:

0
None
строки

такое использование удобно.


Изменяемое значение в fromkeys()

38. Технически это разрешено

Например:

categories = (
    'fruits',
    'vegetables',
    'drinks',
)

products = dict.fromkeys(
    categories,
    [],
)

Такой код не вызывает ошибку.

Но здесь есть серьёзный нюанс.


39. Все значения ссылаются на один список

Если выполнить:

products[
    'fruits'
].append('apple')

и затем:

print(products)

получим:

{
    'fruits': ['apple'],
    'vegetables': ['apple'],
    'drinks': ['apple'],
}

Почему?

Потому что при:

dict.fromkeys(
    categories,
    [],
)

создаётся один список.

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

'fruits'     ─┐
'vegetables' ─┼→ один список []
'drinks'     ─┘

40. Для независимых списков нужен другой подход

Например:

products = {
    category: []
    for category in categories
}

Теперь на каждой итерации:

[]

создаёт новый отдельный список.

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


Метод clear()

41. Полная очистка словаря

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

user.clear()

print(user)

Результат:

{}

Сам объект словаря остаётся существовать, но все пары удаляются.


42. clear() изменяет существующий объект

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

old_id = id(user)

user.clear()

print(
    id(user) == old_id
)

Результат:

True

Обход словаря

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

43. Обычный for

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

for key in user:
    print(key)

Получим:

name
age
city

При обычной итерации словарь отдаёт:

ключи

44. Значения через ключи

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

Результат:

Alex
30
Tbilisi

45. Ключ и значение

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

Результат:

name Alex
age 30
city Tbilisi

Для всего этого методы пока вообще не нужны.


46. Другие конструкции тоже получают ключи

print(
    list(user)
)

Результат:

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

print(
    tuple(user)
)

Получим:

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

print(
    sorted(user)
)

Получим отсортированный список ключей.

То есть при обычной итерации:

dict → ключи

Метод keys()

47. Явно получаем ключи

for key in user.keys():
    print(key)

Результат будет точно таким же:

name
age
city

Поэтому:

for key in user:

и:

for key in user.keys():

в обычной ситуации выполняют одну и ту же задачу.


48. Что возвращает keys()

keys = user.keys()

print(keys)

print(
    type(keys)
)

Можно увидеть:

dict_keys(['name', 'age', 'city'])

и:

<class 'dict_keys'>

Это специальный view-объект — представление ключей словаря.


49. dict_keys является итерируемым

Поэтому его можно передать туда, где требуется итерируемый объект:

keys = user.keys()

print(
    list(keys)
)

print(
    tuple(keys)
)

print(
    sorted(keys)
)

dict_keys — не снимок данных

50. Представление остаётся связанным со словарём

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

keys = user.keys()

print(keys)

Получим:

dict_keys(['name', 'age'])

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

user[
    'city'
] = 'Tbilisi'

И снова:

print(keys)

Получим уже:

dict_keys(['name', 'age', 'city'])

Мы не вызывали:

user.keys()

заново.

Сохранённый view-объект показывает текущее состояние словаря.


51. View-объект не хранит отдельную копию ключей

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

dict
  ↑
  │
dict_keys

Он позволяет смотреть на словарь с точки зрения его ключей.

При изменении словаря view также отражает изменения.

Это не:

list(user)

потому что list() создаёт отдельный список с ключами на конкретный момент времени.


Нужно ли писать keys()?

52. Оба варианта допустимы

for key in user:

— очень распространённый и идиоматичный Python-код.

Но:

for key in user.keys():

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

Здесь специально работаем с ключами.

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


Метод values()

53. Представление значений

values = user.values()

print(values)

Получим примерно:

dict_values(['Alex', 30, 'Tbilisi'])

Тип:

print(
    type(values)
)
<class 'dict_values'>

54. Обход только значений

for value in user.values():
    print(value)

Получим:

Alex
30
Tbilisi

Здесь ключи нам вообще не нужны.


55. dict_values тоже динамический view

values = user.values()

user[
    'age'
] = 31

print(values)

Сохранённое представление уже покажет новое значение.

Как и dict_keys, оно не является отдельной копией содержимого словаря.


56. Можно преобразовывать

print(
    list(
        user.values()
    )
)

Получим список значений.

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

tuple(
    user.values()
)

или, если значения между собой сравнимы:

sorted(
    user.values()
)

Метод items()

57. Ключи и значения одновременно

items = user.items()

print(items)

Получим примерно:

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

Тип:

<class 'dict_items'>

58. При обходе получаем пары

for item in user.items():
    print(item)

Результат:

('name', 'Alex')
('age', 30)
('city', 'Tbilisi')

Каждый элемент при таком обходе — пара:

(key, value)

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


59. Можно обращаться по индексам пары

for item in user.items():
    print(
        item[0],
        item[1],
    )

Результат:

name Alex
age 30
city Tbilisi

Но гораздо удобнее использовать распаковку.


60. Распаковка key, value

for key, value in user.items():
    print(
        key,
        value,
    )

Результат:

name Alex
age 30
city Tbilisi

На каждой итерации пара:

(
    key,
    value,
)

распаковывается сразу в две переменные.

Это один из самых распространённых вариантов обхода словаря.


Сравниваем способы обхода

61. Только ключи

for key in user:
    print(key)

или:

for key in user.keys():
    print(key)

62. Только значения

for value in user.values():
    print(value)

63. Ключи и значения

Через обычный обход:

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

Или через items():

for key, value in user.items():
    print(
        key,
        value,
    )

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


items() тоже является динамическим представлением

64. Изменения видны через сохранённый view

items = user.items()

user[
    'language'
] = 'Python'

print(items)

В items появится новая пара.

Методы:

keys()
values()
items()

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


Оператор in

65. Для самого словаря проверяются ключи

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

print(
    'name' in user
)

Результат:

True

print(
    'Alex' in user
)

Результат:

False

Потому что:

'Alex'

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

x in dictionary

ищет среди ключей.


66. Через keys()

Можно написать:

print(
    'name'
    in user.keys()
)

Результат:

True

Но:

'name' in user

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


67. Ищем среди значений

print(
    'Alex'
    in user.values()
)

Результат:

True

Здесь уже поиск идёт именно среди значений.


68. Можно проверить целую пару

print(
    (
        'name',
        'Alex',
    )
    in user.items()
)

Результат:

True

Метод copy()

69. Поверхностная копия словаря

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

copied = original.copy()

print(
    original == copied
)

print(
    original is copied
)

Получим:

True
False

Словари содержат одинаковые данные, но являются разными объектами.


70. Это shallow copy

Метод:

copy()

создаёт поверхностную копию.

Например:

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

copied = original.copy()

Внешние словари разные:

print(
    original
    is copied
)
False

Но вложенный список один и тот же:

print(
    original['skills']
    is copied['skills']
)
True

71. Изменение вложенного объекта видно в обеих копиях

copied[
    'skills'
].append(
    'Django'
)

print(
    original[
        'skills'
    ]
)

Получим:

['Python', 'SQL', 'Django']

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


Глубокая копия

72. deepcopy()

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

from copy import deepcopy


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

copied = deepcopy(
    original
)

copied[
    'skills'
].append(
    'Django'
)

Теперь исходный список не изменится:

print(
    original[
        'skills'
    ]
)

Результат:

['Python', 'SQL']

Смысл здесь тот же, который мы уже рассматривали для списков:

copy()     → поверхностная копия
deepcopy() → глубокая копия структуры

Краткая таблица методов

Метод Что делает
get(key, default) Получает значение без KeyError
update(...) Добавляет и обновляет пары
setdefault(key, default) Получает значение, а отсутствующий ключ создаёт
pop(key, default) Удаляет ключ и возвращает значение
popitem() Удаляет и возвращает последнюю пару
fromkeys(iterable, value) Создаёт новый словарь с заданными ключами
clear() Очищает словарь
keys() Возвращает динамическое представление ключей
values() Возвращает динамическое представление значений
items() Возвращает динамическое представление пар
copy() Создаёт поверхностную копию

Главное по get()

Обычное обращение:

dictionary[key]

если ключа нет:

KeyError

Метод:

dictionary.get(key)

если ключа нет:

None

Или можно определить свой результат:

dictionary.get(
    key,
    default,
)

Особенно полезная конструкция для подсчёта:

counter[element] = (
    counter.get(
        element,
        0,
    )
    + 1
)

Главное по update()

dictionary.update(
    another_dictionary
)

изменяет существующий словарь.

Новые ключи добавляются, существующие получают новые значения.

Также можно передавать:

dictionary.update(
    name='Alex',
    age=30,
)

или:

dictionary.update(
    [
        ('name', 'Alex'),
        ('age', 30),
    ]
)

По смыслу близко к:

dictionary |= another_dictionary

Главное по setdefault()

Если ключ существует:

dictionary.setdefault(
    key,
    default,
)

возвращает существующее значение.

Если ключа нет:

  1. создаёт его;
  2. записывает default;
  3. возвращает default.

Полезный шаблон:

groups.setdefault(
    key,
    [],
).append(value)

Главное по удалению

del dictionary[key]

просто удаляет пару.

dictionary.pop(key)

удаляет и возвращает значение.

dictionary.popitem()

удаляет и возвращает последнюю пару:

(key, value)

Главное по fromkeys()

dictionary = dict.fromkeys(
    keys,
    default_value,
)

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

Например:

inventory = dict.fromkeys(
    products,
    0,
)

При использовании изменяемого значения:

dict.fromkeys(
    keys,
    [],
)

все ключи будут ссылаться на один и тот же список.

Поэтому для независимых изменяемых объектов обычно лучше:

{
    key: []
    for key in keys
}

Главное по keys(), values() и items()

Обычный словарь при итерации отдаёт ключи:

for key in dictionary:
    ...

Явно ключи:

for key in dictionary.keys():
    ...

Значения:

for value in dictionary.values():
    ...

Ключи и значения:

for key, value in dictionary.items():
    ...

Методы:

keys()
values()
items()

возвращают динамические view-объекты, связанные со словарём.

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


Главное по in

key in dictionary

проверяет наличие ключа.

value in dictionary.values()

проверяет наличие значения.

(
    key,
    value,
) in dictionary.items()

проверяет наличие конкретной пары.


Главное по копированию

dictionary.copy()

создаёт новый внешний словарь, но является поверхностной копией.

Если внутри находятся изменяемые объекты, ссылки на них сохраняются общими.

Для глубокой копии сложной структуры можно использовать:

from copy import deepcopy

и:

copied = deepcopy(
    original
)