സമാരംഭിക്കൽ വേരിയബിളുകളെ അടിസ്ഥാനമാക്കി പൈത്തണിൽ ഡൈനാമിക് രീതി ഓവർലോഡിംഗ് ചെയ്യുന്നു

പാസ്റ്ററിംഗ് സോപാധിക രീതി പൈത്തണിൽ ഓവർലോഡിംഗ്

ഒരു ചലനാത്മകമായി ടൈപ്പുചെയ്ത ഭാഷയാണ് പൈത്തൺ, പക്ഷേ ചിലപ്പോൾ കോഡ് വിശ്വാസ്യത ഉറപ്പാക്കാൻ ഞങ്ങൾക്ക് സ്ട്രിക്കർ തരം അനുമാനം ആവശ്യമാണ്. ഒരു രീതിയുടെ മടക്ക തരം ഒരു ഓർഗനൈസേഷൻ വേരിയബിളിനെ ആശ്രയിച്ചിരിക്കുന്നതിലും `വുഡ്ഡാറ്റയും` കോൺസെറ്റെഡാറ്റയും തമ്മിൽ തിരഞ്ഞെടുക്കുന്നതിനെ ആശ്രയിച്ചിരിക്കും എന്നതാണ് ഒരു സാധാരണ രംഗം.

ഒരു കൺസ്ട്രക്റ്റ് കമ്പനി മറ്റൊരു മെറ്റീരിയൽ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനായി സോഫ്റ്റ്വെയർ ഉപയോഗിക്കുന്ന ഒരു സാഹചര്യം സങ്കൽപ്പിക്കുക. മെറ്റീരിയൽ "മരം" ആണെങ്കിൽ, സിസ്റ്റം `വുഡ്ഡാറ്റ 'നൽകണം; അല്ലെങ്കിൽ, അത് `കോൺക്രറ്റെഡാറ്റ 'നൽകണം. എന്നിരുന്നാലും, ഒരു യൂണിയൻ തരം ഉപയോഗിക്കാതെ റിട്ടേൺ തരം ശരിയായി അനുമാനിക്കുന്ന ഒരൊറ്റ രീതി തന്ത്രപരമാണെന്ന് നിർവചിക്കുന്നു. പതനം

ജനറിക് തരങ്ങൾ ഒരു പരിഹാരം പോലെ തോന്നിട്ടും, ഒന്നിലധികം രീതികൾ വ്യത്യസ്ത സോപാധിക ഡാറ്റ തരങ്ങൾ തിരികെ നൽകേണ്ടിവരുമ്പോൾ അവ കാംബ്സോമിലാകാം. പ്രത്യേക സബ്ക്ലാസ് ഉപയോഗിച്ച് മറ്റൊരു സമീപനമാണ്, പക്ഷേ ഒരൊറ്റ ക്ലാസ് പരിപാലിക്കുന്നത് കൂടുതൽ മനോഹരവും കാര്യക്ഷമവുമാണ്.

ഈ ലേഖനം ടൈപ്പ് ഇൻഫറൻസ് കൃത്യമായി സൂക്ഷിക്കുമ്പോൾ ഒരു സമാരംഭിക്കൽ വേരിയബിളിനെ അടിസ്ഥാനമാക്കി എങ്ങനെ രീതികൾ അമിതഭാരം അമിതഭാരം നടത്താമെന്ന് പരിശോധിക്കുന്നു. വൃത്തിയുള്ളതും പരിപാലനപരവുമായ കോഡ് ഉറപ്പാക്കുന്ന പ്രായോഗിക പരിഹാരങ്ങളിലേക്ക് ഞങ്ങൾ മുഴങ്ങുന്നു. നമുക്ക് ആരംഭിക്കാം! പതനം

ടൈപ്പ് ഇൻഫറൻസ് ഉപയോഗിച്ച് പൈത്തണിൽ നടക്കുന്ന രീതി മനസിലാക്കുന്ന രീതി

ചലനാത്മകമായി ടൈപ്പുചെയ്ത ഭാഷയായ പൈത്തൺ, ജാവ അല്ലെങ്കിൽ സി ++ പോലുള്ള ഓവർലോഡിംഗ് രീതിയെ നാട്ടുമായി പിന്തുണയ്ക്കുന്നില്ല. എന്നിരുന്നാലും, ലിവഗിംഗ് വഴി ടൈപ്പ് സൂചനകൾ ഒപ്പം overlod മുതൽ അലങ്കാരക്കാരൻ ടൈപ്പിംഗ് മൊഡ്യൂൾ, നമുക്ക് സമാനമായ പ്രവർത്തനം നേടാൻ കഴിയും. ഒരു പ്രാരംഭ വേരിയബിളിനെ അടിസ്ഥാനമാക്കി ഒരു രീതിയിൽ നിന്ന് ഞങ്ങൾ വികസിപ്പിച്ച സ്ക്രിപ്റ്റുകൾ ഒരു രീതിയിൽ നിന്ന് വ്യത്യസ്ത തരത്തിലുള്ള വിവരങ്ങൾ നൽകുന്നു. ഒരു വസ്തു അനാവശ്യ തരം യൂണിയനുകളൊന്നുമില്ലാതെ നിർദ്ദിഷ്ട ഡാറ്റ ഘടനകൾ തിരികെ നൽകേണ്ട സാഹചര്യത്തിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

ആദ്യ ലായനിയിൽ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു overlod ഒന്നിലധികം ഒപ്പുകൾ നിർവചിക്കുന്നതിന് ഡെക്കറേറ്റർ get_data () രീതി. ഇതുപോലുള്ള തരം ചെക്കറുകൾ ഇത് ഉറപ്പാക്കുന്നു mypy പ്രാരംഭ വേരിയബിളിനെ അടിസ്ഥാനമാക്കി ശരിയായ റിട്ടേൺ തരം അനുമാനിക്കാൻ കഴിയും. ഒരു ഉദാഹരണം ഫൂ ഡാറ്റാ തരം ആയി "മരം" ഉപയോഗിച്ച് സൃഷ്ടിക്കപ്പെടുന്നു, get_data () എന്നതിന്റെ ഒരു ഉദാഹരണം നൽകുന്നു വുഡ്ഡാറ്റ, അതുപോലെ, അത് തിരികെ നൽകുന്നു കോൺക്രീഡാറ്റ "കോൺക്രീറ്റ്" ഉപയോഗിച്ച് സമാരംഭിക്കുമ്പോൾ. ഈ സമീപനം മെച്ചപ്പെടുന്നു കോഡ് റീസിലിറ്റി പ്രാരംഭ ഘട്ടത്തിൽ സാധ്യതയുള്ള പിശകുകൾ പിടിക്കാൻ സഹായിക്കുന്നു.

രണ്ടാമത്തെ സമീപനത്തിൽ ഞങ്ങൾ അവതരിപ്പിച്ചു ഉത്പാദനങ്ങള് ക്ലാസ് കൂടുതൽ വഴക്കമുള്ളതാക്കാൻ. ഉപയോഗിക്കുന്നതിലൂടെ ടൈപ്പ്വൽ കൂടെ ജനറിക് [T], ഞങ്ങളുടെ ക്ലാസ് ഒരു നിർദ്ദിഷ്ട ഡാറ്റ തരം ഉപയോഗിച്ച് പാരാമീറ്ററൈസ് ചെയ്യണമെന്ന് ഞങ്ങൾ അനുവദിച്ചു. പുനരയോഗമുള്ള കോഡ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ ഇത് ഒരു ശക്തമായ സാങ്കേതികതയാണ്, കാരണം വഴക്കം നിലനിർത്തുമ്പോൾ ശക്തമായ ടൈപ്പിംഗ് പ്രാപ്തമാക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു യഥാർത്ഥ ലോക സാഹചര്യത്തിൽ, ഒരു വാസ്തുശില്പിയുടെ സോഫ്റ്റ്വെയറിന് തിരഞ്ഞെടുത്ത നിർമ്മാണ മെറ്റീരിയൽ അനുസരിച്ച് വ്യത്യസ്ത ഭ material തിക സവിശേഷതകൾ ആവശ്യമാണെങ്കിൽ, ഈ സമീപനം തെറ്റായ ഡാറ്റ തരങ്ങൾ ഉപയോഗിക്കുന്നത് തടയും.

അവസാനമായി, ഞങ്ങൾ നടപ്പിലാക്കി യൂണിറ്റ് ടെസ്റ്റുകൾ ഞങ്ങളുടെ പരിഹാരങ്ങൾ സാധൂകരിക്കാൻ. ഉപയോഗിക്കുന്നത് ഏകസ്ഥതയില്ലാത്ത ഫ്രെയിംവർക്ക്, ഞങ്ങളുടെ ഓവർലോഡ് രീതികൾ പ്രതീക്ഷിച്ച സംഭവങ്ങൾ ശരിയായി തിരികെ നൽകുമെന്ന് ഞങ്ങൾ ഉറപ്പാക്കി. ഉൽപാദന-ലെവൽ കോഡിന് ഈ പരിശോധന പ്രക്രിയ അത്യാവശ്യമാണ്, പ്രത്യേകിച്ചും സോപാധിക വരുമാന തരങ്ങൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ. ഒരു യഥാർത്ഥ ലോകമെള്ളത്തെ ഒരു ഇൻവെന്ററി സിസ്റ്റമായിരിക്കും, മരം ഉൽപ്പന്നങ്ങൾ ഒരിക്കലും കോൺക്രീറ്റ് മെറ്റീരിയലുകളിൽ തെറ്റിദ്ധരിക്കപ്പെടുന്നില്ലെന്ന് ഉറപ്പുവരുത്തും. രീതി ഓവർലോഡിംഗ്, ജനറൽ, യൂണിറ്റ് ടെസ്റ്റുകൾ സംയോജിപ്പിക്കുന്നതിലൂടെ, ഞങ്ങൾ തരം സുരക്ഷയും പരിപാലനവും വർദ്ധിപ്പിക്കുന്ന ഒരു ശക്തമായ പരിഹാരം ഞങ്ങൾ സൃഷ്ടിച്ചു. പതനം

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, ശരിയായ ഡാറ്റ തരം ഒരു തവണ നിർണ്ണയിക്കുകയും കാര്യക്ഷമമായി വീണ്ടും ഉപയോഗിക്കുകയും ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കാൻ കഴിയും. ഇത് അനാവശ്യ കണക്കുകൂട്ടലുകൾ കുറയ്ക്കുന്നു, ഞങ്ങളുടെ കോഡ് ക്ലീനറും വേഗതയും ആക്കുന്നു. പതനം