ලැයිස්තු දෙකක් ශබ්ද කෝෂයක් බවට පරිවර්තනය කරන්න

ඔබට ඇති බව සිතන්න:

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ක්‍රියාකාරිත්වය ඉතා ප්‍රයෝජනවත් වේ: 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))

පයිතන් 3 හි, සිප් දැන් කම්මැලි අනුකාරකයක් ලබා දෙයි, මෙය දැන් වඩාත්ම ක්‍රියාකාරී ප්‍රවේශයයි.

dict(zip(keys, values))සඳහා එක් වරක් ගෝලීය විමසුමක් අවශ්‍ය වන dictඅතර zip, නමුත් එය කිසිදු අනවශ්‍ය අතරමැදි දත්ත ව්‍යුහයක් සාදන්නේ නැත, නැතහොත් ක්‍රියාකාරී යෙදුමේ දේශීය සොයා බැලීම් සමඟ කටයුතු කළ යුතුය.

අනුශූරතාවය, අවබෝධය අවබෝධ කර ගැනීම:

ඩික්ට් කන්ස්ට්‍රක්ටර් භාවිතා කිරීමට සමීප අනුශාසකයෙකු වන්නේ ඩික්ට් අවබෝධය පිළිබඳ ස්වදේශික වාක්‍ය ඛණ්ඩය භාවිතා කිරීමයි ( ලැයිස්තු අවබෝධයක් නොවේ, අනෙක් අය එය වැරදියට තබා ඇති පරිදි):

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

යතුරු හෝ වටිනාකම මත පදනම්ව ඔබට සිතියම් ගත කිරීමට හෝ පෙරීමට අවශ්‍ය විට මෙය තෝරන්න.

Python 2 හි, zipලැයිස්තුවක් නැවත ලබා දෙයි, අනවශ්‍ය ලැයිස්තුවක් නිර්මාණය කිරීමෙන් වළක්වා ගැනීමට, izipඒ වෙනුවට භාවිතා කරන්න (zip වෙත අන්වර්ථ කිරීමෙන් ඔබ Python 3 වෙත යන විට කේත වෙනස්වීම් අඩු කළ හැකිය).

from itertools import izip as zip

එබැවින් එය තවමත් පවතී (2.7):

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

පයිතන් 2, <= 2.6 සඳහා වඩාත් සුදුසුය

izipසිට itertoolsබවට පත් zipPython 3. izipPython 2 සඳහා තැපැල් වඩා යහපත් වන්නේ (එය අනවශ්ය ලැයිස්තුව නිර්මාණය මගහැරෙන බැවින්), සහ 2.6 හෝ පහත කදිම:

from itertools import izip
new_dict = dict(izip(keys, values))

සියලුම අවස්ථා සඳහා ප්‍රති ult ල:

සෑම අවස්ථාවකම:

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

ප්‍රශස්ත ප්‍රවේශය නම් අනවශ්‍ය දත්ත ව්‍යුහයන් නිර්මාණය කිරීමෙන් වැළකී නැවත භාවිතා කළ හැකි ය. පයිතන් 2 හි, zip අනවශ්‍ය ලැයිස්තුවක් සාදයි:

>>> zip(keys, values)
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

පයිතන් 3 හි, සමාන වන්නේ:

>>> list(zip(keys, values))
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

පයිතන් 3 හි zipහුදෙක් ප්‍රතිචක්‍රීකරණය කළ හැකි වස්තුවක් නිර්මාණය කරයි:

>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>

අපට අනවශ්‍ය දත්ත ව්‍යුහයන් නිර්මාණය කිරීමෙන් වැළකී සිටීමට අවශ්‍ය බැවින්, අපට සාමාන්‍යයෙන් අවශ්‍ය වන්නේ පයිතන් 2 ගේ zip(එය අනවශ්‍ය ලැයිස්තුවක් නිර්මාණය කරන බැවින්) වළක්වා ගැනීමටය .

අඩු කාර්ය සාධන විකල්ප:

මෙය ජනක යන්ත්‍ර ප්‍රකාශනයකි.

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([(k, v) for k, v in zip(keys, values)])

පළමු අවස්ථා දෙකෙහිදී, ක්‍රියාකාරී නොවන (මේ අනුව අනවශ්‍ය) ගණනය කිරීමේ අතිරේක තට්ටුවක් සිප් නැවත යෙදිය හැකි මට්ටමට වඩා ඉහළින් තබා ඇති අතර, ලැයිස්තුව අවබෝධ කර ගැනීමේදී අමතර ලැයිස්තුවක් අනවශ්‍ය ලෙස නිර්මාණය වේ. මම බලාපොරොත්තු වෙනවා ඔවුන් සියල්ලන්ම අඩු කාර්ය සාධනයක් ඇති, නිසැකවම එසේ නොවේ.

කාර්ය සාධන සමාලෝචනය:

නික්ස් විසින් උබුන්ටු 16.04 හි සපයන ලද බිට් 64 පයිතන් 3.8.2 හි වේගවත් සිට මන්දගාමී දක්වා ඇණවුම් කර ඇත:

>>> 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මෙම ඇල්ගොරිතම නිර්ණායක බැවින් අපි භාවිතා කරමු . අපට හැකි හොඳම කොන්දේසි යටතේ ඇල්ගොරිතම වල ක්‍රියාකාරිත්වය දැන ගැනීමට අපට අවශ්‍යය.

මෙහෙයුම් පද්ධතිය කිසියම් හේතුවක් නිසා එල්ලී තිබේ නම්, එය අප සංසන්දනය කිරීමට උත්සාහ කරන දේ සමඟ කිසිදු සම්බන්ධයක් නැත, එබැවින් අපගේ විශ්ලේෂණයෙන් එම ප්‍රති results ල බැහැර කළ යුතුය.

අප භාවිතා කළේ නම් mean, එම ආකාරයේ සිදුවීම් අපගේ ප්‍රති results ල බොහෝ සෙයින් මග හැරෙනු ඇති අතර, අප භාවිතා කළහොත් අපට maxලැබෙන්නේ වඩාත්ම ආන්තික ප්‍රති result ලය පමණි - එවැනි සිදුවීමකට බොහෝ දුරට බලපානු ඇත.

විචාරකයෙකු ද මෙසේ කියයි:

පයිතන් 3.6.8 හි, මධ්‍යන්‍ය අගයන් භාවිතා කරමින්, මෙම කුඩා ලැයිස්තු සඳහා 30% කින් පමණ නියත අවබෝධය තවමත් වේගවත් ය. විශාල ලැයිස්තු සඳහා (10k අහඹු අංක), dictඇමතුම 10% ක් පමණ වේගවත් වේ.

මම හිතන්නේ අපි අදහස් dict(zip(...කළේ 10k අහඹු සංඛ්‍යා සමඟ. එය තරමක් අසාමාන්‍ය භාවිත අවස්ථාවක් ලෙස පෙනේ. වඩාත්ම සෘජු ඇමතුම් විශාල දත්ත කට්ටලවල ආධිපත්‍යය දරනු ඇති බවට එය අර්ථවත් වන අතර, එම පරීක්ෂණය ක්‍රියාත්මක කිරීමට කොපමණ කාලයක් ගතවේද යන්න මත ඔබේ සංඛ්‍යා තවදුරටත් මඟ හැරී යන විට OS එල්ලීම් ආධිපත්‍යය දරන්නේ නම් මම පුදුම නොවෙමි. ඔබ භාවිතා කරන්නේ නම් meanහෝ maxඔබේ ප්‍රති results ල අර්ථ විරහිත යැයි මම සලකමි.

අපගේ ඉහළම උදාහරණ මත වඩාත් යථාර්ථවාදී ප්‍රමාණයක් භාවිතා කරමු:

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

ඔබට පයිතන් ≥ 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])) 

පයිතොනිස්ටා වැනි කේතයක් බලන්න : අයිඩියෝමැටික් පයිතන් .

පයිතන් 3.x සමඟ, ඩික්ට් අවබෝධය සඳහා යයි

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

සරල කේතයක් අවශ්‍ය සහ හුරුපුරුදු නැති අය සඳහා 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']))

නමුත් ලැයිස්තු වල දිග සමාන වන බවට වග බලා ගන්න. දිග සමාන නොවේ නම්. Zip ශ්‍රිතය දිග එක හරවන්න.

ප්‍රස්ථාර ආශ්‍රිත ගැටලුවක් විසඳීමට උත්සාහ කරන අතරතුර මට මෙම සැකය ඇති විය. මට තිබූ ගැටළුව වූයේ හිස් යාබද ලැයිස්තුවක් නිර්වචනය කිරීමට අවශ්‍ය වූ අතර හිස් ලැයිස්තුවක් සමඟ සියලු නෝඩ් ආරම්භ කිරීමට අවශ්‍ය වීමයි, ඒ මා සිතුවේ එය ප්‍රමාණවත් දැයි පරීක්ෂා කර බලන්නේ කෙසේද යන්නයි, මම අදහස් කළේ එය සිප් මෙහෙයුමක් කිරීම වටී සරල පැවරුම් යතුරු අගය යුගලයට වඩා. බොහෝ විට, කාල සාධකය වැදගත් අයිස් කඩනයකි. ඒ නිසා මම ප්‍රවේශයන් දෙකටම කාලරාමු මෙහෙයුමක් කළා.

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_ 1 පියවරෙහි පුනරාවර්තන ප්‍රවේශය n-1_ වන පියවරේදී කෙටිමං ප්‍රවේශය මගින් ගතවන කාලය ඉක්මවා යයි.

ඔබේ ශබ්ද කෝෂයේ ලැයිස්තු අගයක් එක් කිරීම සඳහා උදාහරණයක් ද මෙන්න

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

ගණන් බැලීම සමඟ ශබ්ද කෝෂ අවබෝධය ලෙස විසඳුම:

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