Как добавить элемент в словарь python – Python. Урок 9. Словари (dict)

Python. Урок 9. Словари (dict)

Словари (dict) – это одна из наиболее часто используемых структур данных, позволяющая хранить объекты, для доступа к которым используется ключ. В этом уроке будут рассмотрены операции создания, удаления, работы со словарями и их методы.

Что такое словарь (dict) в Python?

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

Создание, изменение, удаление словарей и работа с его элементами

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

>>> d1 = dict()
>>> print(type(d1))
<class 'dict'>
>>> d2 = {}
>>> print(type(d2))
<class 'dict'>

Если необходимо создать словарь с заранее подготовленным набором данных, то можно использовать один из перечисленных выше подходов, но с перечислением групп ключ-значение.

>>> d1 = dict(Ivan="manager", Mark="worker")
>>> print(d1)
{'Mark': 'worker', 'Ivan': 'manager'}
>>> d2 = {"A1":"123", "A2":"456"}
>>> print(d2)
{'A2': '456', 'A1': '123'}

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

>>> d1 = {"Russia":"Moscow", "USA":"Washington"}
>>> d1["China"]="Beijing"
>>> print(d1)
{'Russia': 'Moscow', 'China': 'Beijing', 'USA': 'Washington'}

Для удаления элемента из словаря можно воспользоваться командой del.

>>> d2 = {"A1":"123", "A2":"456"}
>>> del d2["A1"]
>>> print(d2)
{'A2': '456'}

Работа со словарем
Проверка наличия ключа в словаре производится с помощью оператора in.

>>> d2 = {"A1":"123", "A2":"456"}
>>> "A1" in d2
True
>>> "A3" in d2
False

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

>>> d1 = {"Russia":"Moscow", "USA":"Washington"}
>>> d1["Russia"]
'Moscow'

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

У словарей доступен следующий набор методов.

clear()
Удаляет все элементы словаря.

>>> d2 = {"A1":"123", "A2":"456"}
>>> print(d2)
{'A2': '456', 'A1': '123'}
>>> d2.clear()
>>> print(d2)
{}

copy()
Создается новая копия словаря.

>>> d2 = {"A1":"123", "A2":"456"}
>>> d3 = d2.copy()
>>> print(d3)
{'A1': '123', 'A2': '456'}
>>> d3["A1"]="789"
>>> print(d2)
{'A2': '456', 'A1': '123'}
>>> print(d3)
{'A1': '789', 'A2': '456'}

fromkeys(seq[, value])
Создает новый словарь с ключами из seq и значениями из value. По умолчанию value присваивается значение None.

get(key)
Возвращает значение из словаря по ключу key.

>>> d = {"A1":"123", "A2":"456"}
>>> d.get("A1")
'123'

items()
Возвращает элементы словаря (ключ, значение) в отформатированном виде.

>>> d = {"A1":"123", "A2":"456"}
>>> d.items()
dict_items([('A2', '456'), ('A1', '123')])

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

>>> d = {"A1":"123", "A2":"456"}
>>> d.keys()
dict_keys(['A2', 'A1'])

pop(key[, default])
Если ключ key есть в словаре, то данный элемент удаляется из словаря и возвращается значение по этому ключу, иначе будет возвращено значение default. Если default не указан и запрашиваемый ключ отсутствует в словаре, то будет вызвано исключение KeyError.

>>> d = {"A1":"123", "A2":"456"}
>>> d.pop("A1")
'123'
>>> print(d)
{'A2': '456'}

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

>>> d = {"A1":"123", "A2":"456"}
>>> d.popitem()
('A2', '456')
>>> print(d)
{'A1': '123'}

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

>>> d = {"A1":"123", "A2":"456"}
>>> d.setdefault("A3", "777")
'777'
>>> print(d)
{'A2': '456', 'A3': '777', 'A1': '123'}
>>> d.setdefault("A1")
'123'
>>> print(d)
{'A2': '456', 'A3': '777', 'A1': '123'}

update([other])
Обновить словарь парами (key/value) из other, если ключи уже существуют, то обновить их значения.

>>> d = {"A1":"123", "A2":"456"}
>>> d.update({"A1":"333", "A3":"789"})
>>> print(d)
{'A2': '456', 'A3': '789', 'A1': '333'}

values()
Возвращает значения элементов словаря.

>>> d = {"A1":"123", "A2":"456"}
>>> d.values()
dict_values(['456', '123'])

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

<<< Python. Урок 8. Кортежи (tuple)   Python. Урок 10. Функции в Python>>>

devpractice.ru

добавление элементов и сортировка, объединение и поиск

Словарем в языке программирования 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[4] = "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[3]
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'}
<class 'str'>

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

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

{1: 'one', 2: 'two', 3: 'three'}
<class 'dict'>

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

Название	Назначение
update	Объединение содержимого двух словарей в один
len	Получение размера
items	Возвращает пары (ключи и значения)
keys	Возвращает ключи
values	Возвращает значения
copy	Копирует содержимое в другой словарь
clear	Полная очистка всех элементов
eval	Конвертация строки в словарь

all-python.ru

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

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

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

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

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

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

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]) — обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

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

pythonworld.ru

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

Сергей Яковлев
Опубликовано 09.08.2010

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

Этот контент является частью # из серии # статей:

https://www.ibm.com/developerworks/ru/library/?series_title_by=**auto**

Следите за выходом новых статей этой серии.

Этот контент является частью серии:

Следите за выходом новых статей этой серии.

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

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() — возвращает итератор;

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

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[name][key])
>>> Alice phone is 2341

copy()

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

>>> x = {"user":'admin','attr':[1,2,3]}
>>> y = x.copy()
>>> y
{'user': 'admin', 'attr': [1, 2, 3]}

Метод 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()
<dictionary-keyiterator object at 0xb7c4dd00>

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]=1
>>> d[2]=2
>>> d[3]=3
>>> d
{1: 1, 2: 2, 3: 3}
>>> d.values()
[1, 2, 3]

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

>>> del d[2]
>>> 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[lang])
..
>>> 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'][1]
'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[key]
        if val not in inv:inv[val] = [key]
        else:inv[val].append(key)
    return inv
print invert_dict(hist)
>>> {1: ['a', 'e', 'i', 'h', 'o', 'n', 's', 't', 'w', 'y'], 2: [' ', 'm']}

Пример 2. Подсчитать частоту повторов каждого уникального слова в файле:

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[word] = words.get(word, 0) + 1
for word in sorted(words):
    print("'{0}' occurs {1} times".format(word, words[word]))

Пример 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[language]
#либо так:
for key in sorted(author.iterkeys()):
    print "%s: %s" % (key, author[key])
   
>>> 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.

Предыдущая статья. Следующая статья.

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

Подпишите меня на уведомления к комментариям

www.ibm.com

Руководство по словарям Python | Python

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

В этом руководстве мы рассмотрим следующие темы:

• как создать словарь, используя фигурные скобки и двоеточия;
• как загрузить данные в словарь с помощью библиотек urllib и random;
• как фильтровать словарь с помощью цикла for и специальных итераторов для перебора ключей и значений словаря;
• как выполнять операции со словарем для получения или удаления значений, и как использовать значения словаря для подмножества значений из него;
• как сортировать словарь с помощью библиотеки re и как в этом могут помочь функции OrderedDict и лямбда-функции;
• сравним словари Python со списками, массивами NumPy и Pandas DataFrames.

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

Словари можно распознать по фигурным скобкам {} и разделению двоеточием : ключа и значения для каждого элемента.

Переменная fruit в приведенном ниже коде является допустимым словарем. Получить доступ к элементу Python словаря можно, поместив ключ между квадратными скобками [].Также можно использовать метод .get(), чтобы сделать то же самое:

fruit = {"apple" : 5, "pear" : 3, "banana" : 4, "pineapple" : 1,https://www.datacamp.com/community/tutorials/python-dictionary-tutorial "cherry" : 20}
# Получаем доступ к словарю `fruit` непосредственно (без использования get) и выводим значение "banana"
print(_____["______"])
# Выбираем один из 5 фруктов и показываем, что оба способа извлечения дают аналогичные результаты
print(fruit["_____"] == fruit.get("_____"))

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

Используемые данные — это отзывы на Amazon о книге Донны Тартт «The Goldfinch«. Они были сохранены в простом файле с разделителями. Таблица содержит четыре столбца: оценка, URL-адрес, заголовок отзыва и текст отзыва.

Есть несколько способов представить эти данные в Python словаре, но в нашем случае мы берем URL-адрес в качестве ключа и помещаем другие столбцы в словарь с вложенными значениями:

import urllib
import random
# Загружаем данные из удаленного места (URL-адреса)
file = urllib.request.urlopen("https://gist.githubusercontent.com/twielfaert/a0972bf366d9aaf6cb1206c16bf93731/raw/dde46ad1fa41f442971726f34ad03aaac85f5414/Donna-Tartt-The-Goldfinch.csv")
f = file.read()
# Преобразуем битовый поток в строки
text = f.decode(encoding='utf-8',errors='ignore')
# Разбиваем эту одну строку на концах линий
lines = text.split("n")
# Инициализируем словарь
reviews = {}
# Заполняем словарь
for line in lines:
  l = line.strip().split("t")

  # Это просто тестовые данные, чтобы посмотреть, что входит в словарь
  score = l[0] 
  id = l[1]
  title = l[2]
  review = l[3]

  reviews[id] = {"score" : score, "title" : title, "review" : review}
# Берем случайный ключ из словаря и выводим его значение

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

# Подсчитываем количество строк в файле
print("Количество строк: " + str(len(lines)))
# Подсчитываем количество ключей в словаре; оно должно равняться количеству строк в файле
print("Количество ключей словаря: " + str(len(reviews.keys())))

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

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

Элементы словаря Python имеют не только ключ и значение, но и специальный итератор для их перебора. Вместо for item in dictionary необходимо использовать for key, value in dictionary.items(). При этом должны использоваться две переменные, ключ и значение, а не одна.

Существуют отдельные итераторы для ключей (.keys()) и значений (.values()).

Мы сохраняем ключи отзывов с низкой оценкой в списке с именем lowscores. Благодаря этому в дальнейшем можно будет повторно использовать список, чтобы извлечь отзывы из словаря:

# Сохраняем ключи отзывов с низкой оценкой (1.0) в списке
lowscores = []
for key, value in reviews.items():
  if float(value["score"]) == 1.0: # Convert score to float
    lowscores.append(key)
# Выводим все записи с низкой оценкой
for item in __________:
  print(reviews[____])

Если словарь, содержащий полный набор данных, большой, то разумнее использовать список lowscores, который мы только что скомпилировали, чтобы создать совершенно новый словарь (Python список в словарь). Преимущество этого приема заключается в том, что для дальнейшего анализа не нужно хранить в памяти большой словарь. Можно просто перейти к соответствующему подмножеству исходных данных.

Во-первых, мы используем ключи, хранящиеся в lowscores, для создания нового словаря. Чтобы сделать это, есть два способа: первый — извлекаем только соответствующие элементы из исходного словаря с помощью метода .get(), оставляя исходный словарь без изменений. Второй — использовать метод .pop(), который удаляет извлеченные записи из исходного словаря.

Код для подмножества может выглядеть следующим образом: subset = dict([(k, reviews.get(k)) for k in lowscores]). Такое написание может показаться незнакомым, потому что цикл задан одной строкой кода. Этот стиль называется «генерацией словаря». На самом деле это цикл for, который перебирает элементы lowscores, извлекает значения из отзывов и использует их для заполнения нового словаря.

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

# Метод с использованием цикла for для создания подмножества словаря
forloop = {}
for k in lowscores:
  forloop[k] = reviews[k]
# Добавляем специальный метод извлечения релевантных элементов из словаря `reviews`
dictcomp = {k : reviews.___(k) for k in lowscores}
# Удостоверимся, что эти объекты аналогичны
print(forloop == ________)

Предположим, что теперь вы хотите изменить словарь Python 3, чтобы оценки выступали в качестве ключей словаря, а не идентификаторов. Можно использовать для этого цикл for, указав как ключи, так и значения, и создав новый вложенный словарь. Нужно будет извлечь «score» из исходного вложенного словаря, чтобы использовать его в качестве нового ключа.

Чтобы упростить код, мы создаем в отдельной строке новый вложенный словарь как новый объект newvalues. После чего заполняем scoredict идентификаторами в качестве ключей и объектами из словаря newvalues в качестве значений:

from collections import defaultdict
scoredict = defaultdict(list)
for key, value in reviews.items():
  newvalues = {'id' : key, "title" : value['title'], "review" : value['review']}
  # Используем 'score' из значений (!) из исходного словаря в качестве ключей для только что созданного  словаря
  scoredict[_____['_____']].append(newvalues)

# Выводим ключи словаря, чтобы удостовериться, что это на самом деле оценки из отзывов
print(scoredict.keys())

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

Нам нужно немного обработать текст отзывов, удалив HTML-теги и конвертировав заглавные буквы в словах в нижний регистр. Для первой задачи мы используем регулярное выражение, которое удаляет все теги: re.sub(«», «»). Регулярные выражения — это полезный инструмент при работе с текстовыми данными. Они довольно сложны для компиляции и заслуживают отдельного руководства.

Но в нашем примере нужно просто определить наборы символов, которые начинаются с символа <, за которым следует произвольное количество символов, после чего стоит символ >. И заменить их на пустые кавычки «» (ничего).

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

Затем мы создаем частотный словарь, используя defaultdict вместо обычного словаря. Это гарантирует, что каждый «ключ» уже инициализирован, и можно просто увеличивать его частоту, начиная с 1.

Если вы не используете defaultdict, Python может выдать ошибку при первом увеличении частоты (с 0 до 1), потому что ключ еще не существует. Этого можно избежать, предварительно проверив, существует ли ключ в Python словаре, прежде чем увеличивать значение его частоты. Но это решение не такое элегантное, как defaultdict:

import re
# Импортируем defaultdict
from collections import ___________
freqdict = defaultdict(int)
for item in lowscores:
  review = reviews[item]["review"]
  cleantext = re.sub(r'<.*?>', '', review).strip().split() # Remove HTML tags and split the review by word (space separated)
  for word in cleantext:
   # Конвертируем все буквы в нижний регистр
    word = word.lower()

    # Заполняем следующую строку, чтобы увеличить частоту на один:
    freqdict[word] += _

print(freqdict)

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

Функция sorted принимает три аргумента. Первый — это объект, который нужно отсортировать, наш частотный словарь. При этом необходимо помнить, что доступ к парам ключ-значение в словаре возможен только через функцию .items(). Если вы забудете об этом, Python даже не выдаст предупреждение, а только вернет первый ключ, который встретит. Другими словами: если вы перебираете словарь, и ваш код ведет себя странным образом, проверьте, добавлена ли функция .items().

Второй аргумент указывает, какую часть первого аргумента следует использовать для сортировки: key=lambda item: item[1]. Но вам придется более углубленно изучить язык Python, чтобы понять, что это такое. Первая часть довольно понятна: вы хотите, чтобы ключи сортировались.

Но что там делает lambda? Она является анонимной функцией, то есть это функция без имени, которая не может быть вызвана извне. Это альтернативный способ обработки через цикл целого ряда объектов с помощью одной функции. В данном случае используется значение словаря (item[1], при item[0] выступающем в качестве ключа) в качестве аргумента для сортировки.

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

Прямо сейчас вы были бы разочарованы словами, которые располагаются в самом верху списка отсортированных элементов. Это были бы просто «функциональные слова», такие как «the», «and», «a» и т. д. В английском, как и во многих других языках, эти слова употребляются достаточно часто. Но при этом они совершенно бессмысленны сами по себе.

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

Можно поэкспериментировать и посмотреть, в каких частях Python словаря можно найти интересные слова:

from collections import OrderedDict
# Создаем словарь Ordered
ordict = OrderedDict(sorted(freqdict.items(), key=lambda item: item[1], reverse=True))
# Игнорируем верхние 10%
top10 = int(len(ordict.keys())/10)
# Выводим 100 слов из верхних 90%
print(list(ordict.items())[top10:top10+100])

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

Такие библиотеки, как Pandas, позволяют обработчикам данных работать быстрее и эффективнее. Им больше не нужно беспокоиться о деталях более низкого уровня, касающихся того, как хранятся данные. Но Pandas также использует словари (наряду с другими расширенными структурами данных, такими как массив NumPy) для хранения данных.

Даже при применении Pandas иногда рекомендуется использовать словари. Например, когда значения необходимо просто сопоставить, и вам не нужны функции Pandas ни для чего другого. Использование объекта Pandas в таких случаях просто неэффективно и излишне.

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

Данная публикация представляет собой перевод статьи «Python Dictionary Tutorial» , подготовленной дружной командой проекта Интернет-технологии.ру

www.internet-technologies.ru

ключи и значения, методы, функции

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

Словарь Python определяется двумя элементами: ключами и значениями.

Ключи представлены одним элементом

Значения могут быть списком или списком в списке, числами и т. д.

В этом руководстве мы рассмотрим:

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Методы словаря Python

Копирование словаря

Обновление словаря

Удаление ключей из словаря

Метод словаря items()

Сортировку словаря

Встроенные функции словаря

Метод словаря len()

Типы переменных

Метод списка Python cmp()

Str(dict)

Синтаксис для словаря Python:

Dict = { ‘ Tim’: 18, xyz,.. }

Dict = { ‘ Tim’: 18,  xyz,.. }

Словарь указан в фигурных скобках, внутри этих фигурных скобок объявляются ключи и значения. Каждый ключ отделяется от своего значения двоеточием (:), а каждый элемент — запятыми.

Свойства ключей словаря

При использовании ключей словаря есть два важных момента.

Не допускается более одной записи для каждого ключа (дубликат ключа не допускается)

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

Ключи словаря чувствительны к регистру. То же имя ключа, но с другим регистром в словарях Python рассматривается как разные ключи.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print (Dict[‘Tiffany’])

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print (Dict[‘Tiffany’])

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print((Dict[‘Tiffany’]))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print((Dict[‘Tiffany’]))

В коде у нас есть словарь с названием «Dict»

Мы объявили в словаре имя и возраст человека, где имя — «ключи», а возраст — «значение».

Теперь запустите код

Он возвращает из словаря возраст Тиффани.

Методы словаря Python

Копирование словаря

Вы также можете скопировать весь словарь в новый словарь. Например, здесь мы скопировали наш оригинальный словарь в новые словари «Boys» и «Girls».

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} studentX=Boys.copy() studentY=Girls.copy() print studentX print studentY

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} studentX=Boys.copy() studentY=Girls.copy() print studentX print studentY

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} studentX=Boys.copy() studentY=Girls.copy() print(studentX) print(studentY)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} studentX=Boys.copy() studentY=Girls.copy() print(studentX) print(studentY)

У нас есть оригинальный словарь (Dict) с именем и возрастом мальчиков и девочек вместе

Но мы хотим, чтобы список мальчиков отличался от списка девочек, поэтому мы определили элемент для мальчиков и девочек в отдельных словарях «Boys» и «Girls».

Теперь мы снова создали новые словари с именами «studentX» и «studentY», где все ключи и значения словаря Boys копируются в studentX, а словаря Girls — в studentY

Так что теперь вам не нужно просматривать весь список в главном словаре (Dict), чтобы узнать, кто является мальчиком, а кто девочкой, вам просто нужно вывести studentX, если вам нужен список мальчиков, и StudentY, если вам нужен список девочек

Итак, когда вы запустите словарь studentX и studentY, он выдаст все элементы, присутствующие в словаре «boys» и «girls» отдельно

Обновление словаря

Вы также можете обновить словарь, добавив новую запись или пару ключ-значение в существующую запись или удалив существующую запись. Здесь в примере мы добавим другое имя «Sarah» в наш существующий словарь.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Dict.update({«Sarah»:9}) print Dict

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Dict.update({«Sarah»:9}) print Dict

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Dict.update({«Sarah»:9}) print(Dict)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Dict.update({«Sarah»:9}) print(Dict)

Наш существующий словарь «Dict» не содержит имени «Sarah».

Мы используем метод Dict.update, чтобы добавить его в существующий словарь

Теперь запустите код, он добавляет «Sarah» в существующий словарь

Удаление ключей из словаря

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

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} del Dict [‘Charlie’] print Dict

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} del Dict [‘Charlie’] print Dict

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} del Dict [‘Charlie’] print(Dict)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} del Dict [‘Charlie’] print(Dict)

Когда вы запускаете этот код, он должен вывести список словаря без Charlie.

Мы использовали код Del Dict

Когда код выполнен, он удалил Charlie из основного словаря

Метод словаря items()

Метод items() возвращает список пар кортежей (ключи, значения) в словаре.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «Students Name: %s» % Dict.items()

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «Students Name: %s» % Dict.items()

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«Students Name: %s» % list(Dict.items()))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«Students Name: %s» % list(Dict.items()))

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Мы используем метод items() для Dict.

Когда код был выполнен, он возвращает список элементов (ключей и значений) из словаря

Проверка, существует ли данный ключ в словаре

Для данного списка вы также можете проверить, существует ли дочерний словарь в главном словаре или нет. Здесь у нас есть два под-словаря «Boys» и «Girls», мы хотим проверить, существует ли словарь «Boys» в нашем основном «Dict» или нет. Для этого мы используем метод forloop с методом else if.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} for key in Dict.keys(): if key in Boys.keys(): print True else: print False

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} for key in Dict.keys():     if key in Boys.keys():         print True     else:               print False

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} for key in list(Dict.keys()): if key in list(Boys.keys()): print(True) else: print(False)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} for key in list(Dict.keys()):     if key in list(Boys.keys()):         print(True)     else:               print(False)

Forloop в коде проверяет каждый ключ в главном словаре для ключей Boys

Если он существует в главном словаре, он должен вывести true, иначе он должен вывести false

Когда вы выполните код, он выведет «True» три раза, так как мы получили три элемента в словаре «Boys»

Таким образом, это означает, что «Boys» существуют в главном словаре (Dict)

Сортировка словаря

В словаре вы также можете отсортировать элементы. Например, если мы хотим вывести название элементов словаря в алфавитном порядке, нам нужно использовать forloop. Это отсортирует каждый элемент словаря соответственно.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} Students = Dict.keys() Students.sort() for S in Students: print»:».join((S,str(Dict[S])))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} Students = Dict.keys() Students.sort() for S in Students:       print»:».join((S,str(Dict[S])))

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} Students = list(Dict.keys()) Students.sort() for S in Students: print(«:».join((S,str(Dict[S]))))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} Students = list(Dict.keys()) Students.sort() for S in Students:       print(«:».join((S,str(Dict[S]))))

Мы объявили переменную Students для словаря «Dict».

Затем мы используем код Students.sort, который сортирует элемент внутри словаря.

Но чтобы отсортировать каждый элемент в словаре, мы запускаем forloop, объявив переменную S

Теперь, когда мы выполним код, forloop вызывает каждый элемент из словаря и выводит строку и значение

Встроенные функции словаря Python

Метод словаря len()

Функция len() выдает количество пар в словаре.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «Length : %d» % len (Dict)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «Length : %d» % len (Dict)

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«Length : %d» % len (Dict))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«Length : %d» % len (Dict))

Когда выполняется функция len(Dict), она выдает значение «4», так как в нашем словаре есть четыре элемента.

Типы переменных

Python не требует явного объявления резервного пространства памяти; это происходит автоматически. Используются присвоения значения переменной «=», знак равенства. Код для определения типа переменной — «%type (Dict)».

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «variable Type: %s» %type (Dict)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «variable Type: %s» %type (Dict)

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«variable Type: %s» %type (Dict))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«variable Type: %s» %type (Dict))

Используем код %type, чтобы узнать тип переменной

Когда код был выполнен, он указывает, что тип переменной — это словарь

Метод списка Python cmp()

Метод сравнения cmp() используется в Python для сравнения значений и ключей двух словарей. Если метод возвращает 0, оба словаря равны, если 1 — dic1>dict2, и если -1 — dict1

Пример Python 2

Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} print cmp(Girls, Boys)

Boys = {‘Tim’: 18,’Charlie’:12,’Robert’:25} Girls = {‘Tiffany’:22} print cmp(Girls, Boys)

Пример Python 3

cmp is not supported in Python 3

cmp is not supported in Python 3

У нас есть два словаря названия «Boys» и «Girls».

То, что вы сначала объявите в коде «cmp (Girls, Boys)», будет рассматриваться как словарь 1. В нашем случае мы сначала объявили «Girls», поэтому он будет рассматриваться как словарь 1, а «Boys» — как словарь 2.

Когда выполняется код, он выводит -1, это означает, что наш словарь 1 меньше словаря 2.

Str(dict)

С помощью метода Str() вы можете преобразовать словарь в печатный формат строки.

Пример Python 2

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «printable string:%s» % str (Dict)

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print «printable string:%s» % str (Dict)

Пример Python 3

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«printable string:%s» % str (Dict))

Dict = {‘Tim’: 18,’Charlie’:12,’Tiffany’:22,’Robert’:25} print(«printable string:%s» % str (Dict))

Используем код %str (Dict)

Он вернет элементы словаря в формате строки для печати

Вот список всех методов словаря

copy() — Копирует весь словарь в новый словарь

update() — Обновляет словарь, добавив новую запись или пару ключ-значение к существующей записи или удалив существующую запись.

items() — Возвращает список пар кортежей (Ключи, Значение) в словаре.

sort() — Вы можете отсортировать элементы

len() — Дает количество пар в словаре.

cmp() — Сравнивает значения и ключи двух словарей

Str() — Создает словарь в формате для печати строки

Заключение

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

Ключи представлены одним элементом

Значения могут быть списком или списком в списке, числами и т. д.

Не допускается более одной записи для каждого ключа (дубликат ключа не допускается)

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

Ключи словаря чувствительны к регистру. То же имя ключа, но с другим регистром в словарях Python рассматривается как разные ключи.

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

webformyself.com

Добавление элемента в словарь в python? — python

Я относительно новый здесь, поэтому, пожалуйста, скажите мне, есть ли что-нибудь, что я должен знать, или любые ошибки, которые я делаю мудро!

Я пытаюсь добавить вещи в словарь через случайный выбор, но мой код, похоже, не работает!

Файл: sports.txt

Soccer, Joshua
Lacrosse, Naome Lee
Soccer, Kat Valentine
Basketball, Huong
Tennis, Sunny
Basketball, Freddie Lacer

мой код:

def sportFileOpen():

    sportFile = open("sport.txt")
    readfile = sportFile.readlines()
    sportFile.close()
    return(readfile)


def sportCreateDict(sportFile):

    sportDict = {}

    for lines in sportFile:
        (sport, name) = lines.split(",")

        if sport in sportDict:
            sportDict[sport].append(name.strip())

        else:
            sportDict[sport] = [name.strip()]


    return(sportDict)



def sportRandomPick(name, sport, sportDict):


    if sport in sportDict:

        ransport = random.choice(sportDict.keys())

        sportDict[ransport].append(name)


        print(name, "has been sorted into", ransport)


def main():

    sportFile = sportFileOpen()

    sportDict = sportCreateDict(sportFile)


    name = input("Enter the name: ")

    preferredSport = input("Which sport do they want? ")

    sportRandomPick(name, preferredSport, sportDict)


main()

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

Я не ожидаю, что кто-нибудь напишет мне код, я знаю, что это занимает много времени, и у вас есть все, что нужно делать! Но может ли кто-нибудь объяснить мне, как я буду заниматься этим? Я понимаю, как делать случайные выборы, но я не знаю, как бы я «удвоил» шансы.

Также я продолжаю получать эту ошибку при запуске моего кода: NameError: global name 'random' is not defined

Я думал, что делаю эту роль правильно, но теперь я застрял. Может ли кто-нибудь дать свои два цента на это?

qaru.site