Создание словаря: фигурные скобки и dict()

Первый словарь уже получился: в уроке 1 телефонная книга собиралась фигурными скобками. Это главный способ — но не единственный. Разберём все: литерал в скобках, фабрику dict() и пустой словарь, который наполняется по ходу программы. Заодно выясним, какие значения можно ставить в роль ключа.

Литерал: фигурные скобки

Самый частый путь. Внутри фигурных скобок через запятую перечисляются пары, ключ отделяется от значения двоеточием. Функция len() считает пары — не ключи и не значения по отдельности:

prices = {'молоко': 89, 'хлеб': 42}

print(prices)
print(len(prices))

{'молоко': 89, 'хлеб': 42}
2

dict(): из списка пар и из другого словаря

Второй способ — встроенная функция dict(). Ей можно передать список пар (в виде кортежей) — например, собранный циклом или прочитанный из файла. Если же передать готовый словарь, функция сделает его копию. А ещё она принимает пары вида имя=значение — имена при этом превращаются в строковые ключи, так удобно описывать короткие наборы опций:

pairs = [('молоко', 89), ('хлеб', 42), ('сыр', 590)]
prices = dict(pairs)

print(prices)
print(len(prices))

{'молоко': 89, 'хлеб': 42, 'сыр': 590}
3

options = dict(theme='dark', lang='ru')
backup = dict({'молоко': 89, 'хлеб': 42})

print(options)
print(backup)

{'theme': 'dark', 'lang': 'ru'}
{'молоко': 89, 'хлеб': 42}

Какие ключи годятся: строки и числа

Оговорка: имена при записи имя=значение подчиняются правилам имён переменных — латиница, без кавычек, поэтому русский ключ 'молоко' так не передать; для таких ключей остаётся литерал. Ключом же может быть любое неизменяемое значение: строка — самый частый выбор, число — второй (номера месяцев, коды ошибок, id записей). Строки и числа спокойно живут в одном словаре, а доступны каждый по-своему: строка — в кавычках, число — без. Как потом пополнять готовый словарь — урок 5.

calendar = {'год': 2026, 1: 'январь', 12: 'декабрь'}

print(calendar['год'])
print(calendar[1])
print(calendar[12])

2026
январь
декабрь

Словарь из двух списков: zip

Отдельно стоит разобрать случай, который встречается на каждом втором собеседовании. Данные приходят двумя списками: один с названиями товаров, второй с ценами. dict() два списка не принимает — ждёт пары. Собирать их руками в цикле — работа, которая ломается при любой опечатке. Помогает встроенная функция zip: она берёт элементы списков попарно и отдаёт пары, а dict() превращает пары в словарь.

names = ['молоко', 'хлеб', 'сыр']
prices = [89, 42, 590]

catalog = dict(zip(names, prices))

print(catalog)
print(catalog['сыр'])

{'молоко': 89, 'хлеб': 42, 'сыр': 590}
590

Одна строка вместо цикла с присваиванием. Но есть подвох: zip останавливается на самом коротком списке. Если в названиях пять позиций, а в ценах четыре — пятая молча пропадёт, и словарь получится на пару короче, чем ожидала программа. Данные такой формы лучше проверять: сравните len(names) и len(prices) до сборки.

Пустой словарь и наполнение в цикле

Третий способ — создать пустой словарь и наполнять его по ходу. Это не экзотика: так работает почти любой код, который читает данные построчно. Сначала catalog = {}, потом в цикле catalog[name] = price. Преимущество в том, что не нужно знать заранее, сколько строк придёт, — словарь вырастет ровно настолько, насколько наполнят.

catalog = {}
rows = [('молоко', 89), ('хлеб', 42), ('сыр', 590)]

for name, price in rows:
    catalog[name] = price

print(catalog)
print(len(catalog))

{'молоко': 89, 'хлеб': 42, 'сыр': 590}
3

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

base = dict.fromkeys(['молоко', 'хлеб', 'сыр'], [])

base['молоко'].append(89)
base['хлеб'].append(42)

print(base)

{'молоко': [89, 42], 'хлеб': [89, 42], 'сыр': [89, 42]}

Один и тот же список под тремя ключами — вот что здесь получилось. Для неизменяемых значений, вроде нуля или пустой строки, fromkeys работает нормально: счётчик стартует с нуля у каждого ключа. Проблема ровно в изменяемых значениях.

dict(имя=значение) и когда он удобен

Третий вид вызова dict() принимает пары в виде именованных аргументов: dict(theme='dark', lang='ru'). Имена превращаются в строковые ключи. Ограничение видно сразу: имя аргумента обязано быть корректным идентификатором Python — латиница, без пробелов, без кириллицы. Русский ключ 'молоко' так не передать, для таких случаев остаётся литерал.

options = dict(theme='dark', lang='ru', retries=3)

print(options)
print(len(options))

{'theme': 'dark', 'lang': 'ru', 'retries': 3}
3

Зато читается такой код отлично — особенно когда это набор параметров по умолчанию: сразу видно, какие опции есть и какие у них значения. В реальных проектах такой словарь потом расширяют: options['timeout'] = 30. Поменять значение по ключу — одна строка, и все места, где опция читалась, сразу увидят новое.

Копия или оригинал

Отдельного внимания заслуживает dict(существующий_словарь). Это не «тот же самый» словарь, а независимая копия: изменение оригинала не тронет копию, и наоборот. Проверить это просто — и заодно полезно знать, потому что расхождение копий потом ищут часами.

original = {'theme': 'dark', 'lang': 'ru'}
copy = dict(original)

copy['theme'] = 'light'

print(original)
print(copy)
print(original is copy)

{'theme': 'dark', 'lang': 'ru'}
{'theme': 'light', 'lang': 'ru'}
False

Оригинал остался тёмным, копия — светлой, и is честно отвечает False: это два разных объекта. Правда, копия копирует только верхний уровень — вложенные словари и списки останутся общими. Про это — в уроке 19, там разбирают глубокие копии.

Словарь или список кортежей

Пара «ключ: значение» внутри списка — почти то же самое, только медленнее. Поиск по списку идёт перебором: чтобы найти цену молока в каталоге из 30 000 позиций, программа в среднем сравнит 15 000 кортежей. Словарь ищет иначе — он считает хеш ключа и сразу прыгает в нужную ячейку, поэтому ответ приходит независимо от размера каталога. На сотнях записей разницу не почувствуешь, она всплывает там, где записей тысячи.

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

rows = [('молоко', 89), ('хлеб', 42), ('сыр', 590)]
prices = dict(rows)

def find_price(rows, key):
    for name, price in rows:
        if name == key:
            return price
    return None

print(find_price(rows, 'сыр'))
print(prices['сыр'])

590
590

Что дальше

Словарь теперь можно создать тремя способами — литералом, через dict() и пустым с наполнением в цикле. Дальше самое интересное: что произойдёт, когда вы обратитесь к ключу, которого в словаре нет. В уроке 3 — настоящий traceback с KeyError и разбор того, как его читать, а в уроке 4 — мягкая замена через get.