Python Language
कार्य

परिचय

वाक्य - विन्यास

• def function_name ( arg1, ... argN, * args, kw1, kw2 = default, ..., ** kwargs ): कथन
• lambda arg1, ... argN, * args, kw1, kw2 = default, ..., ** kggs : अभिव्यक्ति

पैरामीटर

टिप्पणियों

सरल कार्यों को परिभाषित करना और कॉल करना

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

def function_name(parameters):
    statement(s)

function_name के पहचानकर्ता के रूप में जाना जाता है। चूंकि एक फ़ंक्शन परिभाषा एक निष्पादन योग्य कथन है, इसलिए इसका निष्पादन फ़ंक्शन नाम को फ़ंक्शन ऑब्जेक्ट से बांधता है जिसे पहचानकर्ता का उपयोग करने पर बाद में कहा जा सकता है।

parameters पहचानकर्ताओं की एक वैकल्पिक सूची है जो फ़ंक्शन कहे जाने पर तर्कों के रूप में दिए गए मानों से बंध जाते हैं। एक फ़ंक्शन में मनमानी संख्या हो सकती है जो अल्पविराम से अलग हो जाती है।

statement(s) - जिसे फ़ंक्शन बॉडी के रूप में भी जाना जाता है - हर बार फ़ंक्शन को निष्पादित किए जाने वाले कथनों का एक गैर-अनुक्रम होता है। इसका मतलब है कि एक फंक्शन बॉडी किसी इंडेंटेड ब्लॉक की तरह खाली नहीं हो सकती।

यहाँ एक साधारण फ़ंक्शन परिभाषा का उदाहरण दिया गया है जिसका उद्देश्य Hello हर बार प्रिंट करना है:

def greet():
    print("Hello")

अब चलो परिभाषित greet() फ़ंक्शन को कॉल करें:

greet()
# Out: Hello

यह एक फ़ंक्शन परिभाषा का एक अन्य उदाहरण है जो एक एकल तर्क लेता है और हर बार फ़ंक्शन को कॉल किए जाने वाले मान को प्रदर्शित करता है:

def greet_two(greeting):
    print(greeting)

उसके बाद greet_two() फ़ंक्शन को एक तर्क के साथ बुलाया जाना चाहिए:

greet_two("Howdy")
# Out: Howdy

इसके अलावा, आप उस फ़ंक्शन तर्क को एक डिफ़ॉल्ट मान दे सकते हैं:

def greet_two(greeting="Howdy"):
    print(greeting)

अब आप मान दिए बिना फ़ंक्शन को कॉल कर सकते हैं:

greet_two()
# Out: Howdy 

आप देखेंगे कि कई अन्य भाषाओं के विपरीत, आपको फ़ंक्शन के रिटर्न प्रकार को स्पष्ट रूप से घोषित करने की आवश्यकता नहीं है। पायथन फ़ंक्शन return कीवर्ड के माध्यम से किसी भी प्रकार के मूल्यों को वापस कर सकता है। एक फ़ंक्शन विभिन्न प्रकारों की किसी भी संख्या को वापस कर सकता है!

def many_types(x):
    if x < 0:
        return "Hello!"
    else:
        return 0

print(many_types(1))
print(many_types(-1))

# Output:
0
Hello!

जब तक यह कॉलर द्वारा सही ढंग से संभाला जाता है, यह पूरी तरह से वैध पायथन कोड है।

एक फ़ंक्शन जो रिटर्न स्टेटमेंट के बिना निष्पादन के अंत तक पहुंचता है, हमेशा None लौटेगा:

def do_nothing():
    pass

print(do_nothing())
# Out: None

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

कार्यों से मान लौटाना

फ़ंक्शंस एक मान return सकते return जिसका आप सीधे उपयोग कर सकते हैं:

def give_me_five():
    return 5

print(give_me_five())  # Print the returned value
# Out: 5

या बाद में उपयोग के लिए मान को बचाएं:

num = give_me_five()
print(num)             # Print the saved returned value
# Out: 5

या किसी भी ऑपरेशन के लिए मूल्य का उपयोग करें:

print(give_me_five() + 10)
# Out: 15

यदि फ़ंक्शन में return का सामना किया जाता है, तो फ़ंक्शन तुरंत बाहर हो जाएगा और बाद के संचालन का मूल्यांकन नहीं किया जाएगा:

def give_me_another_five():
    return 5
    print('This statement will not be printed. Ever.')

print(give_me_another_five())
# Out: 5

आप कई मान भी return सकते हैं (टुप के रूप में):

def give_me_two_fives():
    return 5, 5  # Returns two 5

first, second = give_me_two_fives()
print(first)
# Out: 5
print(second)
# Out: 5

कोई साथ एक समारोह return बयान परोक्ष रिटर्न None । इसी तरह एक return स्टेटमेंट वाला फंक्शन, लेकिन नो रिटर्न वैल्यू या वैरिएबल रिटर्न None ।

तर्कों के साथ एक फ़ंक्शन को परिभाषित करना

फ़ंक्शन नाम के बाद तर्क को कोष्ठक में परिभाषित किया गया है:

def divide(dividend, divisor):  # The names of the function and its arguments
    # The arguments are available by name in the body of the function
    print(dividend / divisor)

फ़ंक्शन का नाम और उसके तर्कों की सूची को फ़ंक्शन का हस्ताक्षर कहा जाता है। प्रत्येक नामित तर्क प्रभावी रूप से फ़ंक्शन का एक स्थानीय चर है।

फ़ंक्शन को कॉल करते समय, उन्हें क्रम में सूचीबद्ध करके तर्कों के लिए मान दें

divide(10, 2)
# output: 5

या फ़ंक्शन परिभाषा से नाम का उपयोग करके उन्हें किसी भी क्रम में निर्दिष्ट करें:

divide(divisor=2, dividend=10)
# output: 5

वैकल्पिक तर्कों के साथ एक फ़ंक्शन को परिभाषित करना

वैकल्पिक तर्क बताए (का उपयोग करके परिभाषित किया जा सकता = ) तर्क-नाम के लिए एक डिफ़ॉल्ट मूल्य:

def make(action='nothing'):
    return action

इस फ़ंक्शन को कॉल करना 3 अलग-अलग तरीकों से संभव है:

make("fun")
# Out: fun

make(action="sleep")
# Out: sleep

# The argument is optional so the function will use the default value if the argument is 
# not passed in.
make()   
# Out: nothing

चेतावनी

डिफ़ॉल्ट प्रकार ( list , dict , set आदि) को डिफ़ॉल्ट विशेषता के रूप में दिए जाने पर सावधानी के साथ व्यवहार किया जाना चाहिए। डिफ़ॉल्ट तर्क का कोई भी म्यूटेशन इसे स्थायी रूप से बदल देगा। वैकल्पिक म्यूटेबल तर्कों के साथ एक फ़ंक्शन को परिभाषित करना देखें।

एक फ़ंक्शन को कई तर्कों के साथ परिभाषित करना

कोई एक फ़ंक्शन को एक तर्क दे सकता है जैसे कि एक चाहता है, केवल तय नियम हैं कि प्रत्येक तर्क नाम अद्वितीय होना चाहिए और वैकल्पिक तर्क नहीं-वैकल्पिक लोगों के बाद होना चाहिए:

def func(value1, value2, optionalvalue=10):
    return '{0} {1} {2}'.format(value1, value2, optionalvalue1)

फ़ंक्शन को कॉल करते समय आप या तो प्रत्येक कीवर्ड को नाम के बिना दे सकते हैं लेकिन फिर ऑर्डर मायने रखता है:

print(func(1, 'a', 100))
# Out: 1 a 100

print(func('abc', 14))
# abc 14 10

या नाम के साथ और बिना तर्क दिए गठबंधन करें। फिर नाम वाले लोगों को उन लोगों का अनुसरण करना चाहिए लेकिन बिना नाम वाले लोगों के आदेश से कोई फर्क नहीं पड़ता:

print(func('This', optionalvalue='StackOverflow Documentation', value2='is'))
# Out: This is StackOverflow Documentation

मनमाने ढंग से तर्कों के साथ एक फ़ंक्शन को परिभाषित करना

स्थिति संबंधी तर्कों की संख्या:

एक समारोह को परिभाषित करने में सक्षम तर्क की एक मनमानी संख्या लेने में सक्षम किया जा सकता है एक तर्क के साथ एक उपसर्ग *

def func(*args):
    # args will be a tuple containing all values that are passed in
    for i in args:
        print(i)

func(1, 2, 3)  # Calling it with 3 arguments
# Out: 1
#      2
#      3

list_of_arg_values = [1, 2, 3]
func(*list_of_arg_values)  # Calling it with list of values, * expands the list
# Out: 1
#      2
#      3 

func()  # Calling it without arguments
# No Output 

आप args लिए एक डिफ़ॉल्ट प्रदान नहीं कर सकते , उदाहरण के लिए func(*args=[1, 2, 3]) एक सिंटैक्स त्रुटि को बढ़ा देगा (संकलन भी नहीं करेगा)।

फ़ंक्शन को कॉल करते समय आप इन्हें नाम नहीं दे सकते , उदाहरण के लिए func(*args=[1, 2, 3]) एक TypeError उठाएंगे।

लेकिन यदि आपके पास पहले से ही एक सरणी (या किसी अन्य Iterable ) में आपके तर्क हैं, तो आप अपने फ़ंक्शन को इस तरह से आमंत्रित कर सकते हैं : func(*my_stuff) ।

इन तर्कों ( *args ) को सूचकांक द्वारा पहुँचा जा सकता है, उदाहरण के लिए args[0] पहला तर्क लौटाएगा

कीवर्ड तर्कों की संख्या के विपरीत

आप एक तर्क के साथ मनमानी संख्या को तर्क के साथ परिभाषा में परिभाषित कर सकते हैं, जिसके सामने दो * :

def func(**kwargs):
    # kwargs will be a dictionary containing the names as keys and the values as values
    for name, value in kwargs.items():
        print(name, value)

func(value1=1, value2=2, value3=3)   # Calling it with 3 arguments
# Out: value1 1
#      value2 2
#      value3 3

func()                               # Calling it without arguments
# No Out put

my_dict = {'foo': 1, 'bar': 2}
func(**my_dict)                      # Calling it with a dictionary
# Out: foo 1
#      bar 2

आप बिना नाम के इन्हें प्रदान नहीं कर सकते हैं , उदाहरण के लिए func(1, 2, 3) एक TypeError बढ़ाएगा।

kwargs एक सादा देशी अजगर शब्द है। उदाहरण के लिए, args['value1'] तर्क के लिए मूल्य दे देंगे value1 । पहले से जांच कर लें कि इस तरह का कोई तर्क है या कोई KeyError जाएगी।

चेतावनी

आप इन्हें अन्य वैकल्पिक और आवश्यक तर्कों के साथ मिला सकते हैं लेकिन परिभाषा के अंदर यह क्रम मायने रखता है।

स्थिति / कीवर्ड तर्क पहले आते हैं। (आवश्यक तर्क)।
फिर मनमानी *arg तर्क वितर्क आता है। (वैकल्पिक)।
तब कीवर्ड-केवल तर्क अगले आते हैं। () की आवश्यकता।
अंत में मनमाना कीवर्ड **kwargs आते हैं। (वैकल्पिक)।

#       |-positional-|-optional-|---keyword-only--|-optional-|
def func(arg1, arg2=10 , *args, kwarg1, kwarg2=2, **kwargs):
     pass

• arg1 दिया जाना चाहिए, अन्यथा एक TypeError उठाया जाता है। इसे स्थिति-संबंधी ( func(10) ) या कीवर्ड तर्क func(arg1=10) रूप में दिया जा सकता है।
• kwarg1 भी दिया जाना चाहिए, लेकिन यह केवल कीवर्ड-तर्क के रूप में प्रदान किया जा सकता है: func(kwarg1=10) ।
• arg2 और kwarg2 वैकल्पिक हैं। यदि मान को उसी नियम में बदला जाना है जैसे कि arg1 (या तो स्थिति या कीवर्ड) और kwarg1 (केवल कीवर्ड) लागू होते हैं।
• *args अतिरिक्त स्थितीय मापदंडों को पकड़ता है। लेकिन ध्यान दें, कि arg1 और arg2 को दलीलों को पास करने के लिए स्थितीय तर्क के रूप में प्रदान किया जाना चाहिए: *args : func(1, 1, 1, 1) ।
• **kwargs सभी अतिरिक्त कीवर्ड मापदंडों को पकड़ता है। इस स्थिति में कोई भी पैरामीटर जो arg1 , arg2 , kwarg1 या kwarg2 । उदाहरण के लिए: func(kwarg3=10) ।
• पायथन 3 में, आप यह इंगित करने के लिए अकेले * उपयोग कर सकते हैं कि बाद के सभी तर्क कीवर्ड के रूप में निर्दिष्ट होने चाहिए। उदाहरण के लिए Python 3.5 में math.isclose फंक्शन और उससे अधिक def math.isclose (a, b, *, rel_tol=1e-09, abs_tol=0.0) का उपयोग करके परिभाषित किया गया है। तीसरे और चौथे पैरामीटर को केवल कीवर्ड तर्क के रूप में ही दिया जा सकता है।

पायथन 2.x कीवर्ड-केवल मापदंडों का समर्थन नहीं करता है। यह व्यवहार kwargs साथ अनुकरण किया जा सकता है:

def func(arg1, arg2=10, **kwargs):
    try:
        kwarg1 = kwargs.pop("kwarg1")
    except KeyError:
        raise TypeError("missing required keyword-only argument: 'kwarg1'")

    kwarg2 = kwargs.pop("kwarg2", 2)
    # function body ...

नामकरण पर ध्यान दें

वैकल्पिक स्थितीय तर्क नामकरण के सम्मेलन args और वैकल्पिक कीवर्ड तर्क kwargs सिर्फ एक सम्मेलन आप आप की तरह किसी भी नाम का उपयोग कर सकते है, लेकिन इसे का पालन करना है ताकि अन्य लोग जानते हैं कि आप क्या कर रहे हैं, या अपने आप को भी बाद में ऐसा करने के लिए कृपया उपयोगी है।

विशिष्टता पर ध्यान दें

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

वैकल्पिक तर्क के साथ घोंसले के कार्य पर ध्यान दें

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

def fn(**kwargs):
    print(kwargs)
    f1(**kwargs)

def f1(**kwargs):
    print(len(kwargs))

fn(a=1, b=2)
# Out:
# {'a': 1, 'b': 2}
# 2

वैकल्पिक म्यूटेबल तर्कों के साथ एक फ़ंक्शन को परिभाषित करना

एक परस्पर डिफ़ॉल्ट प्रकार के साथ वैकल्पिक तर्कों का उपयोग करते समय एक समस्या है ( वैकल्पिक तर्कों के साथ एक फ़ंक्शन को परिभाषित करने में वर्णित है), जो संभावित रूप से अप्रत्याशित व्यवहार को जन्म दे सकता है।

व्याख्या

यह समस्या उत्पन्न होती है क्योंकि एक समारोह के डिफ़ॉल्ट तर्क एक बार, बिंदु पर जब समारोह परिभाषित किया गया है (कई अन्य भाषाओं की तरह) जब समारोह कहा जाता है initialised रहे हैं, और नहीं। डिफ़ॉल्ट मान फ़ंक्शन ऑब्जेक्ट __defaults__ सदस्य चर के अंदर संग्रहीत किए जाते हैं।

def f(a, b=42, c=[]):
    pass

print(f.__defaults__)
# Out: (42, [])

अपरिवर्तनीय प्रकारों के लिए ( तर्क पारित करने और उत्परिवर्तन देखें) यह एक समस्या नहीं है क्योंकि चर को म्यूट करने का कोई तरीका नहीं है; यह केवल कभी भी पुन: असाइन किया जा सकता है, मूल मूल्य को अपरिवर्तित छोड़कर। इसलिए, बाद में एक ही डिफ़ॉल्ट मान रखने की गारंटी दी जाती है। हालांकि, एक परिवर्तनशील प्रकार के लिए, मूल मूल्य अपने विभिन्न सदस्य कार्यों के लिए कॉल करके, उत्परिवर्तित कर सकता है। इसलिए, फ़ंक्शन को लगातार कॉल करने के लिए प्रारंभिक डिफ़ॉल्ट मान होने की गारंटी नहीं है।

def append(elem, to=[]):
    to.append(elem)      # This call to append() mutates the default variable "to"
    return to

append(1)
# Out: [1]

append(2)  # Appends it to the internally stored list
# Out: [1, 2]

append(3, [])  # Using a new created list gives the expected result
# Out: [3]

# Calling it again without argument will append to the internally stored list again
append(4)   
# Out: [1, 2, 4]

नोट: कुछ IDEs जैसे PyCharm एक चेतावनी जारी करेगा जब एक उत्परिवर्तनीय प्रकार को डिफ़ॉल्ट विशेषता के रूप में निर्दिष्ट किया जाता है।

समाधान

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

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

def append(elem, to=None):
    if to is None:
        to = []

    to.append(elem)
    return to

लैम्ब्डा (इनलाइन / बेनामी) कार्य

lambda कीवर्ड एक इनलाइन फ़ंक्शन बनाता है जिसमें एक एकल अभिव्यक्ति होती है। इस एक्सप्रेशन का मान क्या होता है जब फंक्शन को वापस लाया जाता है।

फ़ंक्शन पर विचार करें:

def greeting():
    return "Hello"

जो, जब कहा जाता है:

print(greeting())

प्रिंट:

Hello

इसे लंबो फंक्शन के रूप में निम्न प्रकार से लिखा जा सकता है:

greet_me = lambda: "Hello"

चर खंडों को लैम्ब्डा के असाइनमेंट के बारे में इस खंड के नीचे देखें। आम तौर पर, यह मत करो।

यह Hello रिटर्न करने वाले greet_me साथ एक इनलाइन फ़ंक्शन बनाता है। ध्यान दें कि लैम्बडा के साथ फंक्शन बनाते समय आप return नहीं लिखते return । के बाद मान : स्वचालित रूप से वापस आ गया है।

एक बार एक चर को सौंपा, यह एक नियमित समारोह की तरह इस्तेमाल किया जा सकता है:

print(greet_me())

प्रिंट:

Hello

lambda दलीलें भी ले सकते हैं:

strip_and_upper_case = lambda s: s.strip().upper()

strip_and_upper_case("  Hello   ")

स्ट्रिंग लौटाता है:

HELLO

वे सामान्य कार्यों की तरह, मनमाने ढंग से तर्क / खोजशब्द तर्क भी ले सकते हैं।

greeting = lambda x, *args, **kwargs: print(x, args, kwargs)
greeting('hello', 'world', world='world')

प्रिंट:

hello ('world',) {'world': 'world'}

lambda s आमतौर पर छोटे कार्यों के लिए उपयोग किया जाता है जो उस बिंदु पर परिभाषित करने के लिए सुविधाजनक होते हैं जहां उन्हें कहा जाता है (आमतौर पर sorted , filter और map )।

उदाहरण के लिए, यह रेखा उनके मामले की अनदेखी करने और शुरुआत में और अंत में व्हाट्सएप की अनदेखी करने वाले तार की एक सूची बनाती है:

sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip().upper())
# Out:
# ['    bAR', 'BaZ    ', ' foo ']

सूची को केवल व्हाट्सएप की अनदेखी करें:

sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip())
# Out:
# ['BaZ    ', '    bAR', ' foo ']

map साथ उदाहरण:

sorted( map( lambda s: s.strip().upper(), [" foo ", "    bAR", "BaZ    "]))
# Out:
# ['BAR', 'BAZ', 'FOO']

sorted( map( lambda s: s.strip(), [" foo ", "    bAR", "BaZ    "]))
# Out:
# ['BaZ', 'bAR', 'foo']

संख्यात्मक सूचियों के उदाहरण:

my_list = [3, -4, -2, 5, 1, 7]
sorted( my_list, key=lambda x: abs(x))
# Out:
# [1, -2, 3, -4, 5, 7]

list( filter( lambda x: x>0, my_list))
# Out:
# [3, 5, 1, 7]

list( map( lambda x: abs(x), my_list))
# Out:
[3, 4, 2, 5, 1, 7]

एक मेमने के कार्य के अंदर से अन्य कार्यों को (तर्कों के साथ / बिना) कह सकते हैं।

def foo(msg):
    print(msg)

greet = lambda x = "hello world": foo(x)
greet()

प्रिंट:

hello world

यह उपयोगी है क्योंकि lambda में केवल एक ही अभिव्यक्ति हो सकती है और एक सहायक फ़ंक्शन का उपयोग करके कोई भी एक से अधिक कथन चला सकता है।

ध्यान दें

यह ध्यान रखें कि PEP-8 (आधिकारिक पायथन शैली गाइड) चर को लैम्ब्डा निर्दिष्ट करने की अनुशंसा नहीं करता है (जैसा कि हमने पहले दो उदाहरणों में किया था):

हमेशा एक असाइनमेंट स्टेटमेंट के बजाय एक डिफ स्टेटमेंट का उपयोग करें जो एक पहचानकर्ता को सीधे एक लैम्ब्डा अभिव्यक्ति को बांधता है।

हाँ:

def f(x): return 2*x

नहीं:

f = lambda x: 2*x

पहले रूप का मतलब है कि परिणामी फ़ंक्शन ऑब्जेक्ट का नाम विशेष रूप से जेनेरिक <lambda> बजाय f । यह सामान्य रूप से ट्रेसबैक और स्ट्रिंग अभ्यावेदन के लिए अधिक उपयोगी है। असाइनमेंट स्टेटमेंट का उपयोग एकमात्र लाभ को समाप्त करता है एक लैम्ब्डा अभिव्यक्ति स्पष्ट def स्टेटमेंट (यानी कि यह एक बड़ी अभिव्यक्ति के अंदर एम्बेड किया जा सकता है) पर पेश कर सकता है।

तर्क पारित करना और परिवर्तनशीलता

सबसे पहले, कुछ शब्दावली:

• तर्क ( वास्तविक पैरामीटर): वास्तविक चर एक समारोह में पारित किया जा रहा है;
• पैरामीटर ( औपचारिक पैरामीटर): प्राप्त चर जो किसी फ़ंक्शन में उपयोग किया जाता है।

पायथन में, असाइनमेंट द्वारा तर्क पारित किए जाते हैं (अन्य भाषाओं के विपरीत, जहां तर्क मूल्य / संदर्भ / सूचक द्वारा पारित किए जा सकते हैं)।

• पैरामीटर को म्यूट करना तर्क को म्यूट करेगा (यदि तर्क का प्रकार परस्पर है)।

  def foo(x):        # here x is the parameter
      x[0] = 9       # This mutates the list labelled by both x and y
      print(x)
  
  y = [4, 5, 6]
  foo(y)             # call foo with y as argument
  # Out: [9, 5, 6]   # list labelled by x has been mutated
  print(y)           
  # Out: [9, 5, 6]   # list labelled by y has been mutated too
  

• पैरामीटर को पुन: असाइन करना तर्क को पुन: असाइन नहीं करेगा।

  def foo(x):        # here x is the parameter, when we call foo(y) we assign y to x
      x[0] = 9       # This mutates the list labelled by both x and y
      x = [1, 2, 3]  # x is now labeling a different list (y is unaffected)
      x[2] = 8       # This mutates x's list, not y's list
    
  y = [4, 5, 6]      # y is the argument, x is the parameter
  foo(y)             # Pretend that we wrote "x = y", then go to line 1
  y
  # Out: [9, 5, 6]
  

पायथन में, हम वास्तव में वेरिएबल्स के लिए मान निर्दिष्ट नहीं करते हैं, इसके बजाय हम ऑब्जेक्ट्स को बांधते हैं (यानी असाइन करते हैं, संलग्न करते हैं) ( नाम के रूप में माना जाता है )।

• अपरिवर्तनीय: Integers, strings, tuples, और इसी तरह। सभी ऑपरेशन कॉपी बनाते हैं।
• म्यूटेबल: सूचियाँ, शब्दकोश, सेट, और इसी तरह। संचालन म्यूट नहीं हो सकता है या नहीं।

x = [3, 1, 9]
y = x
x.append(5)    # Mutates the list labelled by x and y, both x and y are bound to [3, 1, 9]
x.sort()       # Mutates the list labelled by x and y (in-place sorting)
x = x + [4]    # Does not mutate the list (makes a copy for x only, not y)
z = x          # z is x ([1, 3, 9, 4])
x += [6]       # Mutates the list labelled by both x and z (uses the extend function).
x = sorted(x)  # Does not mutate the list (makes a copy for x only).
x
# Out: [1, 3, 4, 5, 6, 9]
y
# Out: [1, 3, 5, 9]
z
# Out: [1, 3, 5, 9, 4, 6]

समापन

पायथन में क्लोज़र फ़ंक्शन कॉल द्वारा बनाए जाते हैं। यहाँ, कॉल करने के लिए makeInc x लिए एक बंधन बनाता है जो फ़ंक्शन inc अंदर संदर्भित होता है। makeInc लिए प्रत्येक कॉल इस फ़ंक्शन का एक नया उदाहरण बनाता है, लेकिन प्रत्येक उदाहरण में x एक अलग बाइंडिंग के लिए एक लिंक होता है।

def makeInc(x):
  def inc(y):
     # x is "attached" in the definition of inc
     return y + x

  return inc

incOne = makeInc(1)
incFive = makeInc(5)

incOne(5) # returns 6
incFive(5) # returns 10

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

def makeInc(x):
  def inc(y):
     # incrementing x is not allowed
     x += y  
     return x

  return inc

incOne = makeInc(1)
incOne(5) # UnboundLocalError: local variable 'x' referenced before assignment

अजगर 3 प्रस्तावों nonlocal बयान ( nonlocal चर नेस्टेड कार्यों के साथ एक पूर्ण बंद को साकार करने के लिए)।

def makeInc(x):
  def inc(y):
     nonlocal x
     # now assigning a value to x is allowed
     x += y  
     return x

  return inc

incOne = makeInc(1)
incOne(5) # returns 6

पुनरावर्ती कार्य

एक पुनरावर्ती कार्य एक फ़ंक्शन है जो अपनी परिभाषा में खुद को कहता है। उदाहरण के लिए गणितीय कार्य, भाज्य, factorial(n) = n*(n-1)*(n-2)*...*3*2*1 द्वारा परिभाषित। के रूप में क्रमादेशित किया जा सकता है

def factorial(n):
    #n here should be an integer
    if n == 0:
        return 1
    else:
        return n*factorial(n-1)

यहाँ आउटपुट हैं:

factorial(0)
#out 1
factorial(1)
#out 1
factorial(2)
#out 2
factorial(3)
#out 6

जैसा सोचा था। ध्यान दें कि यह फ़ंक्शन पुनरावर्ती है क्योंकि दूसरा return factorial(n-1) , जहां फ़ंक्शन अपनी परिभाषा में खुद को कहता है।

कुछ पुनरावर्ती कार्यों को लैम्ब्डा का उपयोग करके कार्यान्वित किया जा सकता है, लैम्बडा का उपयोग करके फैक्टोरियल फ़ंक्शन कुछ इस तरह होगा:

factorial = lambda n: 1 if n == 0 else n*factorial(n-1)

फ़ंक्शन उपरोक्त के समान ही आउटपुट करता है।

पुनरावृत्ति की सीमा

संभावित पुनरावृत्ति की गहराई की एक सीमा है, जो पायथन कार्यान्वयन पर निर्भर करता है। जब सीमा पूरी हो जाती है, तो RuntimeError अपवाद उठाया जाता है:

def cursing(depth):
  try:
    cursing(depth + 1) # actually, re-cursing
  except RuntimeError as RE:
    print('I recursed {} times!'.format(depth))

cursing(0)
# Out: I recursed 1083 times!

sys.setrecursionlimit(limit) का उपयोग करके पुनरावृत्ति की गहराई सीमा को बदलना और sys.getrecursionlimit() द्वारा इस सीमा की जांच करना sys.getrecursionlimit() ।

sys.setrecursionlimit(2000)
cursing(0)
# Out: I recursed 1997 times!

पायथन 3.5 से, अपवाद एक RecursionError , जो RuntimeError से लिया गया है।

निहित कार्य

अजगर में कार्य प्रथम श्रेणी की वस्तुएं हैं। उन्हें किसी भी दायरे में परिभाषित किया जा सकता है

def fibonacci(n):
    def step(a,b):
        return b, a+b
    a, b = 0, 1
    for i in range(n):
        a, b = step(a, b)
    return a

किसी अन्य प्रकार की वस्तु की तरह क्रियाकलापों को उनके घेरने के दायरे पर कब्जा किया जा सकता है

def make_adder(n):
    def adder(x):
        return n + x
    return adder
add5 = make_adder(5)
add6 = make_adder(6)
add5(10)
#Out: 15
add6(10)
#Out: 16

def repeatedly_apply(func, n, x):
    for i in range(n):
        x = func(x)
    return x

repeatedly_apply(add5, 5, 1)
#Out: 26

Iterable और शब्दकोश अनपैकिंग

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

def unpacking(a, b, c=45, d=60, *args, **kwargs):
    print(a, b, c, d, args, kwargs)

>>> unpacking(1, 2)
1 2 45 60 () {}
>>> unpacking(1, 2, 3, 4)
1 2 3 4 () {}
>>> unpacking(1, 2, c=3, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, c=3)
1 2 3 4 () {}


>>> pair = (3,)
>>> unpacking(1, 2, *pair, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, *pair)
1 2 3 4 () {}
>>> unpacking(1, 2, *pair, c=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'
>>> unpacking(1, 2, c=3, *pair)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'

>>> args_list = [3]
>>> unpacking(1, 2, *args_list, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, *args_list)
1 2 3 4 () {}
>>> unpacking(1, 2, c=3, *args_list)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'
>>> unpacking(1, 2, *args_list, c=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'


>>> pair = (3, 4)
>>> unpacking(1, 2, *pair)
1 2 3 4 () {}
>>> unpacking(1, 2, 3, 4, *pair)
1 2 3 4 (3, 4) {}
>>> unpacking(1, 2, d=4, *pair)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, *pair, d=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'



>>> args_list = [3, 4]
>>> unpacking(1, 2, *args_list)
1 2 3 4 () {}
>>> unpacking(1, 2, 3, 4, *args_list)
1 2 3 4 (3, 4) {}
>>> unpacking(1, 2, d=4, *args_list)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, *args_list, d=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'


>>> arg_dict = {'c':3, 'd':4}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {}
>>> arg_dict = {'d':4, 'c':3}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {}
>>> arg_dict = {'c':3, 'd':4, 'not_a_parameter': 75}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {'not_a_parameter': 75}


>>> unpacking(1, 2, *pair, **arg_dict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, 3, 4, **arg_dict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'

# Positional arguments take priority over any other form of argument passing
>>> unpacking(1, 2, **arg_dict, c=3)
1 2 3 4 () {'not_a_parameter': 75}
>>> unpacking(1, 2, 3, **arg_dict, c=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'

नामित मापदंडों के उपयोग के लिए मजबूर करना

फ़ंक्शन हस्ताक्षर में पहले तारांकन के बाद निर्दिष्ट सभी पैरामीटर केवल कीवर्ड हैं।

def f(*a, b):
    pass

f(1, 2, 3)
# TypeError: f() missing 1 required keyword-only argument: 'b'

पायथन 3 में, फ़ंक्शन हस्ताक्षर में एक एकल तारांकन करना संभव है ताकि यह सुनिश्चित किया जा सके कि शेष तर्कों को केवल दलीलों का उपयोग करके पारित किया जा सकता है।

def f(a, b, *, c):
    pass

f(1, 2, 3)
# TypeError: f() takes 2 positional arguments but 3 were given
f(1, 2, c=3)
# No error

असाइन किए गए वेरिएबल का उपयोग करके पुनरावर्ती लैंबडा

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

lambda_factorial = lambda i:1 if i==0 else i*lambda_factorial(i-1)
print(lambda_factorial(4)) # 4 * 3 * 2 * 1 = 12 * 2 = 24

कोड का विवरण

लैंबडा फ़ंक्शन, इसके चर असाइनमेंट के माध्यम से, एक मान (4) पारित किया जाता है, जो इसका मूल्यांकन करता है और 1 रिटर्न करता है यदि यह 0 है या फिर यह वर्तमान मान लौटाता है ( i ) * मान के लैम्ब्डा फ़ंक्शन द्वारा एक और गणना - 1 ( i-1 ) है। यह तब तक जारी रहता है जब तक कि पारित मूल्य 0 ( return 1 ) के लिए घटाया नहीं जाता है। एक प्रक्रिया जिसकी कल्पना की जा सकती है: