पायथन में, तानाशाही क्या है।

Question 1

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) Is ------ दूसरा तर्क क्यों है?

Question 2

डॉक्स की popविधि (जैसे self.data, यानी {'a':'aaa','b':'bbb','c':'ccc'}, यहां) दो तर्क लेती है - डॉक्स देखें

दूसरा तर्क, 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', इसलिए दूसरे popमें defaultतर्क वास्तव में वापस आ जाता है (क्योंकि 'a'अब अनुपस्थित है b.data)।

Question 3

इतने सारे सवाल यहाँ। मुझे कम से कम दो दिखते हैं, शायद तीन:

पॉप (ए, बी) क्या करता है? / एक दूसरा तर्क क्यों हैं?
किस चीज के *argsलिए इस्तेमाल किया जा रहा है?

पहला सवाल तुच्छ मानक पुस्तकालय संदर्भ में तुच्छ उत्तर दिया गया है :

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

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

दूसरा प्रश्न पायथन भाषा संदर्भ में शामिल किया गया है :

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

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

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

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

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

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

Question 4

def func(*args): 
    pass

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

आप इसका उपयोग कीवर्ड तर्क के साथ भी करते हैं **kwargs:

def func2(**kwargs): 
    pass

देखें: मनमाना तर्क सूचियाँ

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

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

दूसरे शब्दों में, आपको अपनी कक्षा की popविधि का उपयोग करने में सक्षम होना चाहिए जैसे dict.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

Question 5

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