துவக்க மாறிகள் அடிப்படையில் பைத்தானில் டைனமிக் முறை ஓவர்லோட்

பைத்தானில் மாஸ்டரிங் நிபந்தனை முறை ஓவர்லோட்

பைதான் ஒரு மாறும் தட்டச்சு செய்யப்பட்ட மொழியாகும், ஆனால் சில நேரங்களில் குறியீடு நம்பகத்தன்மையை உறுதிப்படுத்த நமக்கு கடுமையான வகை அனுமானம் தேவை. `வூட் டாட்டா` மற்றும்` கான்கிரெட்டெடாட்டா` ஆகியவற்றுக்கு இடையில் தேர்ந்தெடுப்பது போன்ற ஒரு முறையின் வருவாய் வகை துவக்க மாறியைப் பொறுத்தது ஒரு பொதுவான காட்சி.

ஒரு கட்டுமான நிறுவனம் வெவ்வேறு பொருள் தரவைக் கையாள மென்பொருளைப் பயன்படுத்தும் ஒரு காட்சியை கற்பனை செய்து பாருங்கள். பொருள் "மரம்" என்றால், கணினி `வூட் டாட்டா` திரும்ப வேண்டும்; இல்லையெனில், அது `கான்கிரெட்டடா` திரும்ப வேண்டும். இருப்பினும், தொழிற்சங்க வகையைப் பயன்படுத்தாமல் வருவாய் வகையை சரியாக ஊகிக்கும் ஒற்றை முறையை வரையறுப்பது தந்திரமானதாக இருக்கும். .

பொதுவான வகைகள் ஒரு தீர்வாகத் தோன்றினாலும், பல முறைகள் வெவ்வேறு நிபந்தனை தரவு வகைகளைத் தர வேண்டியிருக்கும் போது அவை சிக்கலானதாக மாறும். தனி துணைப்பிரிவுகளைப் பயன்படுத்துவது மற்றொரு அணுகுமுறையாகும், ஆனால் ஒரு வகுப்பைப் பராமரிப்பது மிகவும் நேர்த்தியானதாகவும் திறமையாகவும் இருக்கும்.

வகை அனுமானத்தை துல்லியமாக வைத்திருக்கும் போது துவக்க மாறியின் அடிப்படையில் முறைகளை எவ்வாறு சுமை செய்வது என்பதை இந்த கட்டுரை ஆராய்கிறது. சுத்தமான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை உறுதி செய்வதன் மூலம் நாங்கள் நடைமுறை தீர்வுகளில் மூழ்குவோம். தொடங்குவோம்! .

வகை அனுமானத்துடன் பைத்தானில் முறை ஓவர்லோட் புரிந்துகொள்ளுதல்

பைதான், மாறும் தட்டச்சு செய்யப்பட்ட மொழியாக இருப்பதால், ஜாவா அல்லது சி ++ போன்ற முறை சுமைகளை பெரிதாக ஆதரிக்காது. இருப்பினும், அந்நியப்படுத்துவதன் மூலம் குறிப்புகளைத் தட்டச்சு செய்க மற்றும் @overload அலங்காரக்காரர் தட்டச்சு தொகுதி, நாம் ஒத்த செயல்பாட்டை அடைய முடியும். நாங்கள் உருவாக்கிய ஸ்கிரிப்ட்கள் துவக்க மாறியின் அடிப்படையில் ஒரு முறையிலிருந்து வெவ்வேறு வகைகளை நிபந்தனைக்குத் திருப்பித் தரும் சிக்கலைச் சமாளிக்கின்றன. தேவையற்ற வகை தொழிற்சங்கங்கள் இல்லாமல் குறிப்பிட்ட தரவு கட்டமைப்புகளை ஒரு பொருள் திருப்பித் தர வேண்டிய காட்சிகளில் இது மிகவும் பயனுள்ளதாக இருக்கும்.

முதல் தீர்வில், நாங்கள் பயன்படுத்துகிறோம் @overload பல கையொப்பங்களை வரையறுக்க அலங்காரக்காரர் get_data () முறை. வகை செக்கர்கள் போன்றவற்றை இது உறுதி செய்கிறது mypy துவக்க மாறியின் அடிப்படையில் சரியான வருவாய் வகையை ஊகிக்க முடியும். ஒரு நிகழ்வு போது Foo தரவு வகையாக "மரம்" உடன் உருவாக்கப்பட்டது, get_data () ஒரு உதாரணத்தை வழங்குகிறது வூட் டாட்டா, அதேபோல், அது திரும்பும் கான்கிரெட்டெடாட்டா "கான்கிரீட்" உடன் துவக்கும்போது. இந்த அணுகுமுறை மேம்படுகிறது குறியீடு வாசிப்பு மற்றும் ஆரம்ப கட்டத்தில் சாத்தியமான பிழைகளைப் பிடிக்க உதவுகிறது.

இரண்டாவது அணுகுமுறையில், நாங்கள் அறிமுகப்படுத்தினோம் பொதுவான வகுப்பை மேலும் நெகிழ்வாக மாற்ற. பயன்படுத்துவதன் மூலம் தட்டச்சு மற்றும் பொதுவான [t], எங்கள் வகுப்பை ஒரு குறிப்பிட்ட தரவு வகையுடன் அளவுருவாக்க அனுமதித்தோம். மீண்டும் பயன்படுத்தக்கூடிய குறியீட்டில் பணிபுரியும் போது இது ஒரு சக்திவாய்ந்த நுட்பமாகும், ஏனெனில் இது நெகிழ்வுத்தன்மையை பராமரிக்கும் போது வலுவான தட்டச்சு செய்ய உதவுகிறது. உதாரணமாக, ஒரு நிஜ உலக சூழ்நிலையில், ஒரு கட்டிடக் கலைஞரின் மென்பொருளுக்கு தேர்ந்தெடுக்கப்பட்ட கட்டுமானப் பொருளைப் பொறுத்து வெவ்வேறு பொருள் பண்புகள் தேவைப்பட்டால், இந்த அணுகுமுறை தவறான தரவு வகைகளைப் பயன்படுத்துவதைத் தடுக்கும்.

இறுதியாக, நாங்கள் செயல்படுத்தினோம் அலகு சோதனைகள் எங்கள் தீர்வுகளை சரிபார்க்க. பயன்படுத்துகிறது ஒற்றுமையற்றது கட்டமைப்பானது, எங்கள் ஓவர்லோட் முறைகள் எதிர்பார்த்த நிகழ்வுகளை சரியாக திருப்பித் தருவதை உறுதிசெய்தோம். உற்பத்தி-நிலை குறியீட்டில் இந்த சோதனை செயல்முறை அவசியம், குறிப்பாக நிபந்தனை திரும்ப வகைகளுடன் பணிபுரியும் போது. ஒரு நிஜ-உலக ஒப்புமை என்பது ஒரு சரக்கு அமைப்பாக இருக்கும், இது மரப் பொருட்கள் ஒருபோதும் கான்கிரீட் பொருட்களின் கீழ் தவறாக வகைப்படுத்தப்படவில்லை என்பதை உறுதி செய்கிறது. முறை ஓவர்லோட், ஜெனரிக்ஸ் மற்றும் யூனிட் சோதனைகளை இணைப்பதன் மூலம், வகை பாதுகாப்பு மற்றும் பராமரிப்பை மேம்படுத்தும் ஒரு வலுவான தீர்வை நாங்கள் உருவாக்கினோம். .

from typing import Literal, overload
DATA_TYPE = Literal["wood", "concrete"]
class WoodData:
    def __str__(self):
        return "Wood data object"
class ConcreteData:
    def __str__(self):
        return "Concrete data object"
class Foo:
    def __init__(self, data_type: DATA_TYPE) -> None:
        self.data_type = data_type
    @overload
    def get_data(self) -> WoodData: ...
    @overload
    def get_data(self) -> ConcreteData: ...
    def get_data(self):
        if self.data_type == "wood":
            return WoodData()
        return ConcreteData()
foo_wood = Foo("wood")
foo_concrete = Foo("concrete")
print(foo_wood.get_data())  # Outputs: Wood data object
print(foo_concrete.get_data())  # Outputs: Concrete data object

from typing import TypeVar, Generic, Literal
DATA_TYPE = Literal["wood", "concrete"]
T = TypeVar("T", bound="BaseData")
class BaseData:
    pass
class WoodData(BaseData):
    def __str__(self):
        return "Wood data object"
class ConcreteData(BaseData):
    def __str__(self):
        return "Concrete data object"
class Foo(Generic[T]):
    def __init__(self, data_type: DATA_TYPE) -> None:
        self.data_type = data_type
    def get_data(self) -> T:
        if self.data_type == "wood":
            return WoodData()  # type: ignore
        return ConcreteData()  # type: ignore
foo_wood = Foo[WoodData]("wood")
foo_concrete = Foo[ConcreteData]("concrete")
print(foo_wood.get_data())  # Outputs: Wood data object
print(foo_concrete.get_data())  # Outputs: Concrete data object

import unittest
class TestFoo(unittest.TestCase):
    def test_wood_data(self):
        foo = Foo("wood")
        self.assertIsInstance(foo.get_data(), WoodData)
    def test_concrete_data(self):
        foo = Foo("concrete")
        self.assertIsInstance(foo.get_data(), ConcreteData)
if __name__ == "__main__":
    unittest.main()

மேம்பட்ட முறை ஓவர்லோட் மற்றும் வகை-பாதுகாப்பான பைதான் குறியீடு

சிக்கலான பைதான் பயன்பாடுகளில் பணிபுரியும் போது, ​​முறைகள் திருப்பித் தருவதை உறுதிசெய்வதற்கு சரியான தரவு வகை பராமரிக்க அவசியம் குறியீடு தெளிவு மற்றும் இயக்க நேர பிழைகளைத் தடுக்கும். டெவலப்பர்கள் எதிர்கொள்ளும் மிகப்பெரிய சவால்களில் ஒன்று, வகை அனுமானத்தை துல்லியமாக வைத்திருக்கும் போது நிபந்தனை திரும்ப வகைகளைக் கையாள்வது. துவக்க மாறியின் அடிப்படையில் ஒரு வர்க்கம் வெவ்வேறு பொருள்களைத் திருப்பித் தர வேண்டிய சூழ்நிலைகளில் இது மிகவும் பொருத்தமானது.

இந்த சிக்கலுக்கு குறைவாக ஆராயப்பட்ட அணுகுமுறை பைத்தானைப் பயன்படுத்துவதை உள்ளடக்குகிறது டேட்டாக்ளாஸ்கள் முறை ஓவர்லோடிங் உடன். பயன்படுத்துகிறது @dataclass கொதிகலன் குறியீட்டைக் குறைக்கும்போது பொருள் உருவாக்கத்தை எளிதாக்குகிறது மற்றும் வகை குறிப்புகளை செயல்படுத்துகிறது. எடுத்துக்காட்டாக, பல கட்டமைப்பாளர்களை கைமுறையாக வரையறுப்பதற்கு பதிலாக, சரியான வகையை மாறும் வகையில் உருவாக்க இயல்புநிலை தொழிற்சாலை முறைகளுடன் ஒற்றை தரவுத்தளத்தைப் பயன்படுத்தலாம்.

மற்றொரு விமர்சனக் கருத்தாகும் செயல்திறன் தேர்வுமுறை. பெரிய அளவிலான பயன்பாடுகளில், அதிகப்படியான வகை சரிபார்ப்பு மற்றும் நிபந்தனை தர்க்கம் மரணதண்டனை குறைக்கும். பைத்தானை மேம்படுத்துவதன் மூலம் @cached_property, சரியான தரவு வகை ஒரு முறை தீர்மானிக்கப்பட்டு திறமையாக மீண்டும் பயன்படுத்தப்படுவதை நாங்கள் உறுதிப்படுத்த முடியும். இது தேவையற்ற கணக்கீடுகளைக் குறைக்கிறது, இதனால் எங்கள் குறியீட்டை தூய்மையானதாகவும் வேகமாகவும் ஆக்குகிறது. .