python — Как сделать словарь из двух списков? — Stack Overflow на русском

Что такое список?

Список это вид переменной у которой сразу несколько значений. Значения могут быть разных типов, например в одном списке может быть как и int(целое число) так и float(число с плавающей точкой) и до кучи к ним ещё и string(строка, буквы). Все данные в списке упорядоченные индексацией.

Что такое словарь?

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

2   Свёртка списка

К сожалению, нельзя написать программу только с помощью генераторов списков. (Я шучу… конечно, можно.) Они могут отображать и фильтровать, но нет простого способа для свертки списка. Под этим понятием я подразумеваю применение функции к первым двум элементам списка, а затем к получившемуся результату и следующему элементу, и так до конца списка. Можно реализовать это через цикл for:

Copy Source | Copy HTML
numbers = [1,2,3,4,5]
result = 1
for number in numbers: result *= number
# result = 120 

А можно воспользоваться встроенной функцией reduce, принимающей в качестве аргументов функцию от двух параметров и список:

Copy Source | Copy HTML
numbers = [1,2,3,4,5]
result = reduce(lambda a,b: a*b, numbers)
# result = 120 

Не так красиво, как генераторы списков, но короче обычного цикла. Стоит запомнить этот способ.

3   Прохождение по списку: range, xrange и enumerate

Помните, как в языке C для цикла for вы использовали переменную-счетчик вместо элементов списка? Возможно, вы уже знаете, как имитировать это поведение в Python с помощью range и xrange. Передавая число value функции range, мы получим список, содержащий элементы от 0 до value-1 включительно.

Copy Source | Copy HTML
strings = ['a', 'b', 'c', 'd', 'e']
for index in xrange(len(strings)): print index,
# печатает "0 1 2 3 4" 

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

Copy Source | Copy HTML
strings = ['a', 'b', 'c', 'd', 'e']
for index, string in enumerate(strings): print index, string,
# печатает "0 a 1 b 2 c 3 d 4 e" 

Еще один плюс состоит в том, что enumerate выглядит более читаемо, чем xrange(len()). Поэтому range и xrange полезны, наверно, только для создания списка с нуля, а не на основе других данных.

4   Проверка всех элементов списка на выполнение условия

Допустим, нам надо проверить, выполняется ли условие хотя бы для одного элемента. До Python 2.5 можно было писать так:

Copy Source | Copy HTML
numbers = [1,10,100,1000,10000]
if [number for number in numbers if number < 10]: print 'At least one element is over 10'
# Результат: "At least one element is over 10"
<source>
Если ни один из элементов не удовлетворяет условию, генератор создаст пустой список, который считается false. В противном случае будет создан непустой список, который приводится к true. Строго говоря, не нужно проверять все элементы, достаточно остановиться после первого элемента, удовлетворающего условию. Поэтому предыдущий пример менее эффективен и может быть выбран только в том случае, если вы не можете использовать Python 2.5, но хотите уместить всю логику в одно выражение.
С помощью встроенной функции any, введенной в Python 2.5, вы можете решить эту задачу более красиво и эффективно. Функция any прервется и вернет True, как только найдет элемент, удовлетворяющий условию. Ниже я использую выражение-генератор, которое возвращает True или False для каждого элемента, и передаю его функции any. Генератор вычисляет только необходимые в данный момент значения, а any принимает их по очереди.
<source>
Copy Source | Copy HTML
numbers = [1,10,100,1000,10000]
if any(number < 10 for number in numbers): print 'Success'
# Результат: "Success!" 

Аналогично, может возникнуть задача проверки, что

все

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

Copy Source | Copy HTML
numbers = [1,2,3,4,5,6,7,8,9]
if len(numbers) == len([number for number in numbers if number < 10]): print 'Success!'
# Результат: "Success!" 

Здесь мы фильтруем список и проверяем, уменьшилась ли его длина. Если нет, то все его элементы удовлетворяют условию. Опять же, без Python 2.5 это единственный способ уместить всю логику в одно выражение.

В Python 2.5 есть более простой путь — встроенная функция all. Легко догадаться, что она прекращает проверку после первого элемента, не удовлетворяющего условию. Эта функция работает абсолютно аналогично предыдущей.

Copy Source | Copy HTML
numbers = [1,2,3,4,5,6,7,8,9]
if all(number < 10 for number in numbers): print 'Success!'
# Результат: "Success!" 

6   Еще несколько операторов для работы со списками

Ниже перечислены встроенные функции, в качестве аргумента принимающие любой итерируемый объект.

max и min возвращают наибольший и наименьший элемент соответственно.

sum возвращает сумму всех элементов списка. Опциональный второй параметр задает начальную сумму (по умолчанию 0).

7   Продвинутые логические операции с типом set.

Я понимаю, что в разделе, посвященном спискам, не положено говорить о сетах (sets). Но пока я не использовал их, мне не хватало некоторых логических операций в списках. Сет отличается от списка тем, что его элементы уникальны и неупорядоченны. Над сетами также можно выполнять множество логических операций.

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

Copy Source | Copy HTML
numbers = [1,2,3,3,4,1]
set(numbers)
# возвращает set([1,2,3,4])
if len(numbers) == len(set(numbers)): print 'List is unique!'
# не выводит ничего 

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

1   Создание словаря с помощью именованных аргументов

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

Copy Source | Copy HTML
dict(a=1, b=2, c=3)
# возвращает {'a': 1, 'b': 2, 'c': 3} 

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

3   Преобразование списка в словарь

Обратная операция — превращение списка, содержащего пары ключ-значение, в словарь — делается так же просто:

Copy Source | Copy HTML
dict_as_list = [['a', 1], ['b', 2], ['c', 3]]
dictionary = dict(dict_as_list)
# dictionary = {'a': 1, 'b': 2, 'c': 3} 

Вы можете комбинировать методы, добавив именованные аргументы:

Copy Source | Copy HTML
dict_as_list = [['a', 1], ['b', 2], ['c', 3]]
dictionary = dict(dict_as_list, d=4, e=5)
# dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 

Превращать списка и словари друг в друга довольно удобно. Но следующий совет просто потрясающий.

D.clear()

Очищает словарь.

d.clear() очищает словарь d от всех пар ключ-значение:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}
>>> d.clear()
>>> d
{}

D.get(<key>[, <default>])

Возвращает значение ключа, если он существует в словаре.

Метод Python dictionary .get() предоставляет удобный способ получения значения ключа из словаря без предварительной проверки существования ключа и без возникновения ошибки.

d.get(<key>) ищет в словаре d <key> и возвращает связанное значение, если оно найдено. Если <key> не найден, возвращается None:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> print(d.get('b'))
20
>>> print(d.get('z'))
None

Если <key> не найден и указан необязательный аргумент <default>, вместо None возвращается это значение:

>>> print(d.get('z', -1))
-1

D.items()

Возвращает список пар ключ-значение в словаре.

d.items() возвращает список кортежей, содержащих пары ключ-значение в d. Первый элемент в каждом кортеже – это ключ, а второй элемент – значение ключа:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}
>>> list(d.items())
[('a', 10), ('b', 20), ('c', 30)]
>>> list(d.items())[1][0]
'b'
>>> list(d.items())[1][1]
20

D.keys()

Возвращает список ключей в словаре.

d.keys() возвращает список всех ключей в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}
>>> list(d.keys())
['a', 'b', 'c']

D.pop(<key>[, <default>])

Удаляет ключ из словаря, если он присутствует, и возвращает его значение.

Если <key> присутствует в d, d.pop (<key>) удаляет <key> и возвращает связанное с ним значение:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('b')
20
>>> d
{'a': 10, 'c': 30}

d.pop(<key>) вызывает исключение KeyError, если <key> не находится в d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z')
Traceback (most recent call last): File "<pyshell#4>", line 1, in <module> d.pop('z')
KeyError: 'z'

Если <key> не находится в d, и указан необязательный аргумент <по умолчанию>, то возвращается это значение, и исключение не возникает:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z', -1)
-1
>>> d
{'a': 10, 'b': 20, 'c': 30}

D.popitem()

Удаляет пару ключ-значение из словаря

d.popitem() удаляет последнюю пару ключ-значение, добавленную из d, и возвращает ее как кортеж:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.popitem()
('c', 30)
>>> d
{'a': 10, 'b': 20}
>>> d.popitem()
('b', 20)
>>> d
{'a': 10}

Если в d пусто, d.popitem() вызывает исключение KeyError:

>>> d = {}
>>> d.popitem()
Traceback (most recent call last): File "<pyshell#11>", line 1, in <module> d.popitem()
KeyError: 'popitem(): dictionary is empty'

Примечание. В версиях Python менее 3.6 popitem () будет возвращать произвольную (случайную) пару ключ-значение, поскольку словари Python были неупорядоченными до версии 3.6.

D.update(<obj>)

Объединяет словарь с другим словарем или с итерацией пар ключ-значение.

Если <obj> – словарь, d.update(<obj>) объединяет записи из <obj> в d. Для каждого ключа в <obj>:

• Если ключ отсутствует в d, пара ключ-значение из <obj> добавляется к d.
• Если ключ уже присутствует в d, соответствующее значение в d для этого ключа обновляется до значения из <obj>.

Вот пример объединения двух словарей:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d2 = {'b': 200, 'd': 400}
>>> d1.update(d2)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

В этом примере ключ ‘b’ уже существует в d1, поэтому его значение обновляется до 200, значение для этого ключа из d2. Однако в d1 нет ключа ‘d’, поэтому эта пара “ключ-значение” добавляется из d2.

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update([('b', 200), ('d', 400)])
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

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

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update(b=200, d=400)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

D.values()

Возвращает список значений в словаре.

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

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}
>>> list(d.values())
[10, 20, 30]

Любые повторяющиеся значения в d будут возвращаться столько раз, сколько они встречаются:

>>> d = {'a': 10, 'b': 10, 'c': 10}
>>> d
{'a': 10, 'b': 10, 'c': 10}
>>> list(d.values())
[10, 10, 10]

Техническое примечание: методы .items(), .keys() и .values() на самом деле возвращают нечто, называемое объектом представления. Объект представления словаря более или менее похож на окно с ключами и значениями. Для практических целей эти методы можно рассматривать как возвращающие списки ключей и значений словаря.

Вложенный в словарь список из одного элемента — словаря

z = { 'a': 1, 's': [ { 'd': 2, 'f': 3 }, { 'd': 3, 'f': 3 }, { 'f': 3 } ], 'b': { 'd': 5, 'f': { 'd': 1, } }
}

def get_sum_by_key(obj, key): val_sum = 0 if isinstance(obj, dict): for k, v in obj.items(): if isinstance(v, (dict, list)): val_sum = get_sum_by_key(v, key) elif k == key: val_sum = v elif isinstance(obj, list): for v in obj: val_sum = get_sum_by_key(v, key) return val_sum
print(get_sum_by_key(z, 'd')) # сумма 11
print(get_sum_by_key(z, 'f')) # сумма 9

Встроенные словарные методы

Как и в случае со строками и списками, есть несколько встроенных методов, которые можно вызывать в словарях. Фактически, в некоторых случаях методы списка и словаря имеют одно и то же имя. (При обсуждении объектно-ориентированного программирования вы увидите, что для разных типов вполне приемлемо иметь методы с одинаковыми именами.)

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

Доступ к значениям словаря

Конечно, элементы словаря должны быть как-то доступны. Если вы не получите их по индексу, то как их получить?

Значение извлекается из словаря путем указания соответствующего ключа в квадратных скобках ([]):

>>> MLB_team['Minnesota']
'Twins'
>>> MLB_team['Colorado']
'Rockies'

Если вы ссылаетесь на ключ, которого нет в словаре, Python вызывает исключение:

>>> MLB_team['Toronto']
Traceback (most recent call last): File "<pyshell#19>", line 1, in <module> MLB_team['Toronto']
KeyError: 'Toronto'

Добавление записи в существующий словарь – это просто вопрос назначения нового ключа и значения:

>>> MLB_team['Kansas City'] = 'Royals'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners', 'Kansas City': 'Royals'}

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

>>> MLB_team['Seattle'] = 'Seahawks'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Seahawks', 'Kansas City': 'Royals'}

Чтобы удалить запись, используйте оператор del, указав ключ для удаления:

>>> del MLB_team['Seattle']
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Kansas City': 'Royals'}

Беги, Сихокс! Ты команда НФЛ.

Как перевести список в словарь?

lst = ['Tell', 'me', 'what', 'must', 'I', 'do', 'Cause', 'luckily', 'I', 'm', 'good', 'at', 'reading']

dic = {1: 'Tell', 2: 'me', 3: 'what', 4: 'must', 5: 'I', 6: 'do', 7: 'Cause', 8: 'luckily', 9: 'I', 10: 'm', 11: 'good', 12: 'atreading'}

lst = ['Tell', 'me', 'what', 'must', 'I', 'do', 'Cause', 'luckily', "I", 'm', 'good', 'at', 'reading']
ind = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
dic = {ind: lst for ind, lst in zip(ind, lst)}
print(dic)

Как работать с определённым элементом в списке?

Допустим мы хотим вывести на экран определённый элемент из списка. Возьмём 3-й. А запишем в коде мы это так:

print(my_list[2])

Сразу отвечу на вопрос: почему элемент 2-ой, если на самом деле он 3-ий? Давайте вернёмся к школьной программе по математике 5-го класса. Там нам говорят что натуральные числа — числа без плавающей точки, используемые при счёте предметов. 0 и отрицательные числа не являются натуральными числами.

Теперь смотрим на список. Данные — они у нас в памяти компьютера, они предметами имеющими какую либо физическую внешность не являются. Соответственно их счёт мы начинаем с нуля. Следственно: 1-ый для нашего понимания — 0-ой для понимания компьютера.

В прочем работа с определённым элементом из списка идентична работе с переменной, поэтому мы её разбирать не будем.

Как работать с определённым элементом словаря?

Вывести определённый элемент из словаря на экран можно вот так:

print(my_dict(‘key1’))

Сейчас мы вывели значение элемента в словаре с ключем ‘key1’.

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

Как работать с самим списком?

Существует множество функций по работе со списками. Их вы можете найти по ссылке: тык. Сейчас мы разберём поисковые методы.

Таблица поисковых методов

Сохранение результата выполнения поискового метода в переменную выполняется следующим образом:

my_new_list = my_list.func(arg)

НО:

Если мы сортируем список и сохраняем новый список в переменную то

my_sorted_list = my_list.sort()

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

my_list.sort()

my_sorted_list = my_list

Как сделать словарь из двух списков?

for i in range(0, len(uniq)): #тело цикла

uniq_and_fifa = {}
for i in range(0, len(uniq)): uniq_and_fifa[uniq[i]] = fifa[i]

Как сделать список?

Список в коде создаётся таким путём:

my_list = [данные, через, запятую]

Числа в список забивать нужно без кавычек, а строки с одинарными либо двойными, разницы нет. Но если у вас в строке есть двойные кавычки, то обозначать строку нужно одинарными кавычками, и наоборот. В противном случае, компилятор просто потеряется и выдаст ошибку.

Как создать словарь?

Словари в Python объявляются таким путём:

my_dict = {

‘key1′:’value1’

‘key2′:’value2’

Ключи словаря и индексы списка

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

>>> MLB_team['Toronto']
Traceback (most recent call last): File "<pyshell#8>", line 1, in <module> MLB_team['Toronto']
KeyError: 'Toronto'
>>> MLB_team[1]
Traceback (most recent call last): File "<pyshell#9>", line 1, in <module> MLB_team[1]
KeyError: 1

По сути, это та же ошибка. В последнем случае [1] выглядит как числовой индекс, но это не так.

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

>>> d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d[0]
'a'
>>> d[2]
'c'

В выражениях MLB_team [1], d [0] и d [2] числа в квадратных скобках выглядят так, как если бы они могли быть индексами. Но они не имеют ничего общего с порядком пунктов в словаре. Python интерпретирует их как ключи словаря. Если вы определите этот же словарь в обратном порядке, вы все равно получите те же значения, используя те же ключи:

>>> d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d
{3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d[0]
'a'
>>> d[2]
'c'

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

>>> type(d)
<class 'dict'>
>>> d[-1]
Traceback (most recent call last): File "<pyshell#30>", line 1, in <module> d[-1]
KeyError: -1
>>> d[0:2]
Traceback (most recent call last): File "<pyshell#31>", line 1, in <module> d[0:2]
TypeError: unhashable type: 'slice'
>>> d.append('e')
Traceback (most recent call last): File "<pyshell#32>", line 1, in <module> d.append('e')
AttributeError: 'dict' object has no attribute 'append'

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

На такое сохранение порядка можно рассчитывать лишь совсем недавно. Он был добавлен как часть спецификации языка Python в версии 3.7. Однако это было верно и для версии 3.6 – случайно, в результате реализации, но не гарантированной спецификацией языка.

Комплексные словари

Кроме простейших объектов типа чисел и строк словари также могут хранить и более сложные объекты — те же списки, кортежи или другие словари:

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

Метод copy() копирует содержимое словаря, возвращая новый словарь:

Метод – 1 применение определения словаря

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

Пример –

student = ["James", "Abhinay", "Peter", "Bicky"]
student_dictionary = { stu : "Passed" for stu in student }
print(student_dictionary) 

Выход:

{'James': 'Passed', 'Abhinay': 'Passed', 'Peter': 'Passed', 'Bicky': 'Passed'} 

Объяснение:

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

Разберем еще один пример.

Пример – 2

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
square_dict = {n: n*n for n in list1}
print(square_dict) 

Выход:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100} 

Объяснение:

В приведенном выше коде мы создали square_dict с парой ключ-значение/пара значений.

Метод – 2 использование функции zip()

Функция zip() используется для связывания двух значений вместе. Во-первых, нам нужно создать итератор и инициализировать его любой переменной, а затем привести тип к функции dict().

Пример –

def Convert_dict(a): init = iter(list1) res_dct = dict(zip(init, init)) return res_dct
# Driver code
list1 = ['x', 1, 'y', 2, 'z', 3]
print(Convert_dict(list1)) 

Выход:

{'x': 1, 'y': 2, 'z': 3} 

Ограничения для ключей словаря

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

>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

Вы даже можете использовать встроенные объекты, такие как типы и функции:

>>> d = {int: 1, float: 2, bool: 3}
>>> d
{<class 'int'>: 1, <class 'float'>: 2, <class 'bool'>: 3}
>>> d[float]
2
>>> d = {bin: 1, hex: 2, oct: 3}
>>> d[oct]
3

Однако есть пара ограничений, которым должны соответствовать словарные ключи.

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

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

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }
>>> MLB_team['Minnesota'] = 'Timberwolves'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Timberwolves',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

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

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Timberwolves',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners',
... 'Minnesota': 'Twins'
... }
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Прочь, Timberwolves! Вы команда НБА. Вроде, как бы, что-то вроде того.

Во-вторых, ключ словаря должен иметь неизменяемый тип. Вы уже видели примеры, в которых несколько знакомых вам неизменяемых типов – integer, float, string и Boolean – служили ключами словаря.

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

>>> d = {(1, 1): 'a', (1, 2): 'b', (2, 1): 'c', (2, 2): 'd'}
>>> d[(1,1)]
'a'
>>> d[(2,1)]
'c'

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

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

>>> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
Traceback (most recent call last): File "<pyshell#20>", line 1, in <module> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
TypeError: unhashable type: 'list'

Ограничения на значения словаря

Напротив, нет ограничений на значения словаря. Буквально совсем нет. Значением словаря может быть любой тип объекта, поддерживаемый Python, включая изменяемые типы, такие как списки и словари, а также определяемые пользователем объекты, о которых вы узнаете в следующих руководствах.

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

>>> d = {0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d[0] == d[1] == d[2]
True

Операторы и встроенные функции

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

Например, операторы in и not in возвращают True или False в зависимости от того, встречается ли указанный операнд как ключ в словаре:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }
>>> 'Milwaukee' in MLB_team
True
>>> 'Toronto' in MLB_team
False
>>> 'Toronto' not in MLB_team
True

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

>>> MLB_team['Toronto']
Traceback (most recent call last): File "<pyshell#2>", line 1, in <module> MLB_team['Toronto']
KeyError: 'Toronto'
>>> 'Toronto' in MLB_team and MLB_team['Toronto']
False

Во втором случае из-за оценки короткого замыкания выражение MLB_team[‘Toronto’] не оценивается, поэтому исключение KeyError не возникает.

Функция len() возвращает количество пар ключ-значение в словаре:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }
>>> len(MLB_team)
5

Определение словаря

Словари – это реализация Python структуры данных, более известной как ассоциативный массив. Словарь состоит из набора пар ключ-значение. Каждая пара “ключ-значение” сопоставляет ключ с соответствующим значением.

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

d = { <key>: <value>, <key>: <value>, . . . <key>: <value>
}

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

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }

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

d = dict([ (<key>, <value>), (<key>, <value), . . . (<key>, <value>)
])

MLB_team также можно определить следующим образом:

>>> MLB_team = dict([
... ('Colorado', 'Rockies'),
... ('Boston', 'Red Sox'),
... ('Minnesota', 'Twins'),
... ('Milwaukee', 'Brewers'),
... ('Seattle', 'Mariners')
... ])

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

>>> MLB_team = dict(
... Colorado='Rockies',
... Boston='Red Sox',
... Minnesota='Twins',
... Milwaukee='Brewers',
... Seattle='Mariners'
... )

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

>>> type(MLB_team)
<class 'dict'>
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

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

>>> MLB_team[1]
Traceback (most recent call last): File "<pyshell#13>", line 1, in <module> MLB_team[1]
KeyError: 1

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

Для перебора словаря можно воспользоваться циклом for:

Получение и изменение элементов

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

dictionary[ключ]

Например, получим и изменим элементы в словаре:

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

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

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

>>> person = {}
>>> type(person)
<class 'dict'>
>>> person['fname'] = 'Joe'
>>> person['lname'] = 'Fonebone'
>>> person['age'] = 51
>>> person['spouse'] = 'Edna'
>>> person['children'] = ['Ralph', 'Betty', 'Joey']
>>> person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}

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

>>> person
{'fname': 'Joe', 'lname': 'Fonebone', 'age': 51, 'spouse': 'Edna',
'children': ['Ralph', 'Betty', 'Joey'], 'pets': {'dog': 'Fido', 'cat': 'Sox'}}
>>> person['fname']
'Joe'
>>> person['age']
51
>>> person['children']
['Ralph', 'Betty', 'Joey']

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

>>> person['children'][-1]
'Joey'
>>> person['pets']['cat']
'Sox'

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

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

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo[42]
'aaa'
>>> foo[2.78]
'bbb'
>>> foo[True]
'ccc'

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

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

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

Преобразование списка в словарь на python

b = dict(zip(a[::2], a[1::2]))

from itertools import izip
i = iter(a)
b = dict(izip(i, i))

b = {a[i]: a[i 1] for i in range(0, len(a), 2)}

i = iter(a)
b = dict(zip(i, i))

Преобразование списков и кортежей в словарь

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

Удаление

Для удаления элемента по ключу применяется оператор del:

Вывод

В этом руководстве вы рассмотрели основные свойства словаря Python и узнали, как получить доступ к данным словаря и управлять ими.

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

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

Подведём итоги

Для цен в магазине лучше использовать словари, можно указать для чего конкретно цена, для списка банковских клиентов — списки, можно рассортировать по алфавиту. А дальше — по аналогии.

Надеюсь статья была поучительной!