Python словарь: Python | Словари
Python 3: словарь — изменяемый тип данных
На этом занятии
мы познакомимся с еще одной коллекцией данных в Python – словарем. В
отличие от списков
Словарь – это
неупорядоченная коллекция произвольных данных с доступом по ключу.
Это подобно
ассоциативному массиву, когда данные представляются в виде пар
ключ => значение
Например, в
качестве ключа могут выступать обычные уникальные числа:
0, 1, 2, …
В этом случае
ключи напоминают индексы элементов упорядоченного списка:
A = ["дом", "машина", "дерево", "дорога", "река"]
Но в списке изменить эти индексы мы не можем – они создаются списком автоматически. А, что если мы
хотим ассоциировать эти слова со словами английского языка:
Как раз здесь
нам на помощь и приходит словарь. То есть, мы вместо ключей 0, 1, 2,… создадим
другие – в виде английских слов.
Для создания
словаря используется следующий синтаксис:
{key1:
value1, key2: value2, …, keyN:valueN}
И для нашего
случая, имеем:
d = {"house": "дом", "car": "машина",
"tree": "дерево", "road": "дорога",
"river":"река"}Как видите, мы
можем определять словарь в несколько строчек. Не обязательно все писать в одну
строку.
Теперь, мы можем
по ключу получать значение этого словаря по такому же синтаксису, что и для
списков:
Получим значение
«дом». Если же указать не существующий ключ:
то получим
ошибку. Разумеется, ключи в словарях всегда уникальны. Если записать два
одинаковых:
d = {"house": "дом", "house": "дом 2", "car": "машина"}то ключ «house» будет
ассоциирован с последним указанным значением – «дом 2».
Словарь еще
можно определить с помощью функции-конструктора dict:
d2 = dict(house = "дом", car = "машина", tree = "дерево", road = "дорога", river = "река")
Здесь ключи
записываются уже без кавычек и после них ставится знак равно вместо двоеточий.
В результате, получаем точно такой же словарь. И такой способ задания работает
только, если в качестве ключей выступают строки. Например, с числами такой
подход работать не будет:
d2 = dict(1 = "дом", 2 = "машина")
Тогда зачем
нужен такой способ: первый записывался короче и обладает большей гибкостью? Дело
в том, что часто в программах приходится создавать словари на основе ранее
сформированных данных, в частности, списков. Допустим, у нас имеется вот такой
список:
lst = [[2, "неудовлетворительно"], [3, "удовлетворительно"], [4, "хорошо"], [5, "отлично"]]
Здесь у нас
перечислены вложенные списки с двумя элементами: ключ, значение. Этот список
можно преобразовать в словарь как раз с помощью функции dict:
У объекта dict есть один
интересный метод:
dict.fromkeys(список[,
значение по умолчанию])
который
формирует словарь где ключами будут элементы списка. Например:
a = dict.fromkeys(["+7", "+6", "+5", "+4"])
Получим
следующее:
{‘+7’: None, ‘+6’: None, ‘+5’: None, ‘+4’: None}
все значения
ключей равны None. Чтобы указать
другое значение, используется второй необязательный аргумент:
a = dict.fromkeys(["+7", "+6", "+5", "+4"], "код страны")
получим словарь:
{‘+7’: ‘код
страны’, ‘+6’: ‘код страны’, ‘+5’: ‘код страны’, ‘+4’: ‘код страны’}
Далее, если
нужно создать пустой словарь, то это проще всего сделать так:
или же так:
Во всех наших
примерах в качестве ключей словаря выступало либо число, либо строка. Какие
типы данных еще можно указывать? На самом деле любые неизменяемые типы.
Обратите внимание, именно неизменяемые! Например, можно написать так:
d[True] = "Истина" d[False] = "Ложь"
Здесь ключи –
булевые значения. В результате, получим словарь:
{True: ‘Истина’, False: ‘Ложь’}
И этот пример показывает,
что присваивая словарю значение с новым ключом, оно автоматически добавляется в
словарь. В результате, наш изначально пустой словарь стал содержать две записи.
Если же мы существующему ключу присваиваем другое значение:
то он просто
поменяет свое значение в словаре. Вот так можно добавлять и менять значения
словаря. То есть, словарь относится к изменяемым типам.
Далее, если мы укажем
в качестве ключа список:
то возникнет
ошибка, т.к. список – это изменяемый объект. И чаще всего в качестве ключей
используются строки или числа.
На значения
словаря никаких ограничений не накладывается – там могут быть произвольные
данные:
d = {True: 1, False: "Ложь", "list": [1,2,3], 5: 5}Для удаления
ключа можно воспользоваться оператором del:
Теперь записи с
ключом True в словаре не
будет. Однако, если при удалении будет указан несуществующий ключ:
то возникнет
ошибка. Поэтому перед удалением, можно проверить: существует ли данный ключ в
словаре:
Оператор in возвращает True, если ключ
присутствует и False, если отсутствует. Или же, можно делать
противоположную проверку на отсутствие ключа:
Далее, как и для
любой коллекции, мы можем определить длину (число записей) в словаре с помощью
функции len:
А также
перебрать его значения с помощью цикла for:
d = {True: 1, False: "Ложь", "list": [1,2,3], 5: 5}
for x in d:
print(x)И мы видим, что
переменная x ссылается на
значения ключей. Но, зная ключи, мы можем получить ассоциированное с ним
значение:
Это основные моменты работы со словарем. На следующем занятии мы рассмотрим базовые методы для словарей.
Словари в Python
Назад в начало
Словарь — неупорядоченная структура данных, которая позволяет хранить пары «ключ — значение».
# Создание словаря c помощью литерала
student = {‘name’: ‘Ivan’, ‘age’: 12}
credentials = {’email’: ‘[email protected]’, ‘password’: ‘123456’}
# Создание словаря c помощью функции dict()
student = dict(name=’Ivan’, age=12)
credentials = dict(email=’[email protected]’, password=’123456′)
Для получения значения конкретного ключа используются квадратные скобки [].
# Получаем значение с ключом ‘name’
student = dict(name=’Ivan’, age=12)
print(student[‘name’]) # -> Ivan
Обновление существующих значений происходит абсолютно также.
# Получаем значение с ключом ‘name’
student = dict(name=’Ivan’, age=12)
student[‘name’] = ‘Vasya’
print(student[‘name’]) # -> Vasya
Для удаления ключа и соответствующего значения из словаря можно использовать del
# Удаление ключа ‘age’
student = dict(name=’Ivan’, age=12)
del student[‘age’]
print(student) # -> {‘name’: ‘Ivan’}
Метод get() возвращает значение по указанному ключу. Если указанного ключа не существует, метод вернёт None. Также можно указать значение по умолчанию, которое будет возвращено вместо None, если ключа в словаре не окажется.
# Использование метода get()
student = dict(name=’Ivan’, age=12)
print(student.get(‘name’)) # -> Ivan
print(student.get(‘lastname’)) # -> None
print(student.get(‘lastname’, ‘No key’)) # -> No key
Метод pop() удаляет ключ и возвращает соответствующее ему значение.
# Использование метода pop()
sneakers = dict(brand=’Adidas’, price=’9990 RUB’, model=’Nite Jogger’)
model = sneakers.pop(‘model’)
print(sneakers) # -> {‘brand’: ‘Adidas’, ‘price’: ‘9990 RUB’}
print(model) # -> Nite Jogger
Метод keys() возвращает специальную коллекцию ключей в словаре.
# Использование метода keys()
sneakers = dict(brand=’Adidas’, price=’9990 RUB’, model=’Nite Jogger’)
print(sneakers.keys()) # -> dict_keys([‘brand’, ‘price’, ‘model’])
# dict_keys — это неизменяемая коллекция элементов.
keys = list(sneakers.keys())
print(keys) # -> [‘brand’, ‘price’, ‘model’]
Метод values() возвращает специальную коллекцию значений в словаре.
# Использование метода values()
sneakers = dict(brand=’Adidas’, price=’9990 RUB’, model=’Nite Jogger’)
print(sneakers.values()) # -> dict_values([‘Adidas’, ‘9990 RUB’, ‘Nite Jogger’])
# dict_values — это неизменяемая коллекция элементов.
values = list(sneakers.values())
print(values) # -> [‘Adidas’, ‘9990 RUB’, ‘Nite Jogger’]
Метод items() возвращает пары «ключ — значение» в формате кортежей.
# Использование метода items()
sneakers = dict(brand=’Adidas’, price=’9990 RUB’, model=’Nite Jogger’)
print(sneakers.items()) # -> dict_items([(‘brand’, ‘Adidas’), (‘price’, ‘9990 RUB’), (‘model’, ‘Nite Jogger’)])
# dict_items — это неизменяемая коллекция элементов.
items = list(sneakers.items())
print(items) # -> [(‘brand’, ‘Adidas’), (‘price’, ‘9990 RUB’), (‘model’, ‘Nite Jogger’)]
sneakers = dict(brand=’Adidas’, price=’9990 RUB’, model=’Nite Jogger’)
# Вывод ключей словаря с помощью цикла for
for key in sneakers:
print(key)
# -> brand
# -> price
# -> model
# Вывод значений словаря с помощью цикла for
for value in sneakers.values():
print(value)
# -> Adidas
# -> 9990 RUB
# -> Nite Jogger
# Вывод ключей и значений словаря с помощью цикла for
for key, value in sneakers.items():
print(key, value)
# -> brand Adidas
# -> price 9990 RUB
# -> model Nite Jogger
Метод setdefault() возвращает значение ключа, но если его нет, создает ключ с указанным значением (по умолчанию None).
# Метод setdefault()
student = dict(name=’Ivan’, age=12)
student.setdefault(‘lastname’, ‘Ivanov’)
print(student) # -> {‘name’: ‘Ivan’, ‘age’: 12, ‘lastname’: ‘Ivanov’}
1. Пользователь
# Пользователь вводит имя, фамилия, возраст. Создайте словарь user и запишите данные пользователя в него.
firstname = input(‘Enter your firstname: ‘)
lastname = input(‘Enter your lastname: ‘)
age = input(‘Enter your age: ‘)
user = dict(firstname=firstname, lastname=lastname, age=age)
print(user)
2. Найти слово
# Выведите самое часто встречающееся слово в введенной строке.
list_of_words = [‘hello’, ‘hello’, ‘hi’]
words = {}
for word in list_of_words:
words[word] = words.get(word, 0) + 1
# Функция max может получать функцию в качестве второго аргумента
freq_word = max(words, key=words.get)
print(freq_word)
1. Фрукты
Пользователь вводит число K — количество фруктов. Затем он вводит K фруктов в формате: название фрукта и его количество. Добавьте все фрукты в словарь, где название фрукта — это ключ, а количество — значение. Например:
# Ввод:
>> 3 # Количество фруктов
>> Яблоко
>> 3
>> Апельсин
>> 3
>> Мандарин
>> 10
# Вывод:
>> {‘Яблоко’: 3, ‘Апельсин’: 3, ‘Мандарин’: 10}
2. Старший и младший
Пользователь вводит число N. Затем он вводит личные данные (имя и возраст) своих N друзей. Создайте список friends и добавьте в него N словарей с ключами name и age. Найдите самого младшего из друзей и выведите его имя.
# Ввод:
>> 3 # Количество друзей
>> Иван
>> 11
>> Саша
>> 12
>> Леша
>> 10
# Вывод:
>> Леша
3. Еще немного о друзьях
Пользователь вводит число N. Затем он
Словари. Урок 21 курса «Python. Введение в программирование»
В языке программирования Python словари (тип dict) представляют собой еще одну разновидность структур данных наряду со списками и кортежами. Словарь — это изменяемый (как список) неупорядоченный (в отличие от строк, списков и кортежей) набор элементов «ключ:значение».
«Неупорядоченный» – значит, что последовательность расположения пар не важна. Язык программирования ее не учитывает, в следствие чего обращение к элементам по индексам невозможно.
В других языках структуры, схожие со словарями, называются по-другому. Например, в Java подобный тип данных называется отображением.
Чтобы представление о словаре стало более понятным, проведем аналогию с обычным словарем, например, англо-русским. На каждое английское слово в таком словаре есть русское слово-перевод: cat – кошка, dog – собака, table – стол и т. д. Если англо-русский словарь описать с помощью Python, то английские слова можно сделать ключами, а русские – их значениями:
{'cat': 'кошка', 'dog': 'собака', 'bird': 'птица', 'mouse': 'мышь'}Обратите внимание на фигурные скобки, именно с их помощью определяется словарь. Синтаксис словаря на Питоне описывается такой схемой:
Часто при выводе словаря последовательность пар «ключ:значение» не совпадает с тем, как было введено:
>>> a = {'cat': 'кошка', 'dog': 'собака', 'bird': 'птица', 'mouse': 'мышь'}
>>> a
{'dog': 'собака', 'cat': 'кошка', 'bird': 'птица', 'mouse': 'мышь'}Поскольку в словаре не важен порядок пар, то интерпретатор выводит их так, как ему удобно. Тогда как получить доступ к определенному элементу, если индексация не возможна в принципе? В словаре доступ к значениям осуществляется по ключам, которые заключаются в квадратные скобки (по аналогии с индексами списков):
>>> a['cat'] 'кошка' >>> a['bird'] 'птица'
Словари, как и списки, являются изменяемым типом данных: позволительно изменять, добавлять и удалять элементы (пары «ключ:значение»). Изначально словарь можно создать пустым (например, d = {}) и потом заполнить его элементами. Добавление и изменение имеет одинаковый синтаксис: словарь[ключ] = значение. Ключ может быть как уже существующим (тогда происходит изменение значения), так и новым (происходит добавление элемента словаря). Удаление элемента осуществляется с помощью встроенной оператора del языка Python.
>>> a['elephant'] = 'бегемот' # добавляем
>>> a['table'] = 'стол' # добавляем
>>> a
{'dog': 'собака', 'cat': 'кошка', 'mouse': 'мышь',
'bird': 'птица', 'table': 'стол', 'elephant': 'бегемот'}
>>> a['elephant'] = 'слон' # изменяем
>>> del a['table'] # удаляем
>>> a
{'dog': 'собака', 'cat': 'кошка', 'mouse': 'мышь',
'bird': 'птица', 'elephant': 'слон'}В словаре не может быть двух элементов с одинаковыми ключами. Однако могут быть одинаковые значения у разных ключей.
Ключом может быть любой неизменяемый тип данных. Значением – любой тип данных. Значения словарей вполне могут быть структурами, например, другими словарями или списками.
>>> nums = {1: 'one', 2: 'two', 3: 'three'}
>>> person = {'name': 'Tom', 1: [30, 15, 16], 2: 2.34, ('ab', 100): 'no'} Перебор элементов словаря в цикле for
Элементы словаря перебираются в цикле for также, как элементы других сложных объектов. Однако «по-умолчанию» извлекаются только ключи:
>>> nums
{1: 'one', 2: 'two', 3: 'three'}
>>> for i in nums:
... print(i)
...
1
2
3Но по ключам всегда можно получить значения:
>>> for i in nums: ... print(nums[i]) ... one two three
С другой стороны у словаря как класса есть метод items(), который создает особую структуру, состоящую из кортежей. Каждый кортеж включает ключ и значение:
>>> n = nums.items() >>> n dict_items([(1, 'one'), (2, 'two'), (3, 'three')])
В цикле for можно распаковывать кортежи, таким образом сразу извлекая как ключ, так и его значение:
>>> for key, value in nums.items(): ... print(key, 'is', value) ... 1 is one 2 is two 3 is three
Методы словаря keys() и values() позволяют получить отдельно перечни ключей и значений. Так что если, например, надо перебрать только значения или только ключи, лучше воспользоваться одним из этих методов:
>>> v_nums = [] >>> for v in nums.values(): ... v_nums.append(v) ... >>> v_nums ['one', 'two', 'three']
Методы словаря
Кроме рассмотренных выше трех методов items(), keys() и values() словари обладают еще восемью. Это методы clear(), copy(), fromkeys(), get(), pop(), popitem(), setdefault(), update().
Метод clear() удаляет все элементы словаря, но не удаляет сам словарь. В итоге остается пустой словарь:
>>> a
{'dog': 'собака', 'cat': 'кошка', 'mouse': 'мышь',
'bird': 'птица', 'elephant': 'слон'}
>>> a.clear()
>>> a
{}Словарь – это изменяемый тип данных. Следовательно, как и список он передается в функцию по ссылке. Поэтому иногда, чтобы избежать нежелательного изменения глобального словаря его копируют. Это делают и с другими целями.
>>> nums2 = nums.copy()
>>> nums2[4] = 'four'
>>> nums
{1: 'one', 2: 'two', 3: 'three'}
>>> nums2
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}Метод fromkeys() позволяет создать словарь из списка, элементы которого становятся ключами. Применять метод можно как классу dict, так и к его объектам:
>>> a = [1, 2, 3]
>>> c = dict.fromkeys(a)
>>> c
{1: None, 2: None, 3: None}
>>> d = dict.fromkeys(a, 10)
>>> d
{1: 10, 2: 10, 3: 10}
>>> c
{1: None, 2: None, 3: None}Метод get() позволяет получить элемент по его ключу:
>>> nums.get(1) 'one'
Равносильно nums[1].
Метод pop() удаляет из словаря элемент по указанному ключу и возвращает значение удаленной пары. Метод popitem() не принимает аргументов, удаляет и возвращает произвольный элемент.
>>> nums.pop(1)
'one'
>>> nums
{2: 'two', 3: 'three'}
>>> nums.popitem()
(2, 'two')
>>> nums
{3: 'three'}С помощью setdefault() можно добавить элемент в словарь:
>>> nums.setdefault(4, 'four')
'four'
>>> nums
{3: 'three', 4: 'four'}Равносильно nums[4] = 'four', если элемент с ключом 4 отсутствует в словаре. Если он уже есть, то nums[4] = 'four' перезапишет старое значение, setdefault() – нет.
С помощью update() можно добавить в словарь другой словарь:
>>> nums.update({6: 'six', 7: 'seven'})
>>> nums
{3: 'three', 4: 'four', 6: 'six', 7: 'seven'}Также метод обновляет значения существующих ключей. Включает еще ряд особенностей.
Практическая работа
Создайте словарь, связав его с переменной school, и наполните данными, которые бы отражали количество учащихся в разных классах (1а, 1б, 2б, 6а, 7в и т. п.). Внесите изменения в словарь согласно следующему: а) в одном из классов изменилось количество учащихся, б) в школе появился новый класс, с) в школе был расформирован (удален) другой класс. Вычислите общее количество учащихся в школе.
Создайте словарь, где ключами являются числа, а значениями – строки. Примените к нему метод items(), полученный объект dict_items передайте в написанную вами функцию, которая создает и возвращает новый словарь, «обратный» исходному, т. е. ключами являются строки, а значениями – числа.
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
Изучаем словари Python
Словари — это фундаментальный тип данных в Python, представленный в виде пары ключ-значение. Они описываются как объект сопоставления, который сопоставляет хэшируемые значения с произвольными объектами.
Ключи словаря должны быть неизменными, то есть они не могут изменяться. При добавлении в словарь пары ключ-значение он запоминает, в каком порядке они были добавлены.
Словари создаются несколькими способами. Наиболее распространенный метод — указание в фигурных скобках списка разделенных запятыми пар ключ — значение:
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict
{'email': '[email protected]', 'first_name': 'James', 'last_name': 'Doe'}Также можно использовать для создания словаря dict(). Она принимает последовательность аргументов ключевых слов:
>>> numbers = dict(one=1, two=2, three=3)
>>> numbers
{'one': 1, 'three': 3, 'two': 2}
>>> info_list = [('first_name', 'James'), ('last_name', 'Doe'), ('email', '[email protected]')]
>>> info_dict = dict(info_list)
>>> info_dict
{'email': '[email protected]', 'first_name': 'James', 'last_name': 'Doe'}В первом примере используется последовательность ключевых слов dict(). Вы можете представить их как серию ключевых слов со знаком равенства между ними и их значением.
Во втором примере показано, как создать список с тремя кортежами. Затем этот список передается в dict(), чтобы преобразовать его в словарь.
Вы можете получить доступ к любому значению в словаре через ключ. Если ключ не найден, то выведется ошибка KeyError.
Рассмотрим, как использовать словарь.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict['first_name']
'James'Чтобы получить значение first_name, нужно использовать следующий синтаксис: dictionary_name[key]. Теперь попробуем получить ключ, который не существует.
>>> sample_dict['address'] Traceback (most recent call last): Python Shell, prompt 118, line 1 builtins.KeyError: 'address'
Это не сработало. Мы попросили словарь предоставить значение, которого нет. Можно использовать ключевое слово Python in, чтобы спросить, есть ли ключ в словаре.
>>> 'address' in sample_dict False >>> 'first_name' in sample_dict True
А также проверить, нет ли ключа в словаре, используя ключевое слово Python not:
>>> 'first_name' not in sample_dict False >>> 'address' not in sample_dict True
В словарях есть специальные методы, которые можно использовать:
Метод get() позволяет получить значение. Ему нужно указать ключ для поиска. Можно вернуть значение по умолчанию, если ключ не будет найден. По умолчанию это None:
>>> print(sample_dict.get('address'))
None
>>> print(sample_dict.get('address', 'Not Found'))
Not FoundПервый пример иллюстрирует, что происходит, если попытаться получить ключ, которого не существует без установки значения get по умолчанию. В этом случае метод возвращается None.
Во втором примере показано, как установить по умолчанию строку “Not Found”.
Метод clear() используется, чтобы удалить все элементы из словаря.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict
{'email': '[email protected]', 'first_name': 'James', 'last_name': 'Doe'}
>>> sample_dict.clear()
>>> sample_dict
{}Чтобы создать простую копию словаря, используется метод copy().
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> copied_dict = sample_dict.copy()
>>> copied_dict
{'email': '[email protected]', 'first_name': 'James', 'last_name': 'Doe'}Если в словаре есть объекты или словари, то можно столкнуться с логическими ошибками. Так как изменение одного словаря может повлиять на его копию. В этом случае необходимо использовать модуль Python copy, в котором есть функция deepcopy(). Она создаетотдельную копию словаря.
Метод items() возвращает новое представление из элементов словаря.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict.items()
dict_items([('first_name', 'James'), ('last_name', 'Doe'), ('email', '[email protected]')])Этот объект представления будет меняться по мере изменения самого словаря.
Чтобы получить представление ключей, которые есть в словаре, используется метод keys(). Он предоставляет динамическое представление ключей словаря. Можно представление, а также проверить принадлежность представлению по ключевому слову in.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> keys = sample_dict.keys()
>>> keys
dict_keys(['first_name', 'last_name', 'email'])
>>> 'email' in keys
True
>>> len(keys)
3Метод values() возвращает объект динамического представления значений словаря.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> values = sample_dict.values()
>>> values
dict_values(['James', 'Doe', '[email protected]'])
>>> 'Doe' in values
True
>>> len(values)
3Чтобы удалить ключ из словаря, используется метод pop(). Он принимает ключ и строку параметра по умолчанию. Если не установить значение по умолчанию и ключ не будет найден, то выведется ошибка KeyError.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict.pop('something')
Traceback (most recent call last):
Python Shell, prompt 146, line 1
builtins.KeyError: 'something'
>>> sample_dict.pop('something', 'Not found!')
'Not found!'
>>> sample_dict.pop('first_name')
'James'
>>> sample_dict
{'email': '[email protected]', 'last_name': 'Doe'}Метод popitem() используется для удаления и возвращает пары ключ-значение из словаря в порядке «последним добавлен — первым удален». Если метод вызывается в пустом словаре, то отобразится KeyError.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict.popitem()
('email', '[email protected]')
>>> sample_dict
{'first_name': 'James', 'last_name': 'Doe'}Метод обновляет словарь другими парами ключ-значение, перезаписывая существующие ключи. Возвращает None.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict.update([('something', 'else')])
>>> sample_dict
{'email': '[email protected]',
'first_name': 'James',
'last_name': 'Doe',
'something': 'else'}Предположим, что нужно добавить новую пару ключ-значение.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict['address'] = '123 Dunn St'
>>> sample_dict
{'address': '123 Dunn St',
'email': '[email protected]',
'first_name': 'James',
'last_name': 'Doe'}Чтобы добавить новый элемент в словарь, можно использовать квадратные скобки для установки ключа и значения. Если нужно обновить существующий ключ, можно сделать следующее:
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict['email'] = '[email protected]'
>>> sample_dict
{'email': '[email protected]', 'first_name': 'James', 'last_name': 'Doe'}В этом примере для sample_dict[’email’] устанавливается значение [email protected]. Всякий раз, когда для ранее существовавшего ключа задается новое значение, перезаписывается предыдущее значение.
Чтобы удалить ключ из словаря, используйте ключевое слово del:
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> del sample_dict['email']
>>> sample_dict
{'first_name': 'James', 'last_name': 'Doe'}Так вы указываете Python удалить ключ «email» из sample_dict.
Также для удаления ключа используется метод pop(), который был описан в предыдущем разделе.
>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': '[email protected]'}
>>> sample_dict.pop('email')
'[email protected]'
>>> sample_dict
{'first_name': 'James', 'last_name': 'Doe'}При этом метод словаря pop() возвращает значение, которое удаляется.
Словари удобно использовать для быстрого поиска всех типов данных. Если нужен словарь, который создаст значение по умолчанию по несуществующему ключу, примените Python collections. У него есть класс defaultdict, предназначенный для подобного варианта использования.
Данная публикация представляет собой перевод статьи «Python 101 – Learning About Dictionaries» , подготовленной дружной командой проекта Интернет-технологии.ру
телеграм канал. Подпишись, будет полезно!
Python 3: методы словарей — len, clear, get, setdefault, pop
На этом занятии мы продолжаем знакомиться со словарями в Python и рассмотрим основные их методы. Итак, для удаления
всех записей из словаря используется метод
Для создания
копии словаря используется метод copy:
d = {True: 1, False: "Ложь", "list": [1,2,3], 5: 5}
d2 = d.copy()
d2["list"] = [5,6,7]
print(d)
print(d2)Следующий метод get позволяет
получать значение словаря по ключу:
Его отличие от
оператора
в том, что при
указании неверного ключа не возникает ошибки, а выдается по умолчанию значение None:
Это значение
можно изменить, указав его вторым аргументом:
Похожий метод
dict.setdefault(key[, default])
возвращает
значение, ассоциированное с ключом key и если его нет, то добавляет в
словарь со значением None, либо default – если оно
указано:
d.setdefault("list")
d.setdefault(3)Добавит ключ 3
со значением None. Удалим его:
del d[3] d.setdefault(3, "three")
тогда добавится
этот ключ со значением «three». То есть, этот метод способен создать
новую запись, но только в том случае, если указанный ключ изначально
отсутствовал в словаре.
Следующий метод
удаляет
указанный ключ и возвращает его значение. Если в нем указывается несуществующий
ключ, то возникает ошибка:
Но мы можем
легко исправить ситуацию, если в качестве второго аргумента указать значение,
возвращаемое при отсутствии ключа:
Здесь
возвратится False. Если же ключ присутствует,
то возвращается его значение.
Следующий метод
выполняет
удаление произвольной записи из словаря. Если словарь пуст, то возникает
ошибка:
Далее, метод
возвращает
коллекцию ключей. По умолчанию цикл for обходит именно эту коллекцию,
при указании словаря:
d = {True: 1, False: "Ложь", "list": [1,2,3], 5: 5}
for x in d:
print(x)то есть, эта
запись эквивалента такой:
Если же вместо keys записать метод values:
то обход будет
происходить по значениям, то есть, метод values возвращает
коллекцию из значений словаря.
Последний
подобный метод items
возвращает
записи в виде кортежей: ключ, значение. О кортежах мы будем говорить позже,
здесь лишь отмечу, что к элементу кортежа можно обратиться по индексу и вывести
отдельно ключи и значения:
Или, используя
синтаксис множественного наследования:
можно записать
цикл for в таком виде:
for key, value in d.items(): print(key, value)
что гораздо
удобнее и нагляднее.
Задания для самоподготовки
1. Пользователь
вводит произвольные целые числа и нужно создать словарь, у которого ключами
будут только четные числа, а значениями – квадраты этих чисел.
2. Пусть имеется
вот такая строка:
«int= целое число, dict=словарь, list=список, str=строка, bool=булевый
тип»
Требуется из нее
создать словарь с ключами:
int, dict, list, str, bool
и
соответствующими значениями.
3. Пользователь
вводит с клавиатуры M раз данные в формате:
английское
слово: перевод1, перевод2, …, переводN
каждую введенную
строку необходимо преобразовать и поместить в словарь, у которого ключом будет
английское слово, а значением список:
[перевод1,
перевод2, …, переводN]
Python словари. Задачи для начинающих
Вместе с партнерами из telegram-канала Python задачки мы собрали для тебя несколько простых задач по Python. В этой статье разберем словари.
Задача 1
Даны два словаря: dictionary_1 = {'a': 300, 'b': 400} и dictionary_2 = {'c': 500, 'd': 600}. Объедините их в один при помощи встроенных функций языка Python.
Посмотреть решение
Для объединения двух словарей создадим третий словарь в виде копии первого. Для этого используем встроенную функцию copy(). Далее к уже созданному словарю мы присоединяем второй словарь. Для этого мы используем встроенную функцию update().
dictionary_1 = {'a': 100, 'b': 200}
dictionary_2 = {'x': 300, 'y': 200}
dictionary_3 = dictionary_1.copy()
dictionary_3.update(dictionary_2)
print(dictionary_3)Результат:{'a': 100, 'b': 200, 'x': 300, 'y': 200}
Задача 2
Дан словарь с числовыми значениями. Необходимо их все перемножить и вывести на экран.
Посмотреть решение
Для решения данной задачи создадим переменную result, в которой будем накапливать результаты умножения, а для начала инициируем ее значением 1. Затем при помощи цикла for получим все значения словаря через его ключи. После этого результат умножения из переменной result выведем на экран.
my_dictionary = {'data1': 375, 'data2': 567, 'data3': -37, 'data4': 21}
result = 1
for key in my_dictionary:
result = result * my_dictionary[key]
print(result)Результат: -165209625
Задача 3
Создайте словарь, в котором ключами будут числа от 1 до 10, а значениями эти же числа, возведенные в куб.
Посмотреть решение
Для решения этой задачи воспользуемся циклом for, а для получения чисел в диапазоне от 1 до 10 будем использовать функцию range().
my_dict = {i : i ** 3 for i in range(1, 11)}
print(my_dict)Результат:{1: 1, 2: 8, 3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729, 10: 1000}
Задача 4
Даны два списка одинаковой длины. Необходимо создать из них словарь таким образом, чтобы элементы первого списка были ключами, а элементы второго — соответственно значениями нашего словаря.
Посмотреть решение
Для решения задачи воспользуемся функцией zip, которая из двух списков создает один, состоящий из кортежей длиной в два элемента каждый. Первый элемент кортежа взят из первого списка, а второй, соответственно, из второго. Индексы обоих элементов кортежа совпадают. После передачи такого списка в функцию dict получается требуемый словарь.
keys = ['red', 'green', 'blue'] values = ['#FF0000','#008000', '#0000FF'] color_dictionary = dict(zip(keys, values)) print(color_dictionary)
Результат:{'red': '#FF0000', 'green': '#008000', 'blue': '#0000FF'}
Задача 5
Создайте словарь из строки 'pythonist' следующим образом: в качестве ключей возьмите буквы строки, а значениями пусть будут числа, соответствующие количеству вхождений данной буквы в строку.
Посмотреть решение
Для решения данной задачи воспользуемся функцией count(), которая считает количество вхождений элемента в строку. Для генерации словаря воспользуемся синтаксисом представления словарей (dictionary comprehention).
str1 = 'pythonist'
my_dict = {i: str1.count(i) for i in str1}
print(my_dict)Результат:{'p': 1, 'y': 1, 't': 2, 'h': 1, 'o': 1, 'n': 1, 'i': 1, 's': 1}
Представление словарей в языке Python
В данной статье мы рассмотрим, как работают представления словарей (dictionary comprehension) в языке Python. Будет приведено много примеров, из которых мы поймем основную концепцию представления словарей в Python и как оно используется в реальных задачах.
Что такое словарь
Словарь — это встроенный в Python тип данных, в котором значения данных связаны с соответствующими ключами. Грубо говоря, это очень похоже на SQL-таблицы, сходным образом данные хранятся и во многих статистических пакетах. Словарь состоит из двух основных компонентов:
- Ключи. Они сродни колонкам в SQL-таблицах и должны быть уникальными (как и названия колонок не могут повторяться).
- Значения. Они обладают свойствами рядов в таблицах и могут повторяться.
Словари заключаются в фигурные скобки {}, а ключи отделяются от значений двоеточием.
Синтаксис словарей
Словари в языке Python выглядят следующим образом:
d = {'a': [1,2], 'b': [3,4], 'c': [5,6]}Здесь 'a', 'b' и 'c' являются ключами, а списки после двоеточия — значениями (данными). Чтобы извлечь ключи, данные и структуру словаря, можно воспользоваться следующими командами:
d.keys() # 'a', 'b', 'c' - это ключи d.values() # [1, 2], [3, 4], [5, 6] - это данные d.items()
Как в R или SAS, в Python мы можем создать из нашего словаря датафрейм, воспользовавшись библиотекой pandas.
import pandas as pd pd.DataFrame(data = d)
В результате получим следующую таблицу:
a b c 0 1 3 5 1 2 4 6
Что такое представление словарей
Подобно представлению списков, представление словарей позволяет нам перебирать словарь в цикле for при помощи всего одной строчки кода.
Представления списков и словарей являются частью функционального программирования. Главная цель этой конструкции — сделать код более читаемым и создавать словари и списки прозрачным образом, не используя в явном виде полноценный цикл.
Разница между представлением списков и представлением словарей, как не сложно догадаться, состоит в том, что первая конструкция создает списки, а вторая соответственно словари. Синтаксис также слегка различается, так как словари в Python используют квадратные скобки [], а словари — фигурные {}.
Синтаксис представления словарей
{key: value for (key, value) in iterable}
Здесь iterable это любой объект языка Python, по которому можно производить итерацию при помощи цикла. Например, это могут быть списки, кортежи или строки. Рассмотрим следующий код:
keys = ['a', 'b', 'c']
values = [1, 2, 3]
{i: j for (i, j) in zip(keys, values)}Этот код создает словарь: {'a': 1, 'b': 2, 'c': 3}. Также заметим, что точно такой же словарь можно создать при помощи встроенной функции dict следующим образом: dict(zip(keys, values)).
Представление словарей также можно использовать и с одной внутренней переменной. В следующем примере мы используем переменную i, чтобы создать словарь с ключами i и значениями i**2.
Чтобы увидеть разницу между представлением словарей и обычным применением цикла, в таблице ниже приведены оба варианта.
| Представление словарей | Цикл for |
d = {i: i**2 for i in range(5)}
| d = {}
for i in range(5):
d[i] = i**2
print(d)
|
Здесь функция range(5) возвращает последовательность от 0 до 4 включительно (5 не входит).
Результат:
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}Функция d.keys() возвращает все ключи данного словаря d (в виде списка), а функция d.values() соответственно значения.
d.keys() # возвращает [0, 1, 2, 3, 4] d.values() # возвращает [0, 1, 4, 9, 16]
Создание словаря с алфавитными ключами
Допустим, что мы хотим создать словарь, где ключами будут буквы латинского алфавита от ‘a’ до ‘e’, а значениями — числа от 0 до 4 включительно. Функция string.ascii_lowercase[:5] возвращает в качестве результата строку 'abcde'.
import string
{i: j for (i, j) in zip(string.ascii_lowercase[:5], range(5))Данный код создаст словарь следующего вида:
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}Создание нового словаря из уже существующего
Функция dic.items() возвращает словарь целиком, с ключами и соответствующими значениями. В следующем примере мы умножаем значения существующего словаря на 2 и создаем с этими измененными значениями новый словарь в переменной new_dic.
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
new_dic = {i: j * 2 for i, j in dic.items()}
new_dicРезультат:
{'a': 2, 'b': 4, 'c': 6, 'd': 8}Использование оператора if в представлении словарей
В данном примере мы применим условный оператор if и отберем все значения больше 2.
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
{i: j * 2 for (i, j) in dic.items() if j > 2}Результат:
{'c': 6, 'd': 8}Конструкция if - else в представлении словарей
Так же как и в представлении списков, конструкцию if - else можно использовать в представлении словарей. В следующем примере мы проверяем четность числа и ставим данному ключу в соответствие значение либо ‘odd’ (нечетное), либо ‘even’ (четное).
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
{i: ('even' if j % 2 == 0 else 'odd') for (i, j) in dic.items()}Результат:
{'a': 'odd', 'b': 'even', 'c': 'odd', 'd': 'even'}Использование функции enumerate() в представлении словарей
Функция enumerate() может принимать на вход список, кортеж или строку и возвращает каждый элемент последовательности и его индекс в виде кортежей из двух элементов, первым идет индекс, вторым сам элемент. Вот пример работы этой функции:
list(enumerate(['a', 'b', 'c']))
Обернув функцию enumerate() в функцию list(), мы получаем в результате список кортежей:
[(0, 'a'), (1, 'b'), (2, 'c')]
При помощи этой функции мы можем создать словарь, где элементы списка будут ключами, а индексы значениями словаря. (Прим. переводчика: а можем и наоборот).
mylist = ['a', 'b', 'c']
{j: i for (i, j) in enumerate(mylist)}Результат:
{'a': 0, 'b': 1, 'c': 2}Удаление выбранных элементов из словаря
Допустим, у нас есть словарь, который в качестве ключей содержит в себе определенные имена городов, имеющие некоторые числовые значения, и мы хотим удалить несколько городов (скажем, Дели и Лондон) вместе с их значениями. В нашем примере переменная i отвечает за ключи словаря, а выражение d[i] вычисляет значение по этому ключу. Например, d['Mumbai'] возвратит 221.
d = {'Delhi': 121, 'Mumbai': 221, 'New York': 302, 'London': 250}
{i: d[i] for i in d.keys() - {'Delhi', 'London'}}В результате в словаре останется два элемента:
{'Mumbai': 221, 'New York': 302}Словарь Python (Dict) Учебное пособие — Вещи, которые ВЫ ДОЛЖНЫ знать
- Словарь Python — это набор пар ключ-значение. Ключи уникальны в словаре.
- Словарь — это объект класса dict . Это неупорядоченная коллекция.
- Ключи словаря должны быть неизменными. Таким образом, мы можем использовать строку, числа, кортеж в качестве ключа dict.
- Если кортеж содержит изменяемые объекты, мы не можем использовать его как ключ словаря.
- Мы не можем использовать список в качестве ключа словаря, потому что они могут быть изменены.
- Словарь создается с помощью пары скобок. Пары ключ-значение разделяются запятой.
- Ключи и значения словаря могут быть любых типов. Они также могут быть
Нет. - Ключ и его значение разделяются двоеточием.
- Записи словаря индексируются с помощью ключа.
Создание словаря
Рассмотрим простой пример создания словаря и его печати.
>>> fruit_dict = {"1": "Яблоко", "2": "Банан", 3: "Апельсин", None: "NA"}
>>> печать (fruit_dict)
{'1': 'Apple', '2': 'Banana', 3: 'Orange', None: 'NA'}
>>> тип (fruit_dict)
<класс 'dict'>
Обратите внимание, что типом класса словаря является dict , и ключи-значения тоже бывают разных типов.
Создание словаря Python
Доступ к значениям словаря
Мы можем получить доступ к словарному значению, используя имя ключа в квадратных скобках.
>>> fruit_dict ["1"] 'Яблоко' >>> fruit_dict ["2"] 'Банан' >>> fruit_dict [3] 'Оранжевый' >>> fruit_dict [Нет] 'NA'
Доступ к значениям словаря
Если ключ не существует, этот способ доступа к элементу словаря вызовет KeyError. Лучше использовать метод get () , который возвращает None , если ключ отсутствует.
Добавление / обновление значения словаря
Мы можем добавлять или обновлять элементы словаря с помощью оператора присваивания. Если ключа нет в словаре, пара «ключ-значение» добавляется в словарь. В противном случае значение обновляется новым значением.
fruit_dict = {"1": "Яблоко", "2": "Банан"}
print (f'Original Dictionary = {fruit_dict} ')
# вставить
fruit_dict ["3"] = "Апельсин"
# Обновить
fruit_dict ["1"] = "Киви"
print (f'Updated Dictionary = {fruit_dict} ')
Добавление обновления элементов словаря Python
Удаление элементов словаря
Мы можем использовать ключевое слово del для удаления пары ключ-значение словаря.Если мы используем ключевое слово del со словарем, весь словарь будет удален.
>>> my_dict = {1: "1", 2: "2"}
>>> del my_dict [1]
>>> печать (my_dict)
{2: '2'}
>>> del my_dict
>>> печать (my_dict)
Отслеживание (последний вызов последний):
Файл "", строка 1, в
NameError: имя my_dict не определено
>>>
Итерация по словарю с использованием цикла for
Мы можем перебирать словарь, используя цикл for.Есть много способов использования цикла for со словарем.
1. Прокрутите пары ключ-значение с помощью функции items ()
fruit_dict = {"1": "Яблоко", "2": "Банан", "3": "Апельсин"}
для ключа значение в fruit_dict.items ():
print (f '{ключ} = {значение}')
Выход:
1 = яблоко 2 = банан 3 = оранжевый
2. Перебирать ключи словаря
fruit_dict = {"1": "Яблоко", "2": "Банан", "3": "Апельсин"}
для ключа в fruit_dict:
печать (ключ)
Выход:
1 2 3
3.Прокрутите значения словаря с помощью функции values ()
Мы можем использовать функцию values (), чтобы получить значения, а затем перебрать их.
fruit_dict = {"1": "Яблоко", "2": "Банан", "3": "Апельсин"}
для значения в fruit_dict.values ():
печать (значение)
Выход:
яблоко Банан оранжевый
Проверить, существует ли ключ в Словаре
Мы можем использовать в словаре ключевые слова «in» и «not in».
fruit_dict = {"1": "Яблоко", "2": "Банан", "3": "Апельсин"}
если "3" в fruit_dict:
print (f'Key "3" присутствует в словаре, и его значение равно {fruit_dict ["3"]} ')
если «10» нет в fruit_dict:
print («Ключ '10' не существует в словаре»)
Длина словаря
Мы можем использовать функцию len (), чтобы узнать длину или размер словаря.
>>> fruit_dict = {"1": "Яблоко", "2": "Банан", "3": "Апельсин"}
>>> print (f'Длина словаря {len (fruit_dict)} ')
Длина словаря 3
>>>
Python dict () Конструктор
Мы можем использовать встроенный конструктор dict () для создания объекта словаря.
>>> empty_dict = dict ()
>>>
>>> empty_dict
{}
>>> my_dict = dict (id = 1, name = "Pankaj", skill = "Python")
>>>
>>> my_dict
{'id': 1, 'name': 'Pankaj', 'skill': 'Python'}
>>>
Методы словаря Python
Класс Python dict имеет много методов.Давайте рассмотрим некоторые важные словарные методы.
1. значения ()
Этот метод возвращает объект, содержащий значения из словаря. Тип возвращаемого объекта — «dict_values», и мы можем перебирать его, чтобы выполнить некоторую операцию со значениями словаря.
num_dict = {1: "один", 2: "два", 3: "три"}
values = num_dict.values ()
print (значения f'Dictionary - {values}, а его тип - {type (values)} ')
для v в значениях:
print (v, end = "")
Значения словаря Python
2.предметы ()
Этот метод обеспечивает представление элементов словаря в виде набора. В основном он используется для распаковки пары «ключ-значение» словаря в разные значения и последующего перебора их.
num_dict = {1: "один", 2: "два", 3: "три"}
items = num_dict.items ()
печать (элементы)
печать (тип (элементы))
для k, v в деталях: # распаковка
печать (k, v)
Выход:
dict_items ([(1, 'один'), (2, 'два'), (3, 'три')]) <класс 'dict_items'> 1 один 2 два 3 три
3.pop (клавиша [, по умолчанию])
Этот метод удаляет указанный ключ из словаря и возвращает соответствующее значение. Если ключ не найден, возвращается необязательное значение по умолчанию. Если ключ не найден и значение по умолчанию не указано, возникает ошибка KeyError .
num_dict = {1: "один", 2: "два", 3: "три"}
значение = num_dict.pop (1)
print (f'Updated Dictionary = {num_dict} и удаленное значение = {value} ')
значение = num_dict.pop (1, «NA»)
print (f'Updated Dictionary = {num_dict} и удаленное значение = {value} ')
пытаться:
значение = num_dict.поп (1)
кроме KeyError как ke:
print («Ключ не найден: 1»)
Мы используем блок try-except, чтобы перехватить KeyError и распечатать сообщение об ошибке.
4. копия ()
Эта функция возвращает частичную копию словаря.
num_dict = {1: "один", 2: "два", 3: "три"}
num_dict_copy = num_dict.copy ()
печать (num_dict)
печать (num_dict_copy)
num_dict [4] = "четыре"
num_dict_copy [5] = "пять"
печать (num_dict)
печать (num_dict_copy)
Выход:
{1: 'один', 2: 'два', 3: 'три'}
{1: 'один', 2: 'два', 3: 'три'}
{1: "один", 2: "два", 3: "три", 4: "четыре"}
{1: 'один', 2: 'два', 3: 'три', 5: 'пять'}
5.прозрачный ()
Этот метод удаляет все элементы из словаря. Это похоже на присвоение переменной пустому словарю.
num_dict = {1: "один", 2: "два", 3: "три"}
num_dict.clear () # то же, что num_dict = {}
печать (num_dict)
6. fromKeys (iterable, value)
Этот статический метод создает новый словарь с ключами из итерируемого объекта и значениями, установленными на предоставленное значение. Если значение не указано, устанавливаются значения Нет.
seq = (1, 3) sub_dict = dict.fromkeys (seq) печать (sub_dict) sub_dict = dict.fromkeys ([1, 2], «NA») печать (sub_dict) sub_dict = dict.fromkeys («15», «Привет») печать (sub_dict)
Выход:
{1: Нет, 3: Нет}
{1: 'NA', 2: 'NA'}
{'1': 'Привет', '5': 'Привет'}
7. get (ключ [, по умолчанию])
Этот метод возвращает значение ключа. Если ключ не найден, возвращается необязательное значение по умолчанию. Если ключ не найден и значение по умолчанию не указано, возвращается None.
>>> num_dict = {1: "один", 2: "два", 3: "три"}
>>>
>>> num_dict.get (1)
'один'
>>> num_dict.get (10, «десять»)
'10'
>>> num_dict.get (10)
>>> print (num_dict.get (10))
Никто
>>>
8. клавиши ()
Эта функция возвращает объект, подобный множеству, который обеспечивает представление ключей словаря.
num_dict = {1: "один", 2: "два", 3: "три"}
keys = num_dict.keys ()
печать (ключи)
печать (тип (ключи))
для k в ключах:
print (k, num_dict [k])
Выход:
dict_keys ([1, 2, 3]) <класс 'dict_keys'> 1 один 2 два 3 три
9.popitem ()
Этот метод удаляет и возвращает некоторый элемент словаря в виде кортежа «ключ-значение». Если словарь пуст, возникает ошибка KeyError. Мы можем использовать эту функцию с циклом while для обработки элементов словаря в случайном порядке.
num_dict = {1: "один", 2: "два", 3: "три", 0: "ноль"}
а len (num_dict)! = 0:
item = num_dict.poITEm ()
печать (элемент)
Выход:
(0, 'ноль') (3, 'три') (2, 'два') (1, 'один')
10.setdefault (ключ [, по умолчанию])
Этот метод используется для добавления ключа в словарь тогда и только тогда, когда он отсутствует в словаре. Этот метод устанавливает значение ключа для предоставленного значения по умолчанию, в противном случае — None.
Метод возвращает значение ключа, если оно присутствует в словаре, в противном случае возвращает значение по умолчанию.
num_dict = {1: "один", 2: "два", 3: "три"}
# новый ключ
значение = num_dict.setdefault (4, «НД»)
print (f'Updated Dictionary = {num_dict} и возвращаемое значение = {value} ')
# новый ключ без значения по умолчанию
значение = num_dict.setdefault (5)
print (f'Updated Dictionary = {num_dict} и возвращаемое значение = {value} ')
# существующий ключ, не влияет на dict
значение = num_dict.setdefault (1, "ОДИН")
print (f'Updated Dictionary = {num_dict} и возвращаемое значение = {value} ')
Выход:
Обновленный словарь = {1: 'один', 2: 'два', 3: 'три', 4: 'NA'} и возвращаемое значение = NA.
Обновленный словарь = {1: 'один', 2: 'два', 3: 'три', 4: 'NA', 5: None} и возвращаемое значение = None.
Обновленный словарь = {1: 'один', 2: 'два', 3: 'три', 4: 'NA', 5: None} и возвращенное значение = один.
11.обновление (дикт)
Этот метод используется для обновления элементов словаря из данного словаря. Если данный ключ словаря не найден, он добавляется в словарь. Если ключ найден, значение обновляется.
num_dict = {1: "один", 2: "два", 3: "три"}
dict1 = {1: "ОДИН", 2: "ДВА", 5: "ПЯТЬ"}
# обновление из другого дикта
num_dict.update (dict1)
печать (num_dict)
Выход: {1: 'ONE', 2: 'TWO', 3: 'three', 5: 'FIVE'}
Заключение
Python Dictionary — это коллекция в виде карты для хранения пар ключ-значение.Доступ к элементам в словаре осуществляется через индекс на основе ключей. Мы можем легко обновлять, добавлять и удалять элементы словаря. Существуют различные способы использования цикла for для перебора ключей, значений или элементов словаря.
Артикул:
.
Словарь Python с методами, функциями и словарными операциями
1. Учебник по словарю Python
За последние несколько уроков мы узнали о некоторых конструкциях Python, таких как списки и кортежи. Сегодня мы поговорим о словаре Python, который является еще одним типом структуры данных в Python. Более того, мы изучим, как создавать, получать доступ, удалять, переназначать словарь в Python. Наряду с этим мы изучим метод и операции Python Dictionary.
Итак, приступим к руководству по словарю Python.
Словарь Python
2. Введение в словари Python
Реальный словарь содержит слова и их значения. Как вы понимаете, словарь Python содержит пары ключ-значение. Давайте посмотрим, как его создать.
3. Как создать словарь на Python?
Создать словарь Python очень просто. Отделяйте ключи от значений двоеточием (:), а пары от других — запятой (,). Наконец, заключите все в фигурные скобки.
>>> {'PB&J': 'Арахисовое масло и желе', 'PJ': 'Пижамы'} {‘PB&J’: ‘Peanut Butter and Jelly’, ‘PJ’: ‘Pyjamas’}
При желании вы можете поместить словарь в переменную.Если вы хотите использовать его позже в программе, вы должны это сделать.
>>> lingo = {'PB&J': 'Арахисовое масло и желе', 'PJ': 'Пижамы'} Чтобы создать пустой словарь, просто используйте фигурные скобки, а затем назначьте его переменной
>>> dict2 = {}
>>> dict2 {}
>>> тип (dict2)
а. Понимание словаря Python
Вы также можете создать словарный запас Python, используя понимание.Это то же самое, что вы узнали на уроке математики. Для этого после пары выражений следует цикл for-statement в Python. Наконец, заключите все в фигурные скобки.
>>> mydict = {x * x: x для x в диапазоне (8)}
>>> mydict {0: 0, 1: 1, 4: 2, 9: 3, 16: 4, 25: 5, 36: 6, 49: 7}
В приведенном выше коде мы создали словарь Python для хранения квадратов чисел от 0 до 7 в качестве ключей и чисел 0-1 в качестве значений.
г. Словари со смешанными ключами
Нет необходимости использовать одинаковые ключи (или значения) для словаря в Python.
>>> dict3 = {1: 'морковь', 'два': [1,2,3]}
>>> dict3 {1: «морковь», «два»: [1, 2, 3]}
Как вы можете видеть здесь, ключ или значение может быть любым — от целого числа до списка.
г. dict ()
Используя функцию dict (), вы можете преобразовать совместимую комбинацию конструкций в словарь Python.
>>> dict (([1,2], [2,4], [3,6]))
{1: 2, 2: 4, 3: 6}
Однако эта функция принимает только один аргумент.Поэтому, если вы передадите ему три списка, вы должны передать их внутри списка или кортежа. В противном случае выдает ошибку.
>>> dict ([1,2], [2,4], [3,6])
Traceback (последний звонок последний):
Файл «
dict ([1,2], [2,4], [3,6])
TypeError: dict ожидается не более 1 аргумента, получено 3
г. Объявление одного ключа более одного раза
А теперь давайте попробуем объявить один ключ более одного раза и посмотрим, что произойдет.
>>> mydict2 = {1: 2,1: 3,1: 4,2: 4}
>>> mydict2 {1: 4, 2: 4}
Как видите, 1: 2 было заменено на 1: 3, которое затем было заменено на 1: 4. Это показывает нам, что словарь не может содержать один и тот же ключ дважды.
e. Объявление пустого словаря и добавление элементов позже
Если вы не знаете, какие пары «ключ-значение» входят в ваш словарь Python, вы можете просто создать пустой словарь Python и добавить пары позже.
>>> животные = {}
>>> тип (животные)
>>> животные [1] = 'собака' >>> животные [2] = 'кошка' >>> животные [3] = 'хорек' >>> животные
{1: «собака», 2: «кошка», 3: «хорек»}
Еще есть вопросы по Python Dictionay? Оставить комментарий.
4. Как получить доступ к словарю Python?
а. Доступ ко всему словарю Python
Чтобы получить сразу весь словарь, введите его имя в оболочке.
>>> dict3
{1: «морковь», «два»: [1, 2, 3]}
г. Доступ к значению
Чтобы получить доступ к элементу из списка или кортежа, мы используем его индекс в квадратных скобках. Это синтаксис Python, которому необходимо следовать. Однако словарь Python неупорядочен. Поэтому, чтобы получить от него значение, вам нужно заключить его ключ в квадратные скобки.
Чтобы получить квадратный корень из 36 из приведенного выше словаря, мы пишем следующий код.
>>> mydict [36]
6
г. получить ()
Функция get () словаря Python принимает ключ в качестве аргумента и возвращает соответствующее значение.
>>> mydict.get (49)
7
г. Когда ключи словаря Python не существуют
Если ключ, который вы ищете, не существует, посмотрим, что произойдет.
>>> mydict [48]
Traceback (последний звонок последний):
Файл «
mydict [48]
KeyError: 48
Использование ключа в квадратных скобках дает нам KeyError.Теперь посмотрим, что возвращает метод get () в такой ситуации.
>>> mydict.get (48) >>>
Как видите, ничего не напечатано. Давайте поместим его в оператор печати, чтобы узнать, что происходит.
>>> печать (mydict.get (48))
Нет
Итак, мы видим, что когда ключ не существует, функция get () возвращает значение None. Мы обсуждали это ранее и знаем, что это указывает на отсутствие ценности.
5.Переназначение словаря Python
Словарь Python изменяемый. Это означает, что мы можем изменить его или добавить новые элементы без переназначения всего этого.
а. Обновление значения существующего ключа
Если ключ уже существует в словаре Python, вы можете переназначить его значение, используя квадратные скобки.
Давайте для этого возьмем новый словарь Python.
>>> dict4 = {1: 1,2: 2,3: 3} Теперь попробуем обновить значение ключа 2.
>>> dict4 [2] = 4 >>> dict4
{1: 1, 2: 4, 3: 3}
г. Добавление нового ключа
Однако, если ключа еще нет в словаре, он добавляет новый.
>>> dict4 [4] = 6 >>> dict4
{1: 1, 2: 4, 3: 3, 4: 6}
Словарь Python не может быть разрезан.
6. Как удалить словарь Python?
Вы можете удалить весь словарь. Кроме того, в отличие от кортежа, словарь Python изменчив.Так что вы также можете удалить его часть.
а. Удаление всего словаря Python
Чтобы удалить весь Python dict, просто используйте его имя после ключевого слова «del».
>>> del dict4 >>> dict4
Traceback (последний звонок последний):
Файл «
dict4
NameError: имя «dict4» не определено
г. Удаление одной пары «ключ-значение»
Чтобы удалить только одну пару «ключ-значение», используйте ключевое слово «del» с ключом пары, которую нужно удалить.
Теперь давайте сначала переназначим dict4 для этого примера.
>>> dict4 = {1: 1,2: 2,3: 3,4: 4} Теперь удалим пару 2: 2
>>> del dict4 [2] >>> dict4
{1: 1, 3: 3, 4: 4}
Несколько других методов позволяют нам удалить элемент из словаря в Python. Мы увидим их в разделе 8.
7. Встроенные функции в словаре Python
Функция — это процедура, которую можно применить к конструкции для получения значения.Кроме того, он не изменяет конструкцию. Python дает нам несколько функций, которые мы можем применить к словарю Python. Взглянем.
а. len ()
Функция len () возвращает длину словаря в Python. Каждая пара «ключ-значение» добавляет 1 к длине.
>>> len (dict4)
3
Пустой словарь Python имеет длину 0.
>>> len ({}) г. любой ()
Как и в случае со списками и кортежами, функция any () возвращает True, если хотя бы один ключ в словаре имеет логическое значение True.
>>> любое ({False: False, '': ''}) Ложь
>>> любое ({True: False, "": ""}) Правда
>>> любое ({'1': '', '': ''}) Правда
г. все ()
В отличие от функции any (), all () возвращает True, только если все ключи в словаре имеют логическое значение True.
>>> все ({1: 2,2: '', "": 3}) Ложь
г. отсортировано ()
Как и в случае со списками и кортежами, функция sorted () возвращает отсортированную последовательность ключей в словаре.Сортировка выполняется в возрастающем порядке и не изменяет исходный словарь Python.
Но чтобы увидеть эффект, сначала изменим dict4.
>>> dict4 = {3: 3,1: 1,4: 4} Теперь применим к нему функцию sorted ().
>>> отсортировано (dict4)
[1, 3, 4]
Теперь давайте попробуем снова распечатать словарь dict4.
>>> dict4
{3: 3, 1: 1, 4: 4}
Как видите, исходный словарь Python не был изменен.
Эта функция возвращает ключи в отсортированном списке. Чтобы доказать это, давайте посмотрим, что возвращает функция type ().
>>> тип (отсортировано (dict4))
<список "класса">
Это доказывает, что sorted () возвращает список.
8. Встроенные методы в словаре Python
Метод — это набор инструкций, выполняемых над конструкцией, который может изменять конструкцию. Для этого в конструкции должен быть вызван метод. Теперь давайте посмотрим на доступные методы для словарей.
Давайте использовать для этого примера dict4.
>>> dict4
{3: 3, 1: 1, 4: 4}
а. ключи ()
Метод keys () возвращает список ключей в словаре Python.
>>> dict4.keys ()
dict_keys ([3, 1, 4])
г. значения ()
Аналогично, метод values () возвращает список значений в словаре.
>>> dict4.values ()
dict_values ([3, 1, 4])
г.предметы ()
Этот метод возвращает список пар «ключ-значение».
>>> dict4.items ()
dict_items ([(3, 3), (1, 1), (4, 4)])
г. получить ()
Мы впервые увидели эту функцию в разделе 4c. А теперь давайте копнем глубже.
Требуется от одного до двух аргументов. Первый — это ключ для поиска, второй — это значение, которое нужно вернуть, если ключ не найден. Значение по умолчанию для этого второго аргумента — Нет.
>>> dict4.get (3,0)
3
>>> dict4.получить (5,0)
Так как ключа 5 в словаре нет, он вернул 0, как мы и указали.
Есть еще сомнения в словаре Python? Оставить комментарий.
e. ясно ()
Назначение функции clear очевидно. Он очищает словарь Python.
>>> dict4.clear () >>> dict4
{}
Давайте переназначим его для дальнейших примеров.
>>> dict4 = {3: 3,1: 1,4: 4} ф. копия ()
Во-первых, давайте посмотрим, что такое мелкие и глубокие копии.Неглубокая копия копирует только содержимое, а новая конструкция указывает на то же место в памяти. Но глубокая копия копирует содержимое, а новая конструкция указывает на другое место. Метод copy () создает неглубокую копию словаря Python.
>>> newdict = dict4.copy () >>> newdict
{3: 3, 1: 1, 4: 4}
г. поп ()
Этот метод используется для удаления и отображения элемента из словаря. Требуется один-два аргумента. Первый — это ключ, который нужно удалить, а второй — значение, которое возвращается, если ключ не найден.
>>> newdict.pop (4)
4
А теперь попробуем удалить пару 4: 4.
>>> newdict.pop (5, -1)
–1
Однако, в отличие от метода get (), он не имеет значения по умолчанию None для второго параметра.
>>> newdict.pop (5)
Traceback (последний звонок последний):
Файл «
newdict.pop (5)
KeyError: 5
Как видите, он вызвал ошибку KeyError, когда не смог найти ключ.
ч. popitem ()
Давайте сначала переназначим словарь Python newdict.
>>> newdict = {3: 3,1: 1,4: 4,7: 7,9: 9} Теперь попробуем вызвать для этого popitem ().
>>> newdict.poITEm ()
(9, 9)
Вылетела пара 9: 9.
Давайте перезапустим оболочку и снова переназначим словарь и посмотрим, какая пара появится.
=============================== ПЕРЕЗАГРУЗКА: Shell =============== ================
>>> newdict = {3: 3,1: 1,4: 4,7: 7,9: 9}
>>> newdict.popitem () (9, 9)
Как видите, выпала та же пара. Исходя из этого, мы можем интерпретировать, что внутренняя логика метода popitem () такова, что для конкретного словаря он всегда выдает пары в одном и том же порядке.
я. fromkeys ()
Этот метод создает новый словарь Python из существующего. В качестве примера мы пытаемся создать новый словарь из newdict. В то время как первый аргумент берет набор ключей из словаря, второй принимает значение для присвоения всем этим ключам.Но второй аргумент не обязателен.
>>> newdict.fromkeys ({1,2,3,4,7}, 0) {1: 0, 2: 0, 3: 0, 4: 0, 7: 0}
Однако ключи не обязательно должны быть в комплекте.
>>> newdict.fromkeys ((1,2,3,4,7), 0)
{1: 0, 2: 0, 3: 0, 4: 0, 7: 0}
Как мы уже видели, значение по умолчанию для второго аргумента — Нет.
>>> newdict.fromkeys ({'1', '2', '3', '4', '7'}) {«4»: нет, «7»: нет, «3»: нет, «1»: нет, «2»: нет}
Дж.обновление ()
Метод update () принимает в качестве аргумента другой словарь. Затем он обновляет словарь, чтобы в нем содержались значения из другого словаря, которого у него еще нет.
>>> dict1 = {1: 1,2: 2}
>>> dict2 = {2: 2,3: 3}
>>> dict1.update (dict2)
>>> dict1 {1: 1, 2: 2, 3: 3}
9. Операции со словарем Python
Мы узнали о различных классах операторов в Python ранее. Посмотрим, что из этого можно применить к словарям.
а. Членство
Мы можем применить операторы «in» и «not in» к словарю Python, чтобы проверить, содержит ли он определенный ключ.
В этом примере мы будем работать над dict1.
>>> dict1
{1: 1, 2: 2, 3: 3}
>>> 2 в dict1
Правда
>>> 4 в dict1
Ложь
2 — ключ в dict1, а 4 — нет. Следовательно, он возвращает для них True и False соответственно.
10.Словарь Python Iterate
В цикле for вы также можете выполнять итерацию в словаре Python, например, в списке, кортеже или наборе.
>>> dict4
{1: 1, 3: 3, 4: 4}
>>> для i в dict4: print (dict4 [i] * 2)
2
6
8
Приведенный выше код для каждого ключа в словаре Python умножает его значение на 2 и затем распечатывает его.
11. Вложенный словарь
Наконец, давайте посмотрим на вложенные словари.Вы также можете поместить словарь Python в качестве значения в словарь.
>>> dict1 = {4: {1: 2,2: 4}, 8: 16}
>>> dict1 {4: {1: 2, 2: 4}, 8: 16}
Чтобы получить значение ключа 4, напишите следующий код.
>>> dict1 [4]
{1: 2, 2: 4}
Однако вы не можете использовать его в качестве ключа, потому что это вызывает ошибку.
>>> dict1 = {{1: 2,2: 4}: 8,8: 16} Traceback (последний звонок последний):
Файл «
dict1 = {{1: 2,2: 4}: 8,8: 16}
TypeError: нехешируемый тип: «dict»
Итак, это все об учебнике по словарю Python.Надеюсь, вам понравится наше объяснение
12. Заключение
В сегодняшнем уроке мы подробно рассмотрели словарь Python. Мы впервые увидели, как создавать, получать доступ, переназначать и удалять словарь или его элементы. Затем мы рассмотрели встроенные функции и методы для словарей. После этого мы узнали об операциях, которые можем над ними выполнять. Наконец, мы узнали о вложенных словарях и о том, как выполнять итерацию в словаре Python. Тем не менее, у вас есть замешательство? не стесняйтесь спрашивать в поле для комментариев.
Номер ссылки
.
Понимание словаря Python
Словари
— это типы данных в Python, которые позволяют нам хранить данные в паре ключ / значение . Например:
my_dict = {1: 'яблоко', 2: 'мяч'}
Чтобы узнать о них больше, посетите: Python Dictionary
Что такое понимание словаря в Python?
Понимание словарей — это элегантный и лаконичный способ создания словарей.
Пример 1: понимание словаря
Рассмотрим следующий код:
square_dict = dict ()
для числа в диапазоне (1, 11):
square_dict [число] = число * число
печать (square_dict)
Теперь давайте создадим словарь в приведенной выше программе, используя понимание словаря.
# пример понимания словаря
square_dict = {число: число * число для числа в диапазоне (1, 11)}
печать (square_dict)
Результат работы обеих программ будет одинаковым.
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100} В обеих программах мы создали словарь square_dict с парой ключ / значение число-квадрат .
Однако использование понимания словаря позволило нам создать словарь в одной строке .
Использование понимания словаря
Из приведенного выше примера мы видим, что понимание словаря должно быть написано по определенному шаблону.
Минимальный синтаксис для понимания словаря:
словарь = {ключ: значение для переменных в итерабельном}
Давайте сравним этот синтаксис с пониманием словаря из приведенного выше примера.
Теперь давайте посмотрим, как мы можем использовать понимание словаря, используя данные из другого словаря.
Пример 3: Как использовать понимание словаря
# цена товара в долларах
old_price = {'молоко': 1,02, 'кофе': 2,5, 'хлеб': 2,5}
Dollar_to_pound = 0,76
new_price = {item: value * dollar_to_pound для (item, value) в old_price.items ()}
печать (новая_цена)
Выход
{'молоко': 0,7752, 'кофе': 1,9, 'хлеб': 1,9}
Здесь мы видим, что мы получили цены на товары в долларах и преобразовали их в фунты.Использование понимания словаря делает эту задачу намного проще и короче.
Условные выражения в понимании словаря
Мы можем дополнительно настроить понимание словаря, добавив к нему условия. Давайте посмотрим на пример.
Пример 4: Условное понимание словаря
original_dict = {'jack': 38, 'michael': 48, 'guido': 57, 'john': 33}
even_dict = {k: v вместо (k, v) в original_dict.items (), если v% 2 == 0}
печать (even_dict)
Выход
{'jack': 38, 'michael': 48}
Как мы видим, были добавлены только элементы с четным значением из-за предложения if в понимании словаря.
Пример 5: Множественное понимание условного словаря if
original_dict = {'jack': 38, 'michael': 48, 'guido': 57, 'john': 33}
new_dict = {k: v вместо (k, v) в original_dict.items (), если v% 2! = 0, если v <40}
печать (новый_дикт)
Выход
{'john': 33}
В этом случае в новый словарь были добавлены только элементы с нечетным значением менее 40.
Это из-за нескольких предложений if в понимании словаря.Они эквивалентны операциям и , в которых должны выполняться оба условия.
Пример 6: Условное понимание словаря if-else
original_dict = {'jack': 38, 'michael': 48, 'guido': 57, 'john': 33}
new_dict_1 = {k: ('старый', если v> 40 иначе 'молодой')
for (k, v) в original_dict.items ()}
печать (new_dict_1)
Выход
{'jack': 'молодой', 'michael': 'старый', 'guido': 'старый', 'john': 'молодой'}
В этом случае новый словарь создается через понимание словаря.
Предметы стоимостью 40 или более имеют значение «старые», тогда как другие имеют значение «молодые».
Понимание вложенного словаря
Мы можем добавлять понимание словаря к самому пониманию словаря, чтобы создавать вложенные словари. Давайте посмотрим на пример.
Пример 7: Вложенный словарь с двумя словарными интерпретациями
словарь = {
k1: {k2: k1 * k2 для k2 в диапазоне (1, 6)} для k1 в диапазоне (2, 5)
}
печать (словарь)
Выход
{2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10},
3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15},
4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20}}
Как видите, мы построили таблицу умножения во вложенном словаре для чисел от 2 до 4.
Когда используется понимание вложенного словаря, Python сначала запускается из внешнего цикла, а затем переходит во внутренний.
Итак, приведенный выше код будет эквивалентен:
словарь = dict ()
для k1 в диапазоне (11, 16):
словарь [k1] = {k2: k1 * k2 для k2 в диапазоне (1, 6)}
печать (словарь)
Далее можно развернуть:
словарь = dict ()
для k1 в диапазоне (11, 16):
словарь [k1] = dict ()
для k2 в диапазоне (1, 6):
словарь [k1] [k2] = k1 * k2
печать (словарь)
Все эти три программы дают одинаковый результат.
Преимущества использования понимания словаря
Как мы видим, понимание словаря значительно сокращает процесс инициализации словаря. Это делает код более питоническим.
Использование понимания словаря в нашем коде может сократить строки кода при сохранении логики.
Предупреждения об использовании понимания словаря
Несмотря на то, что словарные интерпретации отлично подходят для написания элегантного кода, который легко читать, они не всегда являются правильным выбором.
Мы должны быть осторожны при использовании их как:
- Иногда они могут замедлить выполнение кода и потреблять больше памяти.
- Они также могут снизить читабельность кода.
Мы не должны пытаться уместить в них сложную логику или большое количество словарных понятий только ради того, чтобы сделать код однострочным. В этих случаях лучше выбрать другие альтернативы, например петли.
.
Вложенный словарь Python (с примерами)
В Python словарь - это неупорядоченный набор элементов. Например:
словарь = {'ключ': 'значение',
'ключ_2': 'значение_2'} Здесь словарь имеет пару ключ: значение , заключенную в фигурные скобки {} .
Чтобы узнать больше о словаре, посетите Python Dictionary.
Что такое вложенный словарь в Python?
В Python вложенный словарь - это словарь внутри словаря.Это собрание словарей в один словарь.
nested_dict = {'dictA': {'key_1': 'value_1'},
'dictB': {'ключ_2': 'значение_2'}} Здесь nested_dict - это вложенный словарь со словарями dictA и dictB . Это два словаря, каждый из которых имеет собственный ключ и значение.
Создать вложенный словарь
Мы собираемся создать словарь людей внутри словаря.
Пример 1: Как создать вложенный словарь
человек = {1: {'name': 'John', 'age': '27', 'sex': 'Male'},
2: {'name': 'Marie', 'age': '22', 'sex': 'Female'}}
печать (чел.) Когда мы запустим вышеуказанную программу, она выдаст:
{1: {'name': 'John', 'age': '27', 'sex': 'Male'}, 2: {'name': 'Marie', 'age': '22', ' sex ':' Женский '}} В приведенной выше программе человек - это вложенный словарь.Внутренний словарь 1 и 2 назначен на человек . Здесь оба словаря имеют ключ , имя , возраст , пол с разными значениями. Теперь печатаем результат человек .
Элементы доступа вложенного словаря
Для доступа к элементу вложенного словаря мы используем синтаксис индексации [] в Python.
Пример 2: Доступ к элементам с помощью синтаксиса []
человек = {1: {'name': 'John', 'age': '27', 'sex': 'Male'},
2: {'name': 'Marie', 'age': '22', 'sex': 'Female'}}
печать (люди [1] ['имя'])
печать (люди [1] ['возраст'])
печать (люди [1] ['секс']) Когда мы запустим вышеуказанную программу, она выдаст:
Джон 27 Мужской
В приведенной выше программе мы печатаем значение ключа , имя , используя i.е. человек [1] ['name'] из внутреннего словаря 1 . Точно так же мы печатаем значение возраста и пола одно за другим.
Добавить элемент во вложенный словарь
Пример 3: Как изменить или добавить элементы во вложенном словаре?
человек = {1: {'name': 'John', 'age': '27', 'sex': 'Male'},
2: {'name': 'Marie', 'age': '22', 'sex': 'Female'}}
люди [3] = {}
люди [3] ['name'] = 'Луна'
люди [3] ['age'] = '24'
люди [3] ['sex'] = 'Женский'
люди [3] ['женат'] = 'Нет'
печать (чел. [3]) Когда мы запустим вышеуказанную программу, она выдаст:
{'имя': 'Луна', 'возраст': '24', 'пол': 'Женщина', 'замужем': 'Нет'} В приведенной выше программе мы создаем пустой словарь 3 внутри словаря человек .
Затем мы добавляем пару ключ: значение , т.е. человек [3] ['Name'] = 'Luna' внутри словаря 3 . Точно так же мы делаем это для ключа , возраст , , пол и , женатого один за другим. Когда мы печатаем человек [3] , мы получаем пар ключ: значение словаря 3 .
Пример 4: Добавить еще один словарь во вложенный словарь
человек = {1: {'name': 'John', 'age': '27', 'sex': 'Male'},
2: {'name': 'Marie', 'age': '22', 'sex': 'Female'},
3: {'имя': 'Луна', 'возраст': '24', 'пол': 'Женщина', 'замужем': 'Нет'}}
people [4] = {'name': 'Peter', 'age': '29', 'sex': 'Male', 'женатый': 'Yes'}
печать (чел [4]) Когда мы запустим вышеуказанную программу, она выдаст:
{'имя': 'Петр', 'возраст': '29', 'пол': 'Мужской', 'женатый': 'Да'} В приведенной выше программе мы назначаем словарный литерал людям [4] .Литерал имеет ключи имя , возраст и пол с соответствующими значениями. Затем мы печатаем people [4] , чтобы увидеть, что словарь 4 добавлен во вложенный словарь people.
Удалить элементы из вложенного словаря
В Python мы используем оператор «del» для удаления элементов из вложенного словаря.
Пример 5: Как удалить элементы из вложенного словаря?
человек = {1: {'name': 'John', 'age': '27', 'sex': 'Male'},
2: {'name': 'Marie', 'age': '22', 'sex': 'Female'},
3: {'имя': 'Луна', 'возраст': '24', 'пол': 'Женщина', 'замужем': 'Нет'},
4: {'name': 'Peter', 'age': '29', 'sex': 'Male', 'женатый': 'Yes'}}
дель люди [3] ['женаты']
дель люди [4] ['женаты']
печать (люди [3])
печать (чел [4]) Когда мы запустим вышеуказанную программу, она выдаст:
{'name': 'Luna', 'age': '24', 'sex': 'Female'}
{'name': 'Peter', 'age': '29', 'sex': 'Male'} В приведенной выше программе мы удаляем пары ключ : значение из связанных из внутреннего словаря 3 и 4 .Затем мы печатаем человек [3] и человек [4] , чтобы подтвердить изменения.
Пример 6: Как удалить словарь из вложенного словаря?
человек = {1: {'name': 'John', 'age': '27', 'sex': 'Male'},
2: {'name': 'Marie', 'age': '22', 'sex': 'Female'},
3: {'name': 'Luna', 'age': '24', 'sex': 'Female'},
4: {'name': 'Peter', 'age': '29', 'sex': 'Male'}}
дель люди [3], люди [4]
печать (чел.) Когда мы запустим вышеуказанную программу, она выдаст:
{1: {'name': 'John', 'age': '27', 'sex': 'Male'}, 2: {'name': 'Marie', 'age': '22', ' sex ':' Женский '}} В приведенной выше программе мы удаляем как внутренний словарь 3 , так и 4 , используя del из вложенного словаря человек .Затем печатаем вложенный словарь человек для подтверждения изменений.
Итерация по вложенному словарю
Используя циклы for, мы можем перебирать каждый элемент во вложенном словаре.
Пример 7: Как перебирать вложенный словарь?
человек = {1: {'Имя': 'Джон', 'Возраст': '27', 'Пол': 'Мужской'},
2: {'Имя': 'Мари', 'Возраст': '22', 'Пол': 'Женский'}}
для p_id, p_info в people.items ():
print ("\ nИдентификатор:", p_id)
для ключа в p_info:
print (ключ + ':', p_info [ключ]) Когда мы запустим вышеуказанную программу, она выдаст:
Персональный ID: 1 Имя: Джон Возраст: 27 Пол: Мужской ID человека: 2 Имя: Мари Возраст: 22 года Пол: Женский
В приведенной выше программе первый цикл возвращает все ключи во вложенном словаре человек .Он состоит из идентификаторов p_id каждого человека. Мы используем эти идентификаторы для распаковки информации p_info каждого человека.
Второй цикл перебирает информацию о каждом человеке. Затем он возвращает все ключи имя , возраст , пол словаря каждого человека.
Теперь мы печатаем ключ информации о человеке и значение этого ключа.
Ключевые моменты, о которых следует помнить:
- Вложенный словарь - это неупорядоченный набор словарей
- Нарезка вложенного словаря невозможна.
- При необходимости мы можем уменьшить или увеличить вложенный словарь.
- Как и Dictionary, у него также есть ключ и значение.
- Доступ к словарю осуществляется с помощью клавиши.
.