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

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

Общее введение в словари (создание, доступ к элементам, вложенность) см. в главе Словари Python.

Что такое словарь Python?

Словарь отображает уникальные ключи на значения. Ключи должны быть хешируемыми (строки, числа и кортежи из хешируемых объектов подходят; списки — нет). Значения могут быть любыми объектами Python.

person = {"name": "Alice", "age": 28, "city": "Berlin"}

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

Методы словарей: обзор

clear()

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

Важно: inventory = {} выглядит похоже, но создаёт новый объект словаря. Если другая переменная указывает на тот же словарь, clear() опустошит его для обеих переменных; присваивание же этого не делает.

a = {"x": 1}
b = a
a.clear()
print(b)   # Output: {}  — b sees the change

a = {"x": 1}
b = a
a = {}
print(b)   # Output: {'x': 1}  — b is unaffected

copy()

copy() возвращает поверхностную копию — новый словарь с теми же ключами и ссылками на те же значения.

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

Подробнее о безопасном копировании словарей см. в главе Копирование словарей.

fromkeys()

fromkeys(iterable, value) — это метод класса, который создаёт новый словарь из последовательности ключей, все из которых сопоставлены с одним значением (по умолчанию None).

fields = ["name", "email", "phone"]
record = dict.fromkeys(fields, "")
print(record)
# Output: {'name': '', 'email': '', 'phone': ''}

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

bad = dict.fromkeys(["a", "b"], [])
bad["a"].append(1)
print(bad)  # Output: {'a': [1], 'b': [1]}  — both share the list!

Для исправления используйте вместо этого генератор словаря:

good = {k: [] for k in ["a", "b"]}
good["a"].append(1)
print(good)  # Output: {'a': [1], 'b': []}

get()

get(key, default=None) возвращает значение для key, если оно существует, или default в противном случае. Никогда не вызывает KeyError.

Когда использовать: предпочитайте get() вместо dict[key] всякий раз, когда ключ может отсутствовать. Используйте форму с двумя аргументами, чтобы задать значимое значение по умолчанию, вместо того чтобы перехватывать KeyError в блоке try/except.

items()

items() возвращает представление dict_items — итерируемый объект из кортежей (key, value), отражающий текущее состояние словаря.

Наиболее распространённое использование — распаковка ключа и значения в цикле for:

scores = {"math": 90, "english": 85, "science": 92}
for subject, grade in scores.items():
    print(f"{subject}: {grade}")
# Output:
# math: 90
# english: 85
# science: 92

Представления являются живыми — они отражают изменения в словаре без необходимости повторного создания.

Дополнительные шаблоны цикла см. в главе Цикл по словарям.

keys()

keys() возвращает представление dict_keys всех ключей в порядке вставки.

Поскольку это представление, его можно использовать в операциях над множествами для сравнения двух словарей:

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}

print(a.keys() & b.keys())  # Output: {'y'}    — keys in both
print(a.keys() | b.keys())  # Output: {'x', 'y', 'z'}  — all keys
print(a.keys() - b.keys())  # Output: {'x'}    — keys only in a

values()

values() возвращает представление dict_values всех значений.

Распространённые случаи использования:

prices = {"apple": 0.99, "banana": 0.59, "cherry": 2.49}

total = sum(prices.values())
print(f"Total: {total:.2f}")   # Output: Total: 4.07

most_expensive = max(prices.values())
print(most_expensive)          # Output: 2.49

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

pop()

pop(key, default) удаляет элемент с указанным ключом и возвращает его значение. Если ключ отсутствует и значение по умолчанию не задано, вызывается KeyError.

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

popitem()

popitem() удаляет и возвращает последнюю вставленную пару ключ–значение в виде кортежа (key, value). Вызов на пустом словаре вызывает KeyError.

data = {"a": 1, "b": 2, "c": 3}

last = data.popitem()
print(last)   # Output: ('c', 3)
print(data)   # Output: {'a': 1, 'b': 2}

Практический паттерн — деструктивная обработка словаря до тех пор, пока он не опустеет:

tasks = {"write tests": True, "review PR": False, "deploy": True}
while tasks:
    name, done = tasks.popitem()
    status = "done" if done else "pending"
    print(f"{name}: {status}")

setdefault()

setdefault(key, default=None) возвращает значение для key, если оно существует. Если key отсутствует, вставляет его со значением default и возвращает default.

options = {"color": "blue"}

# Key exists — returns existing value, does NOT overwrite
print(options.setdefault("color", "red"))   # Output: blue

# Key absent — inserts and returns default
print(options.setdefault("size", "medium")) # Output: medium

print(options)
# Output: {'color': 'blue', 'size': 'medium'}

Основной сценарий использования: построение словарей из списков (группировка):

words = ["apple", "avocado", "banana", "blueberry", "cherry"]
grouped = {}
for word in words:
    grouped.setdefault(word[0], []).append(word)

print(grouped)
# Output: {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

Это чище, чем проверка if key not in d: d[key] = [] на каждой итерации.

update()

update(other) объединяет other в словарь, перезаписывая существующие ключи. other может быть другим словарём, итерируемым объектом из пар (key, value) или именованными аргументами.

Альтернатива в Python 3.9+: оператор объединения на месте |= делает то же самое более кратко:

profile = {"name": "Alice", "age": 28}
profile |= {"age": 29, "city": "Berlin"}
print(profile)
# Output: {'name': 'Alice', 'age': 29, 'city': 'Berlin'}

Оператор | (без =) возвращает новый словарь вместо изменения на месте.

Доступ к элементам и их изменение

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

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

Обращение к несуществующему ключу вызывает KeyError. Используйте get(), чтобы этого избежать.

Добавление или перезапись значения:

person = {"name": "Alice", "age": 28}
person["occupation"] = "Engineer"  # new key
person["age"] = 29                 # overwrite existing key
print(person)
# Output: {'name': 'Alice', 'age': 29, 'occupation': 'Engineer'}

Перебор ключей и значений:

Выбор правильного метода

Связанные главы

• Словари Python — основы: создание, доступ и проверка членства
• Вложенные словари — словари словарей для иерархических данных
• Цикл по словарям — все шаблоны цикла с keys(), values() и items()
• Копирование словарей — подробно о поверхностном и глубоком копировании
• Методы списков — аналогичный справочник для списков Python

Практика