Меню
ГлавнаяБраузеры

Добавить значение в словарь python. Словари и их методы в Python

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

Словари в 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

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

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

  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. Словари

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

Словарь - неупорядоченная структура данных, которая позволяет хранить пары «ключ - значение». Вот пример словаря на 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 миль"), ("туфли", "туфля во множественном числе")]

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

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