फंक्शन आर्गुमेंट में

फंक्शन आर्गुमेंट के बारे में

फंक्शन आर्गुमेंट की मूल बातों के लिए, कृपया फंक्शन की अवधारणा देखिए।

पैरामीटर के नाम

पैरामीटर के नाम, वेरिएबल के नाम की तरह, किसी अक्षर या अंडरस्कोर से शुरू होने चाहिए और उनमें अक्षर, अंडरस्कोर या संख्याएँ हो सकते हैं। पैरामीटर के नामों में स्पेस या विराम चिह्न नहीं होने चाहिए।

पोज़िशनल आर्गुमेंट

पोज़िशनल आर्गुमेंट वे वैल्यू हैं जो किसी फंक्शन को उसी क्रम में दी जाती हैं जिस क्रम में उनसे जुड़े पैरामीटर होते हैं। पोज़िशनल आर्गुमेंट को चाहें तो उनके पैरामीटर नाम का उपयोग करके भी दिया जा सकता है:

def concat(greeting, name):
    return f"{greeting}{name}"

# Passing data to the function by position.
print(concat("Hello, ", "Lilly"))
#->  Hello, Lilly

# Passing data to the function using the parameter name.
print(concat(name="Glenn", greeting="Hello, "))
#-> Hello, Glenn

concat को पहली बार कॉल करने पर आर्गुमेंट स्थिति के अनुसार दिए जाते हैं। concat को दूसरी बार कॉल करने पर आर्गुमेंट नाम के साथ दिए जाते हैं, जिससे उनकी स्थिति बदली जा सकती है।

ध्यान दीजिए कि नाम से दिए गए आर्गुमेंट के बाद पोज़िशनल आर्गुमेंट नहीं आ सकते (जिन्हें कीवर्ड आर्गुमेंट भी कहते हैं। इन्हें वेरिएबल-पोज़िशनल पैरामीटर या **kwargs से भ्रमित न हों).

आर्गुमेंट का यह समूह:

print(concat(greeting="Hello, ", "Gregor"))

इससे यह एरर मिलती है:

SyntaxError: positional argument follows keyword argument

फंक्शन कॉल के लिए केवल-पोज़िशनल आर्गुमेंट ज़रूरी करने के लिए पैरामीटर सूची में / ऑपरेटर का उपयोग किया जा सकता है:

# Parameters showing a position-only operator. 
def concat(greeting, name, /):
    return f"{greeting}{name}"

print(concat("Hello, ", "Ginnie"))
#-> Hello, Ginnie

# Call to the function using keyword arguments.
print(concat(name="Franklin", greeting="Hello, "))
Traceback (most recent call last):
    print(concat(name="Franklin", greeting="Hello, "))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting, name'

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

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

def concat(greeting, name):
    return f"{greeting}{name}"

# Function call using parameter names as argument keywords.
print(concat(name="Eliza", greeting="Hello, "))
#-> Hello, Eliza

# Function call with positional data as arguments.
print(concat("Hello, ", "Tim"))
#-> Hello, Tim

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

# Function definition requiring keyword-only arguments.
def concat(*, greeting, name):
    return f"{greeting}{name}"

# Keyword arguments can be in an arbitrary order.
print(concat(name="Kimmie", greeting="Hello, "))
#-> Hello, Kimmie

# Calling the function with positional data raises an error.
print(concat("Hello, ", "Coleen"))
Traceback (most recent call last):
    print(concat("Hello, ", "Coleen"))
TypeError: concat() takes 0 positional arguments but 2 were given

डिफॉल्ट आर्गुमेंट वैल्यू

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

# Function with default argument values.
def concat(greeting, name="you", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

print(concat("Hello"))
#-> Hello, you!

# Overriding the default values
print(concat("Hello", name="Polly", punctuation="."))
#-> Hello, Polly.

पोज़िशनल या कीवर्ड आर्गुमेंट

यदि पैरामीटर की परिभाषाओं में / या * ऑपरेटर का उपयोग नहीं किया गया है, तो आर्गुमेंट पोज़िशनल या कीवर्ड हो सकते हैं। वैकल्पिक रूप से, पोज़िशनल-या-कीवर्ड आर्गुमेंट को बाईं ओर केवल-पोज़िशनल पैरामीटर और दाईं ओर केवल-कीवर्ड पैरामीटर के बीच रखा जा सकता है:

# Position-only argument followed by position-or-keyword, followed by keyword-only.
def concat(greeting, /, name, *, ending):
    return f"{greeting}{name}{ending}"

print(concat("Hello, ", "Mark", ending="!"))
#-> Hello, Mark!

print(concat("Hello, ", name="Rachel", ending="!"))
#-> Hello, Rachel!

print(concat(greeting="Hello, ", name="JoJo", ending="!"))
Traceback (most recent call last):
    print(concat(greeting="Hello, ", name="JoJo", ending="!"))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting'

*args

कोड के उदाहरणों में अक्सर कुछ ऐसी फंक्शन परिभाषा दिखती है:

def my_function(*args, **kwargs):
    # code snipped

*args एक दो-भाग वाला नाम है जो अलग-अलग पोज़िशनल आर्गुमेंट की अनिश्चित संख्या वाले tuple को दर्शाता है, जिसे variadic argument भी कहा जाता है। args आर्गुमेंट के tuple को दिया गया नाम है, लेकिन यह Python का कोई भी अन्य मान्य नाम हो सकता है, जैसे my_args, arguments, आदि। * वह ऑपरेटर है जो अलग-अलग आर्गुमेंट के समूह को tuple में बदल देता है।

चूँकि tuple पर इटरेशन किया जा सकता है, args को किसी भी ऐसे फंक्शन को दिया जा सकता है जो इटरेबल लेता है। हालाँकि *args को आम तौर पर **kwargs के साथ रखा जाता है, ऐसा होना ज़रूरी नहीं है:

def add(*args):
    # args is passed to the sum function, which iterates over it.
    return sum(args)

print(add(1, 2, 3))
#-> 6

यदि *args एक या अधिक पोज़िशनल आर्गुमेंट के बाद आता है, तो पोज़िशनल आर्गुमेंट के बाद जो बचता है वह *args में होता है:

def add(first, *args):
    # first will be 1, leaving the values 2 and 3 in *args
    return first + sum(args)

print(add(1, 2, 3))
#-> 6

यदि *args के बाद एक या अधिक डिफॉल्ट आर्गुमेंट परिभाषित किए जाते हैं, तो वे *args की वैल्यू से अलग होते हैं:

def add(first, *args, last=0):
    return first + sum(args) + last
 
print(add(1, 2, 3))
#-> 6

print(add(1, 2, 3, last=4))
#-> 10

# This uses the unpacking operator * to separate the list elements into positional arguments.
# It does not have the same behavior as the * (packing) in *args.
print(add(*[1, 2, 3]))
#-> 6

ध्यान दीजिए कि जब कोई आर्गुमेंट पहले से किसी iterable के अंदर हो (जैसे tuple या list), तो ऐसे फंक्शन को देने से पहले उसे खोला जाना चाहिए जो मनमानी संख्या में अलग-अलग आर्गुमेंट लेता है। यह * का उपयोग करके किया जाता है, जो खोलने वाला ऑपरेटर है।

इस संदर्भ में * कंटेनर को उसके अलग-अलग एलिमेंट में खोलता है, जिन्हें फिर *args द्वारा tuple में बदल दिया जाता है। जहाँ केवल पोज़िशनल आर्गुमेंट हों, वहाँ खोलने की क्रिया का परिणाम उतने ही आर्गुमेंट होने चाहिए जितने पैरामीटर परिभाषा में दिए गए हैं।

add में दिए गए ऐरे को खोले बिना प्रोग्राम में एरर आ जाएगी:

def add(first, *args, last=0):
    return first + sum(args) + last

print(add([1, 2, 3]))
Traceback (most recent call last):
    print(add([1, 2, 3]))
    return first + sum(args) + last
TypeError: can only concatenate list (not "int") to list

**kwargs

**kwargs एक दो-भाग वाला नाम है जो अलग-अलग की-वैल्यू जोड़ा आर्गुमेंट की अनिश्चित संख्या को दर्शाता है। kwargs आर्गुमेंट के समूह का नाम है और कोई भी अन्य नाम हो सकता है, जैसे my_args, arguments, आदि। ** नामित आर्गुमेंट के समूह को {argument name: argument value} जोड़ों की dictionary में बदल देता है।

चूँकि डिक्शनरी पर इटरेशन किया जा सकता है, kwargs को किसी भी ऐसे फंक्शन को दिया जा सकता है जो इटरेबल लेता है। हालाँकि **kwargs को आम तौर पर *args के साथ रखा जाता है, ऐसा होना ज़रूरी नहीं है:

def add(**kwargs):
    return sum(kwargs.values())

print(add(one=1, two=2, three=3))
#-> 6

ध्यान दीजिए कि kwargs डिक्शनरी की values पर इटरेशन करने के लिए dict.values() मेथड को कॉल किया जाता है। किसी डिक्शनरी पर इटरेशन करते समय डिफॉल्ट रूप से keys पर इटरेशन होता है, इसलिए dict.values() को स्पष्ट रूप से लिखना पड़ता है:

def concat(**kwargs):
    # Join concatenates the tuples from `kwargs.items()`
    return " ".join((str(item) for item in kwargs.items()))

print(concat(one=1, two=2, three=3))
#-> ('one', 1) ('two', 2) ('three', 3)