Словари в Python и методы работы с ними
В одной из прошлых статей я разбирал списки в Python и методы работы с ними. Сегодня мы узнаем, как работать со словарями в Python и изучим их методы.
Что такое словарь
Словари (dict) хранят в себе ключи и их объекты, где ключ – это имя объекта в словаре. Их могут называть ассоциативными массивами или хеш-таблицами.
Как мы знаем, в списках доступ к элементам осуществляется по индексу, который является неотрицательным числом. Индекс в списках создается автоматически при добавлении новых элементов, а индексами в словарях служат ключи, и их мы должны объявлять сами.
Комьюнити теперь в Телеграм
Подпишитесь и будьте в курсе последних IT-новостей
Для каких целей нам будут полезны словари?
- Подсчет каких-то предметов, где ключи – названия предметов, а объект – их количество.
- Для экономии памяти, если есть массив, который использует не все индексы по порядку.
- Установка соответствий между объектами, сортировка.
- Хранение данных разных объектов (например: ключ – ID пользователя ВКонтакте, а объект – массив с данными).
Ключом может быть произвольный неизменяемый тип данных: различные числа, строки, кортежи. Ключом в словаре не может быть множество, но может быть неизменяемый элемент типа frozenset. Значением элемента словаря может быть любой изменяемый или неизменяемый тип данных.
Создание словаря в Python
Пустой словарь в Python, как и в JavaScript, можно создать двумя способами: через функцию dict() или с помощью фигурных скобок. Рассмотрим на примере:
#Создание через функцию: dict1 = dict() #Создание через фигурные скобки: dict2 = <> print(type(dict1)) #Выведет print(type(dict2)) #Выведет print(dict1) #Выведет <> print(dict2) #Выведет <>
Теперь создадим уже заполненный словарь через функцию и фигурные скобки:
#Создание через функцию: dict1 = dict(car=’машина’, apple=’яблоко’) #Создание через фигурные скобки: dict2 = < 'car': 'машина', 'apple': 'яблоко' >print(dict1) #Выведет print(dict2) #Выведет
Изменение словаря
Добавим в наш словарь объект. Для этого нам нужно придумать значение ключу. Рассмотрим на примере:
dict = < 'car': ‘машина’, 'apple': 'яблоко' >dict[‘orange’] = ‘апельсин’ #В квадратных скобках указываем имя ключа, а значение после знака равно print(dict) #Выведет
Для удаления ключа и его объекта в словаре используют метод del, указывая имя ключа в квадратных скобках:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >del dict[‘orange’] print(dict) #Выведет
Перебор элементов словарей в Python
Для вывода всех ключей и значений по порядку используем цикл с оператором in:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >for key in dict: print(key, dict[key]) #Выведет: #car машина #apple яблоко #orange апельсин
Для вывода значения по ключу используем имя словаря и квадратные скобки с именем нужного ключа:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict['car']) #Выведет 'машина'
Методы словарей в Python
copy() – создание копии словаря. Рассмотрим на примере:
dict1 = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >dict2 = dict1.copy() print(dict2) #Выведет
get() – получение значения по ключу. Рассмотрим на примере:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.get('car')) #Выведет 'машина'
clear() – очистка словаря. Рассмотрим на примере:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >dict.clear() print(dict) #Выведет <>
keys() – получение всех ключей словаря. Рассмотрим на примере:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.keys()) #Выведет dict_keys(['car', 'apple', 'orange'])
values() – получение всех значений элементов словаря. Пример:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.values()) #Выведет dict_values(['машина', 'яблоко', 'апельсин'])
items() – получение всех элементов словаря, включая ключи. Рассмотрим на примере:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.items()) #Выведет dict_items([('car', 'машина'), ('apple', 'яблоко'), ('orange', 'апельсин')])
pop() – удаляет и возвращает значение ключа. Рассмотрим на примере:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.pop(‘car’)) #Выведет ‘машина’ print(dict) #Выведет
popitem() – удаляет и возвращает имя и значение ключа. Пример:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.pop()) #Выведет (‘orange’, ‘апельсин’) print(dict) #Выведет
setdefault() – получение значения по ключу, если такой ключ присутствует в словаре. Когда такого ключа нет, он создается со значением None (если оно не указано в свойствах). Рассмотрим на примере:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >print(dict.setdefault(‘car’) #Выведет ‘машина’ print(dict.setdefault(‘home’, ‘дом’) #Выведет ‘дом’ print(dict) #Выведет
update(<>) – обновить значения по ключам, добавление новых ключей:
dict = < 'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин' >dict.update() print(dict) #Выведет
Итог
Мы изучили словари в Python и методы работы с ними. Надеюсь, статья была полезной для вас. Удачи!
Словарь dict в Python
Словарь dict — это изменяемый контейнерный объект, который поддерживает поиск произвольных ключей. В языке Python тип данных словарь dict представлен встроенным классом dict() .
Ключи словаря — это произвольные, неизменяемые (хешируемые) значения. Значения, которые не являются хешируемыми не могут использоваться в качестве ключей. Это такие значения, которые содержат list списки, сами словари dict или другие изменяемые типы, которые сравниваются по значению, а не по идентификатору объекта.
Числовые типы, используемые для ключей, подчиняются обычным правилам числового сравнения: если два числа при сравнении считаются равными, например 1 == 1.0 , то они могут использоваться взаимозаменяемо для индексирования одной и той же записи словаря. Поскольку процессоры хранят числа с плавающей запятой в качестве приближений, то неразумно использовать их в качестве ключей словаря.
Словари можно создать, поместив разделенный запятыми список пар key: value в фигурные скобки <> или с помощью конструктора встроенного класса dict() .
'jack': 4098, 'sjoerd': 4127> # или 4098: 'jack', 4127: 'sjoerd'>
Словари поддерживают следующие операции:
- Словари поддерживают различные методы, которые описаны в разделе «Операции со словарями».
- Методы словаря dict.keys() , dict.values() и dict.items() возвращают списки-представления.
- Словари считаются равными тогда и только тогда, когда они имеют одинаковые пары (key, value) . Равенство не зависит от порядка следования ключей.
- Такие сравнения как ‘=’ , ‘>’ поднимают исключение TypeError .
Свойства типа данных словарь dict :
- Словари гарантированно сохраняют порядок вставки элементов (С версии Python-3.7).
- Обновление ключа не влияет на порядок расположения элементов словаря.
- Ключи, добавленные после удаления, вставляются в конец словаря.
- Словари и словарные представления стали обратимы. Другими словами их можно развернуть с сохранением порядка вставки элементов. Не путать с обратной сортировкой. (С версии Python-3.8)
- Cписки-представления обеспечивают динамическое представление записей словаря. То есть при изменении словаря они отражают эти изменения.
- Встроенный класс dict() .
- Методы словарей и поддерживаемые операции.
- Использование словарей dict в Python.
- Создание пользовательского словаря dict в Python.
Примеры операций со словарями:
>>> d = "one": 1, "two": 2, "three": 3, "four": 4> >>> d # # гарантированное сохранение порядка вставки >>> list(d) # ['one', 'two', 'three', 'four'] >>> list(d.values()) # [1, 2, 3, 4] # обновление ключа не влияет на порядок >>> d["one"] = 42 >>> d # # После удаления, ключ вставляются в конец словаря >>> del d["two"] >>> d["two"] = None >>> d #
Словари и словарные представления стали обратимы:
>>> d = "one": 1, "two": 2, "three": 3, "four": 4> >>> d # >>> list(reversed(d)) # ['four', 'three', 'two', 'one'] >>> list(reversed(d.values())) # [4, 3, 2, 1] >>> list(reversed(d.items())) # [('four', 4), ('three', 3), ('two', 2), ('one', 1)]
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Утиная типизация ‘Duck Typing’
- Что такое вызываемый объект callable?
- Как проверить тип переменной/объекта
- Логический тип данных bool
- Целые числа int
- Ограничение длины преобразования целочисленной строки
- Вещественные числа float
- Комплексные числа complex
- Типы последовательностей
- Список list
- Кортеж tuple
- Диапазон range
- Текстовые строки str
- Словарь dict
- Множество set и frozenset
- Итератор Iterator, протокол итератора
- Генератор generator и выражение yield
- Контекстный менеджер with
- Байтовые строки bytes
- Байтовый массив bytearray
- Тип memoryview, буфер обмена
- Файловый объект file object
- Универсальный псевдоним GenericAlias
- Объект объединения Union
24. Словари в Python
В предыдущем уроке мы познакомились со списками в языке Python. Но они не всегда могут помочь. Например, когда у нас имеются данные в виде ключ/значение, удобнее использовать словари.
Словари в Python напоминают ассоциативные массивы. В них так же уникальному значению ключа соответствует произвольное значение. В языке С++ ему аналогичен контейнер map . Как объявить словарь в Python? Он объявляется в фигурных скобках:
person = "lastname": "Ivanov",
"age": 30>
print(person["firstname"])
Сначала записывается ключ, а затем, через двоеточие, указывается значение. И ключ, и значение могут быть любым объектом языка Python. Кстати, пары ключ/значение необязательно писать на разных строках:
person =
Как видите, такой способ записи словаря менее читабельный.
Обратите внимание на обязательное разделение пар запятыми. Причем запятую после последней пары можно как ставить, так и опустить – интерпретатор Python ее проигнорирует.
Как вы помните, в списках элементы хранятся в порядке добавления. В свою очередь, словарь пренебрегает порядком хранения элементов.
Чтобы обратиться к элементу из списка, вам необходимо указать индекс элемента в квадратных скобках. В словаре, вместо индекса, задается ключ, например:
person["firstname"] # => Ivan
Обращение по ключу позволяет быстро находить необходимую информацию, независимо от размера словаря. Это возможно благодаря хорошо оптимизированным алгоритмам.
Чтобы понять, как динамически добавлять элементы в словарь, рассмотрим следующий пример:
person = "lastname": "Ivanov",
"age": 30,>
print(person)
person["id"] = 1;
print(person)
Как видите, чтобы добавить новый элемент в словарь, необходимо в квадратных скобках указать ключ и присвоить ему значение.
Допустим, нам необходимо посчитать количество определенных букв в заданной фразе:
word = "словарь - это не список"
letters =
for letter in word:
if letter in letters:
letters[letter] = letters[letter] + 1
print(letters)
Сначала мы объявляем словарь, в котором инициализируем наши буквы (то есть присвоим ноль, чтобы избежать ошибок, о которых мы поговорим позже). Далее перебираем все буквы фразы, и если такая буква есть в нашем словаре, то увеличиваем ее значение на единицу. Но что если наш словарь пустой и нам необходимо подсчитать частоту каждого символа в строке? Если оставить все как есть, то наш код работать не будет. Чтобы это устранить, необходимо кое-что добавить:
word = "словарь - это не список"
letters = <>
for letter in word:
if letter in letters:
letters[letter] += 1
else:
letters[letter] = 1
print(letters)
Мы добавили ветку else , которая будет выполняться, если ключа letter нет в словаре и заменили строку, в которой увеличивалось значение на эквивалентную. Давайте еще более упростим наш код, используя оператор not in :
for letter in word:
if letter not in letters:
letters[letter] = 0
letters[letter] += 1
И это еще не все. Для таких случаев был специально придуман метод setdefault :
for letter in word:
letters.setdefault(letter, 0)
letters[letter] += 1
Из этого урока вы узнали, чем различаются словари и списки в Python, когда и что использовать. Так же вы познакомились с методом setdefault .
Словари в Python (dict)
Уместная аналогия для словаря в языке Python — обычный толковый словарь, где каждому отдельному слову (ключу) соответствует его определение (значение).
А теперь разберёмся подробнее, как в Python устроены словари и как с ними работать.
Что такое словарь и как он устроен
Словари в Python можно считать реализацией структуры данных, более известной как ассоциативный массив.
Словарь (dictionary) — это тип данных, представляющий собой неупорядоченный набор пар ключ:значение. (при этом каждый ключ, в рамках одного словаря, является уникальным).
# литерал словаря в Python, где first_key и second_key — ключи, # а 1 и 2 — соответственно ассоциированные с ними значения
Способ хранения словаря Python в памяти
Рассмотрим сначала то, как выглядит структура отдельно взятого элемента словаря в pycore_dict.h :
typedef struct < Py_hash_t me_hash; PyObject *me_key; PyObject *me_value; >PyDictKeyEntry;
- me_hash — кэшированный хеш-код me_key ;
- *me_key — указатель на объект, содержащий ключ элемента;
- *me_value — указатель на объект, содержащий значение элемента.
Теперь перейдем к облику самой C-структуры словаря в Python:
Выходит, что, при объявлении нового словаря, в памяти создается объект, состоящий из следующих блоков:
- PyObject_HEAD — заголовок;
- Py_ssize_t ma_used — количество элементов словаря;
- uint64_t ma_version_tag — уникальная версия словаря, меняющаяся каждый раз при его обновлении;
- PyDictKeysObject *ma_keys — указатель на массив ключей;
- PyObject **ma_values — массив указателей на значения ключей. Если ma_values IS NULL, то все пары ключ:значение содержатся в ma_keys.
Как и в случае со списками, объект словаря хранит лишь указатели, а не сами значения
Базовая работа со словарями
Объявление словаря
Объявить словарь Python 3 можно несколькими способами. Но сначала рассмотрим наиболее простую ситуацию и создадим пустой словарь:
Теперь объявим и инициализируем словарь из трех элементов через соответствующий литерал и выведем на экран значение третьего элемента:
Помимо литерального объявления, в Python существует возможность объявлять словари при помощи функции dict() :
inventory_dict = dict(right_hand=’sword’, left_hand=’shield’) inventory_dict >
Чуть более хитрые способы создания словарей:
Вариант №1 . Если вам необходим словарь, каждому ключу которого сопоставлено одно и то же значение, то можно воспользоваться методом fromkeys() :
# словарь из четырех элементов со значениями, равными 0 zero_array_dict = dict.fromkeys([‘a0’, ‘b0’, ‘c0’, ‘d0’], 0) zero_array_dict >
Вариант №2 . С помощью функции-упаковщика zip() , вызванной внутри dict() , вы можете составить словарь из двух списков (в случае несовпадения длин списков, функция самостоятельно отсечет лишние элементы):
key_list = [‘marvel_hero’, ‘dc_hero’] value_list = [‘Spiderman’, ‘Flash’] superhero_dict = dict(zip(key_list, value_list)) superhero_dict >
Обращение к элементу словаря в Python
Извлечь значение элемента словаря можно единственным образом — обратившись к нему по его ключу:
hero_inventory = dict(strong_right_hand=’sword’, strong_left_hand=’shield +3′) what_in_right_hand = hero_inventory[‘strong_right_hand’] # или так: what_in_right_hand = hero_inventory.get(‘strong_right_hand’) print(what_in_right_hand) > sword
В отличие от списков, номеров позиций в словарях нет:
print(any_dict[1]) > Traceback (most recent call last): File «», line 1, in print(any_dict[1]) NameError: name ‘any_dict’ is not defined
�� Подобная ошибка возникнет и в том случае, если вы, по какой-то причине, вдруг решите извлечь значение по несуществующему ключу.
Добавление нового элемента в словарь
Для того чтобы добавить в словарь новые данные достаточно новому ключу этого словаря назначить какое-либо значение. Добавление выглядит так:
superhero_dict = superhero_dict[‘dark_horse_hero’] = ‘Hellboy’ print(superhero_dict) >
Аналогичным образом можно произвести замену существующего значения по его ключу:
superhero_dict[‘dc_hero’] = ‘Batwoman’ print(superhero_dict) >
Удаление элемента из словаря
Для того чтобы удалить запись в словаре воспользуемся оператором del :
# запись “’dark_horse_hero’: ‘Hellboy’” исчезнет. Прости, Красный! del superhero_dict[‘dark_horse_hero’] print(superhero_dict) >
Проверка на наличие ключа в словаре Python
Как отмечалось выше, обращение по несуществующему ключу вызывает ошибку в работе интерпретатора. Поэтому, наличие ключа в словаре следует проверять. За это дело отвечает оператор in :
if ‘marvel_hero’ in superhero_dict: print («Да, такой ключ есть») else: print(«Этот ключ в словаре отсутствует!») > Да, такой ключ есть # запись с ключом ‘dark_horse_hero’ была удалена нами чуть выше if ‘dark_horse_hero’ in superhero_dict: print («Да, такой ключ есть») else: print(«Этот ключ в словаре отсутствует!») > Этот ключ в словаре отсутствует!
�� Кстати говоря, использование метода get() позволяет корректно обработать ситуацию, когда запрашивается значение по несуществующему ключу. Достаточно в качестве второго параметра написать значение по умолчанию:
my_hero = superhero_dict.get(‘dark_horse_hero’, ‘Этот ключ в словаре отсутствует!’) print(my_hero) > Этот ключ в словаре отсутствует!
Длина словаря в Python
Стоит помнить, что словарь — это лишь набор отображений, а не последовательность, однако количество записей в нём мы все еще можем получить, воспользовавшись функцией len() :
treasure = dict(t1=’gold’, t2=’necklace’) num_of_items = len(treasure) print(num_of_items) > 2
Не самая богатая добыча! ��
Сортировка словаря
Так как словарь состоит из пар, то и отсортировать его можно, как по ключам, так и по значениям.
Сортировка по ключу Сортировка по ключам выполняется с использованием функции sorted() . Работает функция так:
statistic_dict = for key in sorted(statistic_dict): print(key) > a b с d e
Сортировка по значению А вот — один из вариантов сортировки словаря по значениям:
elements = for key, val in sorted(elements.items(), key= lambda x: x[1]): print(val) > -2 0 1 13 95
�� Здесь стоит учитывать, что, сама по себе, запись sorted(elements.items(), key= lambda x: x[1]) будет возвращать не словарь, а отсортированный список кортежей. Поэтому более правильным вариантом будет:
Перебор словаря в Python
Не является великой тайной и тот факт, что словарь, являющийся, по сути своей, набором пар (т.е. коллекцией), можно всячески итерировать. Один из способов — перебор по ключам:
iter_dict = for key in iter_dict: print(key, end=’ ‘) > key_b key_d key_e key_c key_a
Другой способ — проитерировать с использованием метода .items() . В этом случае на каждой итерации, пара ключ:значение будет возвращаться к нам в виде кортежа (‘ключ’, значение):
iter_dict = for item in iter_dict.items(): print(item, end=’ ‘) > (‘key_b’, 1) (‘key_d’, 0) (‘key_e’, -2) (‘key_c’, 95) (‘key_a’, 13)
Наконец, мы можем перебрать значения словаря, пользуясь классным методом .values() :
Объединение словарей
Когда заходит речь об объединении двух словарей, то обязательно следует упомянуть, что для пары сущностей типа «словарь» оператор «+»не определен. Причина этого становится довольно очевидной — стоит лишь вспомнить, что словарь не является последовательностью, а также задуматься над тем, какая именно операция на множестве словарей должна быть реализована этим самым оператором «+». Поэтому как-то так:
dict_1 = dict_2 = print(dict_1 + dict_2) Traceback (most recent call last): File «test.py», line 4, in print(dict_1 + dict_2) TypeError: unsupported operand type(s) for +: ‘dict’ and ‘dict’
Ну а если вы всё-таки хотите добиться результата и всё же выполнить объединение двух словарей, то достаточно воспользоваться методом .update() :
�� Если бы showcase_2 содержал ключи, присутствующие в showcase_1, то значения, ассоциированные с этими ключами, в результирующем словаре были бы взяты именно из showcase_2.
Ограничения
Создавая словарь, вы не должны забывать о некоторых ограничениях, накладываемых, в основном, на его ключи.
- Данные, представляющие собой ключ словаря, должны быть уникальны внутри множества ключей этого словаря. Проще говоря, не должно быть двух одинаковых ключей;
- Ключ должен быть объектом неизменяемого типа, то есть строкой, числом или кортежем. Если говорить строже, то объект содержащий ключ должен быть hashable. То есть иметь хеш-значение, которое не меняется в течение его жизненного цикла;
- На значения нет никаких ограничений. Максимальный уровень свободы. Они не обязаны быть ни уникальными, ни неизменяемыми, поэтому могут себе позволить быть какими угодно.
Методы словарей в Python
Перечислим основные словарные методы, которые помогут вам при работе с этим типом данных.
- clear() — очищает заданный словарь, приводя его к пустому.
- get() — отдаёт значение словаря по указанному ключу. Если ключ не существует, а в качестве дополнительного аргумента передано значение по умолчанию, то метод вернет его. Если же значение по умолчанию опущено, метод вернет None.
- items() — возвращает словарные пары ключ:значение, как соответствующие им кортежи.
- keys() — возвращает ключи словаря, организованные в виде списка.
- values() — подобным образом, возвращает список значений словаря.
- pop() — удалит запись словаря по ключу и вернет её значение.
- popitem() — выбрасывает пару ключ:значение из словаря и возвращает её в качестве кортежа. Такие пары возвращаются в порядке LIFO.
- update() — реализует своеобразную операцию конкатенации для словарей. Он объединяет ключи и значения одного словаря с ключами и значениями другого. При этом если какие-то ключи совпадут, то результирующим значением станет значение словаря, указанного в качестве аргумента метода update.
- copy() — создает полную копию исходного словаря.
# clear() farewell_dict = farewell_dict.clear() print(farewell_dict) > <> # get() seasons = print(seasons.get(‘winter’, ‘Такого ключа в словаре нет’)) > cold seasons_2 = print(seasons_2.get(‘nonexistent_key’, ‘Этот ключ отсутствует’)) > Этот ключ отсутствует seasons_3 = print(seasons_3.get(‘nonexistent_key’)) > None # items() pairs_dict = print(pairs_dict.items()) > dict_items([(’41’, 41), (’42’, 42), (’43’, 43)]) # keys() promo_dict = print(promo_dict.keys()) > dict_keys([‘modelA’, ‘ modelB’, ‘modelC’]) # values() palette = print(palette.values()) > dict_values([‘red’, ‘white’, ‘purple’]) # pop() id_dict = print(id_dict.pop(‘Alex’)) > 101546 print(id_dict) > # Ключ, само собой, должен присутствовать в словаре. # popitem() another_dict = print(another_dict.popitem()) > (‘h’, 23) print(another_dict) > # update() first_dictionary = second_dictionary = first_dictionary.update(second_dictionary) print(first_dictionary) > # copy() some_dict = copy_dict = some_dict.copy() print(copy_dict) >
Приведение Python-словарей к другим типам
dict → json
Чтобы сериализовать словарь в json формат, сперва необходимо импортировать сам модуль json:
Теперь можно развлекаться. Существует два схожих метода:
- dump() позволит вам конвертировать питоновские словари в json объекты и сохранять их в файлы на вашем компьютере. Это несколько напоминает работу с csv.
- dumps() запишет словарь в строку Python, но согласно json-формату.
dict → list
Для конвертации dict в list достаточно проитерировать словарь попарно с помощью метода items() , и, на каждой итерации, добавлять пару ключ:значение к заранее созданному списку. На выходе получим список списков, где каждый подсписок есть пара из исходного словаря.
medicine_chest = dict(top_part=’potion’, bot_part=’bandage’) medicine_list = [] for key, con in medicine_chest.items(): temp = [key, con] medicine_list.append(temp) print(medicine_list) > [[‘top_part’, ‘potion’], [‘bot_part’, ‘ bandage’]]
dict → string
Как указывалось выше, привести словарь к строке (str) можно при помощи модуля json . Но, если словарь не слишком большой, то эквивалентного результата можно добиться, используя стандартную функцию str() :
food_machine = dict(tier_1=’juice’, tier_2=’chocolate’) f_machine_str = str(food_machine) print(f_machine_str) >
Генератор словарей
В Python существует возможность создавать словари с помощью генераторов. Генераторы выполняют цикл, отбирают key:value пары на каждой итерации и заполняют, таким образом, новый словарь.
Создадим словарь, где нескольким элементам ряда натуральных чисел приводятся в соответствие их квадраты:
Также генератор удобен, когда нужно инициализировать какой-то имеющийся список ключей:
list_of_keys = [‘q’, ‘w’, ‘e’, ‘r’, ‘t’] generated_dict = print(generated_dict) >
Вложенные словари
Отдельного упоминания заслуживает тот факт, что элемент словаря может принимать в качестве значения другой словарь:
# где-то улыбается один Xzibit nesting_d = >> print(nesting_d[‘fk’][‘input_lvl_one’][‘input_lvl_two’]) > 42
�� Число уровней вложенности словарей неограниченно!
Альтернативы словарям
Есть такой модуль, который называется collections . В нем представлены альтернативные словарям типы данных: OrderedDict , defaultdict и Counter . Они близки словарям по сути, но имеют несколько расширенный функционал.
OrderedDict
OrderedDict, можно сказать, является обычным словарем, который, однако, запоминает порядок добавления в него ключей. А, значит, у метода popitem() появляется возможность, через присвоение параметру last значений False или True , указывать какой элемент нужно удалить: первый или последний.
defaultdict
Это подмножество словарей также, на первый взгляд, очень похоже на обычный dict. Но и тут есть свои тонкости. В частности, defaultdict , при отсутствии ключа, всегда присваивает значение по умолчанию, если его пытаются извлечь. Соответственно, KeyError вы больше не увидите.
Counter
Counter — подтип словаря, подсчитывающий и хранящий количество совпадающих неизменяемых элементов последовательности. Однако Counter() обладает и своими небезынтересными методами:
- elements() — метод возвращает список элементов в лексикографическом порядке;
- most_common(num) — возвращает num элементов, которые встречаются в последовательности чаще всего;
- subtract() — метод вычитает количество элементов, присутствующих в итерируемом или map объекте из вычисляемого объекта.
Наверно вы заметили, что словари и списки (о которых, кстати, вы можете почитать в нашей предыдущей статье » Списки в Python «) схожи как, внешне, так и в том, что могут изменять свой размер по необходимости.
Вообще говоря, и списки и словари — это изменяемые объекты, однако операции, провоцирующие изменения для этих типов данных, различны. Различаются они ещё и тем, что элементы словарей сохраняются по ключам, а не по позициям. Так или иначе, оба типа коллекций входят в число наиболее важных и часто применяемых на практике в языке Python.