Python как изменить элемент словаря

Словарь в Python — изменяемый или мутабельный. Но для добавления новой пары «ключ-значение» не нужны отдельные методы, вроде спискового метода .append — достаточно обычного присваивания:

d = {}  # пустой словарь
d["a"] = 100
print(d)  # => {'a': 100}
d["b"] = 200
d["a"] = 0
print(d)  # => {'a': 0, 'b': 200}

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

Метод pop

Удаление элементов из словаря можно сделать с помощью метода pop — в этом словарь уже больше похож на список. Только вместо индекса используется ключ:

d = {'a': 1, 'b': 2}
d.pop('a')  # 1
d  # {'b': 2}
d.pop('BANG')  # KeyError: 'BANG'

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

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

d = {'a': 1, 'b': 2}
d.pop('BANG', None)
d.pop('BANG', 42)  # 42

Аналогом спискового pop без аргументов для словаря служит метод popitem. Этот метод извлекает ключ и значение в виде кортежа, а если словарь уже пуст, то возбуждает исключение:

d = {'a': 1}
d.popitem()  # ('a', 1)
d.popitem()  # KeyError: 'popitem(): dictionary is empty'

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

• Все пары будут извлечены
• Каждая пара будет извлечена строго один раз

Дополнение одного словаря другим

У списка есть метод extend, который расширяет один список другим. У словаря есть похожий по смыслу метод update. Но при вызове update ассоциированный объект словаря не просто получает пары «ключ-значение» из нового словаря. Происходит именно обновление данных — поэтому метод и называется update. Работает это так:

• Новые ключи дописываются в словарь
• Если какие-то ключи уже существовали до этого, то связанные с ними значения, будут заменены новыми

Так это выглядит в коде:

cart = {'apples': 2, 'oranges': 1}
addon = {'oranges': 5, 'lemons': 3}
cart.update(addon)
cart  # {'apples': 2, 'oranges': 5, 'lemons': 3}

В коде выше мы добавили лимоны и обновили количество апельсинов.

Копирование словаря

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

• Новый список из двух списков
• Копию одного списка, которую можно дополнить данными из второго

Но словари нельзя складывать, да и срезы словари тоже не поддерживают. Зато у словаря есть метод copy. Он работает как копирование списка с помощью среза [:] — при вызове он возвращает поверхностную копию из словаря. Так же ее называют «неглубокой копией» или shallow copy.

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

d = {'a': 1, 'b': [42]}
c = d.copy()
c.update({'a': 10, '1k': 1024})
c  # {'a': 10, 'b': [42], '1k': 1024}
c['b'].append(None)
c  # {'a': 10, 'b': [42, None], '1k': 1024}
d  # {'a': 1, 'b': [42, None]}

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

Очистка словаря

Списки можно очистить с помощью присваивания срезу l[:] = []. В случае словаря вместо присваивания срезу используется метод clear.

Метод clear() удаляет все элементы из текущего словаря:

d = {'a': 1}

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

Что такое словарь

Словари (dict) хранят в себе ключи и их объекты, где ключ – это имя объекта в словаре. Их могут называть ассоциативными массивами или хеш-таблицами.

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

Для каких целей нам будут полезны словари? 

• Подсчет каких-то предметов, где ключи – названия предметов, а объект – их количество.

• Для экономии памяти, если есть массив, который использует не все индексы по порядку.

• Установка соответствий между объектами, сортировка.

• Хранение данных разных объектов (например: ключ – ID пользователя ВКонтакте, а объект – массив с данными).

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

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

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

#Создание через функцию:
dict1 = dict()
#Создание через фигурные скобки:
dict2 = {}

print(type(dict1)) #Выведет <class 'dict'>
print(type(dict2)) #Выведет <class 'dict'>
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 и методы работы с ними. Надеюсь, статья была полезной для вас. Удачи!

Словари

Последнее обновление: 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, необходимо прописать элементы внутри фигурных скобок {} и разделить их запятыми.

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

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

# пустой словарь
my_dict = {}

# словарь с ключами — целочисленными значениями
my_dict = {1: 'яблоко', 2: 'мяч'}

# словарь с ключами разных типов
my_dict = {'имя': 'Джон', 1: [2, 4, 3]}

# используем dict()
my_dict = dict({1:'яблоко', 2:'мяч'})

# словарь из последовательности, где элементы являются парами
my_dict = dict([(1,'яблоко'), (2,'мяч')])

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

Как получить элементы из словаря

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

При использовании квадратных скобок и отсутствии элемента в словаре вызывается ошибка KeyError. При использовании метода get() и отсутствии элемента возвращается None.

# get vs. [] для получения элементов
my_dict = {'Имя': 'Ваня', 'Возраст': 26}

# Вывод: Jack
print(my_dict['Имя'])

# Вывод: 26
print(my_dict.get('Возраст'))

# Попытка получить ключ, которого не существует, приводит к ошибке
# Вывод: None
print(my_dict.get('Адрес'))

# KeyError
print(my_dict['Адрес'])

Вывод:

Ваня
26
None
Traceback (most recent call last):
  File "<string>", line 15, in <module>
    print(my_dict['Адрес'])
KeyError: 'Адрес'

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

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

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

# Изменение словаря
my_dict = {'Имя': 'Ваня', 'Возраст': 26}

# обновляем значение
my_dict['Возраст'] = 27

# Вывод: {'Возраст': 27, 'Имя': 'Ваня'}
print(my_dict)

# добавляем элемент
my_dict['Адрес'] = 'Центр города'

# Вывод: {'Адрес': 'Центр города', 'Возраст': 27, 'Имя': 'Ваня'}
print(my_dict)

Вывод:

{'Возраст': 27, 'Имя': 'Ваня'}
{'Адрес': 'Центр города', 'Возраст': 27, 'Имя': 'Ваня'}

Как удалить элементы из словаря

Удалить нужный элемент словаря по ключу можно с помощью метода pop(). Этот метод удаляет элемент с соответствующим ключом и возвращает значение.

Удалить произвольную пару (ключ, значение) можно с помощью метода popitem(). Очистить весь словарь за один раз можно с помощью метода clear().

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

# создаем словарь
squares = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# удаляет определенный элемент, возвращает его значение
# Вывод: 16
print(squares.pop(4))

# Вывод: {1: 1, 2: 4, 3: 9, 5: 25}
print(squares)

# удаляет произвольный элемент, возвращает (ключ, эзначение)
# Вывод: (5, 25)
print(squares.popitem())

# Вывод: {1: 1, 2: 4, 3: 9}
print(squares)

# удаляет все элементы
squares.clear()

# Вывод: {}
print(squares)

# удаляет весь словарь
del squares

# выдает ошибку
print(squares)

Вывод:

16
{1: 1, 2: 4, 3: 9, 5: 25}
(5, 25)
{1: 1, 2: 4, 3: 9}
{}
Traceback (most recent call last):
  File "<string>", line 30, in <module>
    print(squares)
NameError: name 'squares' is not defined

Методы словарей

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

marks = {}.fromkeys(['математика', 'русский язык', 'физика'], 0)

# Вывод: {'русский язык': 0, 'математика': 0, 'физика': 0}
print(marks)

for item in marks.items():
    print(item)

# Вывод: ['русский язык', 'математика', 'физика']
print(list(sorted(marks.keys())))

Вывод:

{'математика': 0, 'русский язык': 0, 'физика': 0}
('математика', 0)
('русский язык', 0)
('физика', 0)
['русский язык', 'математика', 'физика']

Представление словарей

Представление словарей — элегантный и лаконичный способ создать новый словарь из итерируемого объекта.

Представление словарей состоит из выражения ключ: значение, за которым следует for, и всё это — внутри фигурных скобок {}.

Создадим словарь с парами чисел и их квадратов в качестве элементов:

squares = {x: x*x for x in range(6)}
print(squares)

Вывод:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

То же самое можно сделать иначе, но так будет длинее:

squares = {}
for x in range(6):
    squares[x] = x*x
print(squares)

Вывод:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

В представлении словарей выражений for и if опционально может быть больше.

Необязательное выражение if поможет отфильтровать элементы для создания нового словаря.

Давайте создадим словарь только с квадратами только нечетных чисел:

# Представление словарей с опциональным if
odd_squares = {x: x*x for x in range(11) if x % 2 == 1}
print(odd_squares)

Вывод:

{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

Другие операции со словарями

Проверка на вхождение в словарь

Проверить, есть ли ключ в словаре, можно с помощью ключевого слова in. Отметим, что проверку на вхождение можно провести только над ключами, не над значениями

squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# Вывод: True
print(1 in squares)

# Вывод: True
print(2 not in squares)

# Проверка на вхождение позволяет проверять только ключи, не значения
# Вывод: False
print(49 in squares)

Вывод:

True
True
False

Итерирование по словарю

Мы можем пройтись по всем ключам словаря, используя цикл for.

squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
for i in squares:
    print(squares[i])

Вывод:

1
9
25
49
81

Встроенные функции для словарей

Встроенные функции all(), any(), len(), cmp(), sorted() и т. д. часто используются со словарями для разных задач.

# Встроенные функции для словарей
squares = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# Вывод: False
print(all(squares))

# Вывод: True
print(any(squares))

# Вывод: 6
print(len(squares))

# Вывод: [0, 1, 3, 5, 7, 9]
print(sorted(squares))

Вывод:

False
True
6
[0, 1, 3, 5, 7, 9]

В 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"] из словаря.

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

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". Он был добавлен в качестве первого элемента словаря.

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

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

Вывод:

An Empty Dictionary:

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

MyDictionary[0] = 'Apples' 
MyDictionary[2] = 'Mangoes' 
MyDictionary[3] = 20 
print("n3 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("n3 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() пытается получить доступ к словарю, который уже не существует.

В определенных случаях может потребоваться удалить все элементы словаря, оставив его пустым. Этого можно добиться, воспользовавшись функцией 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 много функций, которые могут быть использовать для извлечения и обработки данных. В этой статье были рассмотрены способы создания, изменения и удаления словаря, а также самые распространенные методы для работы с этим типом данных.