Python Functions: फ़ंक्शन्स को कैसे कॉल और लिखें

पुन: उपयोग योग्य और कुशल Python फ़ंक्शन्स लिखना सीखें। पैरामीटर्स, return स्टेटमेंट्स, और lambda जैसे उन्नत विषयों में महारत हासिल करें। main() और अन्य श्रेष्ठ तरीकों से अपना कोड बेहतर ढंग से व्यवस्थित करें।

अद्यतन 18 मई 2026 · 14 मि॰ पढ़ना

डेटाकैम्प के साथ करियर-बिल्डिंग Python स्किल्स बैनर

फ़ंक्शन्स Python प्रोग्रामिंग भाषा का एक अनिवार्य हिस्सा हैं: संभव है कि आपने पहले ही Python भाषा में मौजूद कई बेहतरीन बिल्ट-इन फ़ंक्शन्स का या इसकी लाइब्रेरी इकोसिस्टम के साथ आने वाले फ़ंक्शन्स का उपयोग किया हो। फिर भी, एक डेटा वैज्ञानिक के रूप में, आपको अपने डेटा से उत्पन्न समस्याओं को हल करने के लिए बार-बार अपने स्वयं के फ़ंक्शन्स लिखने होंगे।

यह ट्यूटोरियल Python 3 सिंटैक्स का उपयोग करता है। सभी उदाहरण Python 3.10+ पर काम करते हैं और आधुनिक कन्वेंशन्स (f-strings, type hints, positional-only और keyword-only पैरामीटर्स) को प्रतिबिंबित करने के लिए अपडेट किए गए हैं। मौजूदा स्थिर रिलीज Python 3.14 है।

इस ट्यूटोरियल के सभी उदाहरण कोड को खुद आसानी से चलाने के लिए, आप मुफ़्त में एक DataLab वर्कबुक बना सकते हैं, जिसमें Python पहले से इंस्टॉल होता है और सभी कोड सैंपल शामिल होते हैं। Python फ़ंक्शन्स लिखने का और अभ्यास करने के लिए, यह हैंड्स-ऑन DataCamp अभ्यास देखें या हमारा Python Data Science Toolbox कोर्स आज़माएँ!

Python में फ़ंक्शन्स

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

Python में फ़ंक्शन्स के तीन प्रकार होते हैं:

बिल्ट-इन फ़ंक्शन्स, जैसे help() मदद के लिए, min() न्यूनतम मान पाने के लिए, print() किसी ऑब्जेक्ट को टर्मिनल पर प्रिंट करने के लिए,… इन फ़ंक्शन्स का और अवलोकन आप यहाँ पा सकते हैं।
यूज़र-डिफ़ाइन्ड फ़ंक्शन्स (UDFs), जो उपयोगकर्ता अपनी ज़रूरत के अनुसार बनाते हैं; और
गुमनाम फ़ंक्शन्स, जिन्हें lambda फ़ंक्शन्स भी कहा जाता है क्योंकि इन्हें मानक def कीवर्ड से घोषित नहीं किया जाता।

फ़ंक्शन्स बनाम मेथड्स

मेथड किसी क्लास का हिस्सा होने वाला फ़ंक्शन होता है। आप इसे उस क्लास के किसी इंस्टेंस या ऑब्जेक्ट से एक्सेस करते हैं। फ़ंक्शन पर यह पाबंदी नहीं होती: यह एक स्टैंडअलोन फ़ंक्शन होता है। यानी, सभी मेथड्स फ़ंक्शन्स हैं, लेकिन सभी फ़ंक्शन्स मेथड्स नहीं होते।

यह उदाहरण देखें, जहाँ आप पहले plus() नाम का फ़ंक्शन परिभाषित करते हैं और फिर Summation क्लास जिसमें sum() मेथड है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGEgZnVuY3Rpb24gYHBsdXMoKWBcbmRlZiBwbHVzKGEsYik6XG4gIHJldHVybiBhICsgYlxuICBcbiMgQ3JlYXRlIGEgYFN1bW1hdGlvbmAgY2xhc3NcbmNsYXNzIFN1bW1hdGlvbihvYmplY3QpOlxuICBkZWYgc3VtKHNlbGYsIGEsIGIpOlxuICAgIHNlbGYuY29udGVudHMgPSBhICsgYlxuICAgIHJldHVybiBzZWxmLmNvbnRlbnRzICJ9

अब अगर आप Summation क्लास के हिस्से sum() मेथड को कॉल करना चाहते हैं, तो पहले आपको उस क्लास का एक इंस्टेंस या ऑब्जेक्ट बनाना होगा। तो, ऐसा एक ऑब्जेक्ट परिभाषित करते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZGVmIHBsdXMoYSxiKTpcbiAgcmV0dXJuIGEgKyBiXG4gIFxuY2xhc3MgU3VtbWF0aW9uKG9iamVjdCk6XG4gIGRlZiBzdW0oc2VsZiwgYSwgYik6XG4gICAgc2VsZi5jb250ZW50cyA9IGEgKyBiXG4gICAgcmV0dXJuIHNlbGYuY29udGVudHMgIiwic2FtcGxlIjoiIyBJbnN0YW50aWF0ZSBgU3VtbWF0aW9uYCBjbGFzcyB0byBjYWxsIGBzdW0oKWBcbnN1bUluc3RhbmNlID0gU3VtbWF0aW9uKClcbnN1bUluc3RhbmNlLnN1bSgxLDIpIn0=

याद रखें कि plus() फ़ंक्शन को कॉल करने के लिए यह इंस्टैंशिएशन ज़रूरी नहीं है! आप DataCamp Light कोड चंक में बिना किसी समस्या के plus(1,2) चला पाएँगे!

पैरामीटर्स बनाम आर्ग्युमेंट्स

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

यह उदाहरण देखें और ऊपर दिए गए DataCamp Light चंक को याद करें: आप Summation क्लास के sum() मेथड को दो आर्ग्युमेंट्स पास करते हैं, जबकि आपने पहले तीन पैरामीटर्स परिभाषित किए थे: self, a और b।

self का क्या हुआ?

हर क्लास मेथड का पहला आर्ग्युमेंट हमेशा उस क्लास के मौजूदा इंस्टेंस का रेफ़रन्स होता है, जो इस मामले में Summation है। परंपरा के अनुसार, इस आर्ग्युमेंट को self कहा जाता है।

इसका मतलब यह है कि इस मामले में आप self का रेफ़रन्स पास नहीं करते, क्योंकि self वह पैरामीटर नाम है जिसके लिए आर्ग्युमेंट इम्प्लिसिटली पास होता है और उस इंस्टेंस को संदर्भित करता है जिसके माध्यम से मेथड को इनवोक किया जा रहा है। यह आर्ग्युमेंट सूची में स्वतः जोड़ा जाता है।

फ़ंक्शन कैसे परिभाषित करें: यूज़र-डिफ़ाइन्ड फ़ंक्शन्स (UDFs)

Python में फ़ंक्शन परिभाषित करने के चार चरण इस प्रकार हैं:

फ़ंक्शन घोषित करने के लिए def कीवर्ड का उपयोग करें और इसके बाद फ़ंक्शन का नाम लिखें।
फ़ंक्शन में पैरामीटर्स जोड़ें: वे फ़ंक्शन की कोष्ठकों में होने चाहिए। अपनी लाइन को कॉलन के साथ समाप्त करें।
वे स्टेटमेंट्स जोड़ें जिन्हें फ़ंक्शन को निष्पादित करना चाहिए।
यदि फ़ंक्शन को कुछ आउटपुट देना चाहिए तो उसे return स्टेटमेंट के साथ समाप्त करें। बिना return स्टेटमेंट के, आपका फ़ंक्शन None ऑब्जेक्ट लौटाएगा।

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImRlZiBoZWxsbygpOlxuICBwcmludChcIkhlbGxvIFdvcmxkXCIpIFxuICByZXR1cm4gIn0=

बेशक, जैसे-जैसे आप आगे बढ़ेंगे, आपके फ़ंक्शन्स और जटिल होते जाएँगे: आप इसमें for लूप, फ़्लो कंट्रोल, … आदि जोड़कर इसे और सूक्ष्म बना सकते हैं:

def hello():
    name = input("Enter your name: ")
    if name:
        print(f"Hello {name}")
    else:
        print("Hello World")

hello()

ऊपर वाले फ़ंक्शन में, आप यूज़र से नाम देने के लिए कहते हैं। अगर नाम नहीं दिया गया, तो फ़ंक्शन “Hello World” प्रिंट करेगा। अन्यथा, यूज़र को पर्सनलाइज़्ड “Hello” प्रतिक्रिया मिलेगी।

ध्यान रखें कि आप अपने UDF के लिए एक या अधिक फ़ंक्शन पैरामीटर्स भी परिभाषित कर सकते हैं। इसके बारे में आप “फ़ंक्शन आर्ग्युमेंट्स” सेक्शन में और सीखेंगे। इसके अलावा, आपका फ़ंक्शन एक या एक से अधिक वैल्यू लौटा सकता है या नहीं भी लौटा सकता है।

return स्टेटमेंट

ध्यान दें कि आप अपने UDF hello() में कुछ प्रिंट कर रहे हैं, इसलिए वास्तव में आपको उसे रिटर्न करने की ज़रूरत नहीं है। ऊपर दिए गए फ़ंक्शन और इस वाले में कोई अंतर नहीं होगा:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImRlZiBoZWxsb19ub3JldHVybigpOlxuICBwcmludChcIkhlbGxvIFdvcmxkXCIpICJ9

हालाँकि, यदि आप अपने फ़ंक्शन के परिणाम के साथ आगे काम करना चाहते हैं और उस पर कुछ ऑपरेशन्स आज़माना चाहते हैं, तो आपको वास्तव में कोई वैल्यू रिटर्न करने के लिए return स्टेटमेंट का उपयोग करना होगा, जैसे कि एक स्ट्रिंग, एक इंटीजर, …। यह परिदृश्य देखें, जहाँ hello() एक स्ट्रिंग "hello" लौटाता है, जबकि hello_noreturn() None लौटाता है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImRlZiBoZWxsbygpOlxuICBwcmludChcIkhlbGxvIFdvcmxkXCIpIFxuICByZXR1cm4oXCJoZWxsb1wiKVxuXG5kZWYgaGVsbG9fbm9yZXR1cm4oKTpcbiAgcHJpbnQoXCJIZWxsbyBXb3JsZFwiKVxuICBcbiMgTXVsdGlwbHkgdGhlIG91dHB1dCBvZiBgaGVsbG8oKWAgd2l0aCAyIFxuaGVsbG8oKSAqIDJcblxuIyAoVHJ5IHRvKSBtdWx0aXBseSB0aGUgb3V0cHV0IG9mIGBoZWxsb19ub3JldHVybigpYCB3aXRoIDIgXG5oZWxsb19ub3JldHVybigpICogMiJ9

दूसरा फ़ंक्शन आपको एरर देगा क्योंकि आप None के साथ कोई ऑपरेशन नहीं कर सकते। आपको एक TypeError मिलेगा, जो कहेगा कि आप NoneType (यानी hello_noreturn() के परिणाम None) और int (2) के लिए गुणा ऑपरेशन नहीं कर सकते।

टिप फ़ंक्शन्स जैसे ही return स्टेटमेंट पर पहुँचते हैं, वे तुरंत बाहर निकल जाते हैं, भले ही इसका मतलब यह हो कि वे कोई वैल्यू रिटर्न नहीं करेंगे:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImRlZiBydW4oKTpcbiAgZm9yIHggaW4gcmFuZ2UoMTApOlxuICAgICBpZiB4ID09IDI6XG4gICAgICAgcmV0dXJuXG4gIHByaW50KFwiUnVuIVwiKVxuICBcbnJ1 bigpIn0=

एक और महत्वपूर्ण बात यह है कि आप return स्टेटमेंट का उपयोग एक से अधिक वैल्यू लौटाने के लिए भी कर सकते हैं। ऐसा करने के लिए, आप tuples का उपयोग करते हैं।

याद रखें कि यह डेटा स्ट्रक्चर सूची के समान होता है: इसमें कई वैल्यू हो सकती हैं। हालाँकि, tuples अम्यूटेबल होते हैं, यानी आप इसमें संग्रहीत मानों को बदल नहीं सकते! आप इसे डबल कोष्ठकों () की मदद से बनाते हैं। आप कॉमा और असाइनमेंट ऑपरेटर की मदद से tuples को कई वेरिएबल्स में अनपैक कर सकते हैं।

निम्न उदाहरण देखें कि आपका फ़ंक्शन कई वैल्यू कैसे रिटर्न कर सकता है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGBwbHVzKClgXG5kZWYgcGx1cyhhLGIpOlxuICBzdW0gPSBhICsgYlxuICByZXR1cm4gKHN1bSwgYSlcblxuIyBDYWxsIGBwbHVzKClgIGFuZCB1bnBhY2sgdmFyaWFibGVzIFxuc3VtLCBhID0gcGx1cygzLDQpXG5cbiMgUHJpbnQgYHN1bSgpYFxucHJpbnQoc3VtKSJ9

नोट कि return स्टेटमेंट return sum, a का परिणाम return (sum, a) जैसा ही होगा: पहला विकल्प दरअसल sum और a को अंदरूनी तौर पर एक tuple में पैक कर देता है!

फ़ंक्शन को कैसे कॉल करें

पिछले सेक्शनों में, आपने फ़ंक्शन को कॉल करने के कई उदाहरण देखे हैं। फ़ंक्शन को कॉल करने का मतलब है कि आप उस फ़ंक्शन को निष्पादित करते हैं जिसे आपने परिभाषित किया है — या तो सीधे Python प्रॉम्प्ट से या किसी और फ़ंक्शन के माध्यम से (जैसा कि आप “Nested Functions” सेक्शन में देखेंगे)।

अपने नए परिभाषित फ़ंक्शन hello() को बस hello() चलाकर कॉल करें, ठीक नीचे दिए गए DataCamp Light चंक की तरह:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZGVmIGhlbGxvKCk6XG4gIHByaW50KFwiSGVsbG8gV29ybGRcIikgXG4gIHJldHVybiAiLCJzYW1wbGUiOiJoZWxsbygpIn0=

Python फ़ंक्शन में docstrings कैसे जोड़ें

Python में फ़ंक्शन्स लिखने का एक और आवश्यक पहलू: docstrings। Docstrings बताते हैं कि आपका फ़ंक्शन क्या करता है, जैसे वह कौन-सी गणनाएँ करता है या उसके रिटर्न वैल्यू क्या हैं। ये विवरण आपके फ़ंक्शन के लिए डाक्यूमेंटेशन का काम करते हैं ताकि कोई भी जो आपके फ़ंक्शन की docstring पढ़ता है, बिना फ़ंक्शन डेफ़िनिशन के सभी कोड को ट्रेस किए, समझ सके कि आपका फ़ंक्शन क्या करता है।

फ़ंक्शन docstrings फ़ंक्शन हेडर के तुरंत बाद की लाइन में रखे जाते हैं और ट्रिपल कोटेशन मार्क्स के बीच लिखे जाते हैं। आपके hello() फ़ंक्शन के लिए उपयुक्त Docstring है ‘Prints “Hello World”’.

def hello() -> None:
    """Prints "Hello World"."""
    print("Hello World")

नोट कि docstrings यहाँ दिए गए उदाहरण से कहीं लंबी भी हो सकती हैं। अगर आप docstrings को और विस्तार से पढ़ना चाहते हैं, तो Python लाइब्रेरीज़ के कुछ Github रिपॉज़िटरी, जैसे scikit-learn या pandas, देखें, जहाँ आपको बहुत से उदाहरण मिलेंगे!

टाइप हिंट्स

Docstrings से काफ़ी संबंधित — और आधुनिक Python कोड में लगभग उतने ही आम — टाइप हिंट्स हैं। Python 3.5 से, आप अपने फ़ंक्शन के पैरामीटर्स और रिटर्न वैल्यू को अपेक्षित टाइप्स के साथ एनोटेट कर सकते हैं। यह सबसे सरल उदाहरण है:

def plus(a: int, b: int) -> int:
    return a + b

प्रत्येक पैरामीटर के बाद : int का मतलब है "यह एक इंटीजर होना चाहिए," और कोष्ठकों के बाद -> int कहता है "यह फ़ंक्शन एक इंटीजर लौटाता है।" Python स्वयं रनटाइम पर इन एनोटेशन्स को लागू नहीं करता — आप फिर भी plus() को एक स्ट्रिंग पास कर सकते हैं और Python तब तक शिकायत नहीं करेगा जब तक कुछ टूट न जाए। लेकिन mypy, pyright, और VS Code व PyCharm जैसे एडिटर्स में बने टाइप चेकर जैसे टूल, आपके कोड को चलाने से पहले ही इन हिंट्स की मदद से बग पकड़ लेते हैं।

और जटिल टाइप्स के लिए, आप बिल्ट-इन जेनेरिक्स का सीधे उपयोग कर सकते हैं (Python 3.9+) या typing मॉड्यूल से इम्पोर्ट कर सकते हैं:

def greet(names: list[str]) -> None:
    for name in names:
        print(f"Hello {name}")

def find_user(user_id: int) -> dict | None:
    # returns the user dict, or None if not found
    ...

टाइप हिंट्स वैकल्पिक हैं, लेकिन जिन फ़ंक्शन्स को आप दोबारा उपयोग करने, साझा करने, या छह महीने बाद वापस आने की योजना बना रहे हैं, उनके लिए इन्हें सर्वश्रेष्ठ अभ्यास माना जाता है। ये मशीन-चेक योग्य डाक्यूमेंटेशन की तरह काम करते हैं — आपका IDE इन्हीं के आधार पर ऑटो-कम्प्लीट करेगा, टाइपो पकड़ेगा, और गलत टाइप पास करने पर चेतावनी देगा।

Python में फ़ंक्शन आर्ग्युमेंट्स

पहले, आपने पैरामीटर्स और आर्ग्युमेंट्स के बीच के अंतर के बारे में सीखा। संक्षेप में, आर्ग्युमेंट्स वे चीज़ें हैं जो किसी फ़ंक्शन या मेथड कॉल को दी जाती हैं, जबकि फ़ंक्शन या मेथड का कोड उन आर्ग्युमेंट्स को उनके पैरामीटर नामों से संदर्भित करता है। Python UDFs चार प्रकार के आर्ग्युमेंट्स ले सकते हैं:

डिफ़ॉल्ट आर्ग्युमेंट्स
आवश्यक (required) आर्ग्युमेंट्स
कीवर्ड आर्ग्युमेंट्स
वैरिएबल संख्या के आर्ग्युमेंट्स

डिफ़ॉल्ट आर्ग्युमेंट्स

डिफ़ॉल्ट आर्ग्युमेंट्स वे होते हैं जो फ़ंक्शन कॉल के दौरान कोई वैल्यू पास न होने पर एक डिफ़ॉल्ट वैल्यू ले लेते हैं। आप यह डिफ़ॉल्ट वैल्यू असाइनमेंट ऑपरेटर = के साथ दे सकते हैं, जैसे निम्न उदाहरण में:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGBwbHVzKClgIGZ1bmN0aW9uXG5kZWYgcGx1cyhhLGIgPSAyKTpcbiAgcmV0dXJuIGEgKyBiXG4gIFxuIyBDYWxsIGBwbHVzKClgIHdpdGggb25seSBgYWAgcGFyYW1ldGVyXG5wbHVzKGE9MSlcblxuIyBDYWxsIGBwbHVzKClgIHdpdGggYGFgIGFuZCBgYmAgcGFyYW1ldGVyc1xucGx1cyhhPTEsIGI9MykifQ==

आवश्यक आर्ग्युमेंट्स

नाम से ही स्पष्ट है, UDF के आवश्यक आर्ग्युमेंट्स वे होते हैं जिन्हें होना ही चाहिए। इन आर्ग्युमेंट्स को फ़ंक्शन कॉल के समय पास करना पड़ता है और ठीक उसी क्रम में, जैसे इस उदाहरण में:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGBwbHVzKClgIHdpdGggcmVxdWlyZWQgYXJndW1lbnRzXG5kZWYgcGx1cyhhLGIpOlxuICByZXR1cm4gYSArIGIifQ==

फ़ंक्शन को बिना एरर के कॉल करने के लिए आपको a और b पैरामीटर्स से मैप होने वाले आर्ग्युमेंट्स चाहिए। अगर आप a और b को अदल-बदल दें, तो परिणाम अलग नहीं होगा, लेकिन यह तब बदल सकता है जब आप plus() को निम्न रूप में बदल दें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGBwbHVzKClgIHdpdGggcmVxdWlyZWQgYXJndW1lbnRzXG5kZWYgcGx1cyhhLGIpOlxuICByZXR1cm4gYS9iIn0=

कीवर्ड आर्ग्युमेंट्स

यदि आप यह सुनिश्चित करना चाहते हैं कि आप सभी पैरामीटर्स को सही क्रम में कॉल कर रहे हैं, तो आप अपने फ़ंक्शन कॉल में कीवर्ड आर्ग्युमेंट्स का उपयोग कर सकते हैं। आप इन्हें उनके पैरामीटर नाम से आर्ग्युमेंट्स की पहचान करने के लिए उपयोग करते हैं। इसे थोड़ा और स्पष्ट करने के लिए ऊपर वाले उदाहरण को लें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGBwbHVzKClgIGZ1bmN0aW9uXG5kZWYgcGx1cyhhLGIpOlxuICByZXR1cm4gYSArIGJcbiAgXG4jIENhbGwgYHBsdXMoKWAgZnVuY3Rpb24gd2l0aCBwYXJhbWV0ZXJzIFxucGx1cygyLDMpXG5cbiMgQ2FsbCBgcGx1cygpYCBmdW5jdGlvbiB3aXRoIGtleXdvcmQgYXJndW1lbnRzXG5wbHVzKGE9MSwgYj0yKSJ9

ध्यान दें कि कीवर्ड आर्ग्युमेंट्स का उपयोग करके, आप पैरामीटर्स के क्रम को बदल भी सकते हैं और फिर भी फ़ंक्शन चलाने पर वही परिणाम पाएँगे:

वैरिएबल संख्या के आर्ग्युमेंट्स

ऐसे मामलों में जहाँ आपको यह नहीं पता कि आप फ़ंक्शन को कितने आर्ग्युमेंट्स पास करना चाहते हैं, आप *args के साथ निम्न सिंटैक्स का उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgRGVmaW5lIGBwbHVzKClgIGZ1bmN0aW9uIHRvIGFjY2VwdCBhIHZhcmlhYmxlIG51bWJlciBvZiBhcmd1bWVudHNcbmRlZiBwbHVzKCphcmdzKTpcbiAgcmV0dXJuIHN1bShhcmdzKVxuXG4jIENhbGN1bGF0ZSB0aGUgc3VtXG5wbHVzKDEsNCw1KSJ9

एस्टेरिस्क (*) उस वैरिएबल नाम के पहले लगाया जाता है जो सभी nonkeyword वैरिएबल आर्ग्युमेंट्स के मानों को रखता है। ध्यान दें कि आप *varint, *var_int_args या कोई और नाम भी plus() फ़ंक्शन को पास कर सकते थे।

टिप: *args को किसी दूसरे नाम से बदलकर देखें जिसमें एस्टेरिस्क शामिल हो। आप देखेंगे कि ऊपर का कोड वैसे ही काम करता रहेगा!

आप देखते हैं कि ऊपर दिया गया फ़ंक्शन बिल्ट-इन Python sum() फ़ंक्शन का उपयोग करके उन सभी आर्ग्युमेंट्स का योग निकालता है जो plus() को पास किए जाते हैं।

ग्लोबल बनाम लोकल वेरिएबल्स

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

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgR2xvYmFsIHZhcmlhYmxlIGBpbml0YFxuaW5pdCA9IDFcblxuIyBEZWZpbmUgYHBsdXMoKWAgZnVuY3Rpb24gdG8gYWNjZXB0IGEgdmFyaWFibGUgbnVtYmVyIG9mIGFyZ3VtZW50c1xuZGVmIHBsdXMoKmFyZ3MpOlxuICAjIExvY2FsIHZhcmlhYmxlIGBzdW0oKWBcbiAgdG90YWwgPSAwXG4gIGZvciBpIG4gYXJnczoXG4gICAgdG90YWwgKz0gaVxuICByZXR1cm4gdG90YWxcbiAgXG4jIEFjY2VzcyB0aGUgZ2xvYmFsIHZhcmlhYmxlXG5wcmludChcInRoaXMgaXMgdGhlIGluaXRpYWxpemVkIHZhbHVlIFwiICsgc3RyKGluaXQpKVxuXG4jIChUcnkgdG8pIGFjY2VzcyB0aGUgbG9jYWwgdmFyaWFibGVcbnByaW50KFwidGhpcyBpcyB0aGUgc3VtIFwiICsgc3RyKHRvdGFsKSkifQ==

आप देखेंगे कि जब आप फ़ंक्शन बॉडी के अंदर परिभाषित लोकल वेरिएबल total को प्रिंट करने की कोशिश करते हैं, तो आपको NameError मिलेगा, जो कहेगा कि name 'total' is not defined। दूसरी ओर, init वेरिएबल बिना किसी समस्या के प्रिंट किया जा सकता है।

Positional-only और keyword-only पैरामीटर्स

Python 3.8 से, आप अपनी फ़ंक्शन सिग्नेचर में दो विशेष मार्कर्स: / और * का उपयोग करके यह नियंत्रित कर सकते हैं कि आर्ग्युमेंट्स कैसे पास किए जाएँ। / से पहले की हर चीज़ केवल पॉज़िशनली पास की जा सकती है; * के बाद की हर चीज़ केवल कीवर्ड के जरिए पास की जा सकती है।

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

कॉल साइट पर यह इस तरह दिखता है:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-only

आप ऐसा क्यों चाहेंगे? दो मुख्य कारण।

पहला, positional-only पैरामीटर्स आपको बाद में उनके नाम बदलने की आज़ादी देते हैं बिना किसी के कोड को तोड़े — क्योंकि कोई भी पैरामीटर नाम को कीवर्ड के रूप में इस्तेमाल नहीं कर सकता, आप इसे बदलने के लिए स्वतंत्र हैं।

दूसरा, keyword-only पैरामीटर्स कॉलर्स को यह स्पष्ट करने के लिए बाध्य करते हैं कि वे क्या पास कर रहे हैं, जो तब कॉल्स को अधिक पठनीय बनाता है जब आपके पास कई वैकल्पिक फ़्लैग्स या सेटिंग्स हों।

संक्षेप में, ये आशय (intent) को साफ़-साफ़ लागू करने का एक सुथरा तरीका हैं।

Python में गुमनाम (Anonymous) फ़ंक्शन्स

गुमनाम फ़ंक्शन्स को Python में lambda फ़ंक्शन्स भी कहा जाता है क्योंकि इन्हें मानक def कीवर्ड के बजाय lambda कीवर्ड से घोषित किया जाता है।

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImRvdWJsZSA9IGxhbWJkYSB4OiB4KjJcblxuZG91YmxlKDUpIn0=

ऊपर दिए गए DataCamp Light चंक में, lambda x: x*2 गुमनाम या lambda फ़ंक्शन है। x आर्ग्युमेंट है, और x*2 वह एक्सप्रेशन या निर्देश है जिसका मूल्यांकन कर रिटर्न किया जाता है। इस फ़ंक्शन की ख़ास बात यह है कि इसका कोई नाम नहीं है, जैसे कि आपने इस ट्यूटोरियल के पहले भाग में देखे उदाहरणों में था। यदि आपको ऊपर वाले फ़ंक्शन को UDF में लिखना हो, तो परिणाम निम्न होगा:

def double(x):
  return x*2

आइए दो आर्ग्युमेंट्स वाले एक और lambda फ़ंक्शन का उदाहरण देखें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgYHN1bSgpYCBsYW1iZGEgZnVuY3Rpb25cbnN1bSA9IGxhbWJkYSB4LCB5OiB4ICsgeTtcblxuIyBDYWxsIHRoZSBgc3VtKClgIGFub255bW91cyBmdW5jdGlvblxuc3VtKDQsNSlcblxuIyBcIlRyYW5zbGF0ZVwiIHRvIGEgVURGXG5kZWYgc3VtKHgsIHkpOlxuICByZXR1cm4geCt5In0=

आप गुमनाम फ़ंक्शन्स का उपयोग तब करते हैं जब आपको थोड़े समय के लिए बिना नाम का फ़ंक्शन चाहिए, और जिसे रनटाइम पर बनाया जाता है। ऐसे विशिष्ट संदर्भ जहाँ यह प्रासंगिक होता है, वे हैं जब आप filter(), map() और reduce() के साथ काम कर रहे हों:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImZyb20gZnVuY3Rvb2xzIGltcG9ydCByZWR1Y2VcblxubXlfbGlzdCA9IFsxLDIsMyw0LDUsNiw3LDgsOSwxMF1cblxuIyBVc2UgbGFtYmRhIGZ1bmN0aW9uIHdpdGggYGZpbHRlcigpYFxuZmlsdGVyZWRfbGlzdCA9IGxpc3QoZmlsdGVyKGxhbWJkYSB4OiAoeCoyID4gMTApLCBteV9saXN0KSlcblxuIyBVc2UgbGFtYmRhIGZ1bmN0aW9uIHdpdGggYG1hcCgpYFxubWFwcGVkX2xpc3QgPSBsaXN0KG1hcChsYW1iZGEgeDogeCoyLCBteV9saXN0KSlcblxuIyBVc2UgbGFtYmRhIGZ1bmN0aW9uIHdpdGggYHJlZHVjZSgpYFxucmVkdWNlZF9saXN0ID0gcmVkdWNlKGxhbWJkYSB4LCB5OiB4K3ksIG15X2xpc3QpXG5cbnByaW50KGZpbHRlcmVkX2xpc3QpXG5wcmludChtYXBwZWRfbGlzdClcbnByaW50KHJlZHVjZWRfbGlzdCkifQ==

filter() फ़ंक्शन, जैसा कि नाम से स्पष्ट है, मूल इनपुट सूची my_list को किसी मानदंड >10 के आधार पर फ़िल्टर करता है। दूसरी ओर, map() के साथ, आप सूची my_list के सभी आइटम्स पर कोई फ़ंक्शन लागू करते हैं। इस मामले में, आप सभी तत्वों को 2 से गुणा करते हैं।

ध्यान दें कि reduce() फ़ंक्शन functools लाइब्रेरी का हिस्सा है। आप इस फ़ंक्शन का उपयोग my_list की आइटम्स पर बाएँ से दाएँ क्रम में क्रमिक रूप से करते हैं और अनुक्रम को एक एकल मान में घटाते हैं, जो इस मामले में 55 है।

Python में main() को फ़ंक्शन की तरह उपयोग करना

यदि आपको Java जैसी अन्य प्रोग्रामिंग भाषाओं का अनुभव है, तो आप जानते होंगे कि फ़ंक्शन्स को निष्पादित करने के लिए main फ़ंक्शन आवश्यक होता है। जैसा कि आपने ऊपर दिए उदाहरणों में देखा, Python के लिए यह ज़रूरी नहीं है। फिर भी, अपने Python प्रोग्राम में main() फ़ंक्शन शामिल करना आपके कोड को तार्किक रूप से व्यवस्थित करने में सहायक हो सकता है — सबसे महत्वपूर्ण घटक इसी main() फ़ंक्शन के भीतर समाहित होते हैं।

आप आसानी से एक main() फ़ंक्शन परिभाषित कर सकते हैं और इसे वैसा ही कॉल कर सकते हैं जैसा आपने ऊपर अन्य सभी फ़ंक्शन्स के साथ किया है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZGVmIGhlbGxvKCk6XG4gIHByaW50KFwiSGVsbG8gV29ybGRcIikgXG4gIHJldHVybiAiLCJzYW1wbGUiOiIjIERlZmluZSBgbWFpbigpYCBmdW5jdGlvblxuZGVmIG1haW4oKTpcbiAgaGVsbG8oKVxuICBwcmludChcIlRoaXMgaXMgYSBtYWluIGZ1bmN0aW9uXCIpXG5cbm1haW4oKSJ9

हालाँकि, अभी की स्थिति में, जब आप इसे किसी मॉड्यूल के रूप में इम्पोर्ट करेंगे, तो आपके main() फ़ंक्शन का कोड कॉल हो जाएगा। यह सुनिश्चित करने के लिए कि ऐसा न हो, आप __name__ == '__main__' होने पर ही main() फ़ंक्शन को कॉल करते हैं।

इसका मतलब है कि ऊपर दिए गए कोड चंक का कोड इस प्रकार बन जाता है:

नोट कि __main__ फ़ंक्शन के अलावा, आपके पास एक __init__ फ़ंक्शन भी होता है जो किसी क्लास या ऑब्जेक्ट के इंस्टेंस को इनिशियलाइज़ करता है। सरल शब्दों में, यह कंस्ट्रक्टर या इनिशियलाइज़र की तरह काम करता है और जब आप किसी क्लास का नया इंस्टेंस बनाते हैं तो अपने-आप कॉल होता है। इस फ़ंक्शन के साथ, नया बना ऑब्जेक्ट पैरामीटर self को असाइन होता है, जिसे आपने इस ट्यूटोरियल में पहले देखा था। निम्न उदाहरण देखें:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())

Python फ़ंक्शन्स का अभ्यास जारी रखें

बधाई हो! आपने Python में फ़ंक्शन्स पर यह छोटा ट्यूटोरियल पूरा कर लिया है। अगर आप अन्य बुनियादी Python प्रोग्रामिंग सामग्री को दोहराना चाहते हैं, तो Data Types for Data Science मिस न करें, यह एक ऐसा कोर्स है जहाँ आप लिस्ट्स, डिक्शनरीज़, ट्यूपल्स, सेट्स, और डेट टाइम्स का अपना ज्ञान समेकित करेंगे और अभ्यास करेंगे।

Python में फ़ंक्शन क्या है?

आप Python में फ़ंक्शन कैसे परिभाषित करते हैं?

Python में फ़ंक्शन्स और मेथड्स में क्या अंतर है?

Python में फ़ंक्शन्स के प्रकार क्या हैं?

पैरामीटर्स और आर्ग्युमेंट्स में क्या अंतर है?

lambda फ़ंक्शन क्या है?

main फ़ंक्शन का उपयोग क्यों करें?

ग्लोबल और लोकल वेरिएबल्स में क्या अंतर है?

विषय

Python

डेटा विश्लेषण

Python के बारे में और जानें

course

Introduction to Python

4 घंटा

6.8M

Master the basics of data analysis with Python in just four hours. This online course will introduce the Python interface and explore popular packages.

विस्तृत जानकारी देखें

कोर्स शुरू करें

course