फ़ंक्शन रिटर्न प्रकार और तर्क प्रकार कैसे पता करें?

Question

जबकि मैं पायथन की बतख-टाइपिंग अवधारणा से अवगत हूं, मैं कभी-कभी फ़ंक्शन के प्रकार, या फ़ंक्शन के रिटर्न मान के प्रकार के साथ संघर्ष करता हूं।

अब, यदि मैंने फ़ंक्शन को स्वयं लिखा है, तो मुझे इसके प्रकार पता हैं। लेकिन क्या होगा अगर कोई मेरे कार्यों का उपयोग और कॉल करना चाहता है, तो उसे प्रकार जानने की उम्मीद कैसे है? मैं आमतौर पर फ़ंक्शन के डॉकस्ट्रिंग में टाइप जानकारी रखता हूं (जैसे: "...the id argument should be an integer..."और "... the function will return a (string, [integer]) tuple.")

लेकिन डॉकस्ट्रिंग में जानकारी को देख रहा है (और इसे एक कोडर के रूप में वहां डाल रहा है) वास्तव में जिस तरह से इसे करना चाहिए था?

संपादित करें: जबकि अधिकांश उत्तर "हां, दस्तावेज!" मुझे लगता है कि यह हमेशा 'जटिल' प्रकारों के लिए बहुत आसान नहीं है।
उदाहरण के लिए: डॉकस्ट्रिंग में संक्षिप्त रूप से कैसे वर्णन किया जाए कि कोई फ़ंक्शन tuples की सूची देता है, प्रत्येक tuple of the form (नोड_id, node_name, uptime_minutes) के साथ और तत्व क्रमशः एक स्ट्रिंग, स्ट्रिंग और पूर्णांक हैं?
Docstring PEP प्रलेखन उस पर कोई दिशानिर्देश नहीं देता है।
मुझे लगता है कि प्रतिवाद यह होगा कि उस स्थिति में कक्षाओं का उपयोग किया जाना चाहिए, लेकिन मुझे अजगर बहुत लचीला लगता है क्योंकि यह सूचियों और ट्यूपल्स का उपयोग करके इन चीजों को पास करने की अनुमति देता है, अर्थात बिना कक्षाओं के।

Comments

छोटा जवाब हां है"। लंबा उत्तर "हां, बिल्कुल" है। मुझे नहीं पता कि आपने बहुत से पायथन कोड को देखा है, लेकिन आपको संभवतः यह इंगित करने के लिए प्रश्न का अद्यतन करना चाहिए कि आप वास्तव में किन पैकेजों का उपयोग करते हैं, इसलिए हम आपको कोड को निर्देशित कर सकते हैं कि आप यह देखने के लिए पढ़ सकते हैं कि लाइब्रेरी कोड में चीजें आपके द्वारा कैसे की जाती हैं वास्तव में अभी उपयोग कर रहे हैं।

— एस.लॉट

@ एस.लॉट: मैं वर्तमान में मैकेनाइज पैकेज से जूझ रहा हूं, लेकिन मुझे लगता है कि यह सिर्फ (दुर्भाग्य से) खराब दस्तावेज है।

— राबार्शस्की 12

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

— जरमोद

Answer 1

खैर 2011 से चीजें थोड़ी बदल गई हैं! अब Python 3.5 में टाइप संकेत हैं , जिसका उपयोग आप तर्कों को एनोटेट करने और अपने फ़ंक्शन के प्रकार को वापस करने के लिए कर सकते हैं। उदाहरण के लिए यह:

def greeting(name):
  return 'Hello, {}'.format(name)

अब इसे इस प्रकार लिखा जा सकता है:

def greeting(name: str) -> str:
  return 'Hello, {}'.format(name)

जैसा कि आप अब प्रकार देख सकते हैं, कुछ प्रकार के वैकल्पिक स्थिर प्रकार की जाँच है जो आपको और आपके प्रकार के चेकर को आपके कोड की जांच करने में मदद करेगी।

अधिक स्पष्टीकरण के लिए मैं PyCharm ब्लॉग में टाइप संकेत पर ब्लॉग पोस्ट पर एक नज़र डालने का सुझाव देता हूं ।

Comments

ध्यान दें कि एक PEP-0484 में यहां Python 2.7 के लिए एक प्रकार का संकेत सिंटैक्स भी सुझाया गया था । और यह PyCharm में काम करता है, कम से कम v 2017.3 से।

— viddik13

यदि ग्रीटिंग फ़ंक्शन ठीक उसी परिभाषा के साथ int के प्रकार का ऑब्जेक्ट देता है, तो कोई त्रुटि नहीं उठेगी। यदि आप वापसी प्रकार का स्पष्ट रूप से उल्लेख करते हैं तो इस प्रकार की जाँच का क्या उपयोग है, लेकिन नियम का पालन न करें और विभिन्न प्रकार की वस्तु लौटाएँ?

— अराशिह

@ आर्शीव: हाँ, आप सही कह रहे हैं, टाइप करने से पाइथन को वैधानिक रूप से टाइप की जाने वाली भाषा में नहीं बदल जाता है, सही तरीके से सही प्रकार का उपयोग करना आपके ऊपर है। और उन प्रकार के संकेत आपकी सहायता करते हैं - तेजी से विकसित करने के लिए, अपने कोड को स्व-दस्तावेज करें या जब आप कुछ गड़बड़ करते हैं तो चेतावनी दें। विशेष रूप से जब आप PyCharm (या समान IDE) का उपयोग करते हैं, तो यह आपको चेतावनी देगा कि आप विभिन्न प्रकारों का उपयोग करते हैं और कुछ अन्य चीजों के साथ मदद करते हैं। मैं ऊपर दिए गए उत्तर में सुझाए गए ब्लॉग पोस्ट को पढ़ने की सलाह देता हूं।

— 14

क्या यह तेजी से कम्प्यूटेशनल है?

— ब्रायस वेन

Answer 2

इस तरह गतिशील भाषाएँ काम करती हैं। हालांकि यह हमेशा एक अच्छी बात नहीं है, खासकर अगर दस्तावेज खराब है - किसी ने खराब दस्तावेज वाले अजगर ढांचे का उपयोग करने की कोशिश की है? कभी-कभी आपको स्रोत को पढ़ने के लिए वापस लौटना पड़ता है।

बतख टाइपिंग की समस्याओं से बचने के लिए यहां कुछ रणनीतियाँ दी गई हैं:

• अपने समस्या डोमेन के लिए एक भाषा बनाएं
• यह आपको सामान को ठीक से नाम देने में मदद करेगा
• अपनी डोमेन भाषा में अवधारणाओं का प्रतिनिधित्व करने के लिए प्रकारों का उपयोग करें
• डोमेन भाषा शब्दावली का उपयोग करते हुए नाम फ़ंक्शन पैरामीटर

इसके अलावा, सबसे महत्वपूर्ण बिंदुओं में से एक:

• जितना संभव हो उतना स्थानीय रखें!

केवल कुछ अच्छी तरह से परिभाषित और प्रलेखित प्रकारों को पास होना चाहिए। कोड को देखकर और कुछ भी स्पष्ट होना चाहिए: दूर से आने वाले अजीब पैरामीटर प्रकार न हों जो आप कोड के आसपास के क्षेत्र को देखकर समझ नहीं सकते हैं ...

संबंधित, (और भी docstrings से संबंधित), अजगर नामक एक तकनीक है doctests। दस्तावेज़ का उपयोग कैसे करें कि आपके तरीकों का उपयोग करने की उम्मीद है - और एक ही समय में अच्छी इकाई परीक्षण कवरेज करें!

Comments

Numpy प्रलेखन उपरोक्त उत्तर में बताए गए दर्शन का एक अच्छा प्रतिनिधि उदाहरण है।

— संगीतकार पुतरीद

Answer 3

मैंने एक पाठ्यक्रम पाठ्यक्रम में भाग लिया, जिसमें एक पाठ था, जिसमें हमें डिज़ाइन नुस्खा के बारे में पढ़ाया गया था।

डॉकस्ट्रिंग प्रारूप के नीचे मुझे प्रीट्टी उपयोगी लगी।

डीई क्षेत्र (आधार, ऊंचाई):
    '' '(संख्या, संख्या) -> संख्या # ** TypeContract **
    आयाम आधार के साथ एक ट्रिंग के क्षेत्र को वापस करें # ** विवरण **
    और ऊंचाई

    >>> क्षेत्र (10,5) # ** उदाहरण **
    25.0
    >> क्षेत्र (2.5,3)
    3.75
    '' '
    वापसी (आधार * ऊँचाई) / २ 

मुझे लगता है कि अगर डॉकस्ट्रिंग्स को इस तरह लिखा जाता है, तो इससे डेवलपर्स को काफी मदद मिल सकती है।

वीडियो का लिंक [वीडियो देखें] : https://www.youtube.com/watch?v=QAPg6Vb_LgI

Answer 4

हां, आपको अपनी कक्षाओं और कार्यों को अन्य प्रोग्रामरों के अनुकूल बनाने के लिए डॉकस्ट्रिंग्स का उपयोग करना चाहिए:

अधिक: http://www.python.org/dev/peps/pep-0257/#what-is-a-docstring

कुछ संपादक आपको टाइप करते समय डॉकस्ट्रिंग्स देखने की अनुमति देते हैं, इसलिए यह वास्तव में काम को आसान बनाता है।

Comments

+1: यह दस्तावेज है, यह एकमात्र एकमात्र तरीका है, और यह सांख्यिकीय रूप से टाइप की गई भाषाओं के लिए भी है। वापसी प्रकार पूरी तस्वीर का एक नगण्य अंश हैं।

— detly

मुझे पसंद है मेरे प्रकार आपको बहुत बहुत धन्यवाद। प्रलेखन + प्रकार = स्वर्ग

— masm64

Answer 5

हाँ यही है।

पायथन में एक फ़ंक्शन को हमेशा एक ही प्रकार के एक चर को वापस नहीं करना पड़ता है (हालांकि आपका कोड अधिक पठनीय होगा यदि आपके फ़ंक्शन हमेशा उसी प्रकार वापस करते हैं)। इसका मतलब है कि आप फ़ंक्शन के लिए एक भी रिटर्न प्रकार निर्दिष्ट नहीं कर सकते हैं।

उसी तरह, मापदंडों को हमेशा एक ही प्रकार का नहीं होना चाहिए।

Answer 6

उदाहरण के लिए: डॉकस्ट्रिंग में संक्षिप्त रूप से कैसे वर्णन किया जाए कि कोई फ़ंक्शन tuples की सूची देता है, प्रत्येक tuple of the form (नोड_id, node_name, uptime_minutes) के साथ और तत्व क्रमशः एक स्ट्रिंग, स्ट्रिंग और पूर्णांक हैं?

उम ... इसका कोई "संक्षिप्त" विवरण नहीं है। यह जटिल है। आपने इसे जटिल बनाया है। और इसे डॉकस्ट्रिंग में जटिल प्रलेखन की आवश्यकता होती है।

क्षमा करें, लेकिन जटिलता है - अच्छी तरह से जटिल।

Comments

ठीक। ऑफ-टॉपिक (सॉर्ट-ऑफ): लेकिन फिर एक क्लीनर डिजाइन क्या होगा? क्लासेस?

— Rabarberski

@ रबारकी: जरूरी नहीं। यहां जटिलता अपरिहार्य लगती है। संक्षिप्तता हमेशा प्राप्त या वांछनीय नहीं है।

— S.Lott

इस तरह की चीज़ को दस्तावेज करने का एक स्पष्ट तरीका जावा जेनेरिक के समान कुछ का उपयोग करके है, जैसे: सूची <tuple <int, str, int >>। लेकिन वह पायथन तरीका नहीं है, बेहतर या बदतर के लिए।

— स्काइलर

Answer 7

हां, चूंकि यह एक गतिशील प्रकार की भाषा है;)

संदर्भ के लिए इसे पढ़ें: PEP 257

Answer 8

Docstrings (और सामान्य रूप में प्रलेखन)। PyPon 3 परिचय (वैकल्पिक) फ़ंक्शन एनोटेशन, जैसा कि PEP 3107 में वर्णित है (लेकिन डॉकस्ट्रिंग्स को न छोड़ें)