फंक्शन कॉल में स्टार ऑपरेटर का क्या मतलब है?

Question 1

*पायथन में ऑपरेटर का क्या मतलब है, जैसे कोड में zip(*x)या f(**k)?

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

Question 2

सिंगल स्टार *सीक्वेंस / कलेक्शन को पॉजिटिव आर्ग्युमेंट्स में अनपैक करता है, इसलिए आप ऐसा कर सकते हैं:

def sum(a, b):
    return a + b

values = (1, 2)

s = sum(*values)

यह टपल को अनपैक करेगा ताकि वह वास्तव में इस प्रकार निष्पादित हो:

s = sum(1, 2)

डबल स्टार **एक ही करता है, केवल एक शब्दकोश का उपयोग करता है और इस प्रकार नाम तर्क देता है:

values = { 'a': 1, 'b': 2 }
s = sum(**values)

आप भी जोड़ सकते हैं:

def sum(a, b, c, d):
    return a + b + c + d

values1 = (1, 2)
values2 = { 'c': 10, 'd': 15 }
s = sum(*values1, **values2)

के रूप में निष्पादित करेगा:

s = sum(1, 2, c=10, d=15)

इसके अलावा खंड ४.२.४ देखें - पायथन प्रलेखन की अनप्लगिंग सूची ।

इसके अतिरिक्त, आप कार्यों को लेने *xऔर **yबहस करने के लिए परिभाषित कर सकते हैं , यह फ़ंक्शन को किसी भी स्थिति और / या नामित तर्कों को स्वीकार करने की अनुमति देता है जो विशेष रूप से घोषणा में नामित नहीं हैं।

उदाहरण:

def sum(*values):
    s = 0
    for v in values:
        s = s + v
    return s

s = sum(1, 2, 3, 4, 5)

या साथ **:

def get_a(**values):
    return values['a']

s = get_a(a=1, b=2)      # returns 1

यह आपको उन्हें घोषित किए बिना बड़ी संख्या में वैकल्पिक मापदंडों को निर्दिष्ट करने की अनुमति दे सकता है।

और फिर से, आप गठबंधन कर सकते हैं:

def sum(*values, **options):
    s = 0
    for i in values:
        s = s + i
    if "neg" in options:
        if options["neg"]:
            s = -s
    return s

s = sum(1, 2, 3, 4, 5)            # returns 15
s = sum(1, 2, 3, 4, 5, neg=True)  # returns -15
s = sum(1, 2, 3, 4, 5, neg=False) # returns 15

Question 3

एक छोटा बिंदु: ये ऑपरेटर नहीं हैं। ऑपरेटर्स का उपयोग मौजूदा मानों से नए मान बनाने के लिए अभिव्यक्तियों में किया जाता है (उदाहरण के लिए 1 + 2 3 हो जाता है। * * और ** यहां फ़ंक्शन डिक्लेरेशन और कॉल के सिंटैक्स का हिस्सा हैं।

Question 4

जब आप फ़ंक्शन कॉल करना चाहते हैं तो मुझे यह विशेष रूप से उपयोगी लगता है।

उदाहरण के लिए, मान लीजिए कि एक फंक्शन 'ऐड' के लिए मेरे पास कुछ यूनिट टेस्ट हैं:

def add(a, b): return a + b
tests = { (1,4):5, (0, 0):0, (-1, 3):3 }
for test, result in tests.items():
   print 'test: adding', test, '==', result, '---', add(*test) == result

ऐड को कॉल करने का कोई अन्य तरीका नहीं है, मैन्युअल रूप से ऐड (टेस्ट [0], टेस्ट [1]) जैसे कुछ करने के अलावा, जो बदसूरत है। इसके अलावा, यदि कोई चर संख्या होती है, तो कोड उन सभी इफ-स्टेटमेंट्स के साथ बहुत बदसूरत हो सकता है।

एक और जगह यह उपयोगी है फैक्ट्री ऑब्जेक्ट्स को परिभाषित करने के लिए (ऑब्जेक्ट जो आपके लिए ऑब्जेक्ट बनाते हैं)। मान लीजिए कि आपके पास कुछ क्लास फैक्ट्री है, जो कार ऑब्जेक्ट बनाती है और उन्हें वापस करती है। आप इसे ऐसा बना सकते हैं कि myFactory.make_car ('red', 'bmw', '335ix') Car ('red', 'bmw', '335ix') बनाता है, फिर उसे लौटाता है।

def make_car(*args):
   return Car(*args)

यह तब भी उपयोगी है जब आप सुपरक्लास के कंस्ट्रक्टर को बुलाना चाहते हैं।

Question 5

इसे विस्तारित कॉल सिंटैक्स कहा जाता है। से प्रलेखन :

यदि फ़ंक्शन कॉल में वाक्य रचना * अभिव्यक्ति दिखाई देती है, तो अभिव्यक्ति को एक अनुक्रम का मूल्यांकन करना चाहिए। इस क्रम के तत्वों को ऐसे माना जाता है जैसे कि वे अतिरिक्त स्थैतिक तर्क थे; अगर वहाँ स्थितीय तर्क हैं X1, ..., xN, और अभिव्यक्ति एक अनुक्रम y1, ..., yM का मूल्यांकन करता है, तो यह M + N स्थितीय तर्कों X1, ..., xN, y1, के साथ एक कॉल के बराबर है। .., वाई.एम.

तथा:

यदि फ़ंक्शन कॉल में वाक्य रचना ** अभिव्यक्ति दिखाई देती है, तो अभिव्यक्ति को एक मैपिंग का मूल्यांकन करना चाहिए, जिसकी सामग्री को अतिरिक्त कीवर्ड तर्क के रूप में माना जाता है। एक अभिव्यक्ति के रूप में और एक स्पष्ट खोजशब्द तर्क के रूप में प्रदर्शित होने वाले कीवर्ड के मामले में, TypeError अपवाद उठाया जाता है।

Question 6

एक फ़ंक्शन कॉल में सिंगल स्टार एक सूची को अलग-थलग तर्कों में बदल देता है (जैसे zip(*x)कि zip(x1,x2,x3)यदि ऐसा ही है x=[x1,x2,x3]) और डबल स्टार एक शब्द को अलग-अलग कीवर्ड तर्क में बदल देता है (जैसे f(**k)कि जैसा f(x=my_x, y=my_y)है k = {'x':my_x, 'y':my_y}।

एक फ़ंक्शन परिभाषा में यह चारों ओर का दूसरा तरीका है: एकल स्टार एक सूची में तर्कों की एक मनमानी संख्या को बदल देता है, और दोहरी शुरुआत एक शब्दकोश में कीवर्ड तर्कों की एक मनमानी संख्या में बदल जाती है। उदाहरण का def foo(*x)अर्थ है "foo एक मनमानी संख्या लेते हैं और वे सूची x (यानी यदि उपयोगकर्ता कहता है foo(1,2,3), xहोगा [1,2,3]) के माध्यम से पहुंच योग्य होगा " और def bar(**k)इसका अर्थ है "बार एक मनमानी संख्या में कीवर्ड तर्क लेता है और वे शब्दकोश k के माध्यम से सुलभ होंगे (यानी यदि उपयोगकर्ता कॉल करता है bar(x=42, y=23), तो kहोगा {'x': 42, 'y': 23}) "।