Создать словарь из списка python. Словари (dict) и работа с ними. Методы словарей

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

Особенности словарей:
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 миль"), ("туфли", "туфля во множественном числе")]

Итерация через словарь

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

Словарем в языке программирования Python называется неупорядоченный набор данных произвольного типа с доступом по ключу. Элементами такой коллекции выступают пары объектов, каждая из которых включает в себя ключ и значение. Для работы со словарями доступны функции, меняющие их содержимое и выполняющие различные операции над ними. Его можно конвертировать в другие типы данных, например, в строку.

Создание

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

A = {1: "one", 2: "two", 3: "three"} print(a) {1: "one", 2: "two", 3: "three"}

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

A = dict(one = 1, two = 2, three = 3) print(a) {"one": 1, "two": 2, "three": 3}

Как и в прошлый раз, функция print отображает содержимое словаря a. В данном случае имеется пары объектов, представленных также в виде чисел и строк.

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

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

A = {1: "one", 2: "two", 3: "three"} a = "four" print(a) {1: "one", 2: "two", 3: "three", 4: "four"}

В приведенном выше коде применяется оператор присваивания, благодаря чему новая пара (4: “four”) помещается в конец уже созданной ранее коллекции a.

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

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

A = {1: "one", 2: "two", 3: "three"} b = {4: "four", 5: "five"} a.update(b) print(a) {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}

Результатом работы метода print станет вывод на экран обновленного содержимого словаря под названием a.

После объединения, новые элементы были автоматически записаны в конец коллекции.

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

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

A = {1: "one", 2: "two", 3: "three"} del a print(a) {1: "one", 2: "two"}

Так как операция получила ключ 3, в результате ее работы удалилось и значение three.

Получение размера

Функция len позволяет в любой момент определить текущее количество элементов словаря , если передать ей в качестве аргумента имя коллекции. В приведенном ниже примере метод print осуществляет вывод на экран размерность словаря a.

A = {1: "one", 2: "two", 3: "three"} print(len(a)) 3

Стоит заметить, что функция len возвращает точное количество пар, но не объектов . В этом случае имеется словарь, который содержит в себе ровно 3 пары.

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

Произвести перебор элементов словаря можно несколькими способами, в зависимости от желаемой для получения информации о его содержимом.

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

• Пар ключ-значение;
• Перебор всех ключей;
• Перебор значений.

В данном примере показывается как вывести на экран все пары этой коллекции в формате ключ: значение . Для этого используется цикл for и функция items, работающая с элементами словаря.

A = {1: "one", 2: "two", 3: "three"} for key, value in a.items(): print(key, ":", value) 1: one 2: two 3: three

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

A = {1: "one", 2: "two", 3: "three"} for key in a.keys(): print(key) 1 2 3

Аналогичным образом нужно поступить, чтобы вывести только значения словаря . Однако в таком случае в цикле for используется метод values.

A = {1: "one", 2: "two", 3: "three"} for val in a.values(): print(val) one two three

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

Поиск

Проверить наличие определенного ключа можно при помощи операции in . Для этого достаточно вывести результат ее выполнения для словаря по имени a.

A = {1: "one", 2: "two", 3: "three"} print(2 in a) print(4 in a) True False

Как можно заметить, проверка ключа 2 дала положительный результат (True). Во втором случае вывелось значение False, поскольку ключа 4 в словаре не обнаружено.

Сортировка

Средства языка дают возможность проводить в Python сортировку словаря по ключам и значениям, в зависимости от необходимости. В следующем примере имеется коллекция данных по имени a, в которой содержится информация в произвольном порядке. Ключами здесь выступают числа, а значениями являются строки. Сортировка осуществляется за счет импортированного модуля operator и встроенного метода itemgetter , получающего 0 или 1.

Import operator a = {2: "two", 3: "three", 1: "one"} b = sorted(a.items(), key = operator.itemgetter(0)) print(b) b = sorted(a.items(), key = operator.itemgetter(1)) print(b) [(1, "one"), (2, "two"), (3, "three")] [(1, "one"), (3, "three"), (2, "two")]

Как можно заметить, аргумент 0 позволяет отсортировать словарь по ключу, в то время как 1 дает возможность вывести его содержимое в алфавитном порядке значений.

Сравнение

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

A = {1: "one", 2: "two", 3: "three"} b = {4: "four", 5: "five"} c = {1: "one", 2: "two", 3: "three"} print(cmp(a, b)) print(cmp(b, c)) print(cmp(a, c)) 1 -1 0

Приведенный код продемонстрировал выполнение метода cmp с трема комбинациями аргументов. Как видно из результатов выдачи, функция возвращает 1, если первый больше второго, -1, если наоборот и 0, когда данные полностью идентичны.

Копирование

Метод copy используется для копирования содержимого одного словаря в другой . Данный пример демонстрирует перенос ключей и значений из коллекции a в b.

A = {1: "one", 2: "two", 3: "three"} b = a.copy() print(b) {1: "one", 2: "two", 3: "three"}

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

Очистка

Чтобы избавиться от всех элементов словаря, стоит вызвать для него функцию clear .

A = {1: "one", 2: "two", 3: "three"} a.clear() print(a) {}

В результате получается абсолютно пустой набор данных.

Генератор словарей

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

A = {a: a * a for a in range(5)} print(a) {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Таким образом, на выходе получается словарь a, включающий в себя ровно 5 пар. Ключами являются числа от 0 до 4, а значениями выступают их математические квадраты.

Конвертация в строку

Словарь можно очень легко преобразовать в строку для более удобной работы с цельным представлением его содержимого. Чтобы сделать это, потребуется функция str . Как можно видеть из результатов выполнения метода type, конвертация прошла успешно.

A = {1: "one", 2: "two", 3: "three"} b = str(a) print(b) print(type(b)) {1: "one", 2: "two", 3: "three"}

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

A = "{1: "one", 2: "two", 3: "three"}" b = eval(a) print(b) print(type(b)) {1: "one", 2: "two", 3: "three"}

Как видно из примера, метод eval конвертирует весь текст строки в новый словарь.

Вложенные

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

A = { "First": { 1: "one", 2: "two", 3: "three" }, "Second": { 4: "four", 5: "five" } } print(a) {"First": {1: "one", 2: "two", 3: "three"}, "Second": {4: "four", 5: "five"}}

В примере, описанном выше, создается словарь a, включающий в себя два других словаря (First и Second). Те, в свою очередь, содержат несколько пар ключей и значений.

Резюме

Следующая таблица демонстрирует краткую сводку по всем рассмотренным методам для работы со словарями в Python 3 . В таблице отображаются названия методов, а также информация о их назначении.

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

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

Словари – это изменяемый неупорядоченный тип данных, состоящий из коллекций произвольных объектов в формате «ключ: значение». Также словари называются хэш-таблицами или ассоциативными массивами.

Обычно словари используются для хранения связанных между собой данных; например, пара может состоять из имени пользователя и его ID. Элементы словарей берутся в фигурные скобки { }.

Словарь выглядит так:

Чтобы отделить ключ от значения, в словарях используются символы двоеточия. Пары «ключ: значение» отделяются друг от друга запятыми.

Ключи всегда находятся слева от двоеточия. Ключ может быть представлен любым неизменяемым типом данных. В приведённом выше примере содержатся такие ключи:

• ‘username’
• ‘online’
• ‘followers’

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

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

• ‘8host-blog’

Первый ключ представлен строкой, второй – логическим значением, а третий – целым числом.

Читайте также:

Попробуйте отобразить словарь 8host:

print(8host)
{"username": "8host-blog", "followers": 987, "online": True}

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

Читайте также:

В словарях пары всегда расположены в случайном порядке. Однако сами пары «ключ: значение» всегда остаются неизменными, благодаря чему и осуществляется доступ к данным.

Доступ к элементам словаря

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

Доступ к данным по ключу

Словари могут стать важной частью разработанной в Python программы.

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

print(8host["username"])
8host-blog

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

Таким же образом можно вызвать и остальные значения этого словаря:

print(8host["followers"])
987
print(8host["online"])
True

Доступ к данным с помощью функций

Доступ к значениям можно получить не только с помощью ключей, но и при помощи функций.

• dict.keys() – выводит ключи словаря.
• dict.values() – выводит значения словаря.
• dict.items() – выводит пары в виде кортежа (ключ, значение).

Попробуйте использовать функцию dict.keys(), чтобы получить ключи словаря. Передайте переменную 8host.keys() функции print().

print(8host.keys())
dict_keys(["followers", "username", "online"])

Ключи возвращаются в виде итерируемого объекта класса dict_keys и отображаются в формате списка.

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

8host = {"username": "8host-blog", "online": True, "followers": 987}
jesse = {"username": "Jesse", "online": False, "points": 723}
for common_key in 8host.keys() & jesse.keys():
print(сайтmon_key], jesse)

Словари 8host и jesse содержат данные о профилях пользователей.

Эти профили отличаются: первый – профиль для социальных сетей, второй – профиль для игр. Однако у них совпадают два ключа: username и online. Чтобы убедиться в этом, запустите программу, и она выдаст:

8host-blog Jesse
True False

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

Функция dict.values() используется аналогичным образом и возвращает значения заданного словаря. Например:

8host = {"username": "8host-blog", "online": True, "followers": 987}
print(8host.values())
dict_values()

Методы keys() и values() возвращают неотсортированные ключи или значения словаря 8host в виде объектов dict_keys и dict_values соответственно.

Чтобы запросить все элементы словаря, используйте функцию items():

print(8host.items())
dict_items([("online", True), ("username", "8host-blog"), ("followers", 987)])

Эта функция возвращает объект dict_items, который состоит из пар (ключ, значение), представленных в виде кортежей.

Возвращенные списки можно итерировать с помощью цикла for. К примеру, так можно вывести каждый ключ и значение заданного словаря в более удобном для чтения формате:

for key, value in 8host.items():
print(key, "is the key for the value", value)
online is the key for the value True
followers is the key for the value 987
username is the key for the value 8host-blog

Цикл for выполнил итерацию списков ключей и значений и вывел результат построчно.

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

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

Добавление и изменение элементов словарей

Для добавления элементов используется такой синтаксис:

dict = value

Попробуйте добавить в словарь новую пару. Например:

usernames = {"8host": "8host-blog", "Jamie": "jamie54"}
usernames["Drew"] = "iam-drew"
print(usernames)
{"Drew": "iam-drew", "8host": "8host-blog", "Jamie": "jamie54"}

Как видите, в словаре появилась новая пара ‘Drew’: ‘iam-drew’.

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

Давайте рассмотрим словарь drew, который содержит данные об одном из пользователей этой сети. Предположим, сегодня количество его подписчиков заметно увеличилось, потому нужно обновить значение его ключа ‘followers’. Чтобы убедиться, что значение было изменено, используйте функцию print().

drew = {"username": "iam-drew", "online": True, "followers": 305}
drew["followers"] = 342
print(drew)
{"username": "iam-drew", "followers": 342, "online": True}

Как видите, значение ключа followers было изменено.

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

# Определить исходный словарь
usernames = {"8host": "8host-blog", "Jamie": "jamie54"}
# Добавить цикл while
while True:
# Запросить имя
print("Enter a name:")
# Присвоить его переменной
name = input()
# Проверить, есть ли такое имя в словаре и вывести результат
if name in usernames:
print(usernames + " is the username of " + name)
# Если имени нет…
else:
# Вывести на экран
print("I don\"t have " + name + "\"s username, what is it?")
# Добавить имя пользователя для такого имени
username = input()
# Присвоить имя пользователя ключу
usernames = username
# Сообщить об обновлении данных
print("Data updated.")

Запустите программу с помощью командной строки:

python usernames.py

Она выведен на экран:

Enter a name:
8host
8host-blog is the username of 8hosts
Enter a name:
Jesse
I don"t have Jesse"s username, what is it?
Jesse
Data updated.
Enter a name:

Чтобы остановить программу, нажмите CTRL + C.