python - एक शब्दकोश से एक आइटम हटाएं





dictionary (12)


बस डेल डी ['कुंजी'] पर कॉल करें।

हालांकि, उत्पादन में, यह जांचना हमेशा एक अच्छा अभ्यास है कि डी में 'कुंजी' मौजूद है या नहीं।

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

क्या Python में किसी शब्दकोश से आइटम को हटाने का कोई तरीका है?

मुझे पता है कि मैं सिर्फ शब्दकोश पर .pop को कॉल कर सकता हूं, लेकिन वह उस आइटम को वापस कर देता है जिसे हटा दिया गया था। जो मैं खोज रहा हूं वह कुछ है जो शब्दकोष को प्रश्न में तत्व से घटा देता है।

वर्तमान में मेरे पास एक सहायक कार्य है जो शब्दकोष को पैरामीटर के रूप में स्वीकार करता है, और फिर आइटम को हटाए गए शब्दकोश के साथ एक शब्दकोश देता है, क्या कोई और सुरुचिपूर्ण समाधान है?




मुझे लगता है कि आपका समाधान इसे करने का सबसे अच्छा तरीका है। लेकिन यदि आप एक और समाधान चाहते हैं, तो आप अपनी निर्दिष्ट कुंजी को शामिल किए बिना पुराने शब्दकोश से चाबियों का उपयोग करने के साथ एक नया शब्दकोश बना सकते हैं, जैसे:

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



नहीं, इससे कोई दूसरा रास्ता नहीं है

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

हालांकि, अक्सर थोड़ा बदलते शब्दकोशों की प्रतियां बनाना संभवतः एक अच्छा विचार नहीं है क्योंकि इसके परिणामस्वरूप तुलनात्मक रूप से बड़ी स्मृति मांगें होती हैं। पुराने शब्दकोष (यदि आवश्यक हो) को लॉग करना आम तौर पर बेहतर होता है और फिर इसे संशोधित करता है।




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

यह कोई त्रुटि प्रबंधन नहीं करता है, यह मानता है कि कुंजी dict में है, तो आप इसे पहले जांचना चाहेंगे और अगर नहीं




सूची समझ का उपयोग करके एक और भिन्नता यहां दी गई है:

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

दृष्टिकोण इस पोस्ट के उत्तर पर आधारित है: एक तार से खाली तारों के साथ कुंजी को हटाने के लिए कुशल तरीका




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

परिणाम: डी = {1: 2, '2': 3}




कोड स्निपेट के नीचे आपको निश्चित रूप से मदद मिलेगी, मैंने प्रत्येक पंक्ति में टिप्पणियां जोड़ दी हैं जो कोड को समझने में आपकी सहायता करेंगी।

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}



बहुत अच्छे जवाब हैं, लेकिन मैं एक चीज़ पर जोर देना चाहता हूं।

आप एक शब्दकोश से वस्तुओं को हटाने के लिए 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 । यद्यपि ऐसा हो सकता है कि pop() in चेक के साथ del का उपयोग थोड़ा तेज़ है 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}



del स्टेटमेंट एक तत्व को हटा देता है:

del d[key]

हालांकि, यह मौजूदा शब्दकोश को बदल देता है ताकि शब्दकोश की सामग्री किसी और के लिए बदलती है जिसकी एक ही घटना का संदर्भ है। एक नया शब्दकोश वापस करने के लिए, शब्दकोश की एक प्रति बनाएं:

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

dict() कन्स्ट्रक्टर एक उथली प्रतिलिपि बनाता है। एक गहरी प्रतिलिपि बनाने के लिए, copy मॉड्यूल देखें।




यह जांचने के लिए अच्छा एक-लाइनर है कि कुंजी मौजूद है या नहीं, इसे हटाएं, मान वापस करें, या डिफ़ॉल्ट:

ret_val = ('key' in body and body.pop('key')) or 5



pop शब्दकोश को बदलता है।

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

यदि आप मूल रखना चाहते हैं तो आप इसे कॉपी कर सकते हैं।




'For' loops का उपयोग करके शब्दकोशों पर इटरेट करना

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:
    ...

पाइथन कैसे पहचानता है कि इसे केवल शब्दकोश से कुंजी पढ़ने की आवश्यकता है? पाइथन में एक विशेष शब्द कुंजी है? या यह बस एक चर है?

यह सिर्फ लूप के for नहीं है। यहां महत्वपूर्ण शब्द "पुनरावृत्ति" है।

एक शब्दकोश मूल्यों के लिए कुंजी का मानचित्रण है:

d = {'x': 1, 'y': 2, 'z': 3} 

जब भी हम इसे फिर से करते हैं, हम चाबियों पर फिर से शुरू होते हैं। परिवर्तनीय नाम key केवल वर्णनात्मक होने का इरादा है - और यह उद्देश्य के लिए काफी उपयुक्त है।

यह एक सूची समझ में होता है:

>>> [k for k in d]
['x', 'y', 'z']

ऐसा तब होता है जब हम शब्दकोश को सूची में पास करते हैं (या कोई अन्य संग्रह प्रकार ऑब्जेक्ट):

>>> list(d)
['x', 'y', 'z']

जिस तरह से पाइथन पुनरावृत्त होता है, उस संदर्भ में जहां इसे करने की आवश्यकता होती है, यह ऑब्जेक्ट की __iter__ विधि (इस मामले में शब्दकोश) को कॉल करती है जो एक इटरेटर (इस मामले में, एक कीजिएटर ऑब्जेक्ट) देता है:

>>> d.__iter__()
<dict_keyiterator object at 0x7fb1747bee08>

हमें इन विशेष तरीकों का उपयोग स्वयं नहीं करना चाहिए, इसके बजाय, इसे कॉल करने के लिए संबंधित बिल्टिन फ़ंक्शन का उपयोग करें, इसे:

>>> key_iterator = iter(d)
>>> key_iterator
<dict_keyiterator object at 0x7fb172fa9188>

Iterators के पास __next__ विधि है - लेकिन हम इसे __next__ फ़ंक्शन के साथ कॉल करते हैं, next :

>>> next(key_iterator)
'x'
>>> next(key_iterator)
'y'
>>> next(key_iterator)
'z'
>>> next(key_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

जब एक इटेटरेटर समाप्त हो जाता है, तो यह StopIteration बढ़ाता है। इस प्रकार पाइथन लूप, या एक सूची समझ, या जनरेटर अभिव्यक्ति, या किसी अन्य पुनरावृत्ति संदर्भ से बाहर निकलने के लिए जानता है। एक बार जब StopIteration बढ़ाता है तो यह हमेशा इसे उठाएगा - अगर आप दोबारा पुन: प्रयास करना चाहते हैं, तो आपको एक नया चाहिए।

>>> list(key_iterator)
[]
>>> new_key_iterator = iter(d)
>>> list(new_key_iterator)
['x', 'y', 'z']

डिक्ट्स पर लौट रहा है

हमने कई संदर्भों में पुनरावृत्ति को देखा है। हमने जो देखा है वह यह है कि जब भी हम एक ताना पर पुन: प्रयास करते हैं, तो हमें चाबियां मिलती हैं। मूल उदाहरण पर वापस जाएं:

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:

यदि हम चर नाम बदलते हैं, तो हमें अभी भी चाबियां मिलती हैं। चलो यह कोशिश करते हैं:

>>> for each_key in d:
...     print(each_key, '=>', d[each_key])
... 
x => 1
y => 2
z => 3

यदि हम मूल्यों पर .items : .items करना चाहते हैं, तो हमें dicts की .values विधि, या दोनों के लिए एक साथ उपयोग करने की आवश्यकता है .items :

>>> list(d.values())
[1, 2, 3]
>>> list(d.items())
[('x', 1), ('y', 2), ('z', 3)]

दिए गए उदाहरण में, इस तरह की वस्तुओं पर पुन: प्रयास करना अधिक कुशल होगा:

for a_key, corresponding_value in d.items():
    print(a_key, corresponding_value)

लेकिन अकादमिक उद्देश्यों के लिए, प्रश्न का उदाहरण ठीक है।







python dictionary