पायथन में * आर्ग्स और ** क्वार्ग्स क्या हैं?

कार्य जीवन हैं। सच? यदि आपने अभी-अभी पायथन सीखना शुरू किया है, तो यह मायने नहीं रखता है कि यह आपकी पहली प्रोग्रामिंग भाषा है, या आप किसी अन्य भाषा से पायथन में आए हैं, तो आप पहले से ही जानते हैं कि फ़ंक्शन घोषणा में मापदंडों की संख्या उस तर्क से मेल खाती है जो फ़ंक्शन को कॉल करने पर गुजरती है।



ये मूल बातें हैं। यह वही है जो लोगों को उनके आसपास की दुनिया को समझने में मदद करता है। लेकिन बयान "मापदंडों की संख्या तर्कों की संख्या के बराबर है" शुरुआती के सिर में एक समय बम लगाती है, जो फ़ंक्शन घोषणा में रहस्यमय *args या **kwargs निर्माण देखने के बाद आग लगाती है।

किसी भी बैज को आपको एक बेवकूफ़ में नहीं चलने दें। यहां कुछ भी पुरातन नहीं है। सामान्य तौर पर, यदि ये डिज़ाइन आपके लिए अपरिचित हैं, तो मेरा सुझाव है कि आप उनसे निपटें।

स्थिति और नामित तर्क

*args और **kwargs से निपटने के लिए, हमें स्थिति और नामित तर्कों की अवधारणाओं को मास्टर करने की आवश्यकता है।

सबसे पहले, आइए बात करते हैं कि वे कैसे भिन्न हैं। सरलतम फ़ंक्शन में, हम बस तर्कों और मापदंडों के पदों को मैप करते हैं। तर्क नंबर 1 पैरामीटर नंबर 1, तर्क नंबर 2 से पैरामीटर नंबर 2, और इसी तरह से मेल खाता है।

 def printThese(a,b,c):   print(a, "is stored in a")   print(b, "is stored in b")   print(c, "is stored in c") printThese(1,2,3) """ 1 is stored in a 2 is stored in b 3 is stored in c """ 

किसी फ़ंक्शन को कॉल करने के लिए, तीनों तर्कों की आवश्यकता होती है। यदि आप उनमें से कम से कम एक को छोड़ते हैं, तो एक त्रुटि संदेश प्रदर्शित होगा।

 def printThese(a,b,c):   print(a, "is stored in a")   print(b, "is stored in b")   print(c, "is stored in c") printThese(1,2) """ TypeError: printThese() missing 1 required positional argument: 'c' """ 

यदि आप फ़ंक्शन की घोषणा करते समय पैरामीटर को एक डिफ़ॉल्ट मान असाइन करते हैं, तो फ़ंक्शन को कॉल करते समय संबंधित तर्क को इंगित करना आवश्यक नहीं है। पैरामीटर वैकल्पिक हो जाता है।

 def printThese(a,b,c=None):   print(a, "is stored in a")   print(b, "is stored in b")   print(c, "is stored in c") printThese(1,2) """ 1 is stored in a 2 is stored in b None is stored in c """ 

उनके नाम का उपयोग करके फ़ंक्शन को कॉल करते समय वैकल्पिक पैरामीटर भी सेट किए जा सकते हैं।

निम्नलिखित उदाहरण में, हम तीन मापदंडों को None के डिफ़ॉल्ट मान पर सेट करते हैं और देखते हैं कि फ़ंक्शन को कॉल करते समय उपयोग किए गए तर्कों के क्रम पर ध्यान न देते हुए उनके नाम का उपयोग करके उन्हें कैसे सौंपा जा सकता है।

 def printThese(a=None,b=None,c=None):   print(a, "is stored in a")   print(b, "is stored in b")   print(c, "is stored in c") printThese(c=3, a=1) """ 1 is stored in a None is stored in b 3 is stored in c """ 

तारक संचालक

* ऑपरेटर अक्सर लोगों में गुणा के संचालन से जुड़ा होता है, लेकिन पायथन में इसका एक और अर्थ है।

यह ऑपरेटर आपको उन वस्तुओं को "अनपैक" करने की अनुमति देता है जिनके अंदर कुछ तत्व संग्रहीत होते हैं। यहाँ एक उदाहरण है:

 a = [1,2,3] b = [*a,4,5,6] print(b) # [1,2,3,4,5,6] 

यहां, सूची की सामग्री को a , अनपैक किया गया है और सूची b पर रखा गया है।

कैसे उपयोग करने के लिए * आर्ग और ** kwargs

तो, हम जानते हैं कि पायथन में "तारांकन" ऑपरेटर वस्तुओं से उनके घटक तत्वों को "बाहर" निकालने में सक्षम है। हम यह भी जानते हैं कि दो प्रकार के पैरामीटर फ़ंक्शन हैं। यह संभव है कि आपने पहले से ही खुद के बारे में सोचा था, लेकिन सिर्फ मामले में, मैं यह कहूंगा। अर्थात्, *args "तर्कों" (तर्कों) के लिए एक संक्षिप्त नाम है, और ** कवर्स "कीवर्ड तर्कों" (तर्कों का नाम) के लिए एक संक्षिप्त नाम है।

इनमें से प्रत्येक निर्माण का उपयोग संबंधित प्रकार के तर्कों को अनपैक करने के लिए किया जाता है, जिससे आप फ़ंक्शन को चर लंबाई के तर्कों की सूची के साथ कॉल कर सकते हैं। उदाहरण के लिए - एक फ़ंक्शन बनाएं जो एक छात्र द्वारा परीक्षा में टाइप किए गए परिणाम प्रदर्शित कर सकता है:

 def printScores(student, *scores):   print(f"Student Name: {student}")   for score in scores:      print(score) printScores("Jonathan",100, 95, 88, 92, 99) """ Student Name: Jonathan 100 95 88 92 99 """ 

मैंने फ़ंक्शन की घोषणा करते समय *args कंस्ट्रक्शन का उपयोग नहीं किया। इसके बजाय, मेरे पास *scores । क्या यहाँ कोई त्रुटि है? यहां कोई गलती नहीं है। तथ्य यह है कि "आर्ग्स" सिर्फ अक्षरों का एक सेट है जो तर्कों को निरूपित करने के लिए उपयोग किया जाता है। यहां सबसे महत्वपूर्ण बात * ऑपरेटर है। और इसके बाद जो आता है वह विशेष भूमिका नहीं निभाता है। * का उपयोग करते हुए * हमने उस स्थिति के आधार पर स्थिति संबंधी तर्कों की एक सूची बनाई * जो उस फ़ंक्शन को दी गई थी जब उसे बुलाया गया था।

हम पता लगाने के बाद *args , **kwargs को समझने में कोई समस्या नहीं होनी चाहिए। नाम, फिर से, कोई फर्क नहीं पड़ता। मुख्य बात दो वर्ण ** । उनके लिए धन्यवाद, एक शब्दकोश बनाया जाता है जिसमें फ़ंक्शन के पास नामांकित तर्क होते हैं जब इसे कहा जाता है।

 def printPetNames(owner, **pets):   print(f"Owner Name: {owner}")   for pet,name in pets.items():      print(f"{pet}: {name}") printPetNames("Jonathan", dog="Brock", fish=["Larry", "Curly", "Moe"], turtle="Shelldon") """ Owner Name: Jonathan dog: Brock fish: ['Larry', 'Curly', 'Moe'] turtle: Shelldon """ 

परिणाम

कार्यों के साथ काम करने और अपने ज्ञान का विस्तार करने पर आने वाली आम समस्याओं से बचने में आपकी मदद करने के लिए यहां कुछ सुझाव दिए गए हैं:

• स्थितीय और नामित तर्कों को पकड़ने के लिए आम *args और **kwargs निर्माण का उपयोग करें।
• **kwarg *args से पहले नहीं रखा जा सकता है। यदि आप ऐसा करते हैं, तो एक त्रुटि संदेश प्रदर्शित किया जाएगा।
• नाम के मापदंडों और **kwargs बीच संघर्ष से सावधान रहें, ऐसे मामलों में जब मूल्य को **kwarg तर्क के रूप में पारित करने की योजना बनाई **kwarg है, लेकिन इस मूल्य का प्रमुख नाम नामित पैरामीटर के नाम से मेल खाता है।
• * ऑपरेटर का उपयोग न केवल फ़ंक्शन घोषणाओं में किया जा सकता है, बल्कि जब कहा जाता है।

प्रिय पाठकों! पायथन फ़ंक्शंस की घोषणा करते समय आप सबसे अधिक किन मापदंडों का उपयोग करते हैं?