पायथन फ़ंक्शन परिभाषाओं में *args और **kwargs को समझना

पायथन के फ़ंक्शन पैरामीटर्स की खोज

पायथन में, लचीले और गतिशील कार्यों को लिखने के लिए *args और kwargs के उपयोग को समझना महत्वपूर्ण है। ये विशेष सिंटैक्स तत्व डेवलपर्स को किसी फ़ंक्शन में चर संख्या में तर्क पारित करने की अनुमति देते हैं, जिससे कोड अधिक पुन: प्रयोज्य और कुशल हो जाता है।

इस लेख में, हम यह पता लगाएंगे कि फ़ंक्शन पैरामीटर में उपयोग किए जाने पर * (सिंगल स्टार) और (डबल स्टार) प्रतीकों का क्या मतलब है। हम आपके कोड में विभिन्न परिदृश्यों को संभालने के लिए *args और kwargs का उपयोग करने के व्यावहारिक उदाहरण भी देखेंगे।

आज्ञा	विवरण
*args	किसी फ़ंक्शन को स्थितीय तर्कों की एक परिवर्तनीय संख्या को स्वीकार करने की अनुमति देता है। तर्कों को टुपल के रूप में पारित किया जाता है।
kwargs	किसी फ़ंक्शन को कीवर्ड तर्कों की एक परिवर्तनीय संख्या को स्वीकार करने की अनुमति देता है। तर्कों को शब्दकोश के रूप में पारित किया जाता है।
print()	निर्दिष्ट संदेश को कंसोल या अन्य मानक आउटपुट डिवाइस पर आउटपुट करता है।
get()	किसी शब्दकोश से निर्दिष्ट कुंजी से संबद्ध मान पुनर्प्राप्त करता है। यदि कुंजी नहीं मिलती है तो एक डिफ़ॉल्ट मान लौटाता है।
join()	एक निर्दिष्ट विभाजक के साथ, पुनरावृत्त के तत्वों (उदाहरण के लिए, सूची या टुपल) को एक स्ट्रिंग में जोड़ता है।
f-string	एक स्वरूपित स्ट्रिंग शाब्दिक जो रनटाइम पर घुंघराले ब्रेसिज़ के अंदर अभिव्यक्तियों का मूल्यांकन करने की अनुमति देता है।

पायथन में *आर्ग्स और क्वार्ग्स में गहराई से उतरें

प्रदान की गई स्क्रिप्ट दर्शाती है कि कैसे उपयोग करना है और पायथन फ़ंक्शन परिभाषाओं में। पहली स्क्रिप्ट एक फ़ंक्शन को परिभाषित करती है इसमें दो आवश्यक तर्क लगते हैं, x और , इसके बाद किसी भी संख्या में अतिरिक्त स्थितीय तर्क प्रस्तुत किए जाते हैं . कॉल करते समय अतिरिक्त तर्कों के साथ, इन्हें टपल के रूप में कैप्चर किया जाता है और मुद्रित किया जाता है। यह फ़ंक्शन को अलग-अलग संख्या में तर्कों को खूबसूरती से संभालने की अनुमति देता है। दूसरा कार्य, bar, दो आवश्यक तर्क और किसी भी संख्या में कीवर्ड तर्क स्वीकार करता है . ये कीवर्ड तर्क एक शब्दकोश में एकत्र किए जाते हैं, जो फ़ंक्शन को लचीले नामित इनपुट को संसाधित करने में सक्षम बनाता है।

दूसरा उदाहरण स्क्रिप्ट परिचय देता है और के उपयोग को और स्पष्ट करने का कार्य करता है और kwargs. स्थितिगत और कीवर्ड दोनों तर्कों को प्रिंट करता है, उनके संग्रह को क्रमशः टुपल्स और शब्दकोशों में प्रदर्शित करता है। फ़ंक्शन एक व्यावहारिक उपयोग के मामले पर प्रकाश डालता है वैकल्पिक कीवर्ड तर्कों की अनुमति देता है, जैसे अनुकूलन योग्य शुभकामना संदेश। लाभ उठाकर get() पर शब्दकोश, जब ग्रीटिंग कीवर्ड की आपूर्ति नहीं की जाती है तो फ़ंक्शन एक डिफ़ॉल्ट मान प्रदान कर सकता है, जो वास्तविक दुनिया के परिदृश्यों में इन संरचनाओं का उपयोग करने के लचीलेपन और शक्ति को प्रदर्शित करता है।

def foo(x, y, *args):
    print("Required arguments:", x, y)
    print("Additional arguments:", args)

def bar(x, y, kwargs):
    print("Required arguments:", x, y)
    print("Keyword arguments:", kwargs)

foo(1, 2, 3, 4, 5)
# Output:
# Required arguments: 1 2
# Additional arguments: (3, 4, 5)

bar(1, 2, a=3, b=4, c=5)
# Output:
# Required arguments: 1 2
# Keyword arguments: {'a': 3, 'b': 4, 'c': 5}

def example_function(*args, kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

example_function(1, 2, 3, a="apple", b="banana")
# Output:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {'a': 'apple', 'b': 'banana'}

def greet(name, *args, kwargs):
    greeting = kwargs.get('greeting', 'Hello')
    print(f"{greeting}, {name}!")
    if args:
        print("Additional names:", ', '.join(args))

greet("Alice")
# Output: Hello, Alice!

greet("Alice", "Bob", "Charlie", greeting="Hi")
# Output:
# Hi, Alice!
# Additional names: Bob, Charlie

*आर्ग्स और क्वार्ग्स का उन्नत उपयोग

बुनियादी उदाहरणों से परे, और उन्नत पायथन प्रोग्रामिंग में अविश्वसनीय रूप से शक्तिशाली उपकरण हो सकते हैं। एक उन्नत उपयोग का मामला फ़ंक्शन डेकोरेटर्स में है। डेकोरेटर उनके वास्तविक कोड को बदले बिना कार्यों या विधियों को संशोधित करने या बढ़ाने का एक तरीका है। का उपयोग करके और kwargs, डेकोरेटर्स को किसी भी संख्या में तर्कों के साथ काम करने के लिए लिखा जा सकता है, जिससे वे बेहद लचीले और पुन: प्रयोज्य बन जाते हैं। उदाहरण के लिए, एक लॉगिंग डेकोरेटर किसी भी फ़ंक्शन को स्वीकार कर सकता है, उसके तर्कों को लॉग कर सकता है और मान लौटा सकता है, और फिर उन तर्कों को मूल फ़ंक्शन का उपयोग करके पास कर सकता है और . यह डेकोरेटर को बिना किसी संशोधन के विभिन्न हस्ताक्षरों के कार्यों के साथ उपयोग करने की अनुमति देता है।

एक अन्य उन्नत अनुप्रयोग वर्ग विधियों और वंशानुक्रम के संदर्भ में है। बेस क्लास विधि को परिभाषित करते समय जो उपयोग करता है और , व्युत्पन्न कक्षाएं इस पद्धति को ओवरराइड कर सकती हैं और फिर भी अतिरिक्त तर्कों को स्पष्ट रूप से सूचीबद्ध किए बिना स्वीकार कर सकती हैं। यह कोड रखरखाव को सरल बना सकता है और लचीलेपन को बढ़ा सकता है, क्योंकि बेस क्लास को सभी संभावित तर्कों को पहले से जानने की आवश्यकता नहीं है। आगे, और kwargs इसका उपयोग मूल वर्ग विधियों में तर्कों को अग्रेषित करने के लिए किया जा सकता है, यह सुनिश्चित करते हुए कि इसके व्यवहार को विस्तारित या संशोधित करते समय बेस क्लास की पूर्ण कार्यक्षमता बरकरार रखी जाती है।

1. क्या हैं ?
2. इनका उपयोग किसी फ़ंक्शन में स्थितीय तर्कों की एक चर संख्या को पारित करने के लिए किया जाता है।
3. क्या हैं ?
4. वे आपको किसी फ़ंक्शन में चर संख्या में कीवर्ड तर्क पारित करने की अनुमति देते हैं।
5. क्या मैं उपयोग कर सकता हूँ और एक साथ?
6. हां, आप स्थितीय और कीवर्ड तर्कों के किसी भी संयोजन को संभालने के लिए एक ही फ़ंक्शन में दोनों का उपयोग कर सकते हैं।
7. मैं पारित तर्कों तक कैसे पहुँच सकता हूँ? ?
8. वे फ़ंक्शन के भीतर टपल के रूप में पहुंच योग्य हैं।
9. मैं पारित तर्कों तक कैसे पहुँच सकता हूँ? ?
10. वे फ़ंक्शन के भीतर एक शब्दकोश के रूप में पहुंच योग्य हैं।
11. मैं क्यों उपयोग करूंगा ?
12. किसी फ़ंक्शन को किसी भी संख्या में स्थितीय तर्कों को स्वीकार करने की अनुमति देना, जिससे उसका लचीलापन बढ़ जाता है।
13. मैं क्यों उपयोग करूंगा ?
14. किसी भी संख्या में कीवर्ड तर्क स्वीकार करना, जो फ़ंक्शन को अधिक बहुमुखी बना सकता है।
15. कर सकना और अलग नाम दिया जाए?
16. हां, नाम परंपरागत हैं, लेकिन आप उन्हें अपनी पसंद के अनुसार कुछ भी नाम दे सकते हैं।
17. प्रयोग करने का व्यावहारिक उदाहरण क्या है? ?
18. किसी फ़ंक्शन में एकाधिक मान पास करना जो उन्हें सारांशित करता है।
19. प्रयोग करने का व्यावहारिक उदाहरण क्या है? ?
20. एक फ़ंक्शन बनाना जो कीवर्ड तर्कों से एक शब्दकोश बनाता है।

*आर्ग्स और क्वार्ग्स के साथ रैपिंग अप

समझना और उपयोग करना और पायथन फ़ंक्शंस में आपके प्रोग्रामिंग कौशल में काफी सुधार हो सकता है। ये उपकरण फ़ंक्शन परिभाषाओं में उच्च स्तर का लचीलापन प्रदान करते हैं, जिससे आप अधिक गतिशील और पुन: प्रयोज्य कोड लिख सकते हैं। इन अवधारणाओं में महारत हासिल करके, आप अपने कार्यों में तर्कों की एक विस्तृत श्रृंखला को संभाल सकते हैं, जिससे आपका कोड अधिक अनुकूलनीय और बनाए रखने में आसान हो जाता है।

चाहे आप डेकोरेटर लिख रहे हों, कक्षाओं में विरासत को संभाल रहे हों, या बस अज्ञात संख्या में तर्क पारित करना चाहते हों, और आवश्यक कार्यक्षमता प्रदान करें. इन सुविधाओं की पूरी क्षमता को उजागर करने और अधिक कुशल और शक्तिशाली पायथन प्रोग्रामिंग के लिए उन्हें अपनी कोडिंग प्रथाओं में एकीकृत करने के लिए उनके साथ प्रयोग करते रहें।