Python есть ли ключ в словаре. Словари (dict) и работа с ними

09.05.2019

Сегодня я расскажу о таком типе данных, как словари , о работе со словарями, операциях над ними, методах, о генераторах словарей.

Словари в Python - неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

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

>>> d = {} >>> d {} >>> d = { "dict" : 1 , "dictionary" : 2 } >>> d {"dict": 1, "dictionary": 2}

Во-вторых, с помощью функции dict :

>>> d = dict (short = "dict" , long = "dictionary" ) >>> d {"short": "dict", "long": "dictionary"} >>> d = dict ([(1 , 1 ), (2 , 4 )]) >>> d {1: 1, 2: 4}

В-третьих, с помощью метода fromkeys:

>>> d = dict . fromkeys ([ "a" , "b" ]) >>> d {"a": None, "b": None} >>> d = dict . fromkeys ([ "a" , "b" ], 100 ) >>> d {"a": 100, "b": 100}

В-четвертых, с помощью генераторов словарей, которые очень похожи на .

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

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

>>> d = { 1 : 2 , 2 : 4 , 3 : 9 } >>> d [ 1 ] 2 >>> d [ 4 ] = 4 ** 2 >>> d {1: 2, 2: 4, 3: 9, 4: 16} >>> d [ "1" ] Traceback (most recent call last): File "", line 1, in d["1"] KeyError : "1"

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

Что же можно еще делать со словарями? Да то же самое, что и с другими объектами: , (например, ), а также специальные методы словарей.

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

dict.clear () - очищает словарь.

dict.copy () - возвращает копию словаря.

classmethod dict.fromkeys (seq[, value]) - создает словарь с ключами из seq и значением value (по умолчанию None).

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

dict.items () - возвращает пары (ключ, значение).

dict.keys () - возвращает ключи в словаре.

dict.pop (key[, default]) - удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

dict.popitem () - удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

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

dict.update () - обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

dict.values () - возвращает значения в словаре.

и является НЕУПОРЯДОЧЕННОЙ коллекцией значений.

Особенности словарей:
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

Серия контента:

После списков словарь является самым гибким встроенным типом. Если список - это упорядоченная коллекция, то словарь - неупорядоченная. Основные особенности словарей:

Доступ осуществляется по ключу, а не по индексу. По аналогии со списком, в словаре можно получить доступ к элементам в цикле по ключам.
Значения словаря хранятся в неотсортированном порядке, более того, ключи могут храниться не в том порядке, в котором они добавляются.
По аналогии со списками, словарь может хранить вложенные словари. Словарь может хранить в качестве значений объекты любого типа (heterogeneous). Ключ в словаре - immutable тип, может быть строкой, целым числом, float либо кортежем, состоящим из указанных типов.
Словари реализованы как хеш-таблицы с быстрым доступом.
Словари, так же как и списки, хранят ссылки на объекты, а не сами объекты.

Сегодня мы рассмотрим следующие темы.

Что такое словарь.
Функции/методы словаря.
Операции со словарем.
Примеры.

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

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

Основные операции над словарем - сохранение с заданным ключом и извлечение по нему значения. Также можно удалить пару key: value с помощью инструкции del .

Метод keys() для словаря возвращает список всех используемых ключей в произвольном порядке; для сортировки списка нужно применить метод sort() . Для определения наличия определенного ключа есть метод has_key() , который в версии 3.0 успеет устареть - вместо него есть оператор in . Добавление нового объекта в словарь не требует предварительных проверок: если ранее ключу уже соответствовало некоторое значение, оно будет перезаписано.

Пример - словарь в качестве телефонного справочника:

>>> dic = {"vanya" : 23323223, "smith" : 32232332} >>> dic["fedya"] = 33332222 >>> dic {"vanya": 23323223, "fedya": 33332222, "smith": 32232332} >>> dic["smith"] 32232332 >>> del dic["vanya"] >>> dic {"fedya": 33332222, "smith": 32232332} >>> dic.keys() ["fedya", "smith"] >>> dic.has_key("fedya") True

Создать словарь можно несколькими способами:

Обычное выражение - оно удобно, если словарь статичен: D = {"name": "mel", "age": 45}
Динамический вариант создания на лету: D = {} D["name"] = "mel" D["age"] = 45
С помощью функции dict() - ключи при этом должны быть строками. С помощью этой функции можно избавить себя от обязательного условия заключать ключ в кавычки. В примере приведены четыре варианта создания одного и того же словаря: d1 = dict(id=1948, name="Washer", size=3) d2 = dict({"id": 1948, "name": "Washer", "size": 3}) d3 = dict([("id", 1948), ("name", "Washer"), ("size", 3)]) d4 = dict(zip(("id", "name", "size"), (1948, "Washer", 3)))
С помощью fromkeys() - создает словарь по списку ключей с пустыми значениями: D = {}.fromkeys(["name", "age"],123)
С помощью конструктора: d = dict((x, x**2) for x in xrange(5))

2. Функции/методы словаря

dict() - создание словаря;

len() - возвращает число пар;

clear() - удаляет все значения из словаря;

copy() - создает псевдокопию словаря;

deepcopy() - создает полную копию словаря;

fromkeys() - создание словаря;

get() - получить значение по ключу;

has_key() - проверка значения по ключу;

items() - возвращает список значений;

iteriyems() - возвращает итератор;

iterkeys() - возвращает итератор ключей;

pop() - извлекает значение по ключу;

popitem() - извлекает произвольное значение;

update() - изменяет словарь;

values() - возвращает список значений;

itervalues() - возвращает итератор на список значений.

in - оператор, проверяет наличие значения по ключу;

del - оператор, удаляет пару по ключу;

dict() - конструирует словарь с помощью последовательности.

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

>>> items = [("name","sveta"),("age",20)] >>> d = dict(items) >>> d {"age": 20, "name": "sveta"} >>> len(d) 2

in() - оператор проверки вхождения.

Пример: база данных может быть заполнена в виде словаря.

Проверить наличие в базе данных телефона по имени:

people = {"Alice": {"phone": "2341", "addr": "Foo drive 23" }, "Beth": {"phone": "9102", "addr": "Bar street 42"}} name = "Alice" key = "phone" if name in people: print "%s phone is %s" % (name, people) >>> Alice phone is 2341 copy()

Пример создания копии словаря:

>>> x = {"user":"admin","attr":} >>> y = x.copy() >>> y {"user": "admin", "attr": }

Метод copy() не делает полного копирования: если мы, например, сделаем операцию:

>>> x["attr"].remove(1)

то с удивлением обнаружим, что удаление атрибута произойдет также и в копии.

Чтобы этого не произошло, нужно использовать метод deepcopy() .

>>> from copy import deepcopy >>> y = x.deepcopy()

fromkeys() - создает словарь по заданным ключам с пустыми значениями:

>>> {}.fromkeys(["name", "age"]) {"age": None, "name": None}

Можно все значения заполнить по умолчанию:

>>> {}.fromkeys(["name", "age"],123) {"age": 123, "name": 123}

get() - получает значение по ключу, в случае отсутствия дает None:

>>> d = {} >>> print d.get("name") None

has_key() - проверяет, есть ли в словаре значение по данному ключу:

>>> d = {} >>> d.has_key("name") False

items() - возвращает список значений:

for key, value in d.items(): print(key, value)

iteriyems() - возвращает итератор - выдает тот же результат:

>>> for k, v in d.iteritems(): ... print k, v

keys() - возвращает список ключей;

iterkeys() - возвращает итератор ключей:

>>> d.keys() ["url", "title"] >>> d.iterkeys()

pop() - извлекает значение по ключу с последующим удалением:

>>> d.pop("title") >>> d {"url": "http://www.python.org"}

popitem() - извлекает произвольное значение с последующим удалением:

>>> d = {"title": "Python Web Site", "url": "http://www.python.org", "www": "python"} >>> d.popitem() >>> d {"www": "python", "title": "Python Web Site"}

update() - изменяет значение по ключу:

>>> d2 = {"www":"python.org"} >>> d.update(d2) >>> d {"www": "python.org", "title": "Python Web Site"}

values() - возвращает список значений:

>>> d={} >>> d=1 >>> d=2 >>> d=3 >>> d {1: 1, 2: 2, 3: 3} >>> d.values()

del - оператор удаляет пару ключ: значение по ключу:

>>> del d >>> d {1: 1, 3: 3}

3. Операции

Поскольку словари представляют собой мапы (map), а не последовательности, к ним нельзя применить конкатенацию или срезы.

К словарям можно применять стандартные операторы сравнения:

<, <=, ==, !=, >=, >

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

>>> table = {"Python": "Guido van Rossum", ... "Perl": "Larry Wall", ... "Tcl": "John Ousterhout" } >>> for lang in table: ... print(lang, table) .. >>> Tcl John Ousterhout >>> Python Guido van Rossum >>> Perl Larry Wall

Словари хорошо подходят для хранения многомерных массивов или матриц:

>>> Matrix = {} >>> Matrix[(2, 3, 4)] = 88 >>> Matrix[(7, 8, 9)] = 99 >>> >>> X = 2; Y = 3; Z = 4 >>> Matrix[(X, Y, Z)] 88 >>> Matrix {(2, 3, 4): 88, (7, 8, 9): 99}

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

>>> man = {"name": "Serg", ... "jobs": ["programmer", "writer"], ... "web": "www.iakovlev.org", ... "home": {"city": "Moscow", "zip":129000}} >>> man["name"] Serg >>> man["jobs"] "writer"

4. Примеры

Пример 1. Подсчитаем, сколько раз в строке встречается каждый символ:

def histogram(s): d = dict() for c in s: if c not in d:d[c] = 1 else:d[c] += 1 return d hist = histogram("how many times") >>> {"a": 1,"e": 1,"i": 1,"h": 1,"m": 2,"o": 1,"n": 1,"s": 1,"t": 1,"w": 1,"y": 1}

Если нам нужно инвертировать данный словарь и в качестве ключа поставить частоту:

def invert_dict(d): inv = dict() for key in d: val = d if val not in inv:inv = else:inv.append(key) return inv print invert_dict(hist) >>> {1: ["a", "e", "i", "h", "o", "n", "s", "t", "w", "y"], 2: [" ", "m"]} import string import sys words = {} strip = string.whitespace + string.punctuation + string.digits + "\""" filename = "file" for line in open(filename): for word in line.lower().split(): word = word.strip(strip) if len(word) > 2: words = words.get(word, 0) + 1 for word in sorted(words): print(""{0}" occurs {1} times".format(word, words))

Пример 3. Сортировка словаря по ключам:

author = {"php":"Rasmus Lerdorf",\ "perl":"Larry Wall",\ "tcl":"John Ousterhout",\ "awk":"Brian Kernighan",\ "java":"James Gosling",\ "parrot":"Simon Cozens",\ "python":"Guido van Rossum"} #Либо так: langs = author.keys() langs.sort() for language in langs: print language," - ",author #либо так: for key in sorted(author.iterkeys()): print "%s: %s" % (key, author) >>> awk - Brian Kernighan >>> java - James Gosling >>> parrot - Simon Cozens >>> perl - Larry Wall >>> php - Rasmus Lerdorf >>> python - Guido van Rossum >>> tcl - John Ousterhout

Пример 4. Как инвертировать словарь, т.е. поменять ключи со значениями:

def invert_dict_nonunique(d): newdict = {} for k, v in d.iteritems(): newdict.setdefault(v, ).append(k) return newdict d = {"child1": "parent1","child2": "parent1","child3": "parent2","child4": "parent2"} print invert_dict_nonunique(d) >>> {"parent2": ["child3", "child4"], "parent1": ["child1", "child2"]}

Заключение

Можно подвести итоги: словари наряду со списками являются наиболее простыми, гибкими и мощными коллекционными типами. Словарь, как и список, является изменяемым (mutable) типом данных, хотя и содержит неизменяемые ключи и может неограниченно расти. Если вам нужна коллекция с доступом по ключу - словарь подходит для этого лучше всего. Если вам нужна коллекция для хранения произвольных объектов произвольной вложенности - словарь в этом вам поможет.

Код примеров проверялся на версии питона 2.6.

Ресурсы для скачивания

static.content.url=http://www.сайт/developerworks/js/artrating/

Zone=Open source, Linux

ArticleID=505647

ArticleTitle=Программирование на Python: Часть 4. Словари

Обычные списки (массивы) представляют собой набор пронумерованных элементов, то есть для обращения к какому-либо элементу списка необходимо указать его номер. Номер элемента в списке однозначно идентифицирует сам элемент. Но идентифицировать данные по числовым номерам не всегда оказывается удобно. Например, маршруты поездов в России идентифицируются численно-буквенным кодом (число и одна буква), также численно-буквенным кодом идентифицируются авиарейсы, то есть для хранения информации о рейсах поездов или самолетов в качестве идентификатора удобно было бы использовать не число, а текстовую строку.

Структура данных, позволяющая идентифицировать ее элементы не по числовому индексу, а по произвольному, называется словарем или ассоциативным массивом . Соответствующая структура данных в языке Питон называется 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)