Python Language
संकेत टाइप करें

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

• typing.Callable [[int, str], कोई नहीं] -> def func (a: int, b: str) -> कोई नहीं
• टाइपिंग। मैपिंग [str, int] -> {"a": 1, "b": 2, "c": 3}
• टाइपिंग। सूची [इंट] -> [१, २, ३]
• टाइपिंग। सेट [int] -> {1, 2, 3}
• टाइपिंग। वैकल्पिक [इंट] -> कोई नहीं या इंट
• टाइपिंग। असमानता [int] -> [१, २, ३] या (१, २, ३)
• टाइपिंग। किसी भी प्रकार का
• typing.Uionion [int, str] -> 1 या "1"
• टी = टाइपिंग। टाइप वी ('टी') -> सामान्य प्रकार

टिप्पणियों

सामान्य प्रकार

typing.TypeVar एक सामान्य प्रकार का कारखाना है। यह प्राथमिक लक्ष्य सामान्य कार्य / वर्ग / विधि एनोटेशन के लिए एक पैरामीटर / प्लेसहोल्डर के रूप में सेवा करना है:

import typing

T = typing.TypeVar("T")

def get_first_element(l: typing.Sequence[T]) -> T:
    """Gets the first element of a sequence."""
    return l[0]

किसी फ़ंक्शन में प्रकार जोड़ना

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

def two_sum(a, b):
    return a + b

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

print(two_sum(2, 1))  # result: 3

और तार के साथ:

print(two_sum("a", "b"))  # result: "ab"

और अन्य मूल्यों के साथ, जैसे कि list एस, tuple एस वगैरह।

अजगर प्रकारों की इस गतिशील प्रकृति के कारण, जहां कई दिए गए ऑपरेशन के लिए लागू होते हैं, किसी भी प्रकार के चेकर यथोचित रूप से यह दावा नहीं कर पाएंगे कि इस फ़ंक्शन के लिए कॉल की अनुमति दी जानी चाहिए या नहीं।

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

यह इंगित करने के लिए कि हम केवल int प्रकारों को अनुमति देना चाहते हैं हम अपनी फ़ंक्शन परिभाषा को बदल सकते हैं जैसे कि:

def two_sum(a: int, b: int):
    return a + b

एनोटेशन तर्क नाम का अनुसरण करते हैं और a : वर्ण द्वारा अलग किए जाते हैं।

इसी तरह, इंगित करने के लिए केवल str प्रकार की अनुमति है, हम अपने समारोह में यह निर्दिष्ट करने के लिए बदल देंगे:

def two_sum(a: str, b: str): 
    return a + b

तर्कों के प्रकार को निर्दिष्ट करने के अलावा, कोई फ़ंक्शन कॉल के रिटर्न मान का संकेत भी दे सकता है। यह तर्क सूची में बंद कोष्ठक के बाद टाइप -> वर्ण को जोड़कर किया जाता है, लेकिन फ़ंक्शन घोषणा के अंत में : से पहले:

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

अब हमने संकेत दिया है कि two_sum पर कॉल करते समय रिटर्न वैल्यू टाइप int की होनी चाहिए। इसी प्रकार हम str , float , list , set और अन्य के लिए उपयुक्त मान निर्धारित कर सकते हैं।

यद्यपि टाइप संकेत ज्यादातर प्रकार के चेकर्स और आईडीई द्वारा उपयोग किए जाते हैं, कभी-कभी आपको उन्हें पुनर्प्राप्त करने की आवश्यकता हो सकती है। यह __annotations__ विशेष विशेषता का उपयोग करके किया जा सकता है:

two_sum.__annotations__
# {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

कक्षा के सदस्य और तरीके

class A:
    x = None  # type: float
    def __init__(self, x: float) -> None:
        """
        self should not be annotated
        init should be annotated to return None
        """
        self.x = x
    
    @classmethod
    def from_int(cls, x: int) -> 'A': 
        """
        cls should not be annotated
        Use forward reference to refer to current class with string literal 'A'
        """
        return cls(float(x))

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

चर और गुण

चर का उपयोग टिप्पणियों के साथ किया जाता है:

x = 3  # type: int
x = negate(x)
x = 'a type-checker might catch this error'

x: int = 3

y: int

class Foo:
    x: int
    y: str = 'abc'

print(typing.get_type_hints(Foo))
# ChainMap({'x': <class 'int'>, 'y': <class 'str'>}, {})

x: int
print(__annotations__)
# {'x': <class 'int'>}

class C:
    s: str
print(C.__annotations__)
# {'s': <class 'str'>}

NamedTuple

टाइप हिंट के साथ एक नेमप्लुप बनाना typing मॉड्यूल से फ़ंक्शन NamedTuple का उपयोग करके किया जाता है:

import typing
Point = typing.NamedTuple('Point', [('x', int), ('y', int)])

ध्यान दें कि परिणामी प्रकार का नाम फ़ंक्शन का पहला तर्क है, लेकिन इसे उसी नाम के साथ एक चर को सौंपा जाना चाहिए ताकि प्रकार चेकर्स के काम को आसान बनाया जा सके।

कीवर्ड तर्क के लिए संकेत टाइप करें

def hello_world(greeting: str = 'Hello'):
    print(greeting + ' world!')

समान रूप से संकेत के विपरीत रिक्त स्थान पर ध्यान दें कि कीवर्ड तर्क आमतौर पर कैसे स्टाइल किए जाते हैं।