Как перебирать словарь в Python

Рука держит книгу по Python

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

Словарь в Python — это коллекция пар “ключ:значение”. Часто нужно перебрать либо ключи, либо значения, либо сразу и то и другое.

Итерация по ключам (через .keys() или прямо по словарю):

myDict = {"A": 2, "B": 5, "C": 6}
for i in myDict.keys():
    print("Key", i)
# Вывод:
# Key A
# Key B
# Key C

Прямой перебор словаря эквивалентен перебору его ключей:

for key in myDict:
    print("Key", key)
# Вывод:
# Key A
# Key B
# Key C

Перебор значений с помощью .values():

for v in myDict.values():
    print(v)
# Вывод:
# 2
# 5
# 6

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

for key in myDict:
    print(myDict[key])
# Вывод:
# 2
# 5
# 6

Перебор пар ключ‑значение через .items():

for key, value in myDict.items():
    print(key, "|", value)
# Вывод:
# A | 2
# B | 5
# C | 6

Перебор в обратном порядке (сортировка по ключу):

for key, value in sorted(myDict.items(), reverse=True):
    print(key, "|", value)
# Вывод:
# C | 6
# B | 5
# A | 2

Важно: .keys(), .values(), .items() возвращают “views” (представления). Они обновляются при изменении словаря, но не являются списком. Если нужен срез или фиксированный набор, оберните в list(…).

Преобразование словаря в список

Иногда нужно представить словарь как список кортежей, вложенных списков или плоский (flattened) список.

Список кортежей (ключ, значение):

myDict = {"A": "MUO", "B": "Google", "C": "Python"}
myList = []
for key, value in myDict.items():
    myList.append((key, value))
print(myList)
# Вывод:
# [('A', 'MUO'), ('B', 'Google'), ('C', 'Python')]

Вложенный список [[ключ, значение], …]:

myList = []
for key, value in myDict.items():
    myList.append([key, value])
print(myList)
# Вывод:
# [['A', 'MUO'], ['B', 'Google'], ['C', 'Python']]

Плоский список [‘A’, ‘MUO’, ‘B’, ‘Google’, …]:

myList = []
for key, value in myDict.items():
    myList += key, value
print(myList)
# Вывод:
# ['A', 'MUO', 'B', 'Google', 'C', 'Python']

Альтернатива: используйте list(myDict.items()) для списка кортежей и itertools.chain.from_iterable для плоского списка.

Сумма значений в словаре

Если значения — числа, их легко суммировать.

Через цикл:

myDict = {"A": 6, "B": 7, "C": 9}
g = 0  # инициализация аккумулятора
for i in myDict.values():
    g += i  # добавляем каждое значение
print(g)
# Вывод:
# 22

Короткая альтернатива — встроенная функция sum:

summedValues = sum(myDict.values())
print(summedValues)
# Вывод:
# 22

Перебор вложенного словаря

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

myDict = {"A": [1, 2, 3], "B": [4, 5, 6]}
for i in myDict.keys():
    print(myDict[i])
# Вывод:
# [1, 2, 3]
# [4, 5, 6]

for i in myDict.items():
    print(i)
# Вывод:
# ('A', [1, 2, 3])
# ('B', [4, 5, 6])

Пример со словарём, содержащим другие словари:

complexArray = {
    "Detail": {
        "Name": "Idowu",
        "Logs": 20,
        "isAdmin": True
    },
    "Activities": {
        "Inputs": 14,
        "Input Type": "Video"
    }
}

for value in complexArray.values():
    print(value)
# Вывод:
# {'Name': 'Idowu', 'Logs': 20, 'isAdmin': True}
# {'Inputs': 14, 'Input Type': 'Video'}

Чтобы вывести значения конкретного вложенного словаря:

for value in complexArray["Detail"].values():
    print(value)
# Вывод:
# Idowu
# 20
# True

Чтобы пройтись по всем дочерним значениям:

for value in complexArray.values():
    for i in value.values():
        print(i)
# Вывод:
# Idowu
# 20
# True
# 14
# Video

Изменение элементов словаря при переборе

Словари в Python изменяемы (mutable), поэтому можно модифицировать их содержимое. Но будьте осторожны при удалении/добавлении ключей во время прямого перебора — это источник ошибок.

Поменять местами ключи и значения (создать новый словарь):

myDict = {"A": "MUO", "B": "Google", "C": "Python"}
swappedDict = {}
for key, value in myDict.items():
    swappedDict[value] = key
print(swappedDict)
# Вывод:
# {'MUO': 'A', 'Google': 'B', 'Python': 'C'}

С тем же эффектом через словарную генерацию:

swappedDict = {value: key for key, value in myDict.items()}
print(swappedDict)
# Вывод:
# {'MUO': 'A', 'Google': 'B', 'Python': 'C'}

Удаление ключей во время перебора — безопасно, если вы итерируете по копии списка ключей:

myDict = {"A": "MUO", "B": "Google", "C": "Python", "C": "Python"}
for key in list(myDict.keys()):
    if key == 'C':
        del myDict[key]
        myDict[key] = "Python"
print(myDict)
# Вывод:
# {'A': 'MUO', 'B': 'Google', 'C': 'Python'}

Альтернативные подходы и полезные приёмы

dict.items(), dict.keys(), dict.values() — основные инструменты; используйте их прежде всего.
dict comprehension ускоряет операции трансформации: {k:v for k,v in src.items() if условие}.
itertools.chain и operator.itemgetter помогают для сложных преобразований и выборок.
Для больших словарей используйте генераторы и view‑объекты, чтобы не создавать лишних копий.

Когда подход не сработает или приведёт к ошибке

Нельзя изменять структуру словаря (добавлять/удалять ключи) при итерации по самому словарю без создания копии ключей — это вызовет RuntimeError или непредсказуемое поведение.
Если значения не хешируемы (например, списки) и вы пытаетесь использовать их как ключи в новом словаре, это приведёт к TypeError.
При дедубликации через swap 값->ключ важен уникальный характер значений — дублирующиеся значения будут перезаписаны.

Ментальные модели и эвристики

Словарь — отображение (mapping) ключ→значение; цикл по словарю по умолчанию даёт ключи.
Представляйте .items() как поток кортежей (ключ, значение), .keys()/.values() — как динамические окна на словарь.
При преобразовании думайте: «мне нужен список пар», «мне нужен плоский список» или «мне нужен новый словарь» — и выбирайте соответствующий приём.

Шпаргалка: быстрые сниппеты

Список кортежей: list(myDict.items())
Список ключей: list(myDict)
Список значений: list(myDict.values())
Сумма значений: sum(myDict.values())
Словарь без ключа ‘x’: {k: v for k, v in myDict.items() if k != ‘x’}
Обратный словарь (values→keys): {v: k for k, v in myDict.items()}

Контрольные списки по ролям

Для начинающего:
- Понимать, что цикл по словарю даёт ключи.
- Использовать .items() для пар ключ‑значение.
- Не удалять элементы непосредственно в цикле без list(…).
Для разработчика приложений:
- Предпочесть dict comprehension для читаемого и быстрого кода.
- Проверять уникальность значений при инверсии словаря.
- Использовать итераторы для памяти‑эффективности при больших наборах.
Для инженера данных:
- Преобразовывать словари в структуры, удобные для агрегации (DataFrame, list of dicts).
- Следить за типами значений (числа, строки, None) перед суммированием или агрегацией.

Критерии приёмки

Код корректно перебирает ожидаемые элементы (ключи/значения/пары).
Нет ошибок при модификации словаря во время перебора (используется копия ключей или безопасные операции).
Результат соответствует ожидаемому типу (list/tuple/dict) и структуре.
Тесты покрывают случаи пустого словаря, дублирующихся значений и вложенных структур.

Короткий глоссарий

keys() — метод, возвращающий представление ключей.
values() — метод, возвращающий представление значений.
items() — метод, возвращающий представление пар (key, value).
dict comprehension — компактный способ создавать словари через выражение в фигурных скобках.

Примеры тестов (несколько приемочных сценариев)

Пустой словарь: цикл не должен падать, список/словарь результата пуст.
Вложенный словарь: вложенные значения корректно перебираются двумя вложенными циклами.
Инверсия словаря: при дублировании значений убедиться, что поведение — ожидаемое (последняя запись перезаписывает предыдущую).

Краткое резюме

Перебор словаря в Python прост и гибок: используйте .keys(), .values(), .items() в зависимости от цели, применяйте dict comprehension для преобразований и помните о безопасности при модификации структуры во время итерации. Если следовать базовым эвристикам и шаблонам, работа с словарями становится безопасной, выразительной и эффективной.

Заметка: практикуйтесь на небольших примерах и добавляйте тесты на граничные случаи — это ускорит понимание и снизит количество ошибок в реальных проектах.