පයිතන් ශබ්දකෝෂයකින් යතුරක් ඉවත් කරන්නේ කෙසේද?

ශබ්දකෝෂයකින් යතුරක් මකා දැමීමේදී, මම භාවිතා කරන්නේ:

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

මෙය කිරීමට එක් පේළියක් තිබේද?

යතුරක් ශබ්ද කෝෂයේ තිබේද යන්න නොසලකා එය මකා දැමීමට, තර්ක දෙකේ ආකෘතිය භාවිතා කරන්න dict.pop():

my_dict.pop('key', None)

ශබ්ද කෝෂයේ තිබේ my_dict[key]නම් මෙය නැවත පැමිණේ . දෙවන පරාමිතිය නිශ්චිතව දක්වා නොමැති නම් (එනම් ) සහ නොපවතී නම්, a මතු වේ.keyNonemy_dict.pop('key')keyKeyError

පවතින බවට සහතික වී ඇති යතුරක් මකා දැමීමට, ඔබට ද භාවිතා කළ හැකිය

del my_dict['key']

KeyErrorයතුර ශබ්ද කෝෂයේ නොමැති නම් මෙය මතු කරයි .

නිශ්චිතවම පිළිතුරු දීමට "මෙය කිරීමට එක් පේළියක් තිබේද?"

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

... හොඳයි, ඔබ ඇසුවා ;-)

ඔබ සිට වස්තුවක් මකා මෙම මාර්ගය බව, නමුත්, සලකා බැලිය යුතුය dictකියන්නේ පරමාණුක නොවන -it බව හැකි ය 'key'විය යුතු my_dictකාලය තුළ ifප්රකාශයක්, නමුත් පෙර මකා දැමීමට ඉඩ ඇත delක්රියාත්මක වන අවස්ථාවක,del සමඟ අසාර්ථක වනු ඇත KeyError. මේ අනුව, භාවිතා කිරීමdict.pop හෝ වෙනත් දෙයක් භාවිතා කිරීම ආරක්ෂිත වේ

try:
    del my_dict['key']
except KeyError:
    pass

ඇත්ත වශයෙන්ම, එය අනිවාර්යයෙන්ම නොවේ එක් නෞකාවක්.

හරියටම my_dict.pop("key", None)කරන්නේ කුමක්දැයි වටහා ගැනීමට මට යම් කාලයක් ගත විය . ඒ නිසා මම මෙය අන් අයගේ කාලය ඉතිරි කර ගැනීම සඳහා පිළිතුරක් ලෙස එකතු කරමි.

pop(key[, default])

නම් ප්රධාන ශබ්දකෝෂයට දී වන අතර, එය ඉවත් කිරීම හා එහි අගය, වෙන ආපසු නැවත ප්රකෘති . නම් පෙරනිමි ලබා නැති අතර ප්රධාන වන ශබ්ද කෝෂය තුළ නැත, එය KeyErrorමතු කර ඇත.

ප්‍රලේඛනය

del my_dict[key]my_dict.pop(key)යතුර පවතින විට ශබ්දකෝෂයකින් යතුරක් ඉවත් කිරීමට වඩා තරමක් වේගවත් වේ

>>> import timeit
>>> setup = "d = {i: i for i in range(100000)}"

>>> timeit.timeit("del d[3]", setup=setup, number=1)
1.79e-06
>>> timeit.timeit("d.pop(3)", setup=setup, number=1)
2.09e-06
>>> timeit.timeit("d2 = {key: val for key, val in d.items() if key != 3}", setup=setup, number=1)
0.00786

නමුත් යතුර නොපවතින විට ඊට if key in my_dict: del my_dict[key]වඩා තරමක් වේගවත් වේ my_dict.pop(key, None). දෙකම වඩා අඩු තරමින් තුන් වතාවක් වේගවත් delදී try/ exceptප්රකාශය:

>>> timeit.timeit("if 'missing key' in d: del d['missing key']", setup=setup)
0.0229
>>> timeit.timeit("d.pop('missing key', None)", setup=setup)
0.0426
>>> try_except = """
... try:
...     del d['missing key']
... except KeyError:
...     pass
... """
>>> timeit.timeit(try_except, setup=setup)
0.133

ඔබට එක් කේත පේළියක ශබ්ද කෝෂයකින් යතුරු විශාල ප්‍රමාණයක් ඉවත් කිරීමට අවශ්‍ය නම්, සිතියම () භාවිතා කිරීම තරමක් සංක්ෂිප්ත වන අතර පයිතොනික් කියවිය හැකිය:

myDict = {'a':1,'b':2,'c':3,'d':4}
map(myDict.pop, ['a','c']) # The list of keys to remove
>>> myDict
{'b': 2, 'd': 4}

ශබ්ද කෝෂයේ නොමැති අගයක් ඔබ පොප් කරන තැන දෝෂ හඳුනා ගැනීමට අවශ්‍ය නම්, සිතියම තුළ ලැම්බඩා භාවිතා කරන්න () මේ ආකාරයට:

map(lambda x: myDict.pop(x,None), ['a', 'c', 'e'])
[1, 3, None] # pop returns
>>> myDict
{'b': 2, 'd': 4}

හෝ තුළ python3, ඒ වෙනුවට ඔබ ලැයිස්තු අවබෝධයක් භාවිතා කළ යුතුය:

[myDict.pop(x, None) for x in ['a', 'c', 'e']]

එය වැඩ කරනවා. MyDict හි 'e' යතුරක් නොතිබුණද 'e' දෝෂයක් ඇති කළේ නැත.

එම යතුර ඉවත් කර නව ශබ්ද කෝෂයක් නිර්මාණය කිරීමට ඔබට ශබ්ද කෝෂ අවබෝධය භාවිතා කළ හැකිය :

>>> my_dict = {k: v for k, v in my_dict.items() if k != 'key'}

ඔබට කොන්දේසි අනුව මකා දැමිය හැකිය. keyනොපවතී නම් දෝෂයක් නොමැත .

"ඩෙල්" මූල පදය භාවිතා කිරීම:

del dict[key]

පහත දැක්වෙන ප්‍රවේශයන් මඟින් අපට පයිතන් ශබ්දකෝෂයකින් යතුරක් මකා දැමිය හැකිය.

delමූල පදය භාවිතා කිරීම ; එය ඔබ කළ ආකාරයටම පාහේ සමාන ප්‍රවේශයකි -

 myDict = {'one': 100, 'two': 200, 'three': 300 }
 print(myDict)  # {'one': 100, 'two': 200, 'three': 300}
 if myDict.get('one') : del myDict['one']
 print(myDict)  # {'two': 200, 'three': 300}

හෝ

පහත දැක්වෙන ආකාරයට අපට කළ හැකිය:

නමුත් මෙම ක්‍රියාවලියේදී එය නිශ්චිත ශබ්දයක් එම ශබ්ද කෝෂයෙන් බැහැර කරනවාට වඩා ශබ්දකෝෂයෙන් කිසිදු යතුරක් මකා නොදමන බව මතක තබා ගත යුතුය . ඊට අමතරව, එය ශබ්ද කෝෂයක් ආපසු ලබා දුන් බව මම නිරීක්ෂණය කළෙමි .myDict

myDict = {'one': 100, 'two': 200, 'three': 300, 'four': 400, 'five': 500}
{key:value for key, value in myDict.items() if key != 'one'}

අපි එය කවචයේ ධාවනය කරන්නේ නම්, එය වැනි දෙයක් ක්‍රියාත්මක කරනු ඇත {'five': 500, 'four': 400, 'three': 300, 'two': 200}- එය ඇණවුම් කළ ආකාරයටම නොවන බව සලකන්න myDict. නැවතත් අපි මුද්‍රණය කිරීමට උත්සාහ කළහොත් myDict, මෙම ප්‍රවේශය මඟින් අප ශබ්දකෝෂයෙන් බැහැර කළ සියලුම යතුරු අපට දැක ගත හැකිය. කෙසේ වෙතත්, පහත දැක්වෙන ප්‍රකාශය විචල්‍යයකට පැවරීමෙන් අපට නව ශබ්ද කෝෂයක් සෑදිය හැකිය:

var = {key:value for key, value in myDict.items() if key != 'one'}

දැන් අපි එය මුද්‍රණය කිරීමට උත්සාහ කළහොත් එය මව් අනුපිළිවෙල අනුගමනය කරනු ඇත:

print(var) # {'two': 200, 'three': 300, 'four': 400, 'five': 500}

හෝ

pop()ක්රමය භාවිතා කිරීම .

myDict = {'one': 100, 'two': 200, 'three': 300}
print(myDict)

if myDict.get('one') : myDict.pop('one')
print(myDict)  # {'two': 200, 'three': 300}

අතර වෙනස delසහ popභාවිතා වේ pop()ක්රමය, අප සැබවින්ම ගබඩා කල හැක ප්රධාන වටිනාකම අවශ්ය නම්, පහත සඳහන් ලෙස:

myDict = {'one': 100, 'two': 200, 'three': 300}
if myDict.get('one') : var = myDict.pop('one')
print(myDict) # {'two': 200, 'three': 300}
print(var)    # 100

ෆෝක් මෙම ඔබ මෙම ප්රයෝජනවත් නම්, අනාගත ප්රයෝජනය සඳහා දැන් ලොකු තැනක්.

ඔබට ඉතා වාචික වීමට අවශ්‍ය නම් ව්‍යතිරේක හැසිරවීම භාවිතා කළ හැකිය:

try: 
    del dict[key]

except KeyError: pass

කෙසේ වෙතත්, pop()යතුර නොපවතී නම් මෙය ක්‍රමයට වඩා මන්දගාමී වේ.

my_dict.pop('key', None)

යතුරු කිහිපයක් සඳහා එය වැදගත් නොවේ, නමුත් ඔබ මෙය නැවත නැවතත් කරන්නේ නම්, දෙවන ක්‍රමය වඩා හොඳ ඔට්ටුවක් වේ.

වේගවත්ම ප්රවේශය මෙයයි:

if 'key' in dict: 
    del myDict['key']

නමුත් මෙම ක්‍රමය භයානක වන්නේ 'key'පේළි දෙක අතර ඉවත් කළහොත් a KeyErrorමතු කරනු ඇති බැවිනි.

තවත් ක්‍රමයක් නම් අයිතම () + ඩික්ට් අවබෝධය භාවිතා කිරීමයි

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

test_dict = {"sai" : 22, "kiran" : 21, "vinod" : 21, "sangam" : 21} 

# Printing dictionary before removal 
print ("dictionary before performing remove is : " + str(test_dict)) 

# Using items() + dict comprehension to remove a dict. pair 
# removes  vinod
new_dict = {key:val for key, val in test_dict.items() if key != 'vinod'} 

# Printing dictionary after removal 
print ("dictionary after remove is : " + str(new_dict)) 

ප්‍රතිදානය:

dictionary before performing remove is : {'sai': 22, 'kiran': 21, 'vinod': 21, 'sangam': 21}
dictionary after remove is : {'sai': 22, 'kiran': 21, 'sangam': 21}

මම වෙනස් කළ නොහැකි අනුවාදයට කැමතියි

foo = {
    1:1,
    2:2,
    3:3
}
removeKeys = [1,2]
def woKeys(dct, keyIter):
    return {
        k:v
        for k,v in dct.items() if k not in keyIter
    }

>>> print(woKeys(foo, removeKeys))
{3: 3}
>>> print(foo)
{1: 1, 2: 2, 3: 3}

යතුර මත තනි පෙරණය

• my_dict හි "යතුර" තිබේ නම් "යතුර" ආපසු ගෙන එය my_dict වෙතින් ඉවත් කරන්න
• my_dict හි "යතුර" නොපවතී නම් කිසිවක් ආපසු එවන්න

මෙය my_dictස්ථානයෙහි වෙනස් වේ (විකෘති)

my_dict.pop('key', None)

යතුරු මත පෙරහන් කිහිපයක්

නව නියෝගයක් ජනනය කරන්න (වෙනස් කළ නොහැකි)

dic1 = {
    "x":1,
    "y": 2,
    "z": 3
}

def func1(item):
    return  item[0]!= "x" and item[0] != "y"

print(
    dict(
        filter(
            lambda item: item[0] != "x" and item[0] != "y", 
            dic1.items()
            )
    )
)

ශබ්ද කෝෂයේ දත්ත වර්ගයට ක්‍රමයක් ඇති අතර dict_name.pop(item)එය යතුරක් මකා දැමීමට භාවිතා කළ හැකිය : ශබ්දකෝෂයකින් අගය යුගලය.

a={9:4,2:3,4:2,1:3}
a.pop(9)
print(a)

මෙය ප්‍රතිදානය පහත පරිදි ලබා දෙනු ඇත:

{2: 3, 4: 2, 1: 3}

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