පයිතන් ශබ්දකෝෂයක් නිර්මාණය කිරීමෙන් පසු එයට යතුරක් එක් කළ හැකිද?

එයට .add()ක්‍රමයක් ඇති බවක් නොපෙනේ .

d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

එම යතුරට අගයක් ලබා දීමෙන් ඔබ ශබ්දකෝෂයක නව යතුරු \ අගය යුගලයක් සාදයි. යතුර නොපවතී නම්, එය එකතු කර එම අගයට යොමු කරයි. එය පවතින්නේ නම්, එය පෙන්වා දෙන වත්මන් අගය නැවත ලියනු ලැබේ. - ආර්. නවෙගා

එකවර යතුරු කිහිපයක් එක් කිරීමට, භාවිතා කරන්න dict.update():

>>> x = {1:2}
>>> print(x)
{1: 2}

>>> d = {3:4, 5:6, 7:8}
>>> x.update(d)
>>> print(x)
{1: 2, 3: 4, 5: 6, 7: 8}

තනි යතුරක් එක් කිරීම සඳහා, පිළිගත් පිළිතුරට අඩු පරිගණක පොදු කාර්යයක් ඇත.

පයිතන් ශබ්දකෝෂ පිළිබඳ තොරතුරු ඒකාබද්ධ කිරීමට මට හැඟේ:

හිස් ශබ්ද කෝෂයක් නිර්මාණය කිරීම

data = {}
# OR
data = dict()

ආරම්භක අගයන් සහිත ශබ්ද කෝෂයක් නිර්මාණය කිරීම

data = {'a': 1, 'b': 2, 'c': 3}
# OR
data = dict(a=1, b=2, c=3)
# OR
data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))}

තනි අගයක් ඇතුළත් කිරීම / යාවත්කාලීන කිරීම

data['a'] = 1  # Updates if 'a' exists, else adds 'a'
# OR
data.update({'a': 1})
# OR
data.update(dict(a=1))
# OR
data.update(a=1)

බහු අගයන් ඇතුළත් කිරීම / යාවත්කාලීන කිරීම

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd'

මුල් පිටපත් වෙනස් නොකර ඒකාබද්ධ ශබ්ද කෝෂයක් නිර්මාණය කිරීම

data3 = {}
data3.update(data)  # Modifies data3, not data
data3.update(data2)  # Modifies data3, not data2

ශබ්ද කෝෂයේ අයිතම මකා දැමීම

del data[key]  # Removes specific element in a dictionary
data.pop(key)  # Removes the key & returns the value
data.clear()  # Clears entire dictionary

යතුරක් දැනටමත් ශබ්ද කෝෂයේ තිබේදැයි පරීක්ෂා කරන්න

key in data

ශබ්ද කෝෂයක යුගල හරහා අනුකරණය කරන්න

for key in data: # Iterates just through the keys, ignoring the values
for key, value in d.items(): # Iterates through the pairs
for key in d.keys(): # Iterates just through key, ignoring the values
for value in d.values(): # Iterates just through value, ignoring the keys

ලැයිස්තු දෙකකින් ශබ්ද කෝෂයක් සාදන්න

data = dict(zip(list_with_keys, list_with_values))

පයිතන්ට අලුත් 3.5

මුල් පිටපත් වෙනස් නොකර ඒකාබද්ධ ශබ්ද කෝෂයක් නිර්මාණය කිරීම:

මෙය ශබ්ද කෝෂ ඉවත් කිරීම නමින් නව අංගයක් භාවිතා කරයි .

data = {**data1, **data2, **data3}

පයිතන්ට අලුත් 3.9

පවතින ශබ්ද කෝෂයක් සඳහා අගයන් යාවත්කාලීන කරන්න හෝ එකතු කරන්න

මෙම යාවත්කාලීන ක්රියාකරු |= දැන් ශබ්ද කෝෂ සඳහා ක්රියා:

data |= {'c':3,'d':4}

මුල් පිටපත් වෙනස් නොකර ඒකාබද්ධ ශබ්ද කෝෂයක් නිර්මාණය කිරීම

මෙම ඒකාබද්ධ ක්රියාකරු | දැන් ශබ්ද කෝෂ සඳහා ක්රියා:

data = data1 | {'c':3,'d':4}

තවත් එකතු කිරීමට නිදහස් වන්න!

"පයිතන් ශබ්දකෝෂයක් නිර්මාණය කිරීමෙන් පසු එයට යතුරක් එක් කළ හැකිද? එයට .add () ක්‍රමයක් ඇති බවක් නොපෙනේ."

ඔව් එය කළ හැකි අතර, මෙය ක්‍රියාත්මක කරන ක්‍රමයක් එයට ඇත, නමුත් ඔබට එය කෙලින්ම භාවිතා කිරීමට අවශ්‍ය නැත.

ඒ කෙසේ ද, කෙසේ නැහැ පෙන්නුම් එය භාවිතා කිරීමට,, අපි dict ප්රායෝගික සමග හිස් dict නිර්මාණය කරමු {}:

my_dict = {}

හොඳම පුහුණුව 1: දායක අංකනය

තනි නව යතුරක් සහ අගයක් සමඟ මෙම නියමය යාවත්කාලීන කිරීම සඳහා, ඔබට අයිතම පැවරීම සඳහා සපයන දායක අංකනය භාවිතා කළ හැකිය (මෙහි සිතියම් බලන්න) :

my_dict['new key'] = 'new value'

my_dict මේ දැන්:

{'new key': 'new value'}

හොඳම පුහුණුව 2: updateක්‍රමය - ක්‍රම 2 යි

ඒ වගේම අපි භාවිතා කාර්යක්ෂමව මෙන්ම බහු වටිනාකම් සමග dict යාවත්කාලීන කිරීම් ඔබට සිදු කල හැක මෙම updateක්රමය . අපි අනවශ්‍ය ලෙස dictමෙහි අතිරේකයක් නිර්මාණය කරමින් සිටිය හැකිය , එබැවින් අපගේ dictදැනටමත් නිර්මාණය කර ඇති බවත් වෙනත් කටයුත්තක් සඳහා භාවිතා කර ඇති බවත් අපි විශ්වාස කරමු :

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})

my_dict මේ දැන්:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}

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

my_dict.update(foo='bar', foo2='baz')

හා my_dictදැන්:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value', 
 'foo': 'bar', 'foo2': 'baz'}

දැන් අපි a යාවත්කාලීන කිරීමේ පයිතොනික් ක්‍රම තුනක් ආවරණය කර ඇත්තෙමු dict.

මැජික් ක්රමය, __setitem__සහ එය වළක්වා ගත යුත්තේ ඇයි

dictඔබ භාවිතා නොකළ යුතු යාවත්කාලීන කිරීමේ තවත් ක්‍රමයක් තිබේ , එය __setitem__ක්‍රමය භාවිතා කරයි . __setitem__යතුරු අගය යුගලයක් a ට එක් කිරීම සඳහා යමෙක් ක්‍රමවේදය භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් මෙහි දැක්වේ dict, සහ එය භාවිතා කිරීමේ දුර්වල ක්‍රියාකාරිත්වය පෙන්නුම් කරයි:

>>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> d
{'foo': 'bar'}


>>> def f():
...     d = {}
...     for i in xrange(100):
...         d['foo'] = i
... 
>>> def g():
...     d = {}
...     for i in xrange(100):
...         d.__setitem__('foo', i)
... 
>>> import timeit
>>> number = 100
>>> min(timeit.repeat(f, number=number))
0.0020880699157714844
>>> min(timeit.repeat(g, number=number))
0.005071878433227539

එබැවින් දායකත්ව අංකනය භාවිතා කිරීම ඇත්ත වශයෙන්ම භාවිතා කිරීමට වඩා වේගවත් බව අපට පෙනේ __setitem__. පයිතොනික් දේ කිරීම, එනම් භාෂාව භාවිතා කිරීමට අදහස් කළ ආකාරයට භාවිතා කිරීම සාමාන්‍යයෙන් වඩා කියවිය හැකි සහ පරිගණකමය වශයෙන් කාර්යක්ෂම වේ.

dictionary[key] = value

ඔබට ශබ්ද කෝෂයක් තුළ ශබ්ද කෝෂයක් එක් කිරීමට අවශ්‍ය නම් ඔබට එය මේ ආකාරයෙන් කළ හැකිය.

උදාහරණය: ඔබේ ශබ්ද කෝෂයට සහ උප ශබ්දකෝෂයට නව ප්‍රවේශයක් එක් කරන්න

dictionary = {}
dictionary["new key"] = "some new entry" # add new dictionary entry
dictionary["dictionary_within_a_dictionary"] = {} # this is required by python
dictionary["dictionary_within_a_dictionary"]["sub_dict"] = {"other" : "dictionary"}
print (dictionary)

ප්‍රතිදානය:

{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}

සටහන: පයිතන්ට අවශ්‍ය වන්නේ ඔබ මුලින්ම උප එකතු කිරීමයි

dictionary["dictionary_within_a_dictionary"] = {}

ඇතුළත් කිරීම් එකතු කිරීමට පෙර.

ඕතඩොක්ස් සින්ටැක්ස් එක d[key] = value, නමුත් ඔබේ යතුරුපුවරුවේ වර්ග වරහන් යතුරු නොමැති නම් ඔබට කළ හැක්කේ:

d.__setitem__(key, value)

ඇත්ත වශයෙන්ම, නිර්වචනය කිරීම __getitem__සහ __setitem__ක්‍රම යනු ඔබේම පන්තියට වර්ග වරහන් සින්ටැක්ස් සඳහා සහය දැක්විය හැකි ආකාරයයි. Https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php බලන්න

ඔබට එකක් නිර්මාණය කළ හැකිය:

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        self[key] = value

## example

myd = myDict()
myd.add('apples',6)
myd.add('bananas',3)
print(myd)

ලබා දෙයි:

>>> 
{'apples': 6, 'bananas': 3}

මෙම ජනප්රිය ප්රශ්නය ආමන්ත්රණය ක්රියාකාරී ශබ්ද කෝෂ ඒකබද්ධ කිරීමේ ක්රම aසහ b.

මෙන්න වඩාත් සරල ක්‍රම කිහිපයක් (පයිතන් 3 හි පරීක්ෂා කර ඇත) ...

c = dict( a, **b ) ## see also https://stackoverflow.com/q/2255878
c = dict( list(a.items()) + list(b.items()) )
c = dict( i for d in [a,b] for i in d.items() )

සටහන: ඉහත පළමු ක්‍රමය ක්‍රියාත්මක වන්නේ යතුරු bනූල් නම් පමණි .

එකම මුලද්රව්යයේ එකතු කිරීම හෝ වෙනස් කිරීම සඳහා , එම bශබ්ද කෝෂය පමණක් බව එක් අංගයක් අඩංගු වනු ඇත ...

c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'

මෙය සමාන ...

def functional_dict_add( dictionary, key, value ):
   temp = dictionary.copy()
   temp[key] = value
   return temp

c = functional_dict_add( a, 'd', 'dog' )

ඔබට වෙනස් කළ නොහැකි ලෝකයේ ජීවත් වීමට අවශ්‍ය යැයි මවාපාමින් මුල් පිටපත වෙනස් කිරීමට අවශ්‍ය නැති නමුත් මුල් පිටපතට dictනව යතුරක් එක් කිරීමේ ප්‍රති result ලයක් ලෙස නව එකක් නිර්මාණය කිරීමට අවශ්‍යය .

පයිතන් 3.5+ හි ඔබට කළ හැක්කේ:

params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}

පයිතන් 2 සමාන වන්නේ:

params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})

මේ දෙකෙන් පසු:

params තවමත් සමාන වේ {'a': 1, 'b': 2}

සහ

new_params සමාන වේ {'a': 1, 'b': 2, 'c': 3}

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

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3

හෝ

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})

යොමුව: https://stackoverflow.com/a/2255892/514866

බොහෝ පිළිතුරු සහ තවමත් සෑම කෙනෙකුම අමුතු ලෙස නම් කර ඇති, අමුතු ලෙස හැසිරුණු, නමුත් තවමත් හුරුබුහුටි බව අමතක කර ඇත dict.setdefault()

මෙය

value = my_dict.setdefault(key, default)

මූලික වශයෙන් මෙය සිදු කරයි:

try:
    value = my_dict[key]
except KeyError: # key not found
    value = my_dict[key] = default

උදා

>>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # returns new value at mydict['d']
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # a new key/value pair was indeed added
# but see what happens when trying it on an existing key...
>>> mydict.setdefault('a', 111)
1 # old value was returned
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # existing key was ignored

ඔබ ශබ්ද කෝෂ දෙකකට සම්බන්ධ නොවන්නේ නම්, නමුත් නව යතුරු අගය යුගලයක් ශබ්දකෝෂයකට එක් කරන්නේ නම්, දායකත්ව අංකනය භාවිතා කිරීම හොඳම ක්‍රමය ලෙස පෙනේ.

import timeit

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary.update({"aaa": 123123, "asd": 233})')
>> 0.49582505226135254

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary["aaa"] = 123123; dictionary["asd"] = 233;')
>> 0.20782899856567383

කෙසේ වෙතත්, ඔබ එකතු කිරීමට කැමති නම්, උදාහරණයක් ලෙස, නව යතුරු-වටිනා යුගල දහස් ගණනක්, ඔබ update()ක්‍රමය භාවිතා කිරීම ගැන සලකා බැලිය යුතුය .

මම එය ද Python හි පෙන්වා ප්රයෝජනවත් විය හැකි යැයි සිතන collectionsව්යුහය සරල බව බොහෝ වැදගත් ශබ්ද කෝෂය උප වර්ගිකරණයන් හා දවටන සමන්විත මොඩියුලය ශබ්දකෝෂ දත්ත වර්ග එකතු කිරීම සහ වෙනස් කිරීම් , විශේෂයෙන් defaultdict:

අස්ථානගත අගයන් සැපයීම සඳහා කර්මාන්තශාලා ශ්‍රිතයක් කැඳවන ඩික් උප පංතිය

ඔබ සැමවිටම එකම දත්ත වර්ග හෝ ව්‍යුහයන්ගෙන් සමන්විත ශබ්දකෝෂ සමඟ වැඩ කරන්නේ නම් මෙය විශේෂයෙන් ප්‍රයෝජනවත් වේ, උදාහරණයක් ලෙස ලැයිස්තු ශබ්ද කෝෂයකි.

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

යතුර තවමත් නොපවතී නම්, defaultdictලබා දී ඇති අගය (අපගේ නඩුවේදී 10) ශබ්ද කෝෂයේ ආරම්භක අගය ලෙස (බොහෝ විට ලූප තුළ භාවිතා වේ) පවරයි . එබැවින් මෙම මෙහෙයුම කාරණා දෙකක් කරයි : එය ශබ්දකෝෂයකට නව යතුරක් එක් කරයි (ප්‍රශ්නය අනුව), සහ යතුර තවමත් නොපවතී නම් අගය නියම කරයි. සම්මත ශබ්ද කෝෂය සමඟ, +=මෙහෙයුම තවමත් නොපවතින අගයකට ප්‍රවේශ වීමට උත්සාහ කරන බැවින් මෙය දෝෂයක් මතු වනු ඇත :

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

භාවිතයෙන් තොරව, defaultdictනව අංගයක් එකතු කිරීම සඳහා වන කේත ප්‍රමාණය වඩා විශාල වනු ඇති අතර සමහර විට එය සමාන ය:

# This type of code would often be inside a loop
if 'key' not in example:
    example['key'] = 0  # add key and initial value to dict; could also be a list
example['key'] += 1  # this is implementing a counter

defaultdictවැනි සංකීර්ණ දත්ත වර්ග සමග ද භාවිතා කළ හැක listසහ set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

මූලද්රව්යයක් එකතු කිරීම ලැයිස්තුව ස්වයංක්රීයව ආරම්භ කරයි.

මෙන්න මම මෙහි නොදුටු තවත් ක්‍රමයක්:

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

ශබ්ද කෝෂයක් ප්‍රතිනිර්මාණය කිරීම සඳහා ඔබට ශබ්ද කෝෂයේ ඉදිකිරීම්කරු සහ ව්‍යංග ප්‍රසාරණය භාවිතා කළ හැකිය. එපමණක් නොව, ශබ්ද කෝෂ ඉදිකිරීමේදී ස්ථානීය අනුපිළිවෙල පාලනය කිරීම සඳහා මෙම ක්‍රමය භාවිතා කළ හැකිය ( පශ්චාත් පයිතන් 3.6 ). ඇත්ත වශයෙන්ම, ඇතුළත් කිරීමේ අනුපිළිවෙල පයිතන් 3.7 සහ ඊට ඉහළින් සහතික කෙරේ!

>>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v for k, v in list(foo.items())[:2]}
>>> new_dict
{'a': 1, 'b': 2}
>>> new_dict.update(newvalue=99)
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99}
>>> new_dict.update({k: v for k, v in list(foo.items())[2:]})
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99, 'c': 3, 'd': 4}
>>> 

ඉහත දැක්වෙන්නේ ශබ්ද කෝෂ අවබෝධය භාවිතා කිරීමයි.

මුලින්ම යතුර දැනටමත් තිබේදැයි පරීක්ෂා කිරීම

a={1:2,3:4}
a.get(1)
2
a.get(5)
None

එවිට ඔබට නව යතුර සහ අගය එකතු කළ හැකිය

ශබ්ද කෝෂය, අගය පන්තිය එක් කරන්න.

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        #self[key] = value # add new key and value overwriting any exiting same key
        if self.get(key)!=None:
            print('key', key, 'already used') # report if key already used
        self.setdefault(key, value) # if key exit do nothing


## example

myd = myDict()
name = "fred"

myd.add('apples',6)
print('\n', myd)
myd.add('bananas',3)
print('\n', myd)
myd.add('jack', 7)
print('\n', myd)
myd.add(name, myd)
print('\n', myd)
myd.add('apples', 23)
print('\n', myd)
myd.add(name, 2)
print(myd)