पायथन में, dict.pop (ए, बी) का क्या अर्थ है?

Question

class a(object): 
    data={'a':'aaa','b':'bbb','c':'ccc'} 
    def pop(self, key, *args): 
      return self.data.pop(key, *args)#what is this mean. 

b=a() 
print b.pop('a',{'b':'bbb'}) 
print b.data 

self.data.pop(key, *args) ← ------ दूसरा तर्क क्यों है?

Answer 1

dicts (self.data की तरह, यानी {'a':'aaa','b':'bbb','c':'ccc'}, यहाँ) की pop विधि दो तर्क लेता है - the docs

देखना

दूसरा तर्क, default, pop क्या होता है यदि पहला तर्क, key अनुपस्थित है। (यदि आप pop पर केवल एक तर्क के साथ, key पर कॉल करते हैं, तो यह कुंजी अनुपस्थित होने पर अपवाद उठाती है)।

अपने उदाहरण में, print b.pop('a',{'b':'bbb'}), इस अप्रासंगिक क्योंकि 'a'b.data में एक महत्वपूर्ण है। लेकिन आप उस रेखा को दोहराने अगर ...:

b=a() 
print b.pop('a',{'b':'bbb'}) 
print b.pop('a',{'b':'bbb'}) 
print b.data 

आप इसे एक फर्क नहीं पड़ता दिखाई देंगे: पहला pop'a' कुंजी निकाल देता है, इसलिए में दूसरा popdefault तर्क वास्तव में (लौटा दिया जाता है के बाद से 'a' अब है b.data से अनुपस्थित)।

Answer 2

def func(*args): 
    pass 

जब आप एक समारोह इस तरह से परिभाषित करते हैं, *args समारोह के लिए पारित तर्क की सरणी हो जाएगा। इससे आपके कार्य को समय के बारे में जानने के बिना काम करने की अनुमति मिलती है कि इसमें कितने तर्क पारित किए जा रहे हैं।

तुम भी कीवर्ड तर्क के साथ ऐसा करते हैं, **kwargs का उपयोग कर:

def func2(**kwargs): 
    pass 

देखें: Arbitrary argument lists

---

आपके मामले में, आप एक वर्ग है जो एक शब्दकोश की तरह काम कर रहा है परिभाषित किया है। dict.pop विधि को pop(key[, default]) के रूप में परिभाषित किया गया है।

आपकी विधि default पैरामीटर का उपयोग नहीं करती है। लेकिन, *args के साथ अपनी विधि को परिभाषित करके और *args से dict.pop() पर जाकर, आप कॉलर को default पैरामीटर का उपयोग करने की अनुमति दे रहे हैं।

दूसरे शब्दों में, आप dict.pop की तरह अपने वर्ग के pop विधि का उपयोग करने में सक्षम होना चाहिए:

my_a = a() 
value1 = my_a.pop('key1')  # throw an exception if key1 isn't in the dict 
value2 = my_a.pop('key2', None) # return None if key2 isn't in the dict 

Answer 3

यहां बहुत सारे प्रश्न हैं। मैं कम से कम दो देख सकता हूं, शायद तीन:

• पॉप (ए, बी) क्या करता है?/दूसरा तर्क क्यों है?
• *args क्या उपयोग किया जा रहा है?

---

पहला सवाल तुच्छता Python Standard Library संदर्भ में जवाब है:

पॉप (कुंजी [, डिफ़ॉल्ट])

तो कुंजी शब्दकोश में है, इसे हटाने और वापसी इसकी मूल्य, अन्य डिफ़ॉल्ट वापसी। यदि डिफ़ॉल्ट नहीं दिया गया है और कुंजी शब्दकोश में नहीं है, तो एक KeyError उठाया जाता है।

तो प्रपत्र "* पहचानकर्ता" मौजूद है, यह एक टपल किसी भी अतिरिक्त स्थितीय मापदंडों प्राप्त करने के लिए आरंभ नहीं हो जाता, दोषी:

---

दूसरे प्रश्न में Python Language Reference कवर किया जाता है खाली ट्यूपल के लिए। यदि फॉर्म "** पहचानकर्ता" मौजूद है, तो यह किसी नए शब्द को किसी भी अतिरिक्त कीवर्ड तर्क प्राप्त करने के लिए प्रारंभ किया गया है, जो एक नए खाली शब्दकोश में डिफ़ॉल्ट है।

दूसरे शब्दों में, pop फ़ंक्शन में कम से कम दो तर्क होते हैं। पहले दो नाम self और key नाम दिए गए; और बाकी को args नामक टुपल में भर दिया जाता है।

क्या अगली पंक्ति जब *argsself.data.pop करने के लिए कॉल में साथ पारित हो जाता है पर क्या हो रहा है इस का उल्टा होता है - टपल *args स्थितीय मापदंडों जो पारित हो के लिए विस्तार किया गया है। यह Python Language Reference में समझाया गया है:

वाक्य रचना * अभिव्यक्ति में प्रकट होता है समारोह कॉल, अभिव्यक्ति एक दृश्य के लिए मूल्यांकन करना चाहिए। इस क्रम से तत्वों व्यवहार कर रहे हैं जैसे कि वे अतिरिक्त स्थितीय तर्क

संक्षेप में थे, a.pop() लचीला होना और स्थितीय मापदंडों के किसी भी संख्या को स्वीकार करने, इतना है कि यह करने के लिए पर स्थितीय मापदंडों के इस अज्ञात संख्या पारित कर सकते हैं चाहता है self.data.pop()।

यह आपको लचीलापन देता है; data अभी dict होता है, और इसलिए self.data.pop() या तो एक या दो पैरामीटर लेता है; लेकिन अगर आपने data को एक प्रकार के रूप में बदल दिया है जो self.data.pop() पर कॉल के लिए 1 9 पैरामीटर लेता है तो आपको कक्षा a कक्षा को बदलना नहीं होगा। हालांकि आपको आवश्यक 1 9 पैरामीटर पास करने के लिए अभी भी a.pop() नामक किसी भी कोड को बदलना होगा।

Answer 4

>>> def func(a, *args, **kwargs): 
... print 'a %s, args %s, kwargs %s' % (a, args, kwargs) 
... 
>>> func('one', 'two', 'three', four='four', five='five') 
a one, args ('two', 'three'), kwargs {'four': 'four', 'five': 'five'} 

---

>>> def anotherfunct(beta, *args): 
... print 'beta %s, args %s' % (beta, args) 
... 
>>> def func(a, *args, **kwargs): 
... anotherfunct(a, *args) 
... 
>>> func('one', 'two', 'three', four='four', five='five') 
beta one, args ('two', 'three') 
>>>