แปลงสองรายการเป็นพจนานุกรม

ลองนึกภาพว่าคุณมี:

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}

Voila :-) ตัวdictสร้างและzipฟังก์ชันpairwise มีประโยชน์อย่างยิ่ง: https://docs.python.org/3/library/functions.html#func-dict

ลองนึกภาพว่าคุณมี:

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

วิธีที่ง่ายที่สุดในการสร้างพจนานุกรมต่อไปนี้คืออะไร?

dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}

นักแสดงส่วนใหญ่คอนdictสตรัคด้วยzip

new_dict = dict(zip(keys, values))

ใน Python 3 zip จะส่งคืนตัวทำตัวขี้เกียจและตอนนี้เป็นวิธีที่มีประสิทธิภาพมากที่สุด

dict(zip(keys, values))ต้องใช้การค้นหาทั่วโลกแบบครั้งเดียวแต่ละครั้งสำหรับdictและzip, แต่มันไม่ได้สร้างโครงสร้างข้อมูลระดับกลางใด ๆ ที่ไม่จำเป็นหรือต้องจัดการกับการค้นหาแบบโลคัลในแอปพลิเคชันฟังก์ชัน

รองชนะเลิศ, dict comprehension:

นักวิ่งที่ใกล้ชิดเพื่อใช้ตัวสร้าง dict คือใช้ไวยากรณ์ดั้งเดิมของความเข้าใจ dict (ไม่ใช่รายการความเข้าใจเช่นเดียวกับที่คนอื่น ๆ เข้าใจผิด):

new_dict = {k: v for k, v in zip(keys, values)}

เลือกสิ่งนี้เมื่อคุณต้องการแมปหรือตัวกรองตามคีย์หรือค่า

ใน Python 2 zipส่งคืนรายการเพื่อหลีกเลี่ยงการสร้างรายการที่ไม่จำเป็นใช้izipแทน (aliased to zip สามารถลดการเปลี่ยนแปลงรหัสเมื่อคุณย้ายไปที่ Python 3)

from itertools import izip as zip

ดังนั้นยังคงเป็น (2.7):

new_dict = {k: v for k, v in zip(keys, values)}

Python 2 เหมาะสำหรับ <= 2.6

izipจากการitertoolsกลายเป็นzipPython 3 izipดีกว่า zip สำหรับ Python 2 (เพราะหลีกเลี่ยงการสร้างรายการที่ไม่จำเป็น) และเหมาะสำหรับ 2.6 หรือต่ำกว่า:

from itertools import izip
new_dict = dict(izip(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)

วิธีการที่ดีที่สุดคือการใช้ iterable ในขณะที่หลีกเลี่ยงการสร้างโครงสร้างข้อมูลที่ไม่จำเป็น ใน 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)])

ในสองกรณีแรกเลเยอร์พิเศษของการคำนวณแบบไม่ทำงาน (ดังนั้นไม่จำเป็น) จะถูกวางไว้เหนือซิปที่สามารถทวนได้และในกรณีของความเข้าใจในรายการนั้นจะมีการสร้างรายการพิเศษโดยไม่จำเป็น ฉันคาดหวังว่าพวกเขาทั้งหมดจะมีประสิทธิภาพน้อยกว่าและไม่มากไปกว่านั้น

ตรวจสอบประสิทธิภาพ:

ใน Python 3.8.2 64 บิตที่จัดทำโดย Nix บน Ubuntu 16.04 ได้รับคำสั่งจากเร็วที่สุดไปช้าที่สุด:

>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
0.6695233230129816
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.6941362579818815
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
0.8782548159942962
>>> 
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.077607496001292
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.1840861019445583

dict(zip(keys, values)) ชนะแม้จะมีชุดคีย์และค่าจำนวนน้อย แต่สำหรับชุดที่ใหญ่กว่าความแตกต่างของประสิทธิภาพจะยิ่งใหญ่กว่า

ผู้วิจารณ์พูดว่า:

minดูเหมือนจะเป็นวิธีที่ไม่ดีในการเปรียบเทียบประสิทธิภาพ แน่นอนmeanและ / หรือmaxจะเป็นตัวบ่งชี้ที่มีประโยชน์มากขึ้นสำหรับการใช้งานจริง

เราใช้minเพราะอัลกอริธึมเหล่านี้ไม่แน่นอน เราต้องการทราบประสิทธิภาพของอัลกอริทึมภายใต้เงื่อนไขที่ดีที่สุดเท่าที่จะเป็นไปได้

หากระบบปฏิบัติการหยุดทำงานไม่ว่าด้วยเหตุผลใดมันไม่มีส่วนเกี่ยวข้องกับสิ่งที่เราพยายามเปรียบเทียบดังนั้นเราจำเป็นต้องแยกผลลัพธ์ประเภทนั้นออกจากการวิเคราะห์ของเรา

ถ้าเราใช้meanเหตุการณ์ประเภทนั้นจะบิดเบือนผลลัพธ์ของเราอย่างมากและถ้าเราใช้maxเราจะได้ผลลัพธ์ที่รุนแรงที่สุดเท่านั้น - เหตุการณ์ที่น่าจะเกิดขึ้นมากที่สุด

นักวิจารณ์พูดว่า:

ใน python 3.6.8 การใช้ค่าเฉลี่ยความเข้าใจแบบ dict นั้นยังเร็วกว่าประมาณ 30% สำหรับรายการขนาดเล็กเหล่านี้ สำหรับรายการที่ใหญ่ขึ้น (ตัวเลขสุ่ม 10k) การ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

ลองสิ่งนี้:

>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}

ในหลาม 2 zipก็ยังประหยัดมากขึ้นในการใช้หน่วยความจำเมื่อเทียบกับ

>>> 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 3.x ไปเพื่อความเข้าใจของพจน์

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

dic = {k:v for k,v in zip(keys, values)}

print(dic)

ข้อมูลเพิ่มเติมเกี่ยวกับความเข้าใจ dict ที่นี่ตัวอย่างมี:

>>> print {i : chr(65+i) for i in range(4)}
    {0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}

สำหรับผู้ที่ต้องการรหัสง่ายๆและไม่คุ้นเคยกับzip:

List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']

สามารถทำได้ด้วยรหัสหนึ่งบรรทัด:

d = {List1[n]: List2[n] for n in range(len(List1))}

• 2018/04/18

ทางออกที่ดีที่สุดยังคง:

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')

คุณสามารถใช้รหัสด้านล่างนี้:

dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))

แต่ตรวจสอบให้แน่ใจว่าความยาวของรายการจะเท่ากันหากความยาวไม่เหมือนกันจากนั้นฟังก์ชันซิปจะเปิดอีกต่อไป

ฉันสงสัยในขณะที่ฉันพยายามแก้ไขปัญหาที่เกี่ยวข้องกับกราฟ ปัญหาที่ฉันมีคือฉันต้องการกำหนดรายการ adjacency ที่ว่างเปล่าและต้องการเริ่มต้นโหนดทั้งหมดด้วยรายการเปล่านั่นคือเมื่อฉันคิดว่าฉันจะตรวจสอบว่ามันเร็วพอหรือเปล่าฉันหมายความว่ามันจะคุ้มค่ากับการดำเนินการ 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_th จะใช้เวลาโดยวิธีการจดชวเลขในขั้นตอน n-1_th

นี่คือตัวอย่างของการเพิ่มค่ารายการในพจนานุกรมของคุณ

list1 = ["Name", "Surname", "Age"]
list2 = [["Cyd", "JEDD", "JESS"], ["DEY", "AUDIJE", "PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)

ตรวจสอบให้แน่ใจเสมอว่า "คีย์" ของคุณ (รายการ 1) อยู่ในพารามิเตอร์แรกเสมอ

{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}

วิธีแก้ไขความเข้าใจในพจนานุกรมที่มีการแจกแจง:

dict = {item : values[index] for index, item in enumerate(keys)}

โซลูชันสำหรับลูปที่มีการแจกแจง:

dict = {}
for index, item in enumerate(keys):
    dict[item] = values[index]

คุณอาจลองกับหนึ่งรายการซึ่งเป็นการรวมกันของสองรายการ;)

a = [1,2,3,4]
n = [5,6,7,8]

x = []
for i in a,n:
    x.append(i)

print(dict(zip(x[0], x[1])))

วิธีการที่ไม่มีฟังก์ชั่นซิป

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'}