पायथन 3 के "फंक्शन एनोटेशन" के लिए अच्छे उपयोग क्या हैं

Question

समारोह व्याख्या: PEP-3107

मैं Python3 के फ़ंक्शन एनोटेशन का प्रदर्शन करने वाले कोड के एक स्निपेट में भाग गया। अवधारणा सरल है, लेकिन मैं यह नहीं सोच सकता कि ये पायथन 3 में क्यों लागू किए गए थे या उनके लिए कोई अच्छा उपयोग नहीं किया गया था। शायद एसओ मुझे बता सकते हैं?

यह काम किस प्रकार करता है:

def foo(a: 'x', b: 5 + 6, c: list) -> max(2, 9):
    ... function body ...

एक तर्क के बाद बृहदान्त्र के बाद सब कुछ एक 'एनोटेशन' है, और निम्नलिखित जानकारी ->फ़ंक्शन के वापसी मूल्य के लिए एक एनोटेशन है।

foo.func_annotations एक शब्दकोश लौटाएगा:

{'a': 'x',
 'b': 11,
 'c': list,
 'return': 9}

यह उपलब्ध होने का क्या महत्व है?

Comments

python.org/dev/peps/pep-3107/#use-cases

— साइलेंटगॉस्ट

@SilentGhost: दुर्भाग्य से, वास्तविक उपयोग के मामलों के साथ कई लिंक टूट गए हैं। क्या ऐसी कोई जगह है जहाँ सामग्री संग्रहीत की जा सकती है, या यह हमेशा के लिए चली गई है?

— अधिकतम

python3 में नहीं foo.func_annotations होना चाहिए foo.__annotations__?

— 5

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

— एन रंधावा

क्या def foo(a: 'x', b: 5 + 6, c: list) -> max(2, 9):मतलब है?

— अली एसएच

Answer 1

मुझे लगता है कि यह वास्तव में बहुत अच्छा है।

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

मुझे ऐसा कुछ महसूस होता है कि इसकी कमजोर टाइपिंग की वजह से पाइथन में विशेष रूप से इसकी आवश्यकता है, लेकिन वास्तव में कोई निर्माण नहीं थे जो इसे सीधा और आधिकारिक सिंटैक्स का हिस्सा बनाते थे।

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

Comments

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

— रेमंड हेटिंगर

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

— जीपीएस

AFAICT, आप डेकोरेटर के साथ यह सब कर सकते हैं, जो एनोटेशन की भविष्यवाणी करता है; इसलिए, मुझे अभी भी लाभ नहीं दिखाई दे रहा है। मेरा इस सवाल पर थोड़ा अलग है: stackoverflow.com/questions/13784713/…

— allyourcode

2015 के लिए तेजी से आगे, python.org/dev/peps/pep-0484 और mypy-lang.org सभी naysayers को गलत साबित करना शुरू कर रहे हैं।

— मौरिसियो शेफ़र

यह स्विफ्ट पर पाइथन के प्रभाव को और भी अधिक प्रकट करता है।

— uchuugaka

Answer 2

समारोह एनोटेशन आप उनमें से क्या कर रहे हैं।

वे प्रलेखन के लिए इस्तेमाल किया जा सकता है:

def kinetic_energy(mass: 'in kilograms', velocity: 'in meters per second'):
     ...

उनका उपयोग पूर्व-स्थिति जाँच के लिए किया जा सकता है:

def validate(func, locals):
    for var, test in func.__annotations__.items():
        value = locals[var]
        msg = 'Var: {0}\tValue: {1}\tTest: {2.__name__}'.format(var, value, test)
        assert test(value), msg


def is_int(x):
    return isinstance(x, int)

def between(lo, hi):
    def _between(x):
            return lo <= x <= hi
    return _between

def f(x: between(3, 10), y: is_int):
    validate(f, locals())
    print(x, y)


>>> f(0, 31.1)
Traceback (most recent call last):
   ... 
AssertionError: Var: y  Value: 31.1 Test: is_int

प्रकार की जाँच को लागू करने के तरीके के लिए http://www.python.org/dev/peps/pep-0362/ भी देखें ।

Comments

यह दस्तावेज़ के लिए डॉकस्ट्रिंग, या फ़ंक्शन में स्पष्ट प्रकार की जाँच से बेहतर कैसे है? यह बिना किसी कारण के भाषा को जटिल लगता है।

— एंडोलिथ

@endolith हम निश्चित रूप से फ़ंक्शन एनोटेशन के बिना कर सकते हैं। वे केवल एनोटेशन तक पहुंचने के लिए मानक तरीका प्रदान करते हैं। यह उन्हें मदद करने के लिए सुलभ बनाता है () और उपकरण-युक्तियों के लिए और उन्हें आत्मनिरीक्षण के लिए उपलब्ध कराता है।

— रेमंड हेटिंगर

संख्याओं के आसपास से गुजरने के बजाय आप प्रकार Massऔर Velocityइसके बजाय बना सकते हैं ।

— 1943

इसे प्रदर्शित करने के लिए मुझे def kinetic_energy(mass: 'in kilograms', velocity: 'in meters per second') -> float:रिटर्न प्रकार भी दिखाना होगा । यह यहाँ पर मेरा पसंदीदा उत्तर है।

— टॉमी

अपने कोड का उपयोग करना, क्या returnएनोटेशन को सत्यापित करने का कोई तरीका है ? यह प्रकट नहीं होता हैlocals

— user189728

Answer 3

यह एक तरह से देर से जवाब है, लेकिन AFAICT, फ़ंक्शन एनोटेशन का सबसे अच्छा वर्तमान उपयोग PEP-0484 और MyPy है ।

Mypy Python के लिए एक वैकल्पिक स्थिर प्रकार का चेकर है। आप पायथन 3.5 बीटा 1 (PEP 484) में पेश किए गए प्रकार एनोटेशन के लिए आगामी मानक का उपयोग करके अपने पायथन कार्यक्रमों में टाइप संकेत जोड़ सकते हैं, और स्टेटिक रूप से जाँच करने के लिए mypy टाइप का उपयोग कर सकते हैं।

ऐसे इस्तेमाल किया:

from typing import Iterator

def fib(n: int) -> Iterator[int]:
    a, b = 0, 1
    while a < n:
        yield a
        a, b = b, a + b

Comments

अधिक उदाहरण यहाँ Mypy के उदाहरण और यहाँ आप किस प्रकार के लाभ से लाभ

— El Ruso

इसके अलावा pytype देखें - PEP-0484 को ध्यान में रखकर बनाया जा रहा अन्य स्थिर विश्लेषक।

— जीपीएस

दुर्भाग्य से प्रकार लागू नहीं है। यदि मैं list(fib('a'))आपके उदाहरण समारोह के साथ टाइप करता हूं , तो Python 3.7 खुशी से तर्क स्वीकार करता है और शिकायत करता है कि स्ट्रिंग और इंट की तुलना करने का कोई तरीका नहीं है।

— डेनिस डे बर्नार्डी

PED-484 के रूप में @DenisdeBernardy पायथन केवल प्रकार के एनोटेशन प्रदान करता है। प्रकारों को लागू करने के लिए आपको मैपी का उपयोग करना होगा।

— डस्टिन व्याट

Answer 4

यहाँ मेरे उत्तर से एक अच्छे उपयोग का एक विशिष्ट उदाहरण जोड़ने के लिए , डेकोरेटर्स के साथ मिलकर मल्टीमिथोड्स के लिए एक सरल तंत्र किया जा सकता है।

# This is in the 'mm' module

registry = {}
import inspect

class MultiMethod(object):
    def __init__(self, name):
        self.name = name
        self.typemap = {}
    def __call__(self, *args):
        types = tuple(arg.__class__ for arg in args) # a generator expression!
        function = self.typemap.get(types)
        if function is None:
            raise TypeError("no match")
        return function(*args)
    def register(self, types, function):
        if types in self.typemap:
            raise TypeError("duplicate registration")
        self.typemap[types] = function

def multimethod(function):
    name = function.__name__
    mm = registry.get(name)
    if mm is None:
        mm = registry[name] = MultiMethod(name)
    spec = inspect.getfullargspec(function)
    types = tuple(spec.annotations[x] for x in spec.args)
    mm.register(types, function)
    return mm

और उपयोग का एक उदाहरण:

from mm import multimethod

@multimethod
def foo(a: int):
    return "an int"

@multimethod
def foo(a: int, b: str):
    return "an int and a string"

if __name__ == '__main__':
    print("foo(1,'a') = {}".format(foo(1,'a')))
    print("foo(7) = {}".format(foo(7)))

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

नोट : में अजगर आप के रूप में एनोटेशन का उपयोग कर सकते function.__annotations__बजाय function.func_annotationsके रूप में func_*शैली अजगर 3 पर हटा दिया गया था।

Comments

दिलचस्प है, हालांकि मुझे डर है कि function = self.typemap.get(types)जब उपवर्ग शामिल होंगे तो मैं काम नहीं करूंगा। उस स्थिति में आपको संभवतः typemapउपयोग के माध्यम से लूप करना होगा isinnstance। मुझे आश्चर्य है कि अगर @overloadयह सही ढंग से संभालता है

— तोबियस किंजलर 28'13

मुझे लगता है कि यह टूट गया है यदि फ़ंक्शन का रिटर्न टाइप है

— zenna

यह __annotations__ वह dictतर्क है जो तर्कों को सुनिश्चित नहीं करता है, इसलिए यह स्निपेट कभी-कभी विफल हो जाता है। मैं बदलने की सलाह देते हैं types = tuple(...)करने के लिए spec = inspect.getfullargspec(function)तो types = tuple([spec.annotations[x] for x in spec.args])।

— १२:१६

आप काफी सही हैं, @xoolive आप अपना फिक्स जोड़ने के लिए उत्तर का संपादन क्यों नहीं करते?

— मुहम्मद अलकरौरी

@xoolive: मैंने गौर किया। कभी-कभी संपादक संपादनों के प्रबंधन में भारी हाथ का उपयोग करते हैं। मैंने आपके फ़िक्सेस को शामिल करने के लिए प्रश्न संपादित किया है। वास्तव में, मुझे इस बारे में चर्चा करनी थी , लेकिन फिक्स को अप्रतिबंधित करने का कोई तरीका नहीं है। वैसे मदद के लिए धन्यवाद।

— मुहम्मद अल्करौरी

Answer 5

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

Comments

इसे प्यार करना। +1। हालाँकि, अंत में, डॉकस्ट्रिंग लिखना अभी भी नंबर एक तरीका है जिससे मैं अपने कोड को पठनीय बनाता हूँ, हालाँकि, यदि आप किसी भी तरह की स्टैटिक या डायनेमिक चेकिंग को लागू करना चाहते हैं, तो यह अच्छा है। शायद मुझे इसका कोई उपयोग मिल जाए।

— वॉरेन पी।

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

— जीपीएस

@gps: जैसा मैंने कहा, यह कम गंभीर जवाब था।

— JAB

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

— मार्क

@ मुझे यकीन नहीं है कि डॉकस्ट्रिंग्स की मेमोरी खपत 99.999% मामलों में चिंता करने वाली है।

— टॉमी

Answer 6

पहली बार मैंने एनोटेशन देखा, मैंने सोचा "महान! अंत में मैं कुछ प्रकार की जाँच में विकल्प चुन सकता हूँ!" बेशक, मैंने देखा नहीं था कि एनोटेशन वास्तव में लागू नहीं होते हैं।

इसलिए मैंने उन्हें लागू करने के लिए एक साधारण फंक्शन डेकोरेटर लिखने का फैसला किया :

def ensure_annotations(f):
    from functools import wraps
    from inspect import getcallargs
    @wraps(f)
    def wrapper(*args, **kwargs):
        for arg, val in getcallargs(f, *args, **kwargs).items():
            if arg in f.__annotations__:
                templ = f.__annotations__[arg]
                msg = "Argument {arg} to {f} does not match annotation type {t}"
                Check(val).is_a(templ).or_raise(EnsureError, msg.format(arg=arg, f=f, t=templ))
        return_val = f(*args, **kwargs)
        if 'return' in f.__annotations__:
            templ = f.__annotations__['return']
            msg = "Return value of {f} does not match annotation type {t}"
            Check(return_val).is_a(templ).or_raise(EnsureError, msg.format(f=f, t=templ))
        return return_val
    return wrapper

@ensure_annotations
def f(x: int, y: float) -> float:
    return x+y

print(f(1, y=2.2))

>>> 3.2

print(f(1, y=2))

>>> ensure.EnsureError: Argument y to <function f at 0x109b7c710> does not match annotation type <class 'float'>

मैंने इसे सुनिश्चित पुस्तकालय में जोड़ा ।

Comments

मेरे पास एक ही निराशा है कि मैं पायथन पर विश्वास करने के बाद बाहर निकल गया था आखिरकार टाइपिंग की जाँच हो रही है। अंत में घर के साथ ‑ पर जाना होगा check प्रकार की जाँच कार्यान्वयन।

— हिबू ५

Answer 7

यह पूछे जाने के बाद एक लंबा समय था, लेकिन प्रश्न में दिया गया उदाहरण स्निपेट (जैसा कि वहां भी कहा गया है) PEP 3107 से और thas PEP उदाहरण के अंत में उपयोग किए गए मामले भी दिए गए हैं, जो पीईपी के बिंदु से प्रश्न का उत्तर दे सकते हैं राय ;)

निम्नलिखित PEP3107 से उद्धृत किया गया है

बक्सों का इस्तेमाल करें

एनोटेशन पर चर्चा करने के दौरान, कई उपयोग-मामलों को उठाया गया है। इनमें से कुछ को यहां प्रस्तुत किया गया है, जिसे वे किस प्रकार की जानकारी से जोड़ते हैं। इसमें मौजूदा उत्पादों और पैकेजों के उदाहरण भी शामिल हैं जो एनोटेशन का उपयोग कर सकते हैं।

• टाइपिंग की जानकारी देना
  • प्रकार की जाँच ([3], [४])
  • आइए दिखाते हैं कि फ़ंक्शन किस प्रकार की अपेक्षा करता है और वापस लौटता है ([17])
  • कार्य अधिभार / सामान्य कार्य ([22])
  • विदेशी भाषा के पुल ([18], [19])
  • अनुकूलन ([२१], [२०])
  • तर्क कार्यों को समर्पित करें
  • डेटाबेस क्वेरी मैपिंग
  • आरपीसी पैरामीटर मार्शलिंग ([23])
• अन्य सूचना
  • मापदंडों और वापसी मूल्यों के लिए प्रलेखन ([24])

विशिष्ट बिंदुओं पर अधिक जानकारी के लिए पीईपी देखें (साथ ही उनके संदर्भ)

Comments

मैं वास्तव में सराहना करूंगा यदि डाउनवोटर्स कम से कम एक छोटी टिप्पणी छोड़ते हैं जो डाउनवोट का कारण बनता है। यह वास्तव में (कम से कम मुझे) बहुत सुधार करने में मदद करेगा।

— कलस

Answer 8

एक्सटेंशन में उपयोग के लिए ऑब्जेक्ट मानों के साथ तर्कों और वापसी मानों को एनोटेट करने की अनुमति देने के लिए पायथन 3.X (केवल) फ़ंक्शन परिभाषा को सामान्य करता है ।

फ़ंक्शन के मूल्यों के बारे में अधिक स्पष्ट होने के लिए इसका मेटा-डेटा समझाने के लिए।

एनोटेशन को :valueतर्क नाम के बाद और डिफ़ॉल्ट से पहले और ->valueतर्क सूची के बाद के रूप में कोडित किया जाता है ।

उन्हें __annotations__फ़ंक्शन की विशेषता के रूप में एकत्र किया जाता है , लेकिन अन्यथा पायथन द्वारा स्वयं को विशेष नहीं माना जाता है:

>>> def f(a:99, b:'spam'=None) -> float:
... print(a, b)
...
>>> f(88)
88 None
>>> f.__annotations__
{'a': 99, 'b': 'spam', 'return': <class 'float'>}

स्रोत: अजगर पॉकेट संदर्भ, पांचवां संस्करण

उदाहरण:

typeannotationsमॉड्यूल प्रकार की जाँच और अजगर कोड के प्रकार के अनुमान के लिए उपकरणों का एक सेट प्रदान करता है। यह फ़ंक्शन और ऑब्जेक्ट्स को एनोटेट करने के लिए उपयोगी प्रकारों का एक सेट भी प्रदान करता है।

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

https://github.com/ceronman/typeannotations

टाइपिंग कैसे बेहतर कोड लिखने में मदद करता है

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

स्वच्छ पायथन: पायथन में सुरुचिपूर्ण कोडिंग आईएसबीएन: आईएसबीएन -13 (पीबीके): 978-1-4842-4877-5

पीईपी 526 - परिवर्तनीय एनोटेशन के लिए सिंटैक्स

https://www.python.org/dev/peps/pep-0526/

https://www.attrs.org/en/stable/types.html

Comments

@ ब्लेकजैक, "एक्सटेंशन में उपयोग के लिए" स्पष्ट नहीं था?

— डेमज़

यह स्पष्ट है, लेकिन IMHO प्रश्न का उत्तर नहीं देता है। यह उत्तर देने जैसा है answ कक्षाओं के अच्छे उपयोग क्या हैं? ”„ कार्यक्रमों में उपयोग के लिए। ”यह स्पष्ट, सही है, लेकिन पूछने वाली पार्टी वास्तव में समझदार नहीं है कि बिल्ली के अच्छे ठोस उपयोग क्या हैं। आपका उत्तर एक ऐसा उत्तर है जो अधिक सामान्य नहीं हो सकता है, उदाहरण के लिए यह अनिवार्य रूप से वही है जो पहले से ही प्रश्न में है ।

— ब्लैकजैक

Answer 9

यहां वर्णित सभी उपयोगों के बावजूद, एक लागू करने योग्य और, सबसे अधिक संभावना है, एनोटेशन का लागू उपयोग टाइप संकेत के लिए होगा ।

यह वर्तमान में किसी भी तरह से लागू नहीं किया गया है, लेकिन पीईपी 484 से निर्णय लेते हुए, पायथन के भविष्य के संस्करण केवल एनोटेशन के लिए मूल्य के रूप में प्रकारों की अनुमति देंगे।

कोटेशन एनोटेशन के मौजूदा उपयोग के बारे में क्या? :

हम आशा करते हैं कि टाइप संकेत अंततः एनोटेशन के लिए एकमात्र उपयोग बन जाएंगे, लेकिन इसके लिए पाइथन 3.5 के साथ टाइपिंग मॉड्यूल के प्रारंभिक रोल-आउट के बाद अतिरिक्त चर्चा और एक अवमूल्यन अवधि की आवश्यकता होगी। पायथन 3.6 जारी होने तक वर्तमान पीईपी को अनंतिम स्थिति (पीईपी 411 देखें) होगी। सबसे तेजी से बोधगम्य योजना 3.6 में गैर-प्रकार-संकेत एनोटेशन का मूक अवक्षेपण, 3.7 में पूर्ण पदावनति, और पायथन 3.8 में एनोटेशन के केवल अनुमत उपयोग के रूप में टाइप संकेत घोषित करेगी।

हालाँकि मैंने 3.6 में अभी तक कोई भी मूक चित्रण नहीं देखा है, लेकिन इसके बजाय यह अच्छी तरह से 3.7 पर टकरा सकता है।

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

Answer 10

एक विलंबित उत्तर के रूप में, मेरे कई पैकेज (marrow.script, WebCore, आदि) एनोटेशन का उपयोग करते हैं, जहां टाइपकास्टिंग घोषित करने के लिए उपलब्ध है (यानी वेब से आने वाले मूल्यों को बदलना, यह पता लगाना कि कौन से तर्क बुलियन स्विच हैं, आदि)। तर्कों का अतिरिक्त मार्कअप करने के लिए।

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

any_string  # documentation
any_callable  # typecast / callback, not called if defaulting
(any_callable, any_string)  # combination
AnnotationClass()  # package-specific rich annotation object
[AnnotationClass(), AnnotationClass(), …]  # cooperative annotation

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

जोड़ने के लिए संपादित: मैंने सत्यापन के लिए विकास-समय के सिद्धांतों का उपयोग करके टाइपगार्ड पैकेज का उपयोग करना भी शुरू कर दिया है । लाभ: जब "अनुकूलन" सक्षम ( -O/ PYTHONOPTIMIZEenv var) चेक के साथ चलाया जाता है , जो कि महंगा हो सकता है (जैसे पुनरावर्ती) को छोड़ दिया जाता है, तो इस विचार के साथ कि आपने विकास में अपने ऐप का ठीक से परीक्षण किया है ताकि चेक उत्पादन में अनावश्यक हो।

Answer 11

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

def run(param1: int):
    """
    Does things.

    :param param1: Needed for counting.
    """
    pass

और हम "param1" नाम की एक चीज़ के लिए उपयोगकर्ता से पूछ सकते हैं जो "गिनती के लिए आवश्यक है" और "इंट" होना चाहिए। अंत में हम उपयोगकर्ता द्वारा दी गई स्ट्रिंग को सबसे परेशानी मुक्त अनुभव प्राप्त करने के लिए वांछित प्रकार में भी बदल सकते हैं।

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

Answer 12

यदि आप साइथन के लाभों की सूची को देखते हैं, तो एक प्रमुख एक संकलक को यह बताने की क्षमता है कि पायथन ऑब्जेक्ट किस प्रकार का है।

मैं एक ऐसे भविष्य की कल्पना कर सकता हूं जहां साइथन (या आपके समान कुछ उपकरण जो आपके पायथन कोड को संकलित करते हैं) एनोटेशन सिंटैक्स का उपयोग अपने जादू को करने के लिए करेंगे।

Comments

द आरपीथॉन एनोटेटर एक दृष्टिकोण का उदाहरण है जो उपयुक्त रूप से पायथन को महसूस करता है; आपके एप्लिकेशन का ग्राफ़ जेनरेट करने के बाद, यह हर वेरिएबल के प्रकार और (RPython के लिए) सिंगल-टाइप सेफ्टी को लागू कर सकता है। ओटीओएच को गतिशील समृद्ध मूल्यों के लिए अनुमति देने के लिए "मुक्केबाजी" या अन्य समाधान / कार्य-आस-पास की आवश्यकता होती है। मैं multiplyपूर्णांक के खिलाफ काम करने के लिए अपने कार्य के लिए मजबूर करने वाला कौन हूं , जब 'na' * 8 + ' batman!'पूरी तरह से वैध है? ;)

— amcgregor