किसी शब्दकोश से एक तत्व हटाएं

Question

क्या पायथन में एक शब्दकोश से एक आइटम को हटाने का एक तरीका है?

इसके अतिरिक्त, मैं प्रतिलिपि को वापस करने के लिए एक शब्दकोष से एक आइटम को कैसे हटा सकता हूं (यानी, मूल को संशोधित नहीं कर रहा हूं)?

Comments

आपको एक ऐसे फ़ंक्शन की आवश्यकता क्यों है जो एक शब्दकोश देता है, जब आप सीधे शब्दकोश को संशोधित कर सकते हैं?

— एमिलरहॉड्स

शब्दकोश popविधि शब्दकोश में परिवर्तन यथा-स्थान । इसलिए यह उस शब्दकोश के संदर्भ को बदल देता है जो कॉलर से "हेल्पर फ़ंक्शन" में पारित किया गया था। इसलिए "हेल्पर फंक्शन" को कुछ भी वापस करने की आवश्यकता नहीं है, क्योंकि कॉलर में शब्दकोश के मूल संदर्भ को पहले से ही बदल दिया जाएगा। dict.pop()यदि आपको इसकी आवश्यकता नहीं है, तो किसी भी चीज़ से रिटर्न असाइन न करें । ईजी: do stuff with my_dict; my_dict.pop(my_key, None); do more stuff with my_dict # now doesn't have my_key। deepcopy(my_dict)जरूरत पड़ने पर इस्तेमाल करें ।

— मार्क मिकोफ्कि जूल

चूंकि मूल शीर्षक विवरण से असहमत था और विशेष रूप से स्पष्ट समाधान को छोड़कर d.pop(), मैंने विवरण में निर्दिष्ट प्रश्न पूछने के लिए शीर्षक तय किया।

— एसएमसीआई

यदि आप वास्तव में ऐसा करना चाहते हैं, तो हमें एक कैविएट जोड़ना चाहिए , जैसे कि आप इसे उन तत्वों के साथ शब्दकोश में N बार करते हैं, जिन्हें आप सभी गहरी प्रतियों के साथ O (N * E) मेमोरी में लीक करेंगे। यदि आप केवल एक रीड-ओनली (उथली प्रति) चाहते हैं, तो करें d.pop(key)। लेकिन अगर कभी कुछ भी उथली नकल को संशोधित करता है, तो आपको अलियासिंग के साथ एक अच्छी तरह से ज्ञात समस्या है । यदि आप हमें व्यापक संदर्भ बताते हैं तो यह मदद करता है। (कुछ और कभी dict मूल्यों को संशोधित है आप एक सूची से अधिक विध्वंस पुनरावृति करने की कोशिश कर रहे हैं, तो नहीं, क्या???)

— एसएमसीआई

"आपको एक फ़ंक्शन की आवश्यकता क्यों है जो एक शब्दकोश देता है, जब आप सीधे शब्दकोश को संशोधित कर सकते हैं?" शायद इसलिए कि आप शुद्ध कार्य लिखना चाहते हैं जो उनके मापदंडों को संशोधित नहीं करते हैं?

— जीन कैलहन

Answer 1

delबयान एक तत्व निकालता है:

del d[key]

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

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

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

---

ध्यान दें कि प्रत्येक तानाशाही del/ असाइनमेंट / आदि के लिए एक प्रतिलिपि बनाना । इसका मतलब है कि आप निरंतर समय से रैखिक समय पर जा रहे हैं, और रैखिक स्थान का उपयोग भी कर रहे हैं। छोटे dicts के लिए, यह कोई समस्या नहीं है। लेकिन अगर आप बड़े डक्ट्स की बहुत सारी प्रतियां बनाने की योजना बना रहे हैं, तो आप शायद एक अलग डेटा संरचना चाहते हैं, जैसे कि एचएएमटी (जैसा कि इस उत्तर में वर्णित है )।

Comments

शब्दकोशों की परस्परता के बारे में एक बढ़िया बिंदु है +1 - हालाँकि मैं ऐसे समय के बारे में नहीं सोच सकता जब मैं शब्दकोश की प्रतियां चाहता था, मैंने हमेशा 'everyones' की नकल पर भरोसा किया है। महान बिंदु।

— tMC

@tMC यदि आप dictइसके माध्यम से लूपिंग एडिट करते हैं, तो यह आपको एक त्रुटि देगा:RuntimeError: dictionary changed size during iteration

— VertigoRay

popविधि के बारे में क्या वास्तव में वही करता है? यह अधिक पायथोनिक नहीं है? (तानाशाही विधि होने के नाते, विशेष आरक्षित शब्द नहीं)?

— सर्ज

इस जवाब में एक कमजोरी है, यह भ्रामक हो सकता है। पाठकों को गलतफहमी हो सकती है कि तानाशाही (डी) उन्हें 'डी' के साथ एक प्रति दे सकती है। लेकिन यह एक अधूरी कॉपी है। जब केवल डेल की संचालन कर रहा है, तो यह ठीक है। लेकिन जब आप एक नेस्टेड डिक्टेट के लिए कुछ और करना चाहते हैं, तो उस कॉपी पद्धति का उपयोग करके 'r' को संशोधित करके मूल 'd' में बदलाव किया जा सकता है। एक प्रामाणिक प्रति प्राप्त करने के लिए, आपको पहले 'आयात प्रति' चाहिए, और फिर 'r = copy.deepcopy (d)'।

— ज़ेन

@ ज़ेन: पर्याप्त रूप से, मैंने उथले बनाम गहरी प्रति के बारे में एक नोट जोड़ा है।

— ग्रेग हेविगेल

Answer 2

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

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

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

Comments

"डेल" ठीक है, लेकिन "पॉप" मेरी राय में अधिक "पायथोनिक" लगता है।

— ivanleoncz

@ivanleoncz क्यों?

— केवेर

popवह मान लौटाया गया जो 'पॉपप्ड' था, जो आपको इस मूल्य का उपयोग करने की अनुमति देता है जो भी आगे कारण हो। यदि यह अधिक "पायथोनिक" नहीं है, तो मैं कहूंगा कि यह बेहतर है, निश्चित रूप से :)। यह एक तानाशाह नहीं है, लेकिन यह दोनों के लिए एक ही तरह से काम करता है: github.com/ivanlmj/python-prototypes/blob/master/3.4/……

— ivanleoncz

@ivanleoncz यह एक और कारण के लिए भी बेहतर है, popएक डिफ़ॉल्ट मान के साथ प्रदान किया जा सकता है जब एक कुंजी तानाशाह से गायब है। यह अच्छा है जब आपको कुछ चाबियाँ निकालने की आवश्यकता होती है, लेकिन उनमें से कुछ गायब हो सकते हैं; ऐसे मामले में delफेंक देंगे KeyError।

— इताची

Answer 3

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

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

Comments

बहुत कूल। मुझे किसी नए फ़ंक्शन को परिभाषित किए बिना शब्दकोश को फ़िल्टर करने की त्वरित विधि पसंद है।

— जो जे

समझ न रखने वालों के लिए, आप भी कुछ ऐसा कर सकते हैं: {i:a[i] for i in a if i not in [0, 1, 2]}यदि आप कई तत्वों को निकालना चाहते हैं।

— kmatheny

बेहतर होगा {k:v for k,v in a.items() if k != 0}मुझे लगता है।

— rlbond

कुंजी द्वारा किसी आइटम को हटाने और एक ही पंक्ति में नए तानाशाह के परिणाम को वापस करने का सबसे अच्छा समाधान। उदाहरण के लिए यदि आपको किसी एकल आइटम के बिना पहले से निर्मित तानाशाही का उपयोग करने की आवश्यकता है **kwargs, तोsome_function(**{k:v for k,v in some_dict.items() if k not 'some_key'})

— कोल

सबसे अच्छा समाधान यहाँ। एक लाइनर और यह मूल शब्दकोश को म्यूट नहीं करता है।

— एंड्रयू विंटरबोटम

Answer 4

डेल बयान आप जो खोज रहे हैं है। यदि आपके पास 'बार' नामक कुंजी के साथ फू नाम का शब्दकोष है, तो आप इस तरह से 'बार' को हटा सकते हैं:

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

Comments

@ pythonian29033, वास्तव में, नहीं । स्वीकृत उत्तर अपेक्षित रूप से काम करता है - यह एक कुंजी के बिना तानाशाही को लौटाता है। इस उत्तर से दृष्टिकोण मूल रूप से बदल जाता है;) एक महत्वपूर्ण अंतर है

— मैक्सिकोरोविच

@ arussell84, >>>अक्सर अजगर-उदाहरणों में उपयोग क्यों किया जाता है? हाँ, अजगर-डॉक्टर में बहुत सारी ऐसी चीजें हैं। लेकिन ऐसे कोड कोपिपेस्ट के लिए सुविधाजनक नहीं है । मैं उलझन में हूँ ...

— maxkoryukov

@maxkoryukov हाँ यह करता है! लेकिन यह फ़ंक्शन और यह उत्तर बिल्कुल समान है, जिसमें उस उत्तर को एक फ़ंक्शन के अंदर रखा गया है। और आप कुछ समय के लिए अजगर में कोडिंग नहीं कर रहे होंगे, >>>

— पिथी

@ pythonian29033 के बारे में >>>। हां, यह REPL- शैली है, लेकिन आइए खुलकर बात करते हैं: केवल एक आदमी ने यह नमूना लिखा था, और 1000 ने इसे पढ़ा है। मुझे लगता है, आसान कॉपी और रन की अनुमति देने के तरीके में उदाहरण लिखना बहुत अच्छा होगा। मैं इस कोण कोष्ठक को हाथ से हटाना पसंद नहीं करता। या लाइन से कॉपी लाइन .. तो मुझे समझ नहीं आता: यह कोण अभी भी क्यों हैं))) क्या मुझे कुछ पता नहीं है?

— अधिकतमकॉरोविच

मैंने एक ऐसा फ़ंक्शन जोड़ा है जो आपकी सुविधा के लिए कॉपी / पेस्ट किया जा सकता है।

— अरूसेल84

Answer 5

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

शब्दकोश से आइटम निकालने के लिए आप 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साथ उपयोग करने से उपर्युक्त होने वाली अपनी जटिलताओं के साथ एक फ़ंक्शन होने के कारण थोड़ा तेज हो । आमतौर पर ऐसा नहीं होता है, इसलिए डिफ़ॉल्ट मान काफी अच्छा होता है।inpop()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}

Answer 6

... मैं एक प्रतिलिपि को वापस करने के लिए एक शब्दकोश से एक आइटम को कैसे हटा सकता हूं (यानी, मूल को संशोधित नहीं कर रहा हूं)?

ए dictइसके लिए उपयोग करने के लिए गलत डेटा संरचना है।

ज़रूर, कॉपी के काम से तानाशाही और पॉपिंग की नकल करना, और इसी तरह एक नए तानाशाह का निर्माण एक समझ के साथ होता है, लेकिन यह सब नकल करने में समय लगता है - आपने एक रैखिक-समय के साथ निरंतर-समय के ऑपरेशन को बदल दिया है। और उन सभी प्रतियों को एक बार में जीवित रखा गया है- प्रति प्रतिलिपि रैखिक स्थान।

अन्य डेटा संरचनाएं, जैसे कि हैश एरे मैप्ड ट्राइसेज़ , इस तरह के उपयोग के मामले के लिए डिज़ाइन किए गए हैं: तत्व जोड़ना या हटाना लॉगरिदमिक समय में एक प्रति लौटाता है , इसके अधिकांश भंडारण को मूल के साथ साझा करना । ¹

बेशक कुछ डाउनसाइड हैं। प्रदर्शन निरंतर के बजाय लघुगणक है (हालांकि एक बड़े आधार के साथ, आमतौर पर 32-128)। और, जब आप नॉन-म्यूटिंग एपीआई के समान कर सकते हैं dict, तो "म्यूटिंग" एपीआई स्पष्ट रूप से अलग है। और, सबसे ज्यादा, पायथन के साथ शामिल कोई हैम बैटरी नहीं है। ²

pyrsistentपुस्तकालय अजगर के लिए HAMT आधारित dict-प्रतिस्थापन (और विभिन्न अन्य प्रकार के) की एक बहुत ठोस कार्यान्वयन है। यहां तक ​​कि मौजूदा म्यूटिंग कोड को निरंतर कोड को सुचारू रूप से संभव के रूप में पोर्ट करने के लिए एक निफ्टी एवोल्वर एपीआई है। लेकिन यदि आप म्यूटिंग के बजाय प्रतियां वापस लेने के बारे में स्पष्ट होना चाहते हैं, तो आप इसे इस तरह उपयोग करते हैं:

>>> 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। पहले हटाए गए पीईपी बताते हैं कि क्यों। लेकिन यह लाइब्रेरी का छिपा हुआ कार्यान्वयन विवरण है, सार्वजनिक संग्रह प्रकार नहीं।}

Answer 7

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

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

Answer 8

बस डेल डी ['कुंजी'] को फोन करें।

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

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

Comments

हम्म, नहीं, उत्पादन में ईएएफपी विचारधारा का पालन करना बेहतर है । बस try-exceptब्लॉक में कुंजी निकालें । कम से कम, यह एक परमाणु ऑपरेशन होगा;)

— मैक्सकोरियोकोव

और यदि आप संक्षिप्त होना चाहते हैं - उपयोग d.pop('key', None), यह oneliner है। लेकिन वास्तविक प्रश्न एक कुंजी के बिना शब्दकोश प्राप्त करने के बारे में था, न कि तानाशाही को संशोधित करने के बारे में। तो समझ - यहाँ एक अच्छा विकल्प है;)

— मैक्सकोरुकोव

Answer 9

नहीं, इसके अलावा और कोई रास्ता नहीं है

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

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

Answer 10

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

Answer 11

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

यह किसी भी त्रुटि से निपटने के लिए नहीं करता है, यह मानता है कि कुंजी तानाशाही में है, आप पहले यह जांचना चाहते हैं और raiseयदि नहीं

Comments

आपका तरीका किसी से अलग कैसे है del test_dict[key]?

— मैड फिजिसिस्ट

Answer 12

यहाँ एक शीर्ष स्तर का डिज़ाइन दृष्टिकोण:

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}

उम्मीद है की वो मदद करदे!

Answer 13

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

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

या आप तानाशाही का भी उपयोग कर सकते हैं।

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}

Answer 14

सूची बोध का उपयोग करते हुए यहां एक और भिन्नता है:

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

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

Comments

यदि आप एक वर्ष पुराने प्रश्न का उत्तर देने जा रहे हैं जिसमें पहले से ही एक सरल, उपयुक्त, स्वीकृत उत्तर है, तो कम से कम यह सुनिश्चित करें कि आपका उत्तर सही है। यह वह नहीं करता है जो ओपी ने पूछा था।

— user2357112

मैं आमतौर पर उन सवालों पर तारीखों की जांच नहीं करता जो मुझे लगता है कि मूल्यवान जानकारी उनके साथ जोड़ी जा सकती थी। इसके अतिरिक्त, मेरे द्वारा पूछे गए प्रश्न पर टिप्पणियों में से एक: "आमतौर पर यह वही है जो कोई व्यक्ति चाहता है और शायद ओपी की जरूरत है, लेकिन यह नहीं है कि ओपी ने क्या पूछा" stackoverflow.com/questions/12118695/… I पता था कि यह सवाल का सीधा जवाब नहीं था; बल्कि विकल्पों के लिए एक विस्तार।

— BigBlueHat

यह उत्तर, हालांकि पूर्ण नहीं है, हमें यह जानने की अनुमति देता है कि हम शर्तों के साथ भी आइटम निकाल सकते हैं। बस सेशन में जवाब देने के if vलिए बदल रहा है if k is not 'a'। लेकिन मुझे नहीं लगता कि यह एक कुशल तरीका है, यह ओ (लॉग एन) के बजाय ओ (एन) के तत्व को पॉप या डेल के रूप में हटा देता है।

— होल्गाक

Answer 15

    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)