Python Language
* आर्ग और ** क्वार्ग्स

Django Flask HTML GNU/Linux matplotlib MySQL opencv pandas Regular Expressions tensorflow

टिप्पणियों

ध्यान देने योग्य कुछ बातें:

नाम args और kwargs सम्मेलन द्वारा किया जाता है, वे भाषा विनिर्देशन का एक हिस्सा नहीं हैं। इस प्रकार, ये समतुल्य हैं:
```
 def func(*args, **kwargs):
     print(args)
     print(kwargs)
```
```
 def func(*a, **b):
     print(a)
     print(b)
```

आपके पास एक से अधिक args या एक से अधिक kwargs पैरामीटर नहीं हो सकते हैं (हालांकि उनकी आवश्यकता नहीं है)

 def func(*args1, *args2):
 #   File "<stdin>", line 1
 #     def test(*args1, *args2):
 #                      ^
 # SyntaxError: invalid syntax

 def test(**kwargs1, **kwargs2):
 #   File "<stdin>", line 1
 #     def test(**kwargs1, **kwargs2):
 #                       ^
 # SyntaxError: invalid syntax

यदि कोई भी स्थिति संबंधी तर्क *args का पालन करते हैं, तो वे केवल-केवल तर्क हैं जो केवल नाम से पारित किए जा सकते हैं। वेरिएबल पैरामीटर सूची प्रदान किए बिना मानों को तर्क वितर्क के लिए बाध्य करने के लिए *args बजाय एक एकल स्टार का उपयोग किया जा सकता है। कीवर्ड-ओनली पैरामीटर सूचियाँ केवल पायथन 3 में उपलब्ध हैं।
```
 def func(a, b, *args, x, y):
     print(a, b, args, x, y)

 func(1, 2, 3, 4, x=5, y=6)
 #>>> 1, 2, (3, 4), 5, 6
```
```
 def func(a, b, *, x, y):
     print(a, b, x, y)

 func(1, 2, x=5, y=6)
 #>>> 1, 2, 5, 6
```

**kwargs को पैरामीटर सूची में अंतिम स्थान पर आना चाहिए।

 def test(**kwargs, *args):
 #   File "<stdin>", line 1
 #     def test(**kwargs, *args):
 #                      ^
 # SyntaxError: invalid syntax

लेखन कार्य करते समय * आर्ग्स का उपयोग करना

जब आप सभी स्थैतिक (यानी अनाम नाम) तर्कों को एकत्रित करने के लिए फ़ंक्शन लिखते समय * स्टार का उपयोग कर सकते हैं:

def print_args(farg, *args):
   print("formal arg: %s" % farg)
   for arg in args:
       print("another positional arg: %s" % arg)

कॉलिंग विधि:

print_args(1, "two", 3)

उस कॉल में, Farg को हमेशा की तरह असाइन किया जाएगा, और दो अन्य लोगों को आर्गन्स ट्यूपल में खिलाया जाएगा, जिस क्रम में उन्हें प्राप्त किया गया था।

कार्य लिखते समय ** kwargs का उपयोग करना

आप एक फ़ंक्शन को परिभाषित कर सकते हैं जो एक पैरामीटर नाम से पहले डबल स्टार ** का उपयोग करके कीवर्ड (नामित) तर्कों की एक मनमानी संख्या लेता है:

def print_kwargs(**kwargs):
    print(kwargs)

विधि को कॉल करते समय, पायथन सभी कीवर्ड तर्कों का एक शब्दकोश तैयार करेगा और इसे फ़ंक्शन बॉडी में उपलब्ध कराएगा:

print_kwargs(a="two", b=3)
# prints: "{a: "two", b=3}"

ध्यान दें कि फ़ंक्शन परिभाषा में ** kwargs पैरामीटर हमेशा अंतिम पैरामीटर होना चाहिए, और यह केवल उन तर्कों से मेल खाएगा जो पिछले वाले के बाद पारित किए गए थे।

def example(a, **kw):
    print kw

example(a=2, b=3, c=4) # => {'b': 3, 'c': 4}

फ़ंक्शन बॉडी के अंदर, kwargs को एक शब्दकोश के रूप में उसी तरह से हेरफेर किया जाता है; में अलग-अलग तत्वों तक पहुंचने के लिए kwargs तुम सिर्फ उन के माध्यम से पाश आप एक सामान्य शब्दकोश के साथ होता है के रूप में:

def print_kwargs(**kwargs):
    for key in kwargs:
        print("key = {0}, value = {1}".format(key, kwargs[key]))

अब, print_kwargs(a="two", b=1) कॉल करना निम्न आउटपुट दिखाता है:

print_kwargs(a = "two", b = 1)
key = a, value = "two"
key = b, value = 1

कॉलिंग फ़ंक्शन का उपयोग करते हुए * आर्ग्स

फंक्शन डेफिनिशन में *args लिए एक सामान्य उपयोग का मामला प्रोसेसिंग को एक रैपिड या इनहेरिटेड फंक्शन को सौंपना है। एक विशिष्ट उदाहरण एक वर्ग की __init__ विधि में हो सकता है

class A(object):
    def __init__(self, b, c):
        self.y = b
        self.z = c

class B(A):
    def __init__(self, a, *args, **kwargs):
        super(B, self).__init__(*args, **kwargs)
        self.x = a

यहां, a पैरामीटर को चाइल्ड क्लास द्वारा संसाधित किया जाता है, जब अन्य सभी तर्कों (स्थिति और कीवर्ड) को पारित कर दिया जाता है - और बेस क्लास द्वारा संसाधित किया जाता है।

उदाहरण के लिए:

b = B(1, 2, 3)
b.x  # 1
b.y  # 2
b.z  # 3

यहाँ क्या होता है वर्ग B __init__ फ़ंक्शन 1, 2, 3 देखता है। यह जानता है कि इसे एक स्थिति तर्क ( a ) लेने की आवश्यकता है, इसलिए यह पहला तर्क पास करता है ( 1 ), इसलिए फ़ंक्शन के दायरे में a == 1 ।

इसके बाद, यह देखता है कि इसे अनियंत्रित संख्या में स्थितीय तर्क ( *args ) लेने की आवश्यकता है, इसलिए यह ( 1, 2 ) में पारित किए गए शेष *args तर्कों को लेता है और उन्हें *args । अब (फ़ंक्शन के दायरे में) args == [2, 3] ।

फिर, यह कहता है वर्ग A 's __init__ साथ समारोह *args । अजगर आर्ग के सामने * देखता है और तर्कों में सूची को "अनपैक" करता है। इस उदाहरण में, जब वर्ग B 's __init__ फ़ंक्शन को कॉल वर्ग A के __init__ समारोह है, यह तर्क पारित हो जाएगा 2, 3 (यानी A(2, 3) )।

अंत में, यह अपनी x प्रॉपर्टी को पहले स्थितीय तर्क a सेट करता a , जो 1 बराबर होता है।

कॉलिंग फ़ंक्शन का उपयोग करते हुए ** kwargs

आप फ़ंक्शन के मापदंडों के लिए मान निर्दिष्ट करने के लिए एक शब्दकोश का उपयोग कर सकते हैं; शब्दकोश में कुंजी के रूप में पैरामीटर नाम का उपयोग करना और प्रत्येक कुंजी के लिए बाध्य इन तर्कों के मूल्य:

def test_func(arg1, arg2, arg3): # Usual function with three arguments
   print("arg1: %s" % arg1)
   print("arg2: %s" % arg2)
   print("arg3: %s" % arg3)

# Note that dictionaries are unordered, so we can switch arg2 and arg3. Only the names matter.
kwargs = {"arg3": 3, "arg2": "two"}

# Bind the first argument (ie. arg1) to 1, and use the kwargs dictionary to bind the others
test_var_args_call(1, **kwargs)

कॉलिंग फ़ंक्शन का उपयोग करते हुए * आर्ग्स

किसी फ़ंक्शन को कॉल करते समय एक तर्क पर * ऑपरेटर का उपयोग करने का प्रभाव सूची को अलग करना या एक तुच्छ तर्क है

def print_args(arg1, arg2):
    print(str(arg1) + str(arg2))

a = [1,2]
b = tuple([3,4])

print_args(*a)
# 12
print_args(*b)
# 34

ध्यान दें कि तारांकित तर्क की लंबाई फ़ंक्शन के तर्कों की संख्या के बराबर होनी चाहिए।

एक आम अजगर मुहावरे को इसके प्रभावों को उलटने के लिए zip फ़ंक्शन के साथ अनपैकिंग ऑपरेटर * का उपयोग करना है:

a = [1,3,5,7,9]
b = [2,4,6,8,10]

zipped = zip(a,b)
# [(1,2), (3,4), (5,6), (7,8), (9,10)]

zip(*zipped)
# (1,3,5,7,9), (2,4,6,8,10)

कीवर्ड-केवल और कीवर्ड-आवश्यक तर्क

पायथन 3 आपको फ़ंक्शन तर्कों को परिभाषित करने की अनुमति देता है जो केवल डिफ़ॉल्ट मानों के बिना, कीवर्ड द्वारा सौंपा जा सकता है। यह कीवर्ड पैरामीटर सेट किए बिना अतिरिक्त स्थितीय मापदंडों का उपभोग करने के लिए स्टार * का उपयोग करके किया जाता है। * के बाद सभी तर्क केवल कीवर्ड (यानी गैर-स्थिति) तर्क हैं। ध्यान दें कि यदि कीवर्ड-केवल तर्कों को डिफ़ॉल्ट नहीं दिया गया है, तो फ़ंक्शन को कॉल करते समय उन्हें अभी भी आवश्यक है।

def print_args(arg1, *args, keyword_required, keyword_only=True):
    print("first positional arg: {}".format(arg1))
    for arg in args:
        print("another positional arg: {}".format(arg))
    print("keyword_required value: {}".format(keyword_required))
    print("keyword_only value: {}".format(keyword_only))
    
print(1, 2, 3, 4) # TypeError: print_args() missing 1 required keyword-only argument: 'keyword_required'
print(1, 2, 3, keyword_required=4) 
# first positional arg: 1
# another positional arg: 2
# another positional arg: 3
# keyword_required value: 4
# keyword_only value: True

एक शब्दकोश के साथ kwarg मूल्यों को आबाद करना

def foobar(foo=None, bar=None):
    return "{}{}".format(foo, bar)

values = {"foo": "foo", "bar": "bar"}

foobar(**values) # "foobar"

** kwargs और डिफ़ॉल्ट मान

** kwargs के साथ डिफ़ॉल्ट मानों का उपयोग करने के लिए

def fun(**kwargs):
    print kwargs.get('value', 0)

fun()
# print 0
fun(value=1)
# print 1

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow