Это четвертый пост об идиомах в Питона. Теперь пришло время узнать, что же такое словари в Python. Вы наверняка знаете, что это такая структура данных, тип которой обычно обозначают как dict. Пост же несколько подробнее расскажет о словарях: о том, как их перебирать или получать значение по ключу.
Работа со словарями Python
Вообще, словарями в Python называют коллекции произвольных объектов с доступом по ключу. При этом коллекции неупорядоченные. По-другому словари можно называть ассоциативными массивами или хеш-таблицами. Словарь может выглядеть, например, так:
Dict = {"ключ1": 1, "ключ2": 2}
Конечно же, существует куча способов работы со словарями, и все они не поместятся в этот пост. Но некоторые полезные идиомы, пожалуй, стоит упомянуть.
Цикл по ключам словаря Python
Одна из базовых операций, которая требуется при работе со словарями — это цикл по его ключам. Наверняка вы будете часто использовать такую операцию, поэтому стоит обратить внимание на правильный и красивый способ ее выполнения.
#Не перебирайте ключи так for k in dic.keys(): print(k) #Делайте это так for k in dic: print(k)
Как видите. для цикла по ключам словаря не нужно использовать метод dictionary.keys() . Все что нужно — это ссылка на словарь.
Цикл по паре ключ-значение Python
Еще одна нужная операция, которая почти всегда требуется при работе со словарями — это цикл по паре ключ:значение. Конечно же, в Python есть несколько быстрых и простых способ построить такой цикл.
#цикл можно построить так for k in dic: print(k) print(dic[k]) #или вот так for k, val in dic.items(): print(k) print(val)
В примере показано два способа перебора пар ключ-значение в словаре. Первый перебирает ключи словаря, а значения извлекает по ключу. Второй пример пробегает по словарю, распаковывая ключи и значения в две переменные.
Использование dictionary.get() для получения значений
Если нужно получить значение по ключу, но при этом неизвестно, существует такой ключ или нет — используйте метод dictionary.get() .
#Использование get() для получения значения val = dic.get("key1", "na")
Если ключ «key1» существует в словаре dic, то переменной будет присвоено значение в соответствии с ключом. В противном случае переменная получит значение второго аргумента функции get() .
Удаление элементов из словаря Python по критериям
Вероятно, если бы перед вами встала такая задача, то в мыслях сразу бы возникли циклы и условные операторы. Но в Питоне все это не требуется! Смотрите:
#Удаление элементов из словаря по критериям dic = {k: dic[k] for k in dic if not len(k) < 5}
Синтаксис очень простой: {ключ: значение for ключ in словарь [условия]}. Пример выше создаст новый словарь, которые содержит все пары ключ-значение, в которых ключ имеет длину менее 5.
Объединение двух списков в словарь
Например, у вас есть список имен и список фамилий. Но вы хотите иметь словарь из пар фамилия-имя. Что делать в такой ситуации? Объединять списки в словарь, конечно же!
#Объединение двух списков в словарь f_names = ["Ivan", "Anton", "Oleg", "Petr"] l_names = ["Petrov", "Sidorov", "Ivanov", "Skripkin"] names = dict(zip(f_names, l_names))
Эта идиома принимает на вход два списка: f_names и l_names, а затем формирует из них словарь из пар фамилия-имя. Это быстро и просто, как и в других . Если вас заинтересует метод zip() — почитайте о нем подробнее в документации.
На этом все. Надеюсь, несколько описанных идиом помогут вам эффективнее использовать словари в Python, сделать ваш код более читабельным и элегантным. Кстати, если интересно — можете почитать еще об одной структуре данных в Питоне — о .
Спасибо Jamal Moir за замечательные советы.
и является НЕУПОРЯДОЧЕННОЙ коллекцией значений.
Особенности словарей:
1. Доступ по ключу. Есть возможность получить доступ к элементам в цикле по ключам.
2. Значения словаря хранятся в НЕОТСОРТИРОВАННОМ порядке, а ключи могут храниться не встом порядке, в котором они добавляются.
3. Словарь может хранить вложенные словари. Значения словаря могут быть любого типа. Ключь в словаре — immutable тип, может быть строкой, целым числом, float либо кортежем, состоящим из укзанных типов.
4. Словари реализованы как хеш-таблицы с быстрым доступом.
5. Словари хранят ссылки на объекты, а не сам объект.
Основными операциями над словарем являются: сохранение с заданным ключом и извлечение по нему значения. Также можно удалить пару key: value с помощью инструкции del .
Методы (функции) словаря:
- dict() - создание словаря;
- len() - возвращает число пар;
- clear() - удаляет все значения из словаря;
- copy() - создает псевдокопию словаря;
- deepcopy() - создает полную копию словаря;
- fromkeys() - создание словаря;
- get() - получить значение по ключу;
- has_key() - проверка значения по ключу;
- items()
- iteriyems() - возвращает итератор;
- keys() - возвращает список ключей;
- iterkeys() - возвращает итератор ключей;
- pop() - извлекает значение по ключу;
- popitem() - извлекает произвольное значение;
- update() - изменяет словарь;
- values() - возвращает список значений;
- itervalues() - возвращает итератор на список значений.
- in - оператор, проверяет наличие значения по ключу;
- del - оператор, удаляет пару по ключу;
- dict() - конструирует словарь с помощью последовательности.
На примере небольшой программки — телефонной книге покажем некоторые операции со словарями:
Код: telbook = {"sasha": "32-11-4", "vanya": "44-65-99"} # Объявляем словарь telbook["fedya"] = "22-47-32" # добавляем новый объект в словарь print telbook # Выводим все значения словаря print telbook["vanya"] # Выводим номер значения "vanya" del telbook["sasha"] # удаляем значение "sasha" print telbook # смотрим, что получилось print telbook.keys() # Выводим значения print telbook.has_key("vanya") # проверяем, есть ли в словаре значение "vanya" Результат: {"vanya": "44-65-99", "fedya": "22-47-32", "sasha": "32-11-4"} 44-65-99 {"vanya": "44-65-99", "fedya": "22-47-32"} ["vanya", "fedya"] True
Способы создания словаря:
1. По аналогии со списками и кортежами. Только скобочки фигурные {}:
>>> s = {"name": "Vitaliy", "age": 25} >>> s {"age": 25, "name": "Vitaliy"}
2.Динамически. По мере надобности:
>>> s["name"] = "Vitaliy" >>> s["age"] = 26 >>> s {"age": 26, "name": "Vitaliy"}
3. Используя метод dict() . При этом ключи должны быть строками. С помощью этого метода можно писать ключ без кавычек. Ниже представлены четире варианта заполнения словаря:
>>> s1 = dict(id = 1, name = "Vitaliy", age = 26) >>> s1 {"age": 26, "name": "Vitaliy", "id": 1} >>> s2 = dict({"id": 1, "name": "Vitaliy", "age": 26}) >>> s2 {"age": 26, "id": 1, "name": "Vitaliy"} >>> s3 = dict([("id",1),("name","Vitaliy"),("age",26)]) >>> s3 {"age": 26, "id": 1, "name": "Vitaliy"} >>> s4 = dict(zip(("id","name","age"),(1,"Vitaliy",26))) >>> s4 {"age": 26, "id": 1, "name": "Vitaliy"}
4.используя метод fromkeys() — создает словарь из указанного списка ключей с пустыми значениями.
>>> d = {}.fromkeys(["name","age"],123) >>> d {"age": 123, "name": 123} или >>> d = {}.fromkeys(["name","age"]) >>> d {"age": None, "name": None}
5. С помощью конструктора:
>>> s = dict((x,x**2) for x in xrange(5)) >>> s {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Ну, а теперь практика, пробуем создать словарь с помощью списка кортежей:
>>> list = [("name","age"),("Tanya",25)] >>> s = dict(list) >>> s {"Tanya": 25, "name": "age"} >>> len(s) # Длина словаря (количество значений) 2
Создаем небольшую базу данных и производим поиск поней:
Код: ludi = {"Ivan": {"phone": "23-44-6", "age" : "20"}, "Igor": {"phone": "45-2-67", "age" : "40"}} name = raw_input("Vvedite imya, chtobi uznat nomer telefona: ") key = "phone" if name in ludi: print "%s phone is %s" % (name, ludi) Результат: Vvedite imya, chtobi uznat nomer telefona: Igor Igor phone is 45-2-67
Копирование словаря с помощью метода copy() :
>>> x = {"name":"admin","room":} >>> y = x.copy() >>> y {"name": "admin", "room": }
Но метод copy() лишь показывает содержимое источника. Например, если мы удалим удно значения из списка ‘room’ в x, то увидим, что оно пропало и в y:
>>> x["room"].remove(1) >>> y {"name": "admin", "room": }
Чтобы этого не произошло, используем deepcopy() :
>>> from copy import deepcopy >>> y = x.deepcopy()
Метод get() - Выводит значение по ключу,a в случае отсутствия дает None:
>>> a = {"name":"Vitaliy"} >>> print a.get("name") Vitaliy
Метолд items() - возвращает весь список значений словаря:
Код: d = {"name":"user","room":"125"} for key, value in d.items(): print(key, value) Результат: ("name", "user") ("room", "125")
Метод iteriyems() - возвращает итератор - выдает тот же результат:
Код: for k, v in d.iteritems(): print k, v Результат: name user room 125
Метод keys() - возвращает список ключей.
>>> print d.keys() ["name", "room"]
Метод pop() - извлекает значение по ключу с последующим удалением:
>>> d.pop("name") "user" >>> d {"room": "125"}
Метод popitem() - извлекает произвольное значение с последующим удалением.
Метод update() - изменяет значение словаря по ключу:
>>> d1 = {"room":"12"} >>> d.update(d1) >>> d {"room": "12"}
Метод values() - возвращает список значений:
>>> d.values() ["12"]
Оператор del - удаляет пару ключ: значение по ключу:
>>> del d["room"] >>> d {}
Просмотры: 3 890
Словарь - неупорядоченная структура данных, которая позволяет хранить пары «ключ - значение». Вот пример словаря на Python:
Dictionary = {"персона": "человек", "марафон": "гонка бегунов длиной около 26 миль", "противостоять": "оставаться сильным, несмотря на давление", "бежать": "двигаться со скоростью"}
Данный словарь использует строки в качестве ключей, однако ключом может являться в принципе любой неизменяемый тип данных. Значением же конкретного ключа может быть что угодно. Вот ещё один пример словаря, где ключами являются числа, а значениями - строки:
Gender_dict = {0: "муж", 1: "жен"}
Важное уточнение: если вы попробуете использовать изменяемый тип данных в качестве ключа, то получите ошибку:
Dictionary = {(1, 2.0): "кортежи могут быть ключами", 1: "целые числа могут быть ключами", "бежать": "строки тоже", ["носок", 1, 2.0]: "а списки не могут"}
Прим. перев. На самом деле проблема не с изменяемыми, а с нехэшируемыми типами данных, но обычно это одно и то же.
Получение данных из словаря
Для получения значения конкретного ключа используются квадратные скобки . Предположим, что в нашем словаре есть пара "марафон": 26 .
# берём значение с ключом "марафон" dictionary["марафон"]
Опять же, вы получите ошибку, если попытаетесь получить значение по несуществующему ключу. Для избежания подобных ошибок существуют методы, о которых мы сейчас поговорим.
Добавление и обновление ключей
Добавление новых пар в словарь происходит достаточно просто:
# Добавляем ключ "туфля" со значением "род обуви, закрывающей ногу не выше щиколотки" dictionary["туфля"] = "род обуви, закрывающей ногу не выше щиколотки"
Обновление существующих значений происходит абсолютно также:
# Обновляем ключ "туфля" и присваиваем ему значение "хорошая туфля" dictionary["туфля"] = "хорошая туфля"
Удаление ключей
Для удаления ключа и соответствующего значения из словаря можно использовать del
# Удаляем значение с ключом "противостоять" из словаря del dictionary["противостоять"]
Методы
Словари в Python имеют множество различных полезных методов, которые помогут вам в работе с ними. Вот лишь некоторые из них:
Update
Метод update() пригодится, если нужно обновить несколько пар сразу. Метод принимает другой словарь в качестве аргумента.
# Добавляем две пары в словарь dictionary, используя метод update dictionary.update({"бежал": "бежать в прошедшем времени", "туфли": "туфля во множественном числе"}) >>> dictionary {"марафон": "гонка бегунов длиной около 26 миль", "персона": "человек", "бежал": "бежать в прошедшем времени", "бежать": "двигаться со скоростью", "туфля": "род обуви, закрывающей ногу не выше щиколотки", "туфли": "туфля во множественном числе"}
Если вас интересует, почему данные в словаре расположены не в том порядке, в котором они были внесены в него, то это потому что словари не упорядочены.
Get
# Допустим, у нас есть словарь story_count story_count = {"сто": 100, "девяносто": 90, "двенадцать": 12, "пять": 5}Метод get() возвращает значение по указанному ключу. Если указанного ключа не существует, метод вернёт None .
# Ключ "двенадцать" существует и метод get в данном случае вернёт 12 story_count.get("двенадцать")
Метод можно использовать для проверки наличия ключей в словаре:
>>> story_count.get("два") None
Также можно указать значение по умолчанию, которое будет возвращено вместо None , если ключа в словаре не окажется:
# Метод вернёт 0 в случае, если данного ключа не существует story_count.get("два", 0)
Pop
Метод pop() удаляет ключ и возвращает соответствующее ему значение.
>>> story_count.pop("девяносто") 90 >>> story_count {"двенадцать": 12, "сто": 100, "пять": 5}
Keys
Метод keys() возвращает коллекцию ключей в словаре.
>>> story_count.keys() ["сто", "пять", "двенадцать"]
Values
Метод values() возвращает коллекцию значений в словаре.
>>> story_count.values()
Items
Метод items() возвращает пары «ключ - значение».
>>> dictionary.items() [("персона", "человек"), ("бежать", "двигаться со скоростью"), ("туфля", "род обуви, закрывающей ногу не выше щиколотки"), ("бежал", "бежать в прошедшем времени"), ("марафон", "гонка бегунов длиной около 26 миль"), ("туфли", "туфля во множественном числе")]
Итерация через словарь
Вы можете провести итерацию по каждому ключу в словаре.
Обычные списки (массивы) представляют собой набор пронумерованных элементов, то есть для обращения к какому-либо элементу списка необходимо указать его номер. Номер элемента в списке однозначно идентифицирует сам элемент. Но идентифицировать данные по числовым номерам не всегда оказывается удобно. Например, маршруты поездов в России идентифицируются численно-буквенным кодом (число и одна буква), также численно-буквенным кодом идентифицируются авиарейсы, то есть для хранения информации о рейсах поездов или самолетов в качестве идентификатора удобно было бы использовать не число, а текстовую строку.
Структура данных, позволяющая идентифицировать ее элементы не по числовому индексу, а по произвольному, называется словарем или ассоциативным массивом . Соответствующая структура данных в языке Питон называется dict .
Рассмотрим простой пример использования словаря. Заведем словарь Capitals , где индексом является название страны, а значением — название столицы этой страны. Это позволит легко определять по строке с названием страны ее столицу.
# Создадим пустой словать Capitals Capitals = dict() # Заполним его несколькими значениями Capitals["Russia"] = "Moscow" Capitals["Ukraine"] = "Kiev" Capitals["USA"] = "Washington" Countries = ["Russia", "France", "USA", "Russia"] for country in Countries: # Для каждой страны из списка проверим, есть ли она в словаре Capitals if country in Capitals: print("Столица страны " + country + ": " + Capitals) else: print("В базе нет страны c названием " + country)
Итак, каждый элемент словаря состоит из двух объектов: ключа и значения . В нашем примере ключом является название страны, значением является название столицы. Ключ идентифицирует элемент словаря, значение является данными, которые соответствуют данному ключу. Значения ключей — уникальны, двух одинаковых ключей в словаре быть не может.
В жизни широко распространены словари, например, привычные бумажные словари (толковые, орфографические, лингвистические). В них ключом является слово-заголовок статьи, а значением — сама статья. Для того, чтобы получить доступ к статье, необходимо указать слово-ключ.
Другой пример словаря, как структуры данных — телефонный справочник. В нем ключом является имя, а значением — номер телефона. И словарь, и телефонный справочник хранятся так, что легко найти элемент словаря по известному ключу (например, если записи хранятся в алфавитном порядке ключей, то легко можно найти известный ключ, например, бинарным поиском), но если ключ неизвествен, а известно лишь значение, то поиск элемента с данным значением может потребовать последовательного просмотра всех элементов словаря.
Особенностью ассоциативного массива является его динамичность: в него можно добавлять новые элементы с произвольными ключами и удалять уже существующие элементы. При этом размер используемой памяти пропорционален размеру ассоциативного массива. Доступ к элементам ассоциативного массива выполняется хоть и медленнее, чем к обычным массивам, но в целом довольно быстро.
В языке Питон ключом может быть произвольный неизменяемый тип данных: целые и действительные числа, строки, кортежи. Ключом в словаре не может быть множество, но может быть элемент типа frozenset: специальный тип данных, являющийся аналогом типа set , который нельзя изменять после создания. Значением элемента словаря может быть любой тип данных, в том числе и изменяемый.
Когда нужно использовать словари
Словари нужно использовать в следующих случаях:
- Подсчет числа каких-то объектов. В этом случае нужно завести словарь, в котором ключами являются объекты, а значениями — их количество.
- Хранение каких-либо данных, связанных с объектом. Ключи — объекты, значения — связанные с ними данные. Например, если нужно по названию месяца определить его порядковый номер, то это можно сделать при помощи словаря Num["January"] = 1; Num["February"] = 2; ... .
- Установка соответствия между объектами (например, “родитель—потомок”). Ключ — объект, значение — соответствующий ему объект.
- Если нужен обычный массив, но масимальное значение индекса элемента очень велико, и при этом будут использоваться не все возможные индексы (так называемый “разреженный массив”), то можно использовать ассоциативный массив для экономии памяти.
Создание словаря
Пустой словарь можно создать при помощи функции dict() или пустой пары фигурных скобок {} (вот почему фигурные скобки нельзя использовать для создания пустого множества). Для создания словаря с некоторым набором начальных значений можно использовать следующие конструкции:
Capitals = {"Russia": "Moscow", "Ukraine": "Kiev", "USA": "Washington"} Capitals = dict(Russia = "Moscow", Ukraine = "Kiev", USA = "Washington") Capitals = dict([("Russia", "Moscow"), ("Ukraine", "Kiev"), ("USA", "Washington")]) Capitals = dict(zip(["Russia", "Ukraine", "USA"], ["Moscow", "Kiev", "Washington"])) print(Capitals)
Первые два способа можно использовать только для создания небольших словарей, перечисляя все их элементы. Кроме того, во втором способе ключи передаются как именованные параметры функции dict , поэтому в этом случае ключи могут быть только строками, причем являющимися корректными идентификаторами. В третьем и четвертом случае можно создавать большие словари, если в качестве аргументов передавать уже готовые списки, которые могут быть получены не обязательно перечислением всех элементов, а любым другим способом построены по ходу исполнения программы. В третьем способе функции dict нужно передать список, каждый элемент которого является кортежем из двух элементов: ключа и значения. В четвертом способе используется функция zip , которой передаются два списка одинаковой длины: список ключей и список значений.
Работа с элементами словаря
Основная операция: получение значения элемента по ключу, записывается так же, как и для списков: A . Если элемента с заданным ключом нет в словаре, то возникает исключение KeyError .
Другой способ определения значения по ключу — метод get: A.get(key) . Если элемента с ключом get нет в словаре, то возвращается значение None . В форме записи с двумя аргументами A.get(key, val) метод возвращает значение val , если элемент с ключом key отсутствует в словаре.
Проверить принадлежность элемента словарю можно операциями in и not in , как и для множеств.
Для добавления нового элемента в словарь нужно просто присвоить ему какое-то значение: A = value .
Для удаления элемента из словаря можно использовать операцию del A (операция возбуждает исключение KeyError , если такого ключа в словаре нет. Вот два безопасных способа удаления элемента из словаря.
В первом случае мы предварительно проверяем наличие элемента, а во втором - перехватываем и обрабатываем исключение.
Еще один способ удалить элемент из словаря: использование метода pop: A.pop(key) . Этот метод возвращает значение удаляемого элемента, если элемент с данным ключом отсутствует в словаре, то возбуждается исключение. Если методу pop передать второй параметр, то если элемент в словаре отсутствует, то метод pop возвратит значение этого параметра. Это позволяет проще всего организовать безопасное удаление элемента из словаря: A.pop(key, None) .
Перебор элементов словаря
Можно легко организовать перебор ключей всех элементов в словаре:
A = dict(zip("abcdef", list(range(6)))) for key in A: print(key, A)
Следующие методы возвращают представления элементов словаря. Представления во многом похожи на множества, но они изменяются, если менять значения элементов словаря. Метод keys возвращает представление ключей всех элементов, метод values возвращает представление всех значений, а метод items возвращает представление всех пар (кортежей) из ключей и значений.
Соответственно, быстро проверить, есть ли значение val среди всех значений элементов словаря A можно так: val in A.values() , а организовать цикл так, чтобы в переменной key был ключ элемента, а в переменной val , было его значение можно так:
A = dict(zip("abcdef", list(range(6)))) for key, val in A.items(): print(key, val)
В языке программирования 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 >>> 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 .
Метод 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 = "four" , если элемент с ключом 4 отсутствует в словаре. Если он уже есть, то nums = "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 передайте в написанную вами функцию, которая создает и возвращает новый словарь, "обратный" исходному, т. е. ключами являются строки, а значениями – числа.
