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

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

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

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

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

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

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

  1. Обычное выражение - оно удобно, если словарь статичен: D = {"name": "mel", "age": 45}
  2. Динамический вариант создания на лету: D = {} D["name"] = "mel" D["age"] = 45
  3. С помощью функции 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)))
  4. С помощью fromkeys() - создает словарь по списку ключей с пустыми значениями: D = {}.fromkeys(["name", "age"],123)
  5. С помощью конструктора: 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. Словари

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

Можно выделить несколько отличительных характеристик словарей:

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

Понятие словаря

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

С словарем проводится две основные операции – сохранение с указанным ключом, а также извлечение значения по нему. Инструмент del дает возможность удаления пары key: value.

Метод keys () для словарей используется с целью возвращения списка всех применяемых ключей в произвольном порядке. Чтобы отсортировать список необходимо пользоваться методом sort (). Чтобы определить наличие конкретного ключа следует пользоваться методом has key(), однако в 3-й версии он уже устаревший и вместо него следует пользоваться оператором in. Чтобы добавить в словарь новый объект не нужно проводить предварительные проверки: если у ключа дор этого уже было определенное значение, то произойдет его перезапись.

Как пример возьмем работу с электронным досье Васи Пупкина.

# создадим пустой словарь data = {} # или так data = dict() # определим его длину - 0 len(data) # заполним данными - имя и фамилия data = {"firstname": "Vasya", "lastname": "Pupkin"} # длина словаря определяется количеством ключей # на данный момент - 2 len(data) # добавим отчество data["middlename"] = "Vasilyevich" # после женитьбы Васи обновляем поле фамилии и добавляем банковский счет data.update({"lastname":"Gates", "bank_account": 10000000}) # добавляем новым элементом словарь с данными жены... data["wife"] = {"firstname": "Annet", "lastname": "Gates", "middlename": "Billovna"} # ... и загоняем в гараж приданое data["garage"] = ["Jaguar", "Toyota Camry"] # и еще одну машинку data["garage"].append("Honda Civic") # узнаем имя жены - Annet print data["wife"]["firstname"] # Вася хвастается друзьям print data["bank_account"] # если нет элемента с нужным ключом, # можно избежать ошибки if "bank_account" in data: print data["bank_account"] else: print "no money" # или так print data.get("bank_account", 0) # закрываем счет del data["bank_account"] # распечатываем досье for key in data: print key, ":", data #### после распечатки выдаст следующее # firstname: Vasya # wife: {"middlename": "Billovna", "lastname": "Gates", "firstname": "Annet"} # middlename: Vasilyevich # lastname: Gates # garage: ["Jaguar", "Toyota Camry", "Honda Civic"] #### а само досье выглядит так # {"firstname": "Vasya", "wife": {"middlename": "Billovna", "lastname": "Gates", # "firstname": "Annet"}, "middlename": "Vasilyevich", "lastname": "Gates", # "garage": ["Jaguar", "Toyota Camry", "Honda Civic"]}

На этом, пожалуй, все.

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

Словари в 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 () - возвращает значения в словаре.

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

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

Обычно словари используются для хранения связанных между собой данных; например, пара может состоять из имени пользователя и его 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.