මට පයිතන් ශබ්දකෝෂ දෙකක් ඇති අතර, මෙම ශබ්ද කෝෂ දෙක ඒකාබද්ධ කරන ලද තනි ප්‍රකාශනයක් ලිවීමට මට අවශ්‍යය. මෙම update()එය ඒ වෙනුවට දී ස්ථානයක් ශබ්දකෝෂ පික්සලය වෙනස් එහි ප්රතිඵලයක් ආපසු නම් ක්රමය, මම අවශ්ය දේ වනු ඇත.

>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 10, 'c': 11}
>>> z = x.update(y)
>>> print(z)
None
>>> x
{'a': 1, 'b': 10, 'c': 11}

මම කොහොමද ඒ අවසන් ඒකාබද්ධ ශබ්ද කෝෂය ලබා ගත හැක zනැහැ, x?

(පැහැදිලිව dict.update()කිවහොත්, ගැටුම හසුරුවීමේ අවසාන ජයග්‍රාහකයා වන්නේ මා සොයන දෙයයි.)

තනි ප්‍රකාශනයකින් පයිතන් ශබ්දකෝෂ දෙකක් ඒකාබද්ධ කරන්නේ කෙසේද?

ශබ්ද කෝෂ සඳහා xසහ y, zඑය shallowly සිට අගයන් ශබ්ද කෝෂය ඒකාබද්ධ බවට පත් yවූ අය වෙනුවට x.

• පයිතන් 3.5 හෝ ඊට වැඩි:

  z = {**x, **y}

• පයිතන් 2 හි (හෝ 3.4 හෝ ඊට අඩු) ශ්‍රිතයක් ලියන්න:

  def merge_two_dicts(x, y):
      z = x.copy()   # start with x's keys and values
      z.update(y)    # modifies z with y's keys and values & returns None
      return z

  සහ දැන්:

  z = merge_two_dicts(x, y)

• Python 3.9.0a4 හෝ ඊට වැඩි (අවසාන නිකුතුව දිනය දළ වශයෙන් ඔක්තෝබර් 2020): පී-584 , මෙහි සාකච්ඡා , මේ සරල කිරීමට ක්රියාත්මක කරන ලදී:

  z = x | y          # NOTE: 3.9+ ONLY

පැහැදිලි කිරීම

ඔබට නියෝග දෙකක් ඇති බවත්, මුල් නියෝග වෙනස් නොකර ඒවා නව නියෝගයකට ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය බවත් පවසන්න:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

අපේක්ෂිත ප්‍රති result ලය වනුයේ නව ශබ්ද කෝෂයක් ( z) ඒකාබද්ධ කළ අගයන් සමඟ ලබා ගැනීම සහ දෙවන ආ ict ාවේ අගයන් මුල සිට නැවත ලිවීමයි.

>>> z
{'a': 1, 'b': 3, 'c': 4}

මේ සඳහා, නව වාග් රීතිය යෝජනා පී.ඊ.පී. 448 සහ Python 3.5 ලෙස ලබා ගත වේ

z = {**x, **y}

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

අපට වචනානුගත අංකනය සමඟ ඒකාබද්ධ කළ හැකි බව සලකන්න:

z = {**x, 'foo': 1, 'bar': 2, **y}

සහ දැන්:

>>> z
{'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}

එය දැන් 3.5, PEP 478 සඳහා මුදා හැරීමේ කාලසටහනේ ක්‍රියාත්මක කර ඇති බව පෙන්වන අතර එය දැන් පයිතන් 3.5 ලේඛනයේ නව දේ වෙත පිවිස ඇත .

කෙසේ වෙතත්, බොහෝ සංවිධාන තවමත් පයිතන් 2 හි ඇති බැවින්, ඔබට මෙය පසුගාමී අනුකූලතාවයකින් කිරීමට අවශ්‍ය විය හැකිය. පයිතන් 2 සහ පයිතන් 3.0-3.4 වලින් ලබා ගත හැකි සම්භාව්‍ය පයිතොනික් ක්‍රමය මෙය පියවර දෙකක ක්‍රියාවලියක් ලෙස සිදු කිරීම ය:

z = x.copy()
z.update(y) # which returns None since it mutates z

ප්රවේශයන් දෙකෙහිම, yදෙවන ස්ථානයට පැමිණෙනු ඇති අතර එහි අගයන් අගයයන් ප්රතිස්ථාපනය කරනු ඇත x, එබැවින් අපගේ අවසාන ප්රති .ලය 'b'වෙත යොමු වනු ඇත 3.

පයිතන් 3.5 හි තවම නැත, නමුත් තනි ප්‍රකාශනයක් අවශ්‍යය

ඔබ තවමත් පයිතන් 3.5 හි නොමැති නම් හෝ පසුගාමී-අනුකූල කේතයක් ලිවීමට අවශ්‍ය නම් සහ ඔබට මෙය තනි ප්‍රකාශනයකින් අවශ්‍ය නම් , වඩාත්ම ක්‍රියාකාරී වන අතර නිවැරදි ප්‍රවේශය නම් එය ශ්‍රිතයක් තුළට දැමීමයි:

def merge_two_dicts(x, y):
    """Given two dicts, merge them into a new dict as a shallow copy."""
    z = x.copy()
    z.update(y)
    return z

එවිට ඔබට තනි ප්‍රකාශනයක් ඇත:

z = merge_two_dicts(x, y)

නිර්වචනය නොකළ සංඛ්‍යා සංඛ්‍යාවක්, ශුන්‍යයේ සිට ඉතා විශාල සංඛ්‍යාවක් ඒකාබද්ධ කිරීම සඳහා ඔබට ශ්‍රිතයක් කළ හැකිය:

def merge_dicts(*dict_args):
    """
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result

මෙම ශ්‍රිතය සියලුම නියෝග සඳහා පයිතන් 2 සහ 3 හි ක්‍රියා කරයි. ලබා දී dicts උදා aකිරීමට g:

z = merge_dicts(a, b, c, d, e, f, g) 

සහ යතුරු අගයන් යුගලය gඅණපනත් aවලට වඩා ප්‍රමුඛත්වය ගනී f.

වෙනත් පිළිතුරු පිළිබඳ විවේචන

කලින් පිළිගත් පිළිතුරෙන් ඔබ දකින දේ භාවිතා නොකරන්න:

z = dict(x.items() + y.items())

පයිතන් 2 හි, ඔබ එක් එක් ආ ict ාව සඳහා මතකයේ ලැයිස්තු දෙකක් සාදයි, මතකයේ තුන්වන ලැයිස්තුවක් සාදන්න, පළමු දෙකේ දිගට සමාන දිගකින් යුක්ත වන අතර ඉන්පසු ලැයිස්තු තුනම ඉවතලන්න. පයිතන් 3 හි, මෙය අසාර්ථක වනුයේ ඔබ dict_itemsලැයිස්තු දෙකක් නොව වස්තු දෙකක් එකතු කරන බැවිනි -

>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'

ඔබට ඒවා ලැයිස්තු ලෙස පැහැදිලිව නිර්මාණය කිරීමට සිදුවේ, උදා z = dict(list(x.items()) + list(y.items())). මෙය සම්පත් හා ගණනය කිරීමේ බලය නාස්තියකි.

ඒ හා සමානව, items()පයිතන් 3 හි ( viewitems()පයිතන් 2.7 හි) එකමුතුව ගැනීම අගයන් වෙනස් කළ නොහැකි වස්තූන් වන විට ද අසාර්ථක වනු ඇත (උදාහරණයක් ලෙස ලැයිස්තු වැනි). ඔබේ අගයන් හැෂ් කළ හැකි වුවද, කට්ටල අර්ථකථනය කර නොමැති බැවින්, හැසිරීම ප්‍රමුඛතාවය සම්බන්ධයෙන් නිර්වචනය කර නැත. එබැවින් මෙය නොකරන්න:

>>> c = dict(a.items() | b.items())

මෙම උදාහරණයෙන් පෙන්නුම් කරන්නේ සාරධර්ම වෙනස් කළ නොහැකි විට සිදුවන්නේ කුමක්ද යන්නයි:

>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

මෙන්න y ට ප්‍රමුඛතාවයක් තිබිය යුතු උදාහරණයක්, නමුත් ඒ වෙනුවට x හි අගය අත්තනෝමතික ලෙස අනුපිළිවෙල අනුව රඳවා ගනී:

>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}

ඔබ භාවිතා නොකළ යුතු තවත් හැක්:

z = dict(x, **y)

මෙය dictඉදිකිරීම්කරු භාවිතා කරන අතර එය ඉතා වේගවත් හා මතක කාර්යක්ෂම වේ (අපගේ පියවර දෙකේ ක්‍රියාවලියට වඩා මදක් වැඩි ය) නමුත් මෙහි සිදුවන්නේ කුමක්ද යන්න ඔබ හරියටම නොදන්නේ නම් (එනම්, දෙවන ආ ict ාව ප්‍රධාන වචන තර්ක ලෙස සම්මත වේ. ඉදිකිරීම්කරු), කියවීමට අපහසුය, එය අපේක්ෂිත භාවිතය නොවේ, එබැවින් එය පයිතොනික් නොවේ.

ජැන්ගෝ හි භාවිතයට පිළියම් යෙදීම පිළිබඳ උදාහරණයක් මෙන්න .

ඩික්ස් යනු හැෂ් කළ හැකි යතුරු (උදා: ශීත කළ කට්ටල හෝ ටුපල්) ගැනීමට අදහස් කරන නමුත් යතුරු නූල් නොවන විට මෙම ක්‍රමය පයිතන් 3 හි අසමත් වේ.

>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

සිට තැපැල් ලැයිස්තුව ගයිඩෝ වෑන් Rossum, භාෂාව නිර්මාතෘ, මෙසේ ලිවීය:

({}, ** {1: 3}) නීති විරෝධී යැයි ප්‍රකාශ කිරීම ගැන මම සතුටු වෙමි, මන්ද එය ** යාන්ත්‍රණය අනිසි ලෙස භාවිතා කිරීමකි.

හා

පෙනෙන විදිහට (x, ** y) "x.update (y) අමතන්න සහ ආපසු x" සඳහා "සිසිල් හැක්" ලෙස ගමන් කරයි. පුද්ගලිකව මම එය සිසිල් වලට වඩා පහත් කොට සලකමි.

කියවීමට ඇති අරමුණු සඳහා අණපනත් නිර්මාණය කිරීම සඳහා අපේක්ෂිත භාවිතය වන්නේ මගේ අවබෝධය (මෙන්ම භාෂාවේ නිර්මාතෘගේ අවබෝධය ) dict(**y), උදා:

dict(a=1, b=10, c=11)

වෙනුවට

{'a': 1, 'b': 10, 'c': 11}

අදහස් වලට ප්‍රතිචාර

ගයිඩෝ කුමක් dict(x, **y)පැවසුවද, එය dt පිරිවිතරයන්ට අනුකූල වේ. පයිතන් 2 සහ 3 යන දෙකටම වැඩ කරයි. මෙය ක්‍රියා කරන්නේ යතුරු යතුරු සඳහා පමණක් වන අතර එය මූලික වචන පරාමිතීන් ක්‍රියා කරන ආකාරයෙහි සෘජු ප්‍රතිවිපාකයකි. මෙම ස්ථානයේ ** ක්‍රියාකරු භාවිතා කිරීම ද යාන්ත්‍රණය අනිසි ලෙස භාවිතා කිරීමක් නොවේ, ඇත්ත වශයෙන්ම ** නිර්මාණය කර ඇත්තේ හරියටම නියමයන් මූලික වචන ලෙස සම්මත කිරීම සඳහා ය.

යතුරු නූල් නොවන විට නැවතත් 3 සඳහා එය ක්‍රියා නොකරයි. ව්‍යංග ඇමතුම් කොන්ත්‍රාත්තුව නම් නාම අවකාශයන් සාමාන්‍ය විධානයන් ගන්නා අතර පරිශීලකයින් විසින් සම්මත කළ යුත්තේ වචන පද පමණක් වන වචන පමණි. අනෙක් සියලුම ඇමතුම්කරුවන් එය බලාත්මක කළහ. dictපයිතන් 2 හි මෙම අනුකූලතාව බිඳ දැමීය:

>>> foo(**{('a', 'b'): None})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{('a', 'b'): None})
{('a', 'b'): None}

පයිතන් (පයිපී, ජයිතන්, අයන්පයිතන්) ක්‍රියාත්මක කිරීමේදී මෙම නොගැලපීම නරක ය. මේ අනුව එය පයිතන් 3 හි සවි කර ඇති අතර මෙම භාවිතය බිඳෙනසුලු වෙනසක් විය හැකිය.

භාෂාවක එක් අනුවාදයක පමණක් ක්‍රියාත්මක වන හෝ යම් අත්තනෝමතික බාධක ලබා දී ඇති කේත පමණක් හිතාමතාම ලිවීම අනිෂ්ට නොහැකියාව බව මම ඔබට ඉදිරිපත් කරමි.

තවත් අදහස්:

dict(x.items() + y.items()) පයිතන් 2 සඳහා තවමත් කියවිය හැකි විසඳුම වේ. කියවීමේ හැකියාව ගණනය කෙරේ.

මගේ ප්‍රතිචාරය: merge_two_dicts(x, y)කියවීමේ හැකියාව ගැන අප සැබවින්ම සැලකිලිමත් වන්නේ නම්, මට වඩා පැහැදිලිව පෙනේ. පයිතන් 2 වැඩි වැඩියෙන් ක්ෂය වී ඇති බැවින් එය ඉදිරියට නොගැලපේ.

{**x, **y}කැදැලි ශබ්ද කෝෂ හසුරුවන බවක් නොපෙනේ. කැදැලි යතුරු වල අන්තර්ගතය සරලව නැවත ලියනු ලැබේ, ඒකාබද්ධ නොකෙරේ [...] පුනරාවර්තන ලෙස ඒකාබද්ධ නොවන මෙම පිළිතුරු වලින් මා පුළුස්සා දැමූ අතර කිසිවෙකු එය සඳහන් නොකිරීම ගැන මම පුදුමයට පත් වීමි. "ඒකාබද්ධ කිරීම" යන වචනයේ මගේ අර්ථ නිරූපනයේ දී මෙම පිළිතුරු විස්තර කරන්නේ "එක් නියෝගයක් තවත් එකක් සමඟ යාවත්කාලීන කිරීම" මිස ඒකාබද්ධ කිරීම නොවේ.

ඔව්. ශබ්දකෝෂ දෙකක නොගැඹුරු ඒකාබද්ධ කිරීමක් ඉල්ලා සිටින ප්‍රශ්නයට මා ඔබව නැවත යොමු කළ යුතු අතර, පළමු අගයන් දෙවැන්න විසින් නැවත ලියනු ලැබේ - තනි ප්‍රකාශනයකින්.

ශබ්ද කෝෂ දෙකක් උපකල්පනය කරමින්, යමෙකුට ඒවා නැවත නැවත එක් ශ්‍රිතයක් සමඟ ඒකාබද්ධ කළ හැකි නමුත්, එක් මූලාශ්‍රයකින් නියෝග වෙනස් නොකිරීමට ඔබ වගබලා ගත යුතු අතර, එය වළක්වා ගත හැකි ස්ථිරම ක්‍රමය වන්නේ අගයන් පැවරීමේදී පිටපතක් සෑදීමයි. යතුරු හැෂ් කළ හැකි හා සාමාන්‍යයෙන් වෙනස් කළ නොහැකි බැවින් ඒවා පිටපත් කිරීම තේරුමක් නැති දෙයක්:

from copy import deepcopy

def dict_of_dicts_merge(x, y):
    z = {}
    overlapping_keys = x.keys() & y.keys()
    for key in overlapping_keys:
        z[key] = dict_of_dicts_merge(x[key], y[key])
    for key in x.keys() - overlapping_keys:
        z[key] = deepcopy(x[key])
    for key in y.keys() - overlapping_keys:
        z[key] = deepcopy(y[key])
    return z

භාවිතය:

>>> x = {'a':{1:{}}, 'b': {2:{}}}
>>> y = {'b':{10:{}}, 'c': {11:{}}}
>>> dict_of_dicts_merge(x, y)
{'b': {2: {}, 10: {}}, 'a': {1: {}}, 'c': {11: {}}}

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

අඩු ක්‍රියාකාරී නමුත් නිවැරදි තාවකාලික

මෙම ප්‍රවේශයන් අඩු ක්‍රියාකාරීත්වයක් ඇති නමුත් ඒවා නිවැරදි හැසිරීමක් ලබා දෙනු ඇත. ඔවුන් වනු ඇත බෙහෙවින් අඩු performant වඩා copyහා updateවියුක්තීකරණය ඉහළ මට්ටමින් එක් එක් ප්රධාන-අගය යුගල හරහා ඔවුන් අවංකව හෝ නව විහිදු නිසා, නමුත් ඔවුන් කරන්නේ තැනක්ද අනුපිළිවෙල ගරු (අග dicts මූඛ)

ඩික්ට් අවබෝධය තුළ ඔබට අතින් අතින් දම්වැල් දැමිය හැකිය:

{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7

හෝ පයිතන් 2.6 හි (සහ උත්පාදක ප්‍රකාශන හඳුන්වා දුන් විට 2.4 තරම්) ත අතීතයේ):

dict((k, v) for d in dicts for k, v in d.items())

itertools.chain යතුරු අනුපිළිවෙලින් යතුරු අනුපිළිවෙලට නිවැරදි අනුපිළිවෙලින් දාමකාරක දාමය කරයි:

import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))

කාර්ය සාධන විශ්ලේෂණය

මම කරන්න යන්නේ නිවැරදිව හැසිරීමට දන්නා භාවිතයන්ගේ කාර්ය සාධන විශ්ලේෂණය පමණි.

import timeit

පහත දැක්වෙන්නේ උබුන්ටු 14.04 හි ය

පයිතන් 2.7 හි (පද්ධති පයිතන්):

>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934

පයිතන් 3.5 හි (ඩෙඩ්ස්නේක්ස් පීපීඒ):

>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287

ශබ්දකෝෂ පිළිබඳ සම්පත්

• පයිතන්ගේ ශබ්ද කෝෂය ක්‍රියාත්මක කිරීම පිළිබඳ මගේ පැහැදිලි කිරීම 3.6 සඳහා යාවත්කාලීන කරන ලදි.
• ශබ්ද කෝෂයකට නව යතුරු එකතු කරන්නේ කෙසේද යන්න පිළිබඳ පිළිතුර
• ලැයිස්තු දෙකක් ශබ්ද කෝෂයකට අනුරූපණය කිරීම
• ශබ්දකෝෂ පිළිබඳ නිල පයිතන් ලේඛනය
• ශබ්ද කෝෂය ඊටත් වඩා බලවත් - පයිකොන් 2017 හි බ්‍රැන්ඩන් රෝඩ්ස් විසින් කරන ලද කතාව
• නූතන පයිතන් ශබ්දකෝෂ, මහා අදහස්වල එකතුවක් - පයිකොන් 2017 හි රේමන්ඩ් හෙට්ටින්ගර්ගේ කතාව

ඔබේ නඩුවේදී, ඔබට කළ හැක්කේ:

z = dict(x.items() + y.items())

මෙය ඔබට අවශ්‍ය පරිදි අවසාන නියෝගය ඇතුළත් zකර යතුර සඳහා වන අගය bදෙවන ( y) ආ ict ාවේ වටිනාකම මගින් නිසි ලෙස අභිබවා යනු ඇත :

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(x.items() + y.items())
>>> z
{'a': 1, 'c': 11, 'b': 10}

ඔබ පයිතන් 3 භාවිතා කරන්නේ නම්, එය තව ටිකක් සංකීර්ණ වේ. නිර්මාණය කිරීමට z:

>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

ඔබ පයිතන් අනුවාදය 3.9.0a4 හෝ ඊට වැඩි නම්, ඔබට කෙලින්ම භාවිතා කළ හැකිය:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = x | y
print(z)

Output: {'a': 1, 'c': 11, 'b': 10}

විකල්පයක්:

z = x.copy()
z.update(y)

තවත්, වඩාත් සංක්ෂිප්ත, විකල්පය:

z = dict(x, **y)

සටහන : මෙය ජනප්‍රිය පිළිතුරක් බවට පත්ව ඇත, නමුත් yනූල් නොවන යතුරු තිබේ නම් , මෙය කිසිසේත්ම ක්‍රියාත්මක වන්නේ සීපයිතන් ක්‍රියාත්මක කිරීමේ විස්තරයක් අනිසි ලෙස භාවිතා කිරීමක් බවත් එය පයිතන් 3 හි ක්‍රියාත්මක නොවන බවත් පෙන්වා දීම වැදගත්ය . හෝ PyPy, IronPython හෝ Jython හි. එසේම ගයිඩෝ රසිකයෙක් නොවේ . එබැවින් ඉදිරියට-අනුකූල හෝ හරස් ක්‍රියාත්මක කළ හැකි අතේ ගෙන යා හැකි කේතයක් සඳහා මට මෙම තාක්ෂණය නිර්දේශ කළ නොහැක, එයින් අදහස් කරන්නේ එය සම්පූර්ණයෙන්ම වළක්වා ගත යුතු බවයි.

මෙය බොහෝ විට ජනප්‍රිය පිළිතුරක් නොවනු ඇත, නමුත් ඔබට මෙය කිරීමට අවශ්‍ය නැත. ඔබට ඒකාබද්ධ කළ පිටපතක් අවශ්‍ය නම්, පිටපත භාවිතා කරන්න (හෝ ගැඹුරු පිටපත , ඔබට අවශ්‍ය දේ අනුව) ඉන්පසු යාවත්කාලීන කරන්න. කේතයේ පේළි දෙක .items () + .items () සමඟ තනි පේළි නිර්මාණයට වඩා කියවිය හැකි - වඩා පයිතොනික්. ව්‍යංගයට වඩා පැහැදිලිය.

ඊට අමතරව, ඔබ .items () (පෙර පයිතන් 3.0) භාවිතා කරන විට, ඔබ නව ලැයිස්තුවක් සාදයි. ඔබේ ශබ්ද කෝෂ විශාල නම්, එය බොහෝ ඉහළින් (ඒකාබද්ධ කරන ලද ආ ict ාව නිර්මාණය කළ විගස ඉවත ලන විශාල ලැයිස්තු දෙකක්). යාවත්කාලීනය () වඩාත් කාර්යක්ෂමව ක්‍රියා කළ හැකිය, මන්ද එය අයිතමයෙන් දෙවන අයිතමය හරහා ධාවනය කළ හැකි බැවිනි.

අනුව කාලය :

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

IMO පළමු දෙක අතර ඇති කුඩා මන්දගාමිත්වය කියවීමේ හැකියාව සඳහා එය වටී. ඊට අමතරව, ශබ්ද කෝෂ නිර්මාණය සඳහා යතුරු පද එකතු කරන ලද්දේ පයිතන් 2.3 හි පමණක් වන අතර, පිටපත් () සහ යාවත්කාලීන කිරීම () පැරණි අනුවාද වල ක්‍රියාත්මක වේ.

පසු විපරම් පිළිතුරක දී, ඔබ මෙම විකල්ප දෙකේ සාපේක්ෂ ක්‍රියාකාරිත්වය ගැන විමසීය:

z1 = dict(x.items() + y.items())
z2 = dict(x, **y)

මගේ යන්ත්‍රයේ, අවම වශයෙන් (තරමක් සාමාන්‍ය x86_64 ධාවනය වන පයිතන් 2.5.2), විකල්පය z2කෙටි හා සරල පමණක් නොව සැලකිය යුතු වේගයකින් ද වේ. timeitපයිතන් සමඟ එන මොඩියුලය භාවිතා කර ඔබට මෙය සත්‍යාපනය කළ හැකිය .

උදාහරණ 1: අඛණ්ඩ සංඛ්‍යා 20 ක් සිතියම් ගත කරන සමාන ශබ්දකෝෂ:

% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'
100000 loops, best of 3: 5.67 usec per loop
% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' 
100000 loops, best of 3: 1.53 usec per loop

z23.5 හෝ ඊට වැඩි සාධකයකින් ජය ගනී. විවිධ ශබ්ද කෝෂවලට වඩා වෙනස් ප්‍රති results z2ල ලැබෙන බව පෙනේ , නමුත් සෑම විටම ඉදිරියට එන බව පෙනේ. ( එකම පරීක්ෂණය සඳහා ඔබට නොගැලපෙන ප්‍රති results ල ලැබෙන්නේ නම් -r, පෙරනිමි 3 ට වඩා විශාල සංඛ්‍යාවක් සමඟ යාමට උත්සාහ කරන්න .)

උදාහරණ 2: අතිච්ඡාදනය නොවන ශබ්දකෝෂ කෙටි කෙඳි 252 පූර්ණ සංඛ්‍යාවක් වෙත සිතියම් ගත කරන අතර අනෙක් අතට:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'
1000 loops, best of 3: 260 usec per loop
% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)'               
10000 loops, best of 3: 26.9 usec per loop

z2 10 කින් පමණ ජය ගනී. එය මගේ පොතේ විශාල ජයග්‍රහණයක්!

එම දෙක සංසන්දනය කිරීමෙන් පසු, z1අයිතම ලැයිස්තු දෙක සෑදීමේ පොදු කාර්යයේ දුර්වල ක්‍රියාකාරිත්වයට හේතු විය හැකිදැයි මම කල්පනා කළෙමි , එමඟින් මෙම විචලනය වඩා හොඳින් ක්‍රියාත්මක වේදැයි මට කල්පනා විය:

from itertools import chain
z3 = dict(chain(x.iteritems(), y.iteritems()))

ඉක්මන් පරීක්ෂණ කිහිපයක්, උදා

% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'
10000 loops, best of 3: 66 usec per loop

z3එය තරමක් වේගවත් z1, නමුත් තරම් වේගවත් නොවන නිගමනයකට මා ගෙන යන්න z2. සියලුම අමතර ටයිප් කිරීම අනිවාර්යයෙන්ම වටින්නේ නැත.

මෙම සාකච්ඡාවට තවමත් වැදගත් යමක් අස්ථානගත වී ඇත, එය මෙම විකල්පයන් ලැයිස්තු දෙකක් ඒකාබද්ධ කිරීමේ “පැහැදිලි” ක්‍රමය සමඟ සංසන්දනය කිරීමකි: updateක්‍රමය භාවිතා කිරීම . X හෝ y වෙනස් නොකරන කිසිවක් ප්‍රකාශන සමඟ සමාන පදනමක් මත තබා ගැනීමට උත්සාහ කිරීම සඳහා, මම x හි පිටපතක් තැනින් තැන වෙනස් කිරීම වෙනුවට පහත පරිදි සාදන්නෙමි:

z0 = dict(x)
z0.update(y)

සාමාන්‍ය ප්‍රති result ලයක්:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'
10000 loops, best of 3: 26.9 usec per loop

වෙනත් වචන වලින් කිවහොත්, z0හා z2අවශ්යයෙන්ම සමාන කාර්ය සාධන ඇති කරන බවක් පෙනී යයි. මෙය අහම්බයක් විය හැකි යැයි ඔබ සිතනවාද? මම දන්ෙන නෑ....

ඇත්ත වශයෙන්ම, පිරිසිදු පයිතන් කේතයට මීට වඩා හොඳ දෙයක් කළ නොහැකි යැයි කීමට තරම් මම යන්නෙමි. සී දිගුව මොඩියුලයකින් ඔබට සැලකිය යුතු ලෙස වඩා හොඳින් කළ හැකි නම්, මම සිතන්නේ පයිතන් හරය තුළට ඔබේ කේතය (හෝ ඔබේ ප්‍රවේශයේ වෙනස්කමක්) ඇතුළත් කිරීමට පයිතන් ජනතාව උනන්දු වනු ඇති බවයි. පයිතන් dictබොහෝ ස්ථානවල භාවිතා කරයි ; එහි මෙහෙයුම් ප්‍රශස්ත කිරීම විශාල ගනුදෙනුවක්.

ඔබට මෙයද ලිවිය හැකිය

z0 = x.copy()
z0.update(y)

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

පයිතන් 3.0 සහ පසුව , collections.ChainMapතනි, යාවත්කාලීන කළ හැකි දර්ශනයක් නිර්මාණය කිරීම සඳහා ඔබට විවිධ කණ්ඩායම් හෝ වෙනත් සිතියම් ගත කළ හැකි කණ්ඩායම් භාවිතා කළ හැකිය :

>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(ChainMap({}, y, x))
>>> for k, v in z.items():
        print(k, '-->', v)

a --> 1
b --> 10
c --> 11

පයිතන් 3.5 සහ ඊට පසුව යාවත්කාලීන කරන්න : ඔබට PEP 448 දීර් extended ශබ්ද කෝෂ ඇසුරුම් කිරීම සහ ඉවත් කිරීම භාවිතා කළ හැකිය . මෙය වේගවත් හා පහසු ය:

>>> x = {'a':1, 'b': 2}
>>> y = y = {'b':10, 'c': 11}
>>> {**x, **y}
{'a': 1, 'b': 10, 'c': 11}

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

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

ආ ict ාවක් පුනරාවර්තන / ගැඹුරු යාවත්කාලීන කිරීම

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

නිරූපණය:

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

නිමැවුම්:

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

සංස්කරණයන් සඳහා ස්තූතියි.

පිටපතක් භාවිතා නොකරන අතරතුර මට සිතිය හැකි හොඳම අනුවාදය වනුයේ:

from itertools import chain
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
dict(chain(x.iteritems(), y.iteritems()))

එය අවම වශයෙන් සීපයිතන් වලට වඩා වේගවත් dict(x.items() + y.items())නමුත් වේගවත් නොවේ n = copy(a); n.update(b). මෙම අනුවාදය ද ඔබ වෙනස් නම් පිඹුරා 3 වැඩ iteritems()කිරීමට items()ඇති 2to3 මෙවලම මගින් ස්වයංක්රීයව සිදු කරන.

පුද්ගලිකව මම මෙම අනුවාදයට වඩාත්ම කැමතියි එය තනි ක්‍රියාකාරී වාක්‍ය ඛණ්ඩයකින් මට අවශ්‍ය දේ තරමක් හොඳ විස්තර කරයි. එකම කුඩා ගැටළුව නම්, x වෙතින් ලැබෙන අගයන්ට වඩා y වෙතින් අගයන් ප්‍රමුඛස්ථානයක් ගන්නා බව මුළුමනින්ම පැහැදිලි නොවීමයි, නමුත් එය හඳුනා ගැනීම අපහසු යැයි මම විශ්වාස නොකරමි.

පයිතන් 3.5 (පීඊපී 448) වඩා හොඳ සින්ටැක්ස් විකල්පයකට ඉඩ දෙයි:

x = {'a': 1, 'b': 1}
y = {'a': 2, 'c': 2}
final = {**x, **y} 
final
# {'a': 2, 'b': 1, 'c': 2}

නැත්නම් පවා

final = {'a': 1, 'b': 1, **x, **y}

පයිතන් 3.9 හි ඔබ ද භාවිතා කරයි | සහ | = පහත උදාහරණය සමඟ PEP 584

d = {'spam': 1, 'eggs': 2, 'cheese': 3}
e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
d | e
# {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items() + y.items())
print z

ශබ්ද කෝෂ දෙකෙහිම යතුරු ඇති අයිතම සඳහා ('ආ'), ප්‍රතිදානය අවසන් වන්නේ කුමන ඒවාද යන්න ඔබට පාලනය කළ හැකිය.

ප්‍රශ්නයට දැනටමත් කිහිප වතාවක්ම පිළිතුරු ලබා දී ඇති නමුත් ගැටලුවට මෙම සරල විසඳුම තවමත් ලැයිස්තුගත කර නොමැත.

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

එය z0 තරම් වේගවත් වන අතර ඉහත සඳහන් කළ නපුරු z2 වේ, නමුත් තේරුම් ගැනීමට සහ වෙනස් කිරීමට පහසුය.

def dict_merge(a, b):
  c = a.copy()
  c.update(b)
  return c

new = dict_merge(old, extras)

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

print dict_merge(
      {'color':'red', 'model':'Mini'},
      {'model':'Ferrari', 'owner':'Carl'})

ලබා දෙයි:

{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}

ලැම්බඩා නපුරු යැයි ඔබ සිතන්නේ නම් තවදුරටත් කියවන්න එපා. ඉල්ලූ පරිදි, ඔබට එක් ප්‍රකාශනයකින් වේගවත් හා මතක කාර්යක්ෂම විසඳුම ලිවිය හැකිය:

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

ඉහත යෝජනා කර ඇති පරිදි, පේළි දෙකක් භාවිතා කිරීම හෝ ශ්‍රිතයක් ලිවීම වඩා හොඳ ක්‍රමයක් විය හැකිය.

පයිතොනික් වන්න. අවබෝධයක් භාවිතා කරන්න :

z={i:d[i] for d in [x,y] for i in d}

>>> print z
{'a': 1, 'c': 11, 'b': 10}

Python3 හි, itemsක්‍රමය තවදුරටත් ලැයිස්තුවක් ලබා නොදෙන අතර එය දර්ශනයක් ලෙස ක්‍රියා කරයි. මෙම අවස්ථාවේ දී ඔබ සමිතිය ගත යුතු බැවින් සමපාත වීම සාර්ථක +නොවනු ඇත:

dict(x.items() | y.items())

2.7 අනුවාදයේ python3 වැනි හැසිරීම සඳහා, ඒ වෙනුවට viewitemsක්‍රමය ක්‍රියාත්මක විය යුතුය items:

dict(x.viewitems() | y.viewitems())

මම කෙසේ හෝ මෙම අංකනයට වැඩි කැමැත්තක් දක්වන්නේ එය සම්මුතියකට වඩා නිශ්චිත වෘත්තීය සමිති මෙහෙයුමක් ලෙස සිතීම ස්වාභාවික බැවිනි (මාතෘකාව පෙන්නුම් කරන පරිදි).

සංස්කරණය කරන්න:

පයිතන් 3 සඳහා තවත් කරුණු කිහිපයක්. පළමුව, එය සටහන් කරන්න dict(x, **y) යතුරු yනූල් නොවන්නේ නම් උපක්‍රමය පයිතන් 3 හි ක්‍රියා නොකරන .

එසේම, රේමන්ඩ් Hettinger ගේ Chainmap පිළිතුර එය තර්ක ලෙස, නමුත් dicts හිතුවක්කාරී අංකය ගත හැකි බැවින්, ඉතා අලංකාර වේ ද ලේඛන සිට එය අනුපිලිවෙලට එක් එක් බැලීම සඳහා සියලු dicts ලැයිස්තුවක් හරහා බලයි වගේ පෙනුමක්:

යතුරක් සොයා ගන්නා තෙක් බැලුම් යටි සිතියම් අනුපිළිවෙලින් සොයයි.

ඔබගේ යෙදුමේ බොහෝ සෙවුම් තිබේ නම් මෙය ඔබගේ වේගය අඩු කළ හැකිය:

In [1]: from collections import ChainMap
In [2]: from string import ascii_uppercase as up, ascii_lowercase as lo; x = dict(zip(lo, up)); y = dict(zip(up, lo))
In [3]: chainmap_dict = ChainMap(y, x)
In [4]: union_dict = dict(x.items() | y.items())
In [5]: timeit for k in union_dict: union_dict[k]
100000 loops, best of 3: 2.15 µs per loop
In [6]: timeit for k in chainmap_dict: chainmap_dict[k]
10000 loops, best of 3: 27.1 µs per loop

එබැවින් බැලීම් සඳහා මන්දගාමී අනුපිළිවෙලක් ගැන. මම චේන්මැප් හි රසිකයෙක්, නමුත් බොහෝ බැලූ බැල්මට ප්‍රායෝගික නොවන බව පෙනේ.

අපයෝජනය මතෙව්ගේ පිළිතුර සඳහා එක් ප්‍රකාශන විසඳුමකට මග පාදයි :

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (lambda f=x.copy(): (f.update(y), f)[1])()
>>> z
{'a': 1, 'c': 11, 'b': 10}

ඔයාට කිව්වා ඔයාට එක ප්‍රකාශනයක් ඕන කියලා, ඉතින් මම අතවර කළා lambda නමක් බැඳීමට , සහ ලැම්බඩාගේ එක් ප්‍රකාශන සීමාව ඉක්මවා යාමට ටුප්ල්ස්. බිය වීමට නිදහස් වන්න.

ඔබ එය පිටපත් කිරීම ගැන තැකීමක් නොකරන්නේ නම් ඔබට මෙය කළ හැකිය:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (x.update(y), x)[1]
>>> z
{'a': 1, 'b': 10, 'c': 11}

අනුපිළිවෙල ආරක්ෂා කරන itertools භාවිතා කර සරල විසඳුමක් (පසුකාලීන නියෝග වලට ප්‍රමුඛතාවයක් ඇත)

import itertools as it
merge = lambda *args: dict(it.chain.from_iterable(it.imap(dict.iteritems, args)))

එහි භාවිතය:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> merge(x, y)
{'a': 1, 'b': 10, 'c': 11}

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 4}

ශබ්ද කෝෂ දෙකක්

def union2(dict1, dict2):
    return dict(list(dict1.items()) + list(dict2.items()))

n ශබ්ද කෝෂ

def union(*dicts):
    return dict(itertools.chain.from_iterable(dct.items() for dct in dicts))

sumනරක ක්‍රියාකාරිත්වයක් ඇත. Https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python/ බලන්න

මෙම නොගැඹුරු ශබ්දකෝෂයට පිළිතුරු හොඳ වුවද, මෙහි අර්ථ දක්වා ඇති ක්‍රම කිසිවක් ගැඹුරු ශබ්ද කෝෂයක් ඒකාබද්ධ නොකරයි.

උදාහරණ අනුගමනය කරයි:

a = { 'one': { 'depth_2': True }, 'two': True }
b = { 'one': { 'extra': False } }
print dict(a.items() + b.items())

යමෙක් මෙවැනි දෙයක ප්‍රති result ලයක් අපේක්ෂා කරයි:

{ 'one': { 'extra': False', 'depth_2': True }, 'two': True }

ඒ වෙනුවට, අපට මෙය ලැබේ:

{'two': True, 'one': {'extra': False}}

'එක්' පිවිසුමේ සත්‍ය වශයෙන්ම ඒකාබද්ධ කිරීමක් නම් එහි ශබ්ද කෝෂය තුළ ඇති අයිතම ලෙස 'ගැඹුර_2' සහ 'අමතර' තිබිය යුතුය.

දාමය භාවිතා කිරීම ද ක්‍රියා නොකරයි:

from itertools import chain
print dict(chain(a.iteritems(), b.iteritems()))

ප්‍රති Results ල:

{'two': True, 'one': {'extra': False}}

Rcwesick ලබා දුන් ගැඹුරු ඒකාබද්ධ කිරීම ද එම ප්‍රති .ලයම නිර්මාණය කරයි.

ඔව්, නියැදි ශබ්ද කෝෂ ඒකාබද්ධ කිරීමට එය ක්‍රියා කරනු ඇත, නමුත් ඒ කිසිවක් ඒකාබද්ධ කිරීමට සාමාන්‍ය යාන්ත්‍රණයක් නොවේ. සත්‍ය ඒකාබද්ධ කිරීමක් කරන ක්‍රමයක් ලිවූ පසු මම මෙය පසුව යාවත්කාලීන කරමි.

(Python2.7 * සඳහා පමණි; Python3 * සඳහා සරල විසඳුම් ඇත.)

සම්මත පුස්තකාල මොඩියුලයක් ආනයනය කිරීමට ඔබ අකමැති නම්, ඔබට එය කළ හැකිය

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

( සෑම විටම සාර්ථකත්වය මත නැවත පැමිණෙන බැවින් අවශ්‍ය ප්‍රමාණය or aටිකක් lambdaඅවශ්‍ය වේ.)dict.updateNone

විකෘති වීමට ඔබට අවශ්‍ය නැතිනම් x,

x.update(y) or x

සරල, කියවිය හැකි, කාර්ය සාධනය. ඔබ දන්නවා update() සෑම විටම ආපසු පැමිණීම None, එය ව්‍යාජ වටිනාකමක්. එබැවින් ඉහත ප්‍රකාශනය xයාවත්කාලීන කිරීමෙන් පසුව සෑම විටම ඇගයීමට ලක් කෙරේ .

සම්මත පුස්තකාලයේ විකෘති කිරීමේ ක්‍රම (වැනි .update()) Noneසම්මුතිය අනුව නැවත පැමිණේ , එබැවින් මෙම රටාව ද ඒවා මත ක්‍රියාත්මක වේ. ඔබ මෙම සම්මුතිය අනුගමනය නොකරන ක්‍රමයක් භාවිතා කරන්නේ නම්, එය ක්‍රියාත්මක orනොවනු ඇත. එහෙත්, ඒ වෙනුවට ඔබට තනි ප්‍රකාශනයක් බවට පත් කිරීම සඳහා ටුපල් ඩිස්ප්ලේ සහ දර්ශකය භාවිතා කළ හැකිය. පළමු අංගය තක්සේරු කරන්නේ කුමක් වුවත් මෙය ක්‍රියාත්මක වේ.

(x.update(y), x)[-1]

ඔබට xතවම විචල්‍යයක් නොමැති නම්, lambdaපැවරුම් ප්‍රකාශයක් භාවිතා නොකර දේශීයව සෑදීමට ඔබට භාවිතා කළ හැකිය . මෙය ක්‍රියාකාරී භාෂාවන්හි පොදු තාක්‍ෂණයකි, නමුත් සමහර විට අවිධිමත් නොවන, ඉඩ ප්‍රකාශනයක්lambda ලෙස භාවිතා කිරීම සමාන වේ.

(lambda x: x.update(y) or x)({'a': 1, 'b': 2})

නව වොල්රස් ක්‍රියාකරුගේ පහත භාවිතයට වඩා එය වෙනස් නොවූවත් (පයිතන් 3.8+ පමණි):

(x := {'a': 1, 'b': 2}).update(y) or x

ඔබට පිටපතක් අවශ්‍ය නම්, PEP 448 විලාසය පහසුම {**x, **y}වේ. නමුත් එය ඔබගේ (පැරණි) පයිතන් අනුවාදයේ නොමැති නම්, ඉඩ දීමේ රටාව මෙහි ද ක්‍රියාත්මක වේ.

(lambda z: z.update(y) or z)(x.copy())

(එය ඇත්ත වශයෙන්ම සමාන වේ (z := x.copy()).update(y) or z, නමුත් ඔබේ පයිතන් අනුවාදය ඒ සඳහා ප්‍රමාණවත් තරම් නව නම්, PEP 448 විලාසිතාව ලබා ගත හැකිය.)

මෙහි සහ වෙනත් තැන්වල අදහස් ඇඳීම මම ශ්‍රිතයක් වටහාගෙන ඇත:

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

භාවිතය (පයිතන් 3 හි පරීක්ෂා කර ඇත):

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

ඒ වෙනුවට ඔබට ලැම්බඩා භාවිතා කළ හැකිය.

මේ දක්වා ලැයිස්තුගත කර ඇති විසඳුම් සමඟ මට ඇති ගැටළුව නම්, ඒකාබද්ධ කරන ලද ශබ්ද කෝෂයේ “b” යතුර සඳහා වටිනාකම 10 ක් වන නමුත් මගේ සිතීමේ ක්‍රමයට එය 12 ක් විය යුතුය. එම ආලෝකයේ දී මම පහත සඳහන් කරුණු ඉදිරිපත් කරමි:

import timeit

n=100000
su = """
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
"""

def timeMerge(f,su,niter):
    print "{:4f} sec for: {:30s}".format(timeit.Timer(f,setup=su).timeit(n),f)

timeMerge("dict(x, **y)",su,n)
timeMerge("x.update(y)",su,n)
timeMerge("dict(x.items() + y.items())",su,n)
timeMerge("for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k] ",su,n)

#confirm for loop adds b entries together
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]
print "confirm b elements are added:",x

ප්රතිපල:

0.049465 sec for: dict(x, **y)
0.033729 sec for: x.update(y)                   
0.150380 sec for: dict(x.items() + y.items())   
0.083120 sec for: for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]

confirm b elements are added: {'a': 1, 'c': 11, 'b': 12}

එය .updateකිසිවක් මෝඩකමක් නොවේ.
ගැටළුව විසඳීම සඳහා මම සරල උපකාරක ශ්‍රිතයක් භාවිතා කරමි:

def merge(dict1,*dicts):
    for dict2 in dicts:
        dict1.update(dict2)
    return dict1

උදාහරණ:

merge(dict1,dict2)
merge(dict1,dict2,dict3)
merge(dict1,dict2,dict3,dict4)
merge({},dict1,dict2)  # this one returns a new copy

from collections import Counter
dict1 = {'a':1, 'b': 2}
dict2 = {'b':10, 'c': 11}
result = dict(Counter(dict1) + Counter(dict2))

මෙය ඔබේ ගැටලුව විසඳිය යුතුය.

මෙය තනි අවබෝධයකින් තේරුම් ගත හැකිය:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> { key: y[key] if key in y else x[key]
      for key in set(x) + set(y)
    }

මගේ මතය අනුව අමතර කාර්යයන් අවශ්‍ය නොවන බැවින් 'තනි ප්‍රකාශනය' කොටස සඳහා හොඳම පිළිතුර වන අතර එය කෙටි ය.

පයිතන් 3.8 නිකුත් කරන විට නව විකල්පයක් ඇත ( 2019 ඔක්තෝබර් 20 දිනට සැලසුම් කර ඇත ), PEP 572: Assignment Expressions වලට ස්තූතියි . නව පැවරුම් ප්‍රකාශන ක්‍රියාකරු :=ඔබට ප්‍රති result ල ලබා දීමට ඉඩ දී copyඑය ඇමතීමට තවමත් භාවිතා කරයි update, ඒකාබද්ධ කේතය ප්‍රකාශ දෙකකට වඩා තනි ප්‍රකාශනයක් ලෙස වෙනස් කරමින් වෙනස් වේ:

newdict = dict1.copy()
newdict.update(dict2)

වෙත:

(newdict := dict1.copy()).update(dict2)

සෑම ආකාරයකින්ම එක හා සමානව හැසිරෙන අතරතුර. ඔබ එහි dictප්‍රති ing ලය ද ආපසු ලබා දිය යුතු නම් (ඔබ නැවත ප්‍රකාශනයක් ඉල්ලා සිටියේය dict; ඉහත සඳහන් දේ නිර්මාණය කර පවරයි newdict, නමුත් එය ආපසු නොදෙනු ඇත, එබැවින් ඔබට ශ්‍රිතයක් සඳහා තර්කයක් ඉදිරිපත් කිරීමට එය භාවිතා කළ නොහැක, ලා myfunc((newdict := dict1.copy()).update(dict2))) , ඉන්පසු or newdictඅවසානයට එක් කරන්න ( updateප්‍රතිලාභ Noneව්‍යාජ බැවින් එය ප්‍රකාශනයේ ප්‍රති as ලයක් newdictලෙස ඇගයීමට ලක් කර නැවත පැමිණේ ):

(newdict := dict1.copy()).update(dict2) or newdict

වැදගත් අවවාදය: පොදුවේ, මම මෙම ප්‍රවේශය අධෛර්යමත් කරමි:

newdict = {**dict1, **dict2}

ඉවත් කිරීමේ ප්‍රවේශය වඩාත් පැහැදිලිය (සාමාන්‍යයෙන් ඉවත් කිරීම ගැන දන්නා ඕනෑම කෙනෙකුට, ඔබ කළ යුත්තේ එයයි ), ප්‍රති result ලය සඳහා කිසිසේත්ම නමක් අවශ්‍ය නොවේ (එබැවින් තාවකාලික ඉදි කිරීමේදී එය වඩාත් සංක්ෂිප්ත වේ. ශ්‍රිතය හෝ list/ tupleවචනානුසාරයෙන් හෝ ඊට සමාන) ඇතුළත් කර ඇති අතර (සීපයිතන් මත) දළ වශයෙන් සමාන වේ:

newdict = {}
newdict.update(dict1)
newdict.update(dict2)

නමුත් කොන්ක්‍රීට් dictඒපීඅයි භාවිතා කරමින් සී ස්තරයේ සිදු කරනු ලැබේ , එබැවින් ගතික ක්‍රමවේදයක් බැලීම / බන්ධනය කිරීම හෝ ක්‍රියාකාරී ඇමතුම් යැවීමේ උඩිස් සම්බන්ධ නොවේ (එහිදී(newdict := dict1.copy()).update(dict2) ගතික බැලීම සමග, විවික්ත පියවර අනුව කටයුතු කිරීමට, හැසිරීම මුල් දෙකක් නෞකාවකි කිරීමට නො වැලැක්විය හැකි සමාන වේ / බන්ධන / ක්‍රම කැඳවීම.

dictS තුනක් ඒකාබද්ධ කිරීම පැහැදිලිව පෙනෙන පරිදි එය වඩාත් පුළුල් කළ හැකිය :

 newdict = {**dict1, **dict2, **dict3}

පැවරුම් ප්‍රකාශන භාවිතා කිරීම එබඳු පරිමාණයකින් සිදු නොවේ. ඔබට ළඟා විය හැකි ආසන්නම දේ වනුයේ:

 (newdict := dict1.copy()).update(dict2), newdict.update(dict3)

හෝ තාවකාලික වර්‍ගයකින් තොරව None, නමුත් එක් එක් ප්‍රති Noneresult ලවල සත්‍යතාව පරීක්ෂා කිරීම සමඟ :

 (newdict := dict1.copy()).update(dict2) or newdict.update(dict3)

මේ දෙකෙන් එකක් පැහැදිලිවම වඩා අවලස්සන වන අතර, තව දුරටත් අකාර්යක්ෂමතාවයන් ඇතුළත් වේ (එක්කෝ කොමාව වෙන් කිරීම සඳහා තාවකාලිකව නාස්ති tupleකිරීම Noneහෝ වෙන්වීම සඳහා එක් එක් updateඅයගේ Noneප්‍රතිලාභ පිළිබඳ අර්ථ විරහිත සත්‍යතාව පරීක්ෂා කිරීම or).

පැවරුම් ප්‍රකාශන ප්‍රවේශයේ ඇති එකම සැබෑ වාසිය සිදුවන්නේ නම්:

1. ඔබ අවශ්යතා යන දෙකම පිළිබඳව කටයුතු කරන Generic බලපත්රය යටතේ අවසර ලබා ඇත කේතය setනම් සහ dictඒක (ඔවුන් සහයෝගය දෙකම copyහා updateකේතය දළ වශයෙන් ක්රියා කරයි එසේ ඔබ කිරීමට බලාපොරොත්තු වන්නේ කැමතියි ලෙස,)
2. ඔබ බලාපොරොත්තු වන්නේ අත්තනෝමතික ලෙස සමාන වස්තූන් ලැබීමට පමණක් dictනොව, වම් අතෙහි වර්ගය සහ අර්ථ නිරූපණය ආරක්ෂා කළ යුතුය (තැනිතලාවකින් අවසන් වීමට වඩා dict). වැඩ myspecialdict({**speciala, **specialb})කළ හැකි අතර, එයට අමතර තාවකාලික කාලයක් ඇතුළත් වන අතර dict, myspecialdictවිශේෂාංග තිබේ නම් සරල ලෙස dictසංරක්ෂණය කළ නොහැක (උදා: නිත්‍ය dictයතුරක් යතුරක පළමු පෙනුම මත පදනම්ව පිළිවෙල ආරක්ෂා කරයි, සහ යතුරක අවසාන පෙනුම මත පදනම් වූ අගය; ඔබට අවශ්‍ය විය හැකිය. අන්තිම මත පදනම්ව පිළිවෙල ආරක්ෂා කරන එකක්යතුරක පෙනුම නිසා අගයක් යාවත්කාලීන කිරීම ද අවසානය දක්වා ගමන් කරයි), එවිට අර්ථ නිරූපණය වැරදිය. පැවරුම් ප්‍රකාශන අනුවාදය නම් කරන ලද ක්‍රම භාවිතා කරන බැවින් (ඒවා නිසි ලෙස හැසිරීමට අධික ලෙස පටවා ඇති), එය කිසි විටෙකත් කිසිසේත් නිර්මාණය dictනොකරයි ( dict1දැනටමත් නොතිබුණි නම් dict), මුල් වර්ගය (සහ මුල් වර්ගයේ අර්ථ නිරූපණයන්) ආරක්ෂා කරමින්, තාවකාලික අවස්ථාවන් මඟහරවා ගනී.

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x, z = dict(x), x.update(y) or x
>>> x
{'a': 1, 'b': 2}
>>> y
{'c': 11, 'b': 10}
>>> z
{'a': 1, 'c': 11, 'b': 10}