Словари

Словарь (dict) – коллекция пар ключ – значение. Доступ к значению идёт по ключу, а не по номеру позиции.

Записывается фигурными скобками: {'Аня': 5, 'Борис': 4}. Ключи в одном словаре не повторяются – у каждого ключа одно значение. Пустой словарь – {} или dict().

Обращение d['Аня'] возвращает значение по ключу. Если ключа нет, программа останавливается с KeyError – словарь не угадывает и не возвращает ничего по умолчанию.

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

marks = {'Аня': 5, 'Борис': 4}
print(marks['Аня'])     # 5

marks['Аня'] = 3        # замена значения по существующему ключу
marks['Вера'] = 5       # новый ключ
print(marks)            # {'Аня': 3, 'Борис': 4, 'Вера': 5}

print(marks['Глеб'])    # KeyError: 'Глеб'
print(dict())           # {} – пустой словарь

in у словаря проверяет ключи, а не значения: 'Аня' in marks отвечает про ключ, а не про оценку.

Добавление нового ключа и замена значения записываются одинаково, d[k] = v. Разницы в записи нет, потому что словарь сам решает: если ключ уже есть – заменить, если нет – создать пару.

d = {'a': 1, 'b': 2}
d['c'] = 3
print(d)          # {'a': 1, 'b': 2, 'c': 3}

del d['a']
print(d)          # {'b': 2, 'c': 3}

print(d.pop('b')) # 2 – pop отдаёт значение
print(d)          # {'c': 3}

print('c' in d)   # True – in проверяет ключи
print(3 in d)     # False – значение 3 ключом не считается
print(len(d))     # 1

Проверка if k in d перед каждым чтением быстро надоедает. Метод get() делает то же в одну запись:

• d.get(k) – значение по ключу или None, если ключа нет;
• d.get(k, default) – значение или указанная замена.

Второй аргумент не записывается в словарь: он только возвращается вместо отсутствующего значения. Если пара нужна в словаре, её добавляют обычным d[k] = default.

Именно get() делает коротким подсчёт частот в следующем блоке.

d = {'Аня': 5}
print(d.get('Борис'))       # None
print(d.get('Борис', 0))    # 0
print(d.get('Аня', 0))      # 5 – ключ есть, замена не нужна
print(d)                    # {'Аня': 5} – словарь не изменился

По словарю ходят тремя способами:

Пары из items() обычно сразу распаковывают: for name, mark in d.items() – распаковка кортежа, знакомая по уроку 9.4.

Порядок перебора – порядок добавления ключей. Это свойство словаря в Python: он запоминает, в каком порядке ключи появились, и не переставляет их при чтении.

d = {'Аня': 5, 'Борис': 4, 'Вера': 5}

for k in d:
    print(k)               # Аня, Борис, Вера – порядок добавления

print(list(d.keys()))     # ['Аня', 'Борис', 'Вера']
print(list(d.values()))   # [5, 4, 5]

for name, mark in d.items():
    print(name, mark)      # Аня 5, Борис 4, Вера 5

Главный приём словаря. Нужно посчитать, сколько раз встретилось каждое значение: ключом становится само значение, а значением – счётчик.

count[x] = count.get(x, 0) + 1

Читается так: возьми текущий счётчик для x, а если такого ключа ещё нет – ноль, прибавь единицу и запиши обратно. Первая встреча создаёт пару, каждая следующая увеличивает счётчик.

Тот же приём считает слова, буквы, оценки – что угодно, у чего есть повторяющиеся значения.

word = 'математика'
count = {}

for ch in word:
    count[ch] = count.get(ch, 0) + 1

print(count)
# {'м': 2, 'а': 3, 'т': 2, 'е': 1, 'и': 1, 'к': 1}

print(count['а'])     # 3 – буква «а» встречается трижды

sorted(d) и sorted(d.items()) упорядочивают по ключу: сравниваются первые элементы пар.

Чтобы упорядочить по значению, применяют приём из урока 9.4: собирают пары (-значение, ключ) и сортируют их. Возрастающая сортировка по отрицательному числу даёт убывание по настоящему значению, а при равенстве – порядок по ключу. При выводе знак возвращают.

Параметр key= у sorted() умеет то же самое короче, но требует функции, а функции появятся только в блоке 11.

count = {'м': 2, 'а': 3, 'т': 2, 'е': 1, 'и': 1, 'к': 1}

print(sorted(count.items()))
# [('а', 3), ('е', 1), ('и', 1), ('к', 1), ('м', 2), ('т', 2)]
# – по алфавиту ключей

pairs = [(-n, ch) for ch, n in count.items()]
for n, ch in sorted(pairs):
    print(ch, -n)
# а 3, м 2, т 2, е 1, и 1, к 1
# – по убыванию частоты, при равенстве по алфавиту

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

if k not in groups:
    groups[k] = []
groups[k].append(x)

Проверка if k not in groups нужна один раз на каждую новую группу: у неё ещё нет списка, в который можно дописывать. Дальше groups[k] возвращает готовый список, и append() дописывает в него.

groups = {}
pairs = [('9А', 'Аня'), ('9Б', 'Борис'), ('9А', 'Вера')]

for cls, name in pairs:
    if cls not in groups:
        groups[cls] = []
    groups[cls].append(name)

print(groups)   # {'9А': ['Аня', 'Вера'], '9Б': ['Борис']}

Ключ должен быть неизменяемым, как элемент множества: число, строка, кортеж. Список в роли ключа даёт TypeError: unhashable type: 'list'.

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

Кортеж в роли ключа удобен для составных признаков: field[(2, 3)] = 'конь' – координата клетки как единый ключ. Значением при этом может быть любой объект, изменяемость значения ничему не мешает.

field = {(2, 3): 'конь'}
print(field[(2, 3)])       # конь – кортеж годится в ключи

d = {1: 'один', 'a': 'буква'}
print(d[1], d['a'])        # один буква

d[[1, 2]] = 'x'            # TypeError: unhashable type:
                           # 'list'

Порядок в таблице – не «лучше-хуже», а разные ответы на разные вопросы. Список нумерует, кортеж закрепляет, множество спрашивает «есть ли», словарь ищет по названию.