python - फंक्शन तर्क(उदाहरण के लिए पायथन में)




function arguments (6)

आपके उदाहरण में वे उपयोग नहीं किया जाता है

यदि आपके फ़ंक्शन को आप किस तर्क को देते हैं, इसके आधार पर अलग ढंग से व्यवहार करने की आवश्यकता होती है, तो इसके लिए तर्क क्या हैं।

def hi_name(name):
    print 'Hi ' + name

hi_name("John doe")

यह "हाय जॉन डो" प्रिंट करता है

अब फ़ंक्शंस के बारे में मूल बातें

[समारोह] तर्क क्या हैं? ये किस काम की लिये प्रायोग होते है?
मैंने हाल ही में अजगर सीखना शुरू किया; मैं प्रोग्रामिंग के लिए नया हूँ और मैं इस मूल प्रश्न के लिए माफी चाहता हूं।

प्रत्येक पायथन ट्यूटोरियल में मैं इनके माध्यम से बहस के बारे में बात करता हूं। मैंने इस प्रश्न का जवाब देखा है और मुझे कई जवाब मिल गए हैं, लेकिन मेरे लिए बस कुछ मुश्किलें हैं I मैं बस कुछ वैचारिक पृष्ठभूमि गायब हो सकता है
इसलिए ... जब मैं एक फ़ंक्शन परिभाषित करता हूं, तो क्या कोष्ठक में इस्तेमाल किया जाता है? उदाहरण:

def hi( This is the part that i dont get):
     print 'hi'

संपादित करें:
इस एक से संबंधित दो अनुवर्ती प्रश्नों को बाद में बंद कर दिया गया था और यहां विलय किया गया था, इसलिए कुछ उत्तरों का आंशिक आउट-ऑफ-प्रैक्टिकल गुण।
अनुवर्ती प्रश्न थे: [पैराफ्रस]


कुछ शब्दों में, वे ऐसे डेटा होते हैं जो कार्य करने के लिए "इसे" बताते हैं कि क्या करना है। विकिपीडिया में विवरण है

http://en.wikipedia.org/wiki/Function_argument

उदाहरण के लिए, आपका hi() फ़ंक्शन को यह जानना ज़रूरी हो सकता है कि कौन कहता है:

def hi(person):
    print "Hi there " + person + ", how are you?"

या किसी गणितीय फ़ंक्शन को संचालित करने के लिए एक मूल्य की आवश्यकता हो सकती है:

def square(x):
     return x * x

यदि आप उन्हें जानकारी नहीं दे सकते हैं, तो उन्हें कार्य करना बेकार होगा।
तर्क ऐसी जानकारी है

def GiveMeANumberAndIDuplicateIt(x):
    return x * 2

def DontGiveMeAnythingAtAll():
    return None

एक तर्क एक विशेष चर है जो उस समारोह में मौजूद है।

आपके उदाहरण में आपके पास एक फ़ंक्शन है जो 2 तर्कों को लेता है:

def add(num1,num2):
    x = num1 + num2
    return x

जब मैं इस फ़ंक्शन को add() साथ कॉल करता हूं, तो मुझे कोष्ठकों में जोड़ना होगा जो मुझे num1 और num2 होना चाहिए। आपके मामले में, आपके पास 1 और 3 , इसलिए आप इसे इस तरह add(1,3)

आप क्या कह रहे हैं कि आप add() चाहते add() और आप पहली तर्क चाहते हैं, num1 के बराबर हो, और दूसरा तर्क, num2 , 3 बराबर हो।


यदि अर्ग एक अस्थिर वस्तु है, तो आप इसे एक आउटपुट कंटेनर के रूप में भी उपयोग कर सकते हैं, उदाहरण के लिए:

def sort_my_arg(foo)
  foo.sort()

x = [1, 3, 2]
sort_my_arg(x)
print x

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

def complicated_calculation(x, cache={})
  if cache.has_key(x):
    # we have already computed this one
    pass
  else:
    # complete some complicated deterministic calculation, and add it to cache
    # ...
    cache[x] = result
  return cache[x]

यह एक पायथन सवाल नहीं है, बल्कि एक सामान्य प्रोग्रामिंग प्रश्न है। एक बहुत ही बुनियादी एक

तर्कों के बारे में प्रश्न का उत्तर देने से पहले, और आपके द्वारा पूछे गए अन्य सवालों को देखते हुए, चर की अवधारणा के बारे में चर्चा करना उपयोगी है।
एक चर स्मृति का नामित टुकड़ा है, जहां अंतर्निहित कार्यक्रम को ब्याज की जानकारी संग्रहीत और पुनः प्राप्त की जा सकती है। दूसरे शब्दों में, यह एक प्रतीकात्मक नाम है, जिसे प्रोग्रामर द्वारा चुना गया है, जो इसकी सामग्री से जुड़ा है। आमतौर पर असाइनमेंट्स के रूप में जाने जाने वाले विभिन्न भाषा निर्माणों का उपयोग करते हुए, प्रोग्रामर एक चर की सामग्री को पढ़ या लिख ​​सकता है
यह ध्यान रखना ज़रूरी है कि एक चर की वैल्यू (यानी सामग्री) को परिभाषित नहीं किया जाना चाहिए जब प्रोग्राम लिखा हो। यह रन-टाइम में केवल आवश्यक है इससे कार्यक्रम को प्रतीकात्मक तत्वों पर किए जाने वाले कार्यों का वर्णन करने की अनुमति मिलती है, इन तत्वों के मूल्य के बारे में जानने के बिना। इस स्निपेट पर विचार करें, एक बड़ा कार्यक्रम का हिस्सा:

# ... some logic above
ball_volume = 4.0 / 3 * math.pi * ball_radius
if ball_volume > 200:
   print ("Man, that's a big ball")
# ... more logic below

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

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

  • डेटाबेस
  • पाठ फ़ाइलें या फाइलें विभिन्न पाठ-आधार प्रारूप (XML, JSON, CSV ..)
  • विभिन्न स्वरूपों के साथ बाइनरी फ़ाइलें
  • इंटरनेट कनेक्शन
  • भौतिक डिवाइस: कैमरे, तापमान सेंसर ...

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

>>> def say_hello(my_name):
...    print("Hello,", my_name, "!")

>>> say_hello("Sam")
Hello, Sam !
>>> customer_name = "Mr Peter Clark"    #imagine this info came from a database
>>> # ...
>>> say_hello(customer_name)
Hello, Mr Peter Clark !
>>>

उपरोक्त उदाहरण में, my_name ही say_hello फ़ंक्शन के किसी भी स्थानीय चर की तरह है; यह फ़ंक्शन को यह परिभाषित करने की अनुमति देता है कि फ़ंक्शन को रन-टाइम पर जब कहा जाता है तो अंतर्निहित मान के साथ क्या होगा।
रन-टाइम में, फ़ंक्शन को तत्काल मूल्य (एक मूल्य जो तर्क में "हार्ड-कोडित" है, जैसे कि "Sam" उदाहरण में), या एक अन्य चर के मूल्य के साथ (जैसे कि customer_name ) दोनों मामलों में फ़ंक्शन के my_name चर का मूल्य क्रमशः कुछ मान, "सैम" और "मिस्टर पीटर क्लार्क" को सौंपा जाता है। उत्तरार्द्ध मामले में, यह मान customer_name चर है जो भी है। नोट करें कि फ़ंक्शन ( my_name ) के अंदर उपयोग किए जाने वाले चर के नाम और जब फ़ंक्शन को कॉल किया जाता है ( customer_name ) को समान होने की आवश्यकता नहीं होती है (इन्हें क्रमशः "औपचारिक पैरामीटर" और "वास्तविक पैरामीटर" कहा जाता है)

ध्यान दें कि आम तौर पर जब किसी फ़ंक्शन पर इनपुट के रूप में पारित किए जाने वाले अधिकांश तर्क , कुछ स्थितियों में, उन्हें आउटपुट के रूप में उपयोग किया जा सकता है , अर्थात तर्क के स्तर पर नए / संशोधित मान प्रदान करने के लिए जो फ़ंक्शन को कहते हैं। ऐसा करने के लिए, निहित या स्पष्ट रूप से, उचित कॉलिंग सम्मेलन विनिर्देश (नीचे दिए गए Argument passing conventions देखें) देखें।

अब ... मापदंडों के उद्देश्य से यह बहुत ही मूलभूत समझ से परे, चीजें उस से थोड़ा अधिक जटिल हो जाती हैं (लेकिन ज्यादा नहीं)। मैं सामान्य रूप से इन अतिरिक्त अवधारणाओं पर चर्चा करूंगा और उनको वर्णन करेगा जैसा कि वे अजगर पर लागू होते हैं।

तर्कों के लिए डिफ़ॉल्ट मान (उर्फ "वैकल्पिक" तर्क)
जब प्रकार्य घोषित किया जाता है तो यह कुछ मापदंडों के लिए डिफ़ॉल्ट मान निर्दिष्ट कर सकता है। इन मानों का उपयोग उन पैरामीटर के लिए किया जाता है जो निर्दिष्ट नहीं किए जाते हैं जब फ़ंक्शन कहा जाता है। स्पष्ट कारणों के लिए ये वैकल्पिक पैरामीटर पैरामीटर सूची के अंत में पाए जाते हैं (अन्यथा भाषा कंपाइलर / इंटरप्रेटर में यह पता लगाना मुश्किल हो सकता है कि कौन सा पैरामीटर है ...)

>>> def say_hello(dude = "Sir"):
...     print("Hello,", dude, "!")
...
>>> say_hello()
Hello, Sir !
>>> say_hello("William Gates")
Hello, Bill !            #just kidding ;-)
Hello, William Gates !   # but indeed. works as the original function when param
                         # is specified

मापदंडों की चर संख्या
कुछ मामलों में यह एक समारोह को परिभाषित करने के लिए आसान हो सकता है ताकि वह मानकों की एक चर संख्या को स्वीकार कर सके। हालांकि पैरामीटर मानों की ऐसी सूची अंततः किसी प्रकार के कंटेनर (सूची, सरणी, संग्रह ...) में पारित हो जाती है, हालांकि विभिन्न भाषाओं ऐसे पैरामीटर मानों को एक्सेस करने के सुविधाजनक तरीके प्रदान करते हैं।

>>> def add_many(operand1, *operands):
...    Sum = operand1
...    for op in operands:
...       Sum += op
...    return Sum
...
>>> add_many(1, 3, 5, 7, 20)
36
>>> add_many(1, 3)
4

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

>>> def do_greetings(greeting, person):
...    print (greeting, "dear", person, "!")
...
>>> do_greetings(person="Jack", greeting="Good evening")
Good evening dear Jack !

पायथन में, आप कई शब्दकोशों के बजाय उदाहरण के लिए डिक्शनरी पास कर सकते हैं, उदाहरण के लिए, do_greetingsas के साथ, कल्पना कीजिए कि आपके पास एक शब्दकोश है:

>>> my_param_dict = {"greeting":"Aloha", "person":"Alan"}

>>> do_greetings(**my_param_dict)
Aloha dear Alan !

समापन में, और तर्कों को पारित करने के फैंसी तरीके, और तर्कों की संख्या को संभाल करने के तरीकों के लिए क्षमता विभिन्न भाषाओं की उपयोगी विशेषताएं हैं, दो प्रमुख अवधारणाओं का उल्लेख किया जाना चाहिए:

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

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

कक्षा के तरीकों का "आत्म" या "इस" तर्क का अभिप्राय
ऑब्जेक्ट ओरिएंटेड भाषाओं में, तरीकों (अर्थात कक्षा में कार्य) एक अतिरिक्त तर्क प्राप्त होता है जो अंतर्निहित ऑब्जेक्ट (क्लास का उदाहरण) का मान होता है, जिससे विधि को अपनी गणना और / या में वर्ग के विभिन्न प्रॉपर्टी सदस्यों का उपयोग करने की अनुमति मिलती है। इन गुणों में से कुछ का मूल्य बदलना

पायथन में, यह तर्क विधि परिभाषा के स्तर पर घोषित किया गया है, लेकिन पारस्परिक रूप से पारित किया गया है। घोषित होने के बाद, इसे किसी भी एक इच्छा का नाम दिया जा सकता है, हालांकि सम्मेलन द्वारा इसे आमतौर पर स्व कहा जाता है।

>>> class Accumulator:
...   def __init__(self, initialValue = 0):
...        self.CurValue = initialValue
...   def Add(self, x):
...        self.CurValue += x
...        return self.CurValue
...
>>> my_accu = Accumulator(10)
>>> my_accu.Add(5)
15
>>> my_accu.Add(3)
18




argument-passing