dictionary = {'персона': 'человек', 'марафон': 'гонка бегунов длиной около 26 миль', 'противостоять': 'оставаться сильным, несмотря на давление', 'бежать': 'двигаться со скоростью'}

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

Вот ещё один пример словаря, где ключами являются числа, а значениями — строки:

gender_dict = {0: 'муж', 1: 'жен'}story_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}

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

dictionary = {(1, 2.0): 'кортежи могут быть ключами', 1: 'целые числа могут быть ключами', 'бежать': 'строки тоже', ['носок', 1, 2.0]: 'а списки не могут'}

Прим. перев. На самом деле проблема не с изменяемыми, а с нехэшируемыми типами данных, но обычно это одно и то же.

Еще момент.
Числовые ключи в словарях подчиняются правилам сравнения чисел.
Таким образом, int(1) и float(1.0) считаются одинаковым ключом, к стати True будет им же.
Однако из-за того, что значения типа float сохраняются приближенно, не рекомендуется использовать их в качестве ключей.

my_dict = {True: 'yes', 1: 'no', 1.0: 'maybe'}# {True: 'maybe'}d = {}# {}d = {'dict_key': 1, 'dictionary': 2}# {'dict_key': 1, 'dictionary': 2}d = dict(short='dict', long='dictionary')# {'short': 'dict', 'long': 'dictionary'}d = dict([(1, 1), (2, 4)])# {1: 1, 2: 4}d_str = dict((«ab», «bc»))# {«a»: «b», «b»: «c»}d = dict.fromkeys(['a', 'b'])# {'a': None, 'b': None}d = dict.fromkeys(['a', 'b'], 100)# {'a': 100, 'b': 100}key_list = ['marvel_hero', 'dc_hero']value_list = ['Spiderman', 'Flash']superhero_dict = dict(zip(key_list, value_list))print((superhero_dict))# {'marvel_hero': 'Spiderman', 'dc_hero': 'Flash'}

Генераторы словарей. Они имеют похожий на генераторы списков синтаксис, но возвращают словарь:

d = {a: a ** 2 for a in range(7)}# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

Подробнее про генераторы словарей можно прочитать тут

Но принцип довольно простой

# Явно{ key:value for item in list if conditional }# функцией dictdict((key, value) for item in list if condition)

Также генератор удобен, когда нужно инициализировать какой-то имеющийся список ключей:

list_of_keys = ['q', 'w', 'e', 'r', 't']generated_dict = {k: 0 for k in list_of_keys}print(generated_dict)# {'q': 0, 'w': 0, 'e': 0, 'r': 0, 't': 0}

Для получения значения конкретного ключа используются квадратные скобки [].
Предположим, что в нашем словаре есть пара 'марафон': 26.

dictionary = {'марафон': 26}# берём значение с ключом «марафон»dictionary['марафон']# 26

Опять же, вы получите ошибку, если попытаетесь получить значение по несуществующему ключу.
Для избежания подобных ошибок существует метод get.

Добавление новых пар в словарь происходит достаточно просто:

# Добавляем ключ «туфля» со значением «род обуви, закрывающей ногу не выше щиколотки»dictionary['туфля'] = 'род обуви, закрывающей ногу не выше щиколотки'

Обновление существующих значений происходит абсолютно также:

# Обновляем ключ «туфля» и присваиваем ему значение «хорошая туфля»dictionary['туфля'] = 'хорошая туфля'

Для удаления ключа и соответствующего значения из словаря можно использовать del

# Удаляем значение с ключом «противостоять» из словаряdel dictionary['противостоять']

Словари в Python имеют множество различных полезных методов, которые помогут вам в работе с ними. Вот лишь некоторые из них:

Метод clear позволяет очистить словарь:

london = {'name': 'London1', 'location': 'London Str'}london.clear()# {}

Метод copy позволяет создать полную копию словаря.

https://www.youtube.com/watch?v=7_Zrh1—d5o\u0026pp=ygUY0KHQu9C-0LLQsNGA0Lgg0LIgUHl0aG9u

Если указать, что один словарь равен другому:

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}london2 = londonid(london)# 25489072id(london2)# 25489072london['vendor'] = 'Juniper'london2['vendor']# 'Juniper'

В этом случае london2 это еще одно имя, которое ссылается на словарь. И
при изменениях словаря london меняется и словарь london2, так как это
ссылки на один и тот же объект.

Поэтому, если нужно сделать копию словаря, надо использовать метод
copy():

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}london2 = london.copy()id(london)# 25524512id(london2)# 25563296london['vendor'] = 'Juniper'london2['vendor']# 'Cisco'

dict.get(key, default) — возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).

# Допустим, у нас есть словарь story_countstory_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}

Метод get() возвращает значение по указанному ключу. Если указанного ключа не существует, метод вернёт None.

# Ключ «двенадцать» существует и метод get в данном случае вернёт 12story_count.get('двенадцать')# 12

Метод можно использовать для проверки наличия ключей в словаре:

story_count.get('два')# None

Также можно указать значение по умолчанию, которое будет возвращено вместо None, если ключа в словаре не окажется:

# Метод вернёт 0 в случае, если данного ключа не существуетstory_count.get('два', 0)

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

# Начальный словарьdictionary = {'персона': 'человек', 'марафон': 'гонка бегунов длиной около 26 миль', 'противостоять': 'оставаться сильным, несмотря на давление', 'бежать': 'двигаться со скоростью'}# Добавляем две пары в словарь dictionary, используя метод updatedictionary.update({'бежал': 'бежать в прошедшем времени', 'туфли': 'туфля во множественном числе'})print(dictionary)# {'марафон': 'гонка бегунов длиной около 26 миль',# 'персона': 'человек',# 'бежал': 'бежать в прошедшем времени',# 'бежать': 'двигаться со скоростью',# 'туфля': 'род обуви, закрывающей ногу не выше щиколотки',# 'туфли': 'туфля во множественном числе'}

Если вас интересует, почему данные в словаре расположены не в том порядке, в котором они были внесены в него, то это потому что словари не упорядочены.

Метод pop() удаляет ключ и возвращает соответствующее ему значение.

story_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}story_count.pop('девяносто')# >>> 90print(story_count)# >>> {'двенадцать': 12, 'сто': 100, 'пять': 5}

Метод setdefault ищет ключ, и если его нет, вместо ошибки создает
ключ со значением None.

london = {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco'}ios = london.setdefault('ios')print(ios)# Noneprint(london)# {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco', 'ios': None}

Если ключ есть, setdefault возвращает значение, которое ему
соответствует:

london.setdefault('name')# 'London1'

Второй аргумент позволяет указать, какое значение должно соответствовать
ключу:

In [26]: model = london.setdefault('model', 'Cisco3580') In [27]: print(model) Cisco3580 In [28]: london Out[28]: {'name': 'London1', 'location': 'London Str', 'vendor': 'Cisco', 'ios': None, 'model': 'Cisco3580'}

Метод setdefault заменяет такую конструкцию:

if key in london: value = london[key] else: london[key] = 'somevalue' value = london[key]

Метод keys() возвращает коллекцию ключей в словаре.

story_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}print(story_count.keys())# dict_keys(['сто', 'девяносто', 'двенадцать', 'пять'])

Метод values() возвращает коллекцию значений в словаре.

story_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}print(story_count.values())# dict_values([100, 90, 12, 5])

Метод items() возвращает пары «ключ — значение».

story_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}story_count.items()# dict_items([('сто', 100), ('девяносто', 90), ('двенадцать', 12), ('пять', 5)])

Вы можете провести итерацию по каждому ключу в словаре.

story_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}for key in story_count: print(key)# сто# девяносто# двенадцать# пять

Очевидно, вместо story_count можно использовать story_count.keys().

В примере кода ниже ниже цикл for использует метод items() для получения пары «ключ — значение» на каждую итерацию.

for key, value in story_count.items(): print(key, value)# сто 100# девяносто 90# двенадцать 12# пять

Сотритовка может производиться разными способами.
Пример сортировки с помощью генератора

people = {3: «Jim», 2: «Jack», 4: «Jane», 1: «Jill»}# Sort by keydict(sorted(people.items()))# {1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}# Sort by valuedict(sorted(people.items(), key=lambda item: item[1]))# {2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}

Если из большого словаря необходимо получить, только его чать. (например 10 самых частых элементов).
Можно использовать метод islice
из itertools

from itertools import islicestory_count = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5, 'семь': 7}nd = dict(islice(story_count.items(), 0, 3))# {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5, 'семь': 7}

islice

Для конвертации 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)# [['top_part', 'potion'], ['bot_part', 'bandage']]

Тот же результат в одну строчку

my_dict = {'сто': 100, 'девяносто': 90, 'двенадцать': 12, 'пять': 5}nl = [[k, v] for k, v in my_dict.items()]# [['сто', 100], ['девяносто', 90], ['двенадцать', 12], ['пять', 5]]Бинарное Дерево (TreeNode)

Python | Словари

Последнее обновление: 31.01.2022

Словарь (dictionary) в языке Python хранит коллекцию элементов, где каждый элемент имеет уникальный ключ и ассоциированое с ним некоторое значение.

Определение словаря имеет следующий синтаксис:

dictionary = { ключ1:значение1, ключ2:значение2, ….}

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

Определим словарь:

users = {1: «Tom», 2: «Bob», 3: «Bill»}

В словаре users в качестве ключей используются числа, а в качестве значений — строки. То есть элемент с ключом 1 имеет значение «Tom», элемент с ключом 2 — значение «Bob» и т.д.

Другой пример:

emails = {«tom@gmail.com»: «Tom», «bob@gmai.com»: «Bob», «sam@gmail.com»: «Sam»}

В словаре emails в качестве ключей используются строки — электронные адреса пользователей и в качестве значений тоже строки — имена пользователей.

Но необязательно ключи и строки должны быть однотипными. Они могу представлять разные типы:

objects = {1: «Tom», «2»: True, 3: 100.6}

Мы можем также вообще определить пустой словарь без элементов:

objects = {}

или так:

objects = dict()

Преобразование списков и кортежей в словарь

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

users_list = [
[«+111123455», «Tom»],
[«+384767557», «Bob»],
[«+958758767», «Alice»]
]
users_dict = dict(users_list)
print(users_dict) # {«+111123455»: «Tom», «+384767557»: «Bob», «+958758767»: «Alice»}

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

users_tuple = (
(«+111123455», «Tom»),
(«+384767557», «Bob»),
(«+958758767», «Alice»)
)
users_dict = dict(users_tuple)
print(users_dict)

Получение и изменение элементов

Для обращения к элементам словаря после его названия в квадратных скобках указывается ключ элемента:

dictionary[ключ]

Например, получим и изменим элементы в словаре:

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}

# получаем элемент с ключом «+11111111»
print(users[«+11111111»]) # Tom

# установка значения элемента с ключом «+33333333»
users[«+33333333»] = «Bob Smith»
print(users[«+33333333»]) # Bob Smith

Если при установки значения элемента с таким ключом в словаре не окажется, то произойдет его добавление:

users[«+4444444»] = «Sam»

Но если мы попробуем получить значение с ключом, которого нет в словаре, то Python сгенерирует ошибку KeyError:

user = users[«+4444444»] # KeyError

И чтобы предупредить эту ситуацию перед обращением к элементу мы можем проверять наличие ключа в словаре с помощью выражения ключ in словарь. Если ключ имеется в словаре, то данное выражение возвращает True:

key = «+4444444»
if key in users:
user = users[key]
print(user)
else:
print(«Элемент не найден»)

Также для получения элементов можно использовать метод get, который имеет две формы:

• get(key): возвращает из словаря элемент с ключом key. Если элемента с таким ключом нет, то возвращает значение None
• get(key, default): возвращает из словаря элемент с ключом key. Если элемента с таким ключом нет, то возвращает значение по умолчанию default

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}

user1 = users.get(«+55555555»)
print(user1) # Alice
user2 = users.get(«+33333333», «Unknown user»)
print(user2) # Bob
user3 = users.get(«+44444444», «Unknown user»)
print(user3) # Unknown user

Удаление

Для удаления элемента по ключу применяется оператор del:

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}

del users[«+55555555»]
print(users) # { «+11111111»: «Tom», «+33333333»: «Bob»}

Но стоит учитывать, что если подобного ключа не окажется в словаре, то будет выброшено исключение KeyError. Поэтому опять же перед удалением желательно проверять наличие элемента с данным ключом.

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}

key = «+55555555″
if key in users:
del users[key]
print(f»Элемент с ключом {key} удален»)
else:
print(«Элемент не найден»)

Другой способ удаления представляет метод pop(). Он имеет две формы:

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

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}
key = «+55555555»
user = users.pop(key)
print(user) # Alice

user = users.pop(«+4444444», «Unknown user»)
print(user) # Unknown user

Если необходимо удалить все элементы, то в этом случае можно воспользоваться методом clear():

users.clear()

Копирование и объединение словарей

Метод copy() копирует содержимое словаря, возвращая новый словарь:

users = {«+1111111»: «Tom», «+3333333»: «Bob», «+5555555»: «Alice»}
students = users.copy()
print(students) # {«+1111111»: «Tom», «+3333333»: «Bob», «+5555555»: «Alice»}

Метод update() объединяет два словаря:

users = {«+1111111»: «Tom», «+3333333»: «Bob»}

users2 = {«+2222222»: «Sam», «+6666666»: «Kate»}
users.update(users2)

print(users) # {«+1111111»: «Tom», «+3333333»: «Bob», «+2222222»: «Sam», «+6666666»: «Kate»}
print(users2) # {«+2222222»: «Sam», «+6666666»: «Kate»}

При этом словарь users2 остается без изменений. Изменяется только словарь users, в который добавляются элементы другого словаря. Но если необходимо, чтобы оба исходных словаря были без изменений, а результатом объединения был какой-то третий словарь, то можно предварительно скопировать один словарь в другой:

users3 = users.copy()
users3.update(users2)

Перебор словаря

Для перебора словаря можно воспользоваться циклом for:

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}
for key in users:
print(f»Phone: {key} User: {users[key]} «)

При переборе элементов мы получаем ключ текущего элемента и по нему можем получить сам элемент.

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

users = {
«+11111111»: «Tom»,
«+33333333»: «Bob»,
«+55555555»: «Alice»
}
for key, value in users.items():
print(f»Phone: {key} User: {value} «)

Метод items() возвращает набор кортежей. Каждый кортеж содержит ключ и значение элемента, которые при переборе мы тут же можем получить в переменные key и value.

Также существуют отдельно возможности перебора ключей и перебора значений. Для перебора ключей мы можем вызвать у словаря метод keys():

for key in users.keys():
print(key)

Правда, этот способ перебора не имеет смысла, так как и без вызова метода keys() мы можем перебрать ключи, как было показано выше.

Для перебора только значений мы можем вызвать у словаря метод values():

for value in users.values():
print(value)

Комплексные словари

Кроме простейших объектов типа чисел и строк словари также могут хранить и более сложные объекты — те же списки, кортежи или другие словари:

users = {
«Tom»: {
«phone»: «+971478745»,
«email»: «tom12@gmail.com»
},
«Bob»: {
«phone»: «+876390444»,
«email»: «bob@gmail.com»,
«skype»: «bob123»
}
}

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

Для обращения к элементам вложенного словаря соответственно необходимо использовать два ключа:

old_email = users[«Tom»][«email»]
users[«Tom»][«email»] = «supertom@gmail.com»
print(users[«Tom»]) # { phone»: «+971478745», «email»: «supertom@gmail.com }

Но если мы попробуем получить значение по ключу, который отсутствует в словаре, Python сгенерирует исключение KeyError:

tom_skype = users[«Tom»][«skype»] # KeyError

Чтобы избежать ошибки, можно проверять наличие ключа в словаре:

key = «skype»
if key in users[«Tom»]:
print(users[«Tom»][«skype»])
else:
print(«skype is not found»)

Во всем остальном работа с комплексными и вложенными словарями аналогична работе с обычными словарями.

Словари в 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) #Выведет {'car': 'машина', 'apple': 'яблоко'}
print(dict2) #Выведет {'car': 'машина', 'apple': 'яблоко'}

Изменение словаря

Добавим в наш словарь объект. Для этого нам нужно придумать значение ключу. Рассмотрим на примере:

dict = {
'car': ‘машина’,
'apple': 'яблоко'
}
dict['orange'] = 'апельсин' #В квадратных скобках указываем имя ключа, а значение после знака равно
print(dict) #Выведет {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}

Для удаления ключа и его объекта в словаре используют метод del, указывая имя ключа в квадратных скобках:

dict = {
'car': 'машина',
'apple': 'яблоко',
'orange': 'апельсин'
}
del dict['orange']
print(dict) #Выведет {'car': 'машина', 'apple': 'яблоко'}

Перебор элементов словарей в 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) #Выведет {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}

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) #Выведет {'apple': 'яблоко', 'orange': 'апельсин'}

popitem() – удаляет и возвращает имя и значение ключа. Пример:

dict = {
'car': 'машина',
'apple': 'яблоко',
'orange': 'апельсин'
}
print(dict.pop()) #Выведет ('orange', 'апельсин')
print(dict) #Выведет {'car': 'машина', 'apple': 'яблоко'}

setdefault() – получение значения по ключу, если такой ключ присутствует в словаре. Когда такого ключа нет, он создается со значением None (если оно не указано в свойствах). Рассмотрим на примере:

dict = {
'car': 'машина',
'apple': 'яблоко',
'orange': 'апельсин'
}
print(dict.setdefault(‘car’) #Выведет 'машина'
print(dict.setdefault('home', 'дом') #Выведет 'дом'
print(dict) #Выведет {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин', 'home': 'дом'}

update({}) – обновить значения по ключам, добавление новых ключей:

dict = {
'car': 'машина',
'apple': 'яблоко',
'orange': 'апельсин'
}
dict.update({'car': 'автомобиль', 'home': 'дом'})
print(dict) #Выведет {'car': 'автомобиль', 'apple': 'яблоко', 'orange': 'апельсин', 'home': 'дом'}

Итог

Мы изучили словари в Python и методы работы с ними. Надеюсь, статья была полезной для вас. Удачи!

Словари в Python 3 — основные методы и функции

В Python есть много встроенных структур данных, используемых для хранения разных типов информации. Словарь (dict) — одна из таких структур, которая хранит данные в формате пар ключ-значение. Получить доступ к значениям словаря Python можно с помощью ключей. Этот материал посвящен подробному обсуждению словаря.

Создание словаря

Для создания словаря в Python необходимо передать последовательность элементов внутри фигурных скобок {}, разделив их запятыми (,). Каждый элемент имеет ключ и значение, выраженное парой «ключ: значение».

• Значения могут быть представлять собой любые типы данных и повторяться, но ключи обязаны быть уникальными.
• Следующие примеры показывают, как создавать словари Python:
• Создание пустого словаря:

dict_sample = {}

Cловарь, где ключи являются целыми числами:

dict_sample = {1: 'mango', 2: 'pawpaw'}

Создание словаря с ключами разных типов:

dict_sample = {'fruit': 'mango', 1: [4, 6, 8]}

Можно также создать словарь, явно вызвав метод dict():

dict_sample = dict({1:'mango', 2:'pawpaw'})

Словарь можно создать с помощью последовательности, как в примере внизу:

dict_sample = dict([(1,'mango'), (2,'pawpaw')])

Словари могут быть вложенными. Это значит, что можно создавать словари внутри существующего словаря. Например:

dict_sample = {
1: {'student1': 'Nicholas', 'student2': 'John', 'student3': 'Mercy'}, 2: {'course1': 'Computer Science', 'course2': 'Mathematics', 'course3': 'Accounting'}
}

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

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio', 'year': 2012}

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

Чтобы получить доступ к элементам словаря, нужно передать ключ в квадратных скобках []. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample[«model»] print(x)

Вывод:

Premio

Был создан словарь dict_sample. Затем была создана переменная x. Ее значение — это значение ключа [«model»] из словаря.

https://www.youtube.com/watch?v=7_Zrh1—d5o\u0026pp=YAHIAQE%3D

Вот другой пример:

dict = {'Name': 'Mercy', 'Age': 23, 'Course': 'Accounting'} print(«Student Name:», dict['Name']) print(«Course:», dict['Course']) print(«Age:», dict['Age'])

Вывод:

Student Name: Mercy
Course: Accounting
Age: 23

Объект словаря также имеет функцию get(), которой можно пользоваться для доступа к элементам словаря. Ее нужно добавлять к словаря через точку и затем передавать название ключа как аргумент функции. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample.get(«model»)
print(x)

Вывод:

Premio

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

Добавление элементов

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

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } dict_sample[«Capacity»] = «1800CC» print(dict_sample)

Вывод:

{'Capacity': '1800CC', 'year': 2012, 'Company': 'Toyota', 'model': 'Premio'}

У нового элемента ключ «Capacity» и значение — «180CC». Он был добавлен в качестве первого элемента словаря.

https://www.youtube.com/watch?v=7_Zrh1—d5o\u0026pp=YAHIAQE%3D

Вот другой пример. Для начала нужно создать пустой словарь:

MyDictionary = {} print(«An Empty Dictionary: «) print(MyDictionary)

Вывод:

An Empty Dictionary:

Словарь ничего не возвращает, потому что в нем ничего не хранится. Добавим в нему элементы, один за одним:

MyDictionary[0] = 'Apples' MyDictionary[2] = 'Mangoes' MyDictionary[3] = 20 print(»
3 elements have been added: «) print(MyDictionary)

Вывод:

3 elements have been added: {0: 'Apples', 2: 'Mangoes', 3: 20}

Для добавления элементов были отдельно указаны ключи и соответствующие значения. Например:

MyDictionary[0] = 'Apples'

В этом примере 0 является ключом, а «Apples» — значение.

Можно даже добавить несколько значений для одного ключа. Например:

MyDictionary['Values'] = 1, «Pairs», 4 print(»
3 elements have been added: «) print(MyDictionary)

Вывод:

3 elements have been added: {'Values': (1, 'Pairs', 4)}

В этом примере название ключа — «Value», а все что после знака = — его значения в формате множества (Set).

Помимо добавления новых элементов в словарь, их можно обновлять или изменять. Об этом в следующем разделе.

Обновление элементов

После добавления значения в словарь существующий элемент словаря можно изменить. Для изменения значения используется соответствующий ключ. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } dict_sample[«year»] = 2014 print(dict_sample)

Вывод:

{'year': 2014, 'model': 'Premio', 'Company': 'Toyota'}

В этом примере видно, что было обновлено значение ключа «year» с 2012 на 2014.

Удаление элементов

Удалить элемент из словаря можно несколькими способами. В этом разделе они будут рассмотрены по одному:

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

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 }
del dict_sample[«year»] print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio'}

Вызывается ключевое слово del, а следом за ним — название словаря. В квадратных скобках следом за словарем идет ключ элемента, который требуется удалить. В этом примере это «year». Запись «year» удаляется из словаря.

Другой способ удалить пару ключ-значение — функция pop() с ключом записи в виде аргумента. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } dict_sample.pop(«year») print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio'}

Функция pop() была вызвана добавлением ее к названию словаря. В этом случае будет удалена запись с ключом «year».

Функция popitem() удаляет последний элемент в словаре. Для нее не нужно указывать конкретный ключ. Примеры:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } dict_sample.popitem() print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio'}

Последней записью в словаре была «year». Она пропала из словаря после вызова функции popitem().

Что делать, если нужно удалить целый словарь? Это будет сложно и займет много времени, если пользоваться этими методами к каждому ключу. Вместо этого можно использовать ключевое слово del для целого словаря. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } del dict_sample print(dict_sample)

Вывод:

NameError: name 'dict_sample' is not defined

Код вернет ошибку, потому что функция print() пытается получить доступ к словарю, который уже не существует.

https://www.youtube.com/watch?v=j6YmTeD31VQ\u0026pp=ygUY0KHQu9C-0LLQsNGA0Lgg0LIgUHl0aG9u

В определенных случаях может потребоваться удалить все элементы словаря, оставив его пустым. Этого можно добиться, воспользовавшись функцией clear():

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } dict_sample.clear() print(dict_sample)

Вывод:

{}

Код вернет пустой словарь, поскольку все его элементы уже удалены.

Другие распространенные методы словарей

Метод len()

С помощью этого метода можно посчитать количество элементов в словаре. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } print(len(dict_sample))

Вывод:

3

В этом словаре три записи, поэтому метод вернет 3.

Метод copy()

Этот метод возвращает копию существующего словаря. Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample.copy() print(x)

Вывод:

{'Company': 'Toyota', 'year': 2012, 'model': 'Premio'}

Была создана копия словаря dict_sample. Она присвоена переменной x. Если вывести x в консоль, то в ней будут те же элементы, что и в словаре dict_sample.

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

Метод items()

Этот метод возвращает итерируемый объект. Такой объект содержит пары ключ-значение для словаря по аналогии с кортежами в списке. Метод используется, когда нужно перебрать значения словаря.

Этот метод нужно вызывать вместе со словарем, как в примере ниже:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } for k, v in dict_sample.items(): print(k, v)

Вывод:

('Company', 'Toyota')
('model', 'Premio')
('year', 2012)

Объект, который возвращает items(), можно использовать, чтобы показать изменения в словаре. Вот как это работает.

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample.items() print(x) dict_sample[«model»] = «Mark X» print(x)

Вывод:

dict_items([('Company', 'Toyota'), ('model', 'Premio'), ('year', 2012)])
dict_items([('Company', 'Toyota'), ('model', 'Mark X'), ('year', 2012)])

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

Метод fromkeys()

Этот метод возвращает словарь с указанными ключами и значениями. У него следующий синтаксис:

dictionary.fromkeys(keys, value)

Значение требуемого параметра keys — итерируемые объекты. Оно отвечает за ключи нового словаря. Значение для параметра value указывать необязательно. Оно отвечает за значение по умолчанию для всех ключей. По умолчанию — None.

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

name = ('John', 'Nicholas', 'Mercy') age = 25 dict_sample = dict.fromkeys(name, age) print(dict_sample)

Вывод:

{'John': 25, 'Mercy': 25, 'Nicholas': 25}

В коде вверху определены ключи и одно значение. Метод fromkeys() перебирает ключи и объединяет их со значением для создания заполненного словаря.

Значение для параметра keys является обязательным. В следующем примере показано, что происходит, если параметр values не определен:

name = ('John', 'Nicholas', 'Mercy') dict_sample = dict.fromkeys(name) print(dict_sample)

Вывод:

{'John': None, 'Mercy': None, 'Nicholas': None}

Используется значение по умолчанию, None.

Метод setdefault()

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

У метода следующий синтаксис:

dictionary.setdefault(keyname, value)

В этой функции параметр keyname является обязательным. Он обозначает название ключа, значение которого нужно вернуть. Параметр value необязательный. Если в словаре уже есть ключ, параметр не будет иметь никакого эффекта. Если ключ не существует, тогда значение функции станет значением ключа. Значение по умолчанию — None.

Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample.setdefault(«color», «Gray») print(x)

Вывод:

Gray

В словаре нет ключа color. Метод setdefault() вставляет этот ключ вместе со значением «Gray».

Следующий пример показывает, как работает метод, если такой ключ уже есть:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample.setdefault(«model», «Allion») print(x)

Вывод:

Premio

Значение «Allion» не повлияло на словарь, потому что у ключа уже есть значение.

Метод keys()

Этот метод также возвращает итерируемый объект. Он является списком всех ключей в словаре. Как и метод items(), этот отображает изменения в самом словаре.

Для использования метода нужно всего лишь использовать его с именем словаря, как показано ниже:

dictionary.keys()

Например:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } x = dict_sample.keys() print(x)

Вывод:

dict_keys(['model', 'Company', 'year'])

Часто этот метод используется, чтобы перебрать все ключи в словаре:

dict_sample = { «Company»: «Toyota», «model»: «Premio», «year»: 2012 } for k in dict_sample.keys(): print(k)

Вывод:

Company
model
year

Выводы

Это все, что нужно знать о словарях Python. Они хранят информацию в парах «ключ: значение». «Ключ» выступает идентификатором объекта, а «значение» — это определенные данные.

В Python много функций, которые могут быть использовать для извлечения и обработки данных.

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