Представьте, что у вас есть:
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
Каков самый простой способ создать следующий словарь?
a_dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}
Как это:
>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> dictionary = dict(zip(keys, values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3}
Парный конструктор dict и функция zip очень полезны: https://docs.python.org/3/library/functions.html#func-dict
Попробуйте следующее:
>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}
В Python 2 он также более экономичен в потреблении памяти по сравнению с zip.
Представьте, что у вас есть:
keys = ('name', 'age', 'food') values = ('Monty', 42, 'spam')Как проще всего создать следующий словарь?
dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}
Возможное улучшение при использовании конструктора dict - использование собственного синтаксиса понимания dict (не списка, как ошибочно выразились другие):
new_dict = {k: v for k, v in zip(keys, values)}
В Python 2 zip возвращает список, чтобы избежать создания ненужного списка, используйте вместо него izip (псевдоним zip может уменьшить изменения кода при переходе на Python 3).
from itertools import izip as zip
Так что это еще:
new_dict = {k: v for k, v in zip(keys, values)}
izip из itertools становится zip в Python 3. izip лучше, чем zip для Python 2 (потому что он избегает ненужного создания списка), и идеально подходит для 2.6 или ниже:
from itertools import izip
new_dict = dict(izip(keys, values))
В Python 3 zip становится той же функцией, что была в модуле itertools, так что это просто:
new_dict = dict(zip(keys, values))
Тем не менее, понимание речи будет более продуктивным (см. обзор производительности в конце этого ответа).
Во всех случаях:
>>> new_dict
{'age': 42, 'name': 'Monty', 'food': 'spam'}
Если мы посмотрим на справку по dict, то увидим, что она принимает различные формы аргументов:
>>> help(dict)
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
Оптимальный подход - использовать итерируемое, избегая при этом создания ненужных структур данных. В Python 2 zip создает ненужный список:
>>> zip(keys, values)
[('name', 'Monty'), ('age', 42), ('food', 'spam')]
В Python 3 эквивалент будет:
>>> list(zip(keys, values))
[('name', 'Monty'), ('age', 42), ('food', 'spam')]
и Python 3 zip просто создают итеративный объект:
>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>
Поскольку мы хотим избежать создания ненужных структур данных, мы обычно хотим избегать Python 2 zip (поскольку он создает ненужный список).
Это выражение генератора передается конструктору dict:
generator_expression = ((k, v) for k, v in zip(keys, values))
dict(generator_expression)
или эквивалентно:
dict((k, v) for k, v in zip(keys, values))
И это понимание списка, передаваемое конструктору dict:
dict([(k, v) for k, v in zip(keys, values)])
В первых двух случаях дополнительный слой неоперативных (таким образом ненужных) вычислений помещается поверх итерируемой zip, а в случае понимания списка дополнительный список создается без необходимости. Я ожидаю, что все они будут менее производительными, и, конечно, не более.
В 64-битном Python 3.7.3 в Ubuntu 18.04 упорядочено от самого быстрого до самого медленного:
>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
0.4772876740025822
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.5217149950040039
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
0.6797661719901953
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
0.7864680950006004
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
0.8561034000013024
Комментатор сказал:
minкажется плохим способом сравнения производительности. Конечно,meanи/илиmaxбыли бы гораздо более полезными индикаторами для реального использования.
Мы используем min, потому что эти алгоритмы являются детерминированными. Мы хотим знать производительность алгоритмов в наилучших возможных условиях.
Если операционная система по какой-либо причине зависает, это не имеет ничего общего с тем, что мы пытаемся сравнить, поэтому мы должны исключить такие результаты из нашего анализа.
Если бы мы использовали mean, то такого рода события сильно исказили бы наши результаты, и если бы мы использовали max, мы получим только самый экстремальный результат - тот, который наиболее вероятно затронут таким событием.
Комментатор также говорит:
В Python 3.6.8, используя средние значения, понимание dict действительно все еще быстрее, примерно на 30% для этих небольших списков. Для больших списков (10 тыс. Случайных чисел) вызов
dictпримерно на 10% быстрее.
Я предполагаю, что мы имеем в виду dict(zip(... с 10k случайных чисел. Это звучит как довольно необычный вариант использования. Имеет смысл, что большинство прямых вызовов будут доминировать в больших наборах данных, и я не удивлюсь, если зависания ОС будут доминирующими, учитывая, сколько времени потребуется для запуска этого теста, что приведет к дальнейшему искажению ваших номеров. И если вы используете mean или max, я бы посчитал ваши результаты бессмысленными.
Давайте использовать более реалистичный размер в наших лучших примерах:
import numpy
import timeit
l1 = list(numpy.random.random(100))
l2 = list(numpy.random.random(100))
И здесь мы видим, что dict(zip(... действительно работает быстрее для больших наборов данных примерно на 20%.
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(l1, l2)}))
9.698965263989521
>>> min(timeit.repeat(lambda: dict(zip(l1, l2))))
7.9965161079890095
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}
Вы также можете использовать словарь в Python ≥ 2.7:
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> {k: v for k, v in zip(keys, values)}
{'food': 'spam', 'age': 42, 'name': 'Monty'}
Более естественным способом является использование понимания словаря
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dict = {keys[i]: values[i] for i in range(len(keys))}
Если вам нужно преобразовать ключи или значения перед созданием словаря, можно использовать выражение . Пример:
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3]))
Посмотрите Код Как Pythonista: Идиоматический Python.
с Python 3.x, идет для понимания dict
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dic = {k:v for k,v in zip(keys, values)}
print(dic)
Подробнее о диктовках здесь, есть пример:
>>> print {i : chr(65+i) for i in range(4)}
{0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}
Для тех, кому нужен простой код и arent, знакомый с zip:
List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']
Это может быть сделано одной строкой кода:
d = {List1[n]: List2[n] for n in range(len(List1))}
Лучшее решение по-прежнему:
In [92]: keys = ('name', 'age', 'food')
...: values = ('Monty', 42, 'spam')
...:
In [93]: dt = dict(zip(keys, values))
In [94]: dt
Out[94]: {'age': 42, 'food': 'spam', 'name': 'Monty'}
Измените это:
lst = [('name', 'Monty'), ('age', 42), ('food', 'spam')]
keys, values = zip(*lst)
In [101]: keys
Out[101]: ('name', 'age', 'food')
In [102]: values
Out[102]: ('Monty', 42, 'spam')
привет это для тех, кому нужен простой код:
List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']
Это можно сделать одной строкой кода:
var = {List1[n]: List2[n] for n in range(len(List1))}
У меня было это сомнение, когда я пытался решить проблему, связанную с графами. Проблема, с которой я столкнулся, заключалась в том, что мне нужно было определить пустой список смежности, и я хотел инициализировать все узлы пустым списком, поэтому, когда я подумал о том, как проверить, достаточно ли он быстр, я имею в виду, стоит ли выполнять операцию zip вместо простой пары ключ-значение присваивания. Ведь в большинстве случаев фактор времени является важным ледоколом. Поэтому я выполнил операцию timeit для обоих подходов.
import timeit
def dictionary_creation(n_nodes):
dummy_dict = dict()
for node in range(n_nodes):
dummy_dict[node] = []
return dummy_dict
def dictionary_creation_1(n_nodes):
keys = list(range(n_nodes))
values = [[] for i in range(n_nodes)]
graph = dict(zip(keys, values))
return graph
def wrapper(func, *args, **kwargs):
def wrapped():
return func(*args, **kwargs)
return wrapped
iteration = wrapper(dictionary_creation, n_nodes)
shorthand = wrapper(dictionary_creation_1, n_nodes)
for trail in range(1, 8):
print(f'Itertion: {timeit.timeit(iteration, number=trails)}\nShorthand: {timeit.timeit(shorthand, number=trails)}')
Для n_nodes = 10 000 000 я получаю,
Итерация: 2.825081646999024 Сокращение: 3.535717916001886
Итерация: 5.051560923002398 Сокращение: 6.255070794999483
Итерация: 6.52859034499852 Сокращение: 8.221581164998497
Итерация: 8.683652416999394 Сокращение: 12.599181543999293
Итерация: 11.587241565001023 Сокращение: 15.27298851100204
Итерация: 14.816342867001367 Сокращение: 17.162912737003353
Итерация: 16.645022411001264 Сокращение: 19.976680120998935
После определенного момента вы можете ясно видеть, что итерационный подход на n-м шаге обгоняет время, необходимое для стенографического подхода на n-1-м шаге.
вы можете использовать этот ниже код:
dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))
Но убедитесь, что длина списков будет одинаковой. Если длина не одинакова, то zip-функция завершает работу более длинным.
Вы можете сделать это одной строкой, используя словарь:
a_dict={key:value for key,value in zip(keys,values)}
и это все. Наслаждайтесь Python.....;)
Вот также пример добавления значения списка в вашем словаре
list1 = ["Name", "Surname", "Age"]
list2 = [["Cyd", "JEDD", "JESS"], ["DEY", "AUDIJE", "PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)
всегда проверяйте, чтобы ваш "Ключ" (list1) всегда был в первом параметре.
{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}
keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']
new_dict = dict(zip(keys,values))
print(new_dict)
метод без функции почтового индекса
l1 = [1,2,3,4,5]
l2 = ['a','b','c','d','e']
d1 = {}
for l1_ in l1:
for l2_ in l2:
d1[l1_] = l2_
l2.remove(l2_)
break
print (d1)
{1: 'd', 2: 'b', 3: 'e', 4: 'a', 5: 'c'}
>>> labels = ["Sessions", "Absences", "Excused"]
>>> label_values = [1,0,3]
>>> dictionary = dict(zip(labels,label_values))
>>> print dictionary
{'Absences': 0, 'Excused': 3, 'Sessions': 1}