ශබ්දකෝෂයකින් අංගයක් මකන්න

පයිතන්හි ශබ්දකෝෂයකින් අයිතමයක් මකා දැමීමට ක්‍රමයක් තිබේද?

ඊට අමතරව, පිටපතක් ආපසු ලබා දීම සඳහා ශබ්ද කෝෂයකින් අයිතමයක් මකා දැමිය හැක්කේ කෙසේද (එනම්, මුල් පිටපත වෙනස් නොකිරීම)?

මෙම delප්රකාශය මූලද්රව්යයක් ඉවත්:

del d[key]

කෙසේ වෙතත්, මෙය පවතින ශබ්ද කෝෂය විකෘති කරයි, එම නිසා එකම අවස්ථාවට යොමු දැක්වීමක් ඇති වෙනත් ඕනෑම කෙනෙකුට ශබ්ද කෝෂයේ අන්තර්ගතය වෙනස් වේ. නව ශබ්ද කෝෂයක් ආපසු ලබා දීමට, ශබ්ද කෝෂයේ පිටපතක් සාදන්න:

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

මෙම dict()ඉදිකිරීමටත් සවිකරලා නොගැඹුරු පිටපතක් . ගැඹුරු පිටපතක් සෑදීමට, copyමොඩියුලය බලන්න .

සෑම නියෝගයක් del/ පැවරුමක් / යනාදිය සඳහා පිටපතක් සෑදීම සැලකිල්ලට ගන්න . එයින් අදහස් වන්නේ ඔබ නියත වේලාවේ සිට රේඛීය වේලාවට යන බවත් රේඛීය අවකාශය භාවිතා කරන බවත්ය. කුඩා නියෝග සඳහා, මෙය ගැටළුවක් නොවේ. නමුත් ඔබ විශාල නියෝගවල පිටපත් ගොඩක් සෑදීමට අදහස් කරන්නේ නම්, ඔබට බොහෝ විට HAMT වැනි වෙනස් දත්ත ව්‍යුහයක් අවශ්‍ය වනු ඇත ( මෙම පිළිතුරෙහි විස්තර කර ඇති පරිදි ).

pop ශබ්ද කෝෂය විකෘති කරයි.

 >>> lol = {"hello": "gdbye"}
 >>> lol.pop("hello")
     'gdbye'
 >>> lol
     {}

ඔබට මුල් පිටපත තබා ගැනීමට අවශ්‍ය නම් ඔබට එය පිටපත් කළ හැකිය.

මම හිතන්නේ ඔබේ විසඳුම එය කිරීමට හොඳම ක්‍රමයයි. නමුත් ඔබට වෙනත් විසඳුමක් අවශ්‍ය නම්, ඔබේ නිශ්චිත යතුර ඇතුළත් නොකර පැරණි ශබ්ද කෝෂයේ යතුරු භාවිතා කරමින් ඔබට නව ශබ්ද කෝෂයක් නිර්මාණය කළ හැකිය:

>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}

මෙම ඩෙල් ප්රකාශය ඔබ සොයන දේ වේ. ඔබට 'බාර්' නමින් යතුරක් සහිත ෆූ නම් ශබ්ද කෝෂයක් තිබේ නම්, ඔබට මේ ආකාරයට foo වෙතින් 'බාර්' මකා දැමිය හැකිය:

del foo['bar']

මෙය ක්‍රියාත්මක වන ශබ්ද කෝෂය ස්ථිරවම වෙනස් කරන බව සලකන්න. ඔබට මුල් ශබ්ද කෝෂය තබා ගැනීමට අවශ්‍ය නම්, ඔබට පෙර පිටපතක් සෑදිය යුතුය:

>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}

මෙම dictඇමතුම් නොගැඹුරු පිටපතක් කරයි. ඔබට ගැඹුරු පිටපතක් අවශ්‍ය නම් භාවිතා කරන්න copy.deepcopy.

ඔබේ පහසුව සඳහා ඔබට පිටපත් කර ඇලවිය හැකි ක්‍රමයක් මෙන්න:

def minus_key(key, dictionary):
    shallow_copy = dict(dictionary)
    del shallow_copy[key]
    return shallow_copy

හොඳ පිළිතුරු ගොඩක් තියෙනවා, නමුත් මට එක දෙයක් අවධාරණය කිරීමට අවශ්‍යයි.

ශබ්ද කෝෂයකින් අයිතම ඉවත් කිරීමට ඔබට dict.pop()ක්‍රමවේදය සහ වඩාත් සාමාන්‍ය delප්‍රකාශය යන දෙකම භාවිතා කළ හැකිය . ඔවුන් දෙදෙනාම මුල් ශබ්ද කෝෂය විකෘති කරයි, එබැවින් ඔබ පිටපතක් සෑදිය යුතුය (පහත විස්තර බලන්න).

ඔබ ඔවුන්ට KeyErrorසපයන යතුර ශබ්ද කෝෂයේ නොමැති නම් ඔවුන් දෙදෙනාම මතු කරයි :

key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove]  # Raises `KeyError: 'c'`

සහ

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove)  # Raises `KeyError: 'c'`

ඔබ මේ ගැන සැලකිලිමත් විය යුතුයි:

ව්යතිරේකය අල්ලා ගැනීමෙන්:

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    del d[key_to_remove]
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

සහ

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    d.pop(key_to_remove)
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

චෙක්පතක් කිරීමෙන්:

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    del d[key_to_remove]

සහ

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    d.pop(key_to_remove)

නමුත් pop()ඊටත් වඩා සංක්ෂිප්ත ක්‍රමයක් ඇත - පෙරනිමි ප්‍රතිලාභ අගය සපයන්න:

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None)  # No `KeyError` here

pop()ඉවත් කරන යතුරක වටිනාකම ලබා ගැනීමට ඔබ භාවිතා නොකරන්නේ නම් ඔබට අවශ්‍ය කිසිවක් අවශ්‍ය නොවේ None. තමන්ගේම සංකූලතා සහිත කාර්යයක් වීම නිසා චෙක්පත delසමඟ භාවිතා inකිරීම තරමක් වේගවත් විය හැකිය pop(). සාමාන්‍යයෙන් එය එසේ නොවේ, එබැවින් pop()පෙරනිමි අගය සමඟ ප්‍රමාණවත් වේ.

ප්‍රධාන ප්‍රශ්නය සඳහා, ඔබේ ශබ්ද කෝෂයේ පිටපතක් සෑදිය යුතුය, මුල් ශබ්ද කෝෂය සුරැකීමට සහ යතුර ඉවත් නොකර නව එකක් තිබිය යුතුය.

මෙහි තවත් සමහර අය යෝජනා කරන්නේ සම්පූර්ණ (ගැඹුරු) පිටපතක් සමඟ copy.deepcopy(), එය අතිරික්තයක්, “සාමාන්‍ය” (නොගැඹුරු) පිටපතක්, භාවිතා කිරීම copy.copy()හෝ dict.copy()ප්‍රමාණවත් විය හැකිය. යතුරක් සඳහා අගයක් ලෙස ශබ්ද කෝෂය වස්තුව වෙත යොමු කිරීමක් තබා ගනී. එබැවින් ඔබ ශබ්දකෝෂයකින් යතුරක් ඉවත් කළ විට මෙම යොමු කිරීම ඉවත් කරනු ලැබේ, යොමු කරන ලද වස්තුව නොවේ. මතකයේ වෙනත් සඳහනක් නොමැති නම්, කසළ එකතු කරන්නා විසින් එම වස්තුව පසුව ස්වයංක්‍රීයව ඉවත් කරනු ඇත. ගැඹුරු පිටපතක් සෑදීම සඳහා නොගැඹුරු පිටපතට සාපේක්ෂව වැඩි ගණනය කිරීම් අවශ්‍ය වේ, එබැවින් එය පිටපත සෑදීම, මතකය නාස්ති කිරීම සහ ග්‍රාම නිලධාරීට වැඩි වැඩ කොටසක් ලබා දීමෙන් කේත ක්‍රියාකාරිත්වය අඩු කරයි, සමහර විට නොගැඹුරු පිටපතක් ප්‍රමාණවත් වේ.

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

නොගැඹුරු පිටපතක් සමඟ:

def get_dict_wo_key(dictionary, key):
    """Returns a **shallow** copy of the dictionary without a key."""
    _dict = dictionary.copy()
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

ගැඹුරු පිටපතක් සමඟ:

from copy import deepcopy


def get_dict_wo_key(dictionary, key):
    """Returns a **deep** copy of the dictionary without a key."""
    _dict = deepcopy(dictionary)
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

… පිටපතක් ආපසු ලබා දීම සඳහා ශබ්ද කෝෂයකින් අයිතමයක් මකා දැමිය හැක්කේ කෙසේද (එනම් මුල් පිටපත වෙනස් නොකිරීම)?

A dictයනු මේ සඳහා භාවිතා කළ යුතු වැරදි දත්ත ව්‍යුහයකි.

නියත වශයෙන්ම, පිටපත පිටපත් කිරීම සහ පිටපතෙන් පිටවීම ක්‍රියා කරයි, එසේම අවබෝධයක් සහිතව නව ආ ict ාවක් ගොඩ නැගීමද සිදු වේ, නමුත් ඒ සියල්ල පිටපත් කිරීමට කාලය ගතවේ - ඔබ නියත-කාලීන මෙහෙයුමක් රේඛීය-කාලීන එකක් සමඟ ප්‍රතිස්ථාපනය කර ඇත. එම පිටපත් සියල්ලම එකවර ජීවමාන වේ.

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

ඇත්ත වශයෙන්ම සමහර අවාසි ඇත. කාර්ය සාධනය නියතයට වඩා ල ar ු ගණකය වේ (විශාල පදනමක් තිබුණද සාමාන්‍යයෙන් 32-128). තවද, ඔබට විකෘති නොවන API එක සමාන කළ හැකි අතර dict, "විකෘති" API පැහැදිලිවම වෙනස් වේ. තවද, බොහෝ විට, පයිතන් සමඟ HAMT බැටරි ඇතුළත් නොවේ. ²

මෙම pyrsistentපුස්තකාලය Python සඳහා HAMT මත පදනම් dict-වෙනුවට ආදේශකයක් (සහ අනෙකුත් විවිධ) ක ඉතා ශක්තිමත් ක්රියාත්මක වේ. පවත්නා විකෘති කේතය හැකි තරම් සුමට ලෙස අඛණ්ඩ කේතයට ගෙනයාම සඳහා එය සතුව නව පරිණාමය API ඇත. නමුත් විකෘති කරනවාට වඩා පිටපත් ආපසු ලබා දීම පිළිබඳව ඔබට පැහැදිලි වීමට අවශ්‍ය නම්, ඔබ එය මේ ආකාරයට භාවිතා කරයි:

>>> from pyrsistent import m
>>> d1 = m(a=1, b=2)
>>> d2 = d1.set('c', 3)
>>> d3 = d1.remove('a')
>>> d1
pmap({'a': 1, 'b': 2})
>>> d2
pmap({'c': 3, 'a': 1, 'b': 2})
>>> d3
pmap({'b': 2})

ඒ d3 = d1.remove('a')ප්රශ්නය ඉල්ලන් එයයි.

ඔබට විකෘති දත්ත ව්‍යුහයන් තිබේ නම් dictසහ ඒවාට ඇතුළත් listකර ඇත්නම් pmap, ඔබට තවමත් අන්වර්ථකරණ ගැටළු ඇත - ඔබට එය නිවැරදි කළ හැක්කේ වෙනස් කළ නොහැකි ලෙස පහළට ගොස්, pmaps සහ pvectors කාවැද්දීමෙනි .

_{1. HAMTs ස්කලා, ක්ලෝජුර්, හැස්කල් වැනි භාෂාවලින් ද ජනප්‍රිය වී ඇත්තේ ඒවා අගුළු රහිත ක්‍රමලේඛන සහ මෘදුකාංග ගනුදෙනු මතකය සමඟ ඉතා හොඳින් ක්‍රීඩා කරන බැවිනි, නමුත් ඒ දෙකම පයිතන්හි එතරම් අදාළ නොවේ.}

_{2. ඇත්ත වසයෙන් ම, ය ක්රියාත්මක කිරීම සඳහා භාවිතා වන stdlib දී HAMT contextvars. කලින් ඉවත් කරන ලද PEP එයට හේතුව පැහැදිලි කරයි. නමුත් මෙය පුස්තකාලයේ සැඟවුණු ක්‍රියාත්මක කිරීමේ විස්තරයක් මිස පොදු එකතු කිරීමේ වර්ගයක් නොවේ.}

d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d

ප්‍රති ult ලය: d = {1: 2, '2': 3}

ඩෙල් ඩී ['යතුර'] අමතන්න.

කෙසේ වෙතත්, නිෂ්පාදනයේදී, 'යතුර' d හි තිබේදැයි පරීක්ෂා කිරීම සැමවිටම හොඳ පුරුද්දකි.

if 'key' in d:
    del d['key']

නැත, වෙනත් මාර්ගයක් නැත

def dictMinus(dct, val):
   copy = dct.copy()
   del copy[val]
   return copy

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

# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)

>>> def delete_key(dict, key):
...     del dict[key]
...     return dict
... 
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>

මෙය කිසිදු දෝෂ හැසිරවීමක් නොකරයි, එය උපකල්පනය කරන්නේ යතුර ආ ict ාවෙහි ඇති බවය, ඔබට එය පළමුව පරීක්ෂා කිරීමට අවශ්‍ය විය හැකි අතර raiseඑසේ නොවේ නම්

මෙන්න ඉහළ මට්ටමේ සැලසුම් ප්‍රවේශයක්:

def eraseElement(d,k):
    if isinstance(d, dict):
        if k in d:
            d.pop(k)
            print(d)
        else:
            print("Cannot find matching key")
    else:
        print("Not able to delete")


exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')

මම ශබ්දකෝෂය සහ මට අවශ්‍ය යතුර මගේ ශ්‍රිතයට යමි, එය ශබ්ද කෝෂයක් නම් සහ යතුර හරි නම් වලංගු වේ, සහ දෙකම තිබේ නම්, ශබ්දකෝෂයෙන් වටිනාකම ඉවත් කර වම් ඕවර මුද්‍රණය කරයි.

ප්‍රතිදානය: {'B': 55, 'A': 34}

උපකාරවත් වන බලාපොරොත්තුව!

පහත දැක්වෙන කේත ස්නිපටය ඔබට නිසැකවම උපකාරී වනු ඇත, මම එක් එක් පේළියේ අදහස් එකතු කර ඇති අතර එය කේතය තේරුම් ගැනීමට ඔබට උපකාරී වනු ඇත.

def execute():
   dic = {'a':1,'b':2}
   dic2 = remove_key_from_dict(dic, 'b')  
   print(dict2)           # {'a': 1}
   print(dict)            # {'a':1,'b':2}

def remove_key_from_dict(dictionary_to_use, key_to_delete):
   copy_of_dict = dict(dictionary_to_use)     # creating clone/copy of the dictionary
   if key_to_delete in copy_of_dict :         # checking given key is present in the dictionary
       del copy_of_dict [key_to_delete]       # deleting the key from the dictionary 
   return copy_of_dict                        # returning the final dictionary

හෝ ඔබට dict.pop () භාවිතා කළ හැකිය

d = {"a": 1, "b": 2}

res = d.pop("c")  # No `KeyError` here
print (res)       # this line will not execute

හෝ වඩා හොඳ ප්‍රවේශය වේ

res = d.pop("c", "key not found")
print (res)   # key not found
print (d)     # {"a": 1, "b": 2}

res = d.pop("b", "key not found")
print (res)   # 2
print (d)     # {"a": 1}

ලැයිස්තු අවබෝධය භාවිතා කරමින් තවත් විචලනයක් මෙන්න:

original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.iteritems() if v)
# result should be {'b': 'Some'}

ප්රවේශය මෙම ලිපියෙන් ලැබෙන පිළිතුරක් මත පදනම් වේ: හිස් නූල් සහිත යතුරු ඉවත් කිරීම සඳහා කාර්යක්ෂම ක්රමයක්

    species = {'HI': {'1': (1215.671, 0.41600000000000004),
  '10': (919.351, 0.0012),
  '1025': (1025.722, 0.0791),
  '11': (918.129, 0.0009199999999999999),
  '12': (917.181, 0.000723),
  '1215': (1215.671, 0.41600000000000004),
  '13': (916.429, 0.0005769999999999999),
  '14': (915.824, 0.000468),
  '15': (915.329, 0.00038500000000000003),
 'CII': {'1036': (1036.3367, 0.11900000000000001), '1334': (1334.532, 0.129)}}

පහත කේතය මඟින් ඩික්ට් පිටපතක් සාදා speciesනැති අයිතම මකා දමනු ඇතtrans_HI

trans_HI=['1025','1215']
for transition in species['HI'].copy().keys():
    if transition not in trans_HI:
        species['HI'].pop(transition)