ਸ਼ੁਰੂਆਤੀ ਵੇਰੀਏਬਲਜ਼ ਦੇ ਅਧਾਰ ਤੇ ਪਾਈਥਨ ਵਿੱਚ ਗਤੀਸ਼ੀਲ ਵਿਧੀ ਨੂੰ ਓਵਰਲੋਡਿੰਗ

ਪਾਈਥਨ ਵਿੱਚ ਓਵਰਲੋਡਿੰਗ ਓਵਰਲੋਡਿੰਗ

ਪਾਈਥਨ ਇੱਕ ਆਰਜੀ ਤੌਰ ਤੇ ਟਾਈਪ ਕੀਤੀ ਭਾਸ਼ਾ ਹੈ, ਪਰ ਕਈ ਵਾਰ ਸਾਨੂੰ ਕੋਡ ਦੀ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਸਾਨੂੰ ਸਖਤ ਪ੍ਰਦੇਸ਼ ਦੀ ਜਾਣਕਾਰੀ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇੱਕ ਆਮ ਦ੍ਰਿਸ਼ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਵਿਧੀ ਦੀ ਵਾਪਸੀ ਦੀ ਕਿਸਮ ਸ਼ੁਰੂਆਤੀ ਵੇਰੀਏਬਲ ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ `ਲੱਕੜ ਦੇ ਕੰਟੇਟਰੇਟਡਤਾ ਦੇ ਵਿਚਕਾਰ ਚੋਣ.

ਇਕ ਅਜਿਹੀ ਸਥਿਤੀ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਇਕ ਨਿਰਮਾਣ ਕੰਪਨੀ ਵੱਖ ਵੱਖ ਪਦਾਰਥਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸੌਫਟਵੇਅਰ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ. ਜੇ ਸਮੱਗਰੀ "ਲੱਕੜ" ਹੈ, ਤਾਂ ਸਿਸਟਮ ਨੂੰ` ਲੁੱਡਦਾਤਾ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ; ਨਹੀਂ ਤਾਂ, ਇਸ ਨੂੰ `ਕੰਸਲਟਰੇਟਡਤਾ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਹਾਲਾਂਕਿ, ਇਕੋ method ੰਗ ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕਰਨਾ ਜੋ ਇਕ ਯੂਨੀਅਨ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਵਾਪਸੀ ਦੀ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ, ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ. 🏗️

ਹਾਲਾਂਕਿ ਆਮ ਕਿਸਮਾਂ ਇੱਕ ਹੱਲ ਦੀ ਤਰ੍ਹਾਂ ਜਾਪਦੀਆਂ ਹਨ, ਉਹ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦੇ ਹਨ ਜਦੋਂ ਸਧਾਰਣ ਸ਼ਰਤ ਦੇ ਡੇਟਾ ਕਿਸਮਾਂ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਵੱਖਰੇ ਸਬਕਾਸੋਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਇਕ ਹੋਰ ਪਹੁੰਚ ਹੈ, ਪਰ ਇਕੋ ਕਲਾਸ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਅਤੇ ਕੁਸ਼ਲ ਹੋਵੇਗਾ.

ਇਹ ਲੇਖ ਟਾਈਪ ਕਰਦੇ ਸਮੇਂ ਅਰੰਭਕ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਤੇ methods ੰਗਾਂ ਨੂੰ ਲੋਡ ਕਰਨਾ ਹੈ. ਅਸੀਂ ਵਿਹਾਰਕ ਹੱਲਾਂ ਵਿੱਚ ਗੋਤਾਖੋਰ ਕਰਾਂਗੇ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਾਂਗੇ ਕਿ ਸਾਫ਼ ਅਤੇ ਕਸ਼ਟਸ਼ਨ ਯੋਗ ਕੋਡ. ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ! 🚀

ਟਾਈਪ ਵਿੱਚ method ੰਗ ਨੂੰ ਸਮਝਣ ਨਾਲ ਟਾਈਪਿੰਗ ਇਨਸੋਰੈਂਸ

ਪਾਈਥਨ, ਇੱਕ ਆਰਜੀ ਤੌਰ ਤੇ ਟਾਈਪ ਕੀਤੀ ਭਾਸ਼ਾ ਹੋਣ ਦੇ ਨਾਤੇ, ਮੂਲ ਰੂਪ ਵਿੱਚ ਜਾਵਾ ਜਾਂ ਸੀ ++ ਵਰਗੇ ਵਿਧੀ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ. ਹਾਲਾਂਕਿ, ਜਵਾਨੀ ਨਾਲ ਕਿਸਮ ਦੇ ਸੰਕੇਤ ਅਤੇ @ਕੋਵਰਲੋਡ ਤੋਂ ਸਜਾਵਟ ਟਾਈਪਿੰਗ ਮੋਡੀ ule ਲ, ਅਸੀਂ ਸਮਾਨ ਕਾਰਜਸ਼ੀਲਤਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ. ਸਕ੍ਰਿਪਟਾਂ ਜੋ ਅਸੀਂ ਸ਼ੁਰੂਆਤੀ ਵੇਰੀਏਬਲ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਵਿਧੀ ਤੋਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦੀ ਸਮੱਸਿਆ ਨਾਲ ਨਜਿੱਠਣ ਦੀ ਸਮੱਸਿਆ ਨਾਲ ਨਜਿੱਠਿਆ. ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ ਜਿੱਥੇ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਬੇਲੋੜੀ ਕਿਸਮ ਦੇ ਯੂਨੀਅਨਾਂ ਤੋਂ ਬਿਨਾਂ ਵਿਸ਼ੇਸ਼ ਡੇਟਾ structures ਾਂਚਿਆਂ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ.

ਪਹਿਲੇ ਹੱਲ ਵਿੱਚ, ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ @ਕੋਵਰਲੋਡ ਲਈ ਕਈ ਦਸਤਖਤਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕਰਨ ਲਈ ਸਜਾਵਟ get_data () .ੰਗ. ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸਮ ਦੀਆਂ ਚੈਕਰ ਪਸੰਦ ਹਨ ਮਾਇਨੀ ਸ਼ੁਰੂਆਤੀ ਵੇਰੀਏਬਲ ਦੇ ਅਧਾਰ ਤੇ ਸਹੀ ਵਾਪਸੀ ਦੀ ਕਿਸਮ ਦਾ ਅਨੁਮਾਨ ਲਗਾ ਸਕਦਾ ਹੈ. ਜਦੋਂ ਇੱਕ ਉਦਾਹਰਣ Foo ਡੇਟਾ ਕਿਸਮ ਦੇ ਤੌਰ ਤੇ "ਲੱਕੜ" ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ, get_data () ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵਾਪਸ ਕਰਦਾ ਹੈ ਵੁੱਡਡਾਟਾ, ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ, ਇਹ ਵਾਪਸੀ ਕਰਦਾ ਹੈ ਕੰਕਰੀਟਰੇਟਿਡਤਾ ਜਦੋਂ "ਕੰਕਰੀਟ" ਨਾਲ ਸ਼ੁਰੂਆਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਹ ਪਹੁੰਚ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ਕੋਡ ਪੜ੍ਹਨਯੋਗਤਾ ਅਤੇ ਸ਼ੁਰੂਆਤੀ ਪੜਾਅ 'ਤੇ ਸੰਭਾਵਿਤ ਗਲਤੀਆਂ ਨੂੰ ਫੜਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ.

ਦੂਜੀ ਪਹੁੰਚ ਵਿਚ ਅਸੀਂ ਪੇਸ਼ ਕੀਤੇ ਸਧਾਰਣ ਕਲਾਸ ਨੂੰ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਉਣ ਲਈ. ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟਾਈਪਵਾਰ ਅਤੇ ਆਮ [ਟੀ]ਪਰ, ਅਸੀਂ ਆਪਣੀ ਕਲਾਸ ਨੂੰ ਇੱਕ ਖਾਸ ਡੇਟਾ ਟਾਈਪ ਦੇ ਨਾਲ ਪੈਰਾਮੀਟਰ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੱਤੀ. ਇਹ ਇਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਕਨੀਕ ਹੈ ਜਦੋਂ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਕੋਡ ਨਾਲ ਕੰਮ ਕਰਨਾ, ਕਿਉਂਕਿ ਲਚਕਤਾ ਬਣਾਈ ਰੱਖਣ ਵੇਲੇ ਮਜ਼ਬੂਤ ​​ਟਾਈਪਿੰਗ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਇੱਕ ਅਸਲ-ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼ ਵਿੱਚ, ਜੇ ਇੱਕ ਆਰਕੀਟੈਕਟ ਦੇ ਸਾੱਫਟਵੇਅਰ ਨੂੰ ਚੁਣੀ ਹੋਈ ਉਸਾਰੀ ਸਮੱਗਰੀ ਦੇ ਅਧਾਰ ਤੇ ਵੱਖ-ਵੱਖ ਪਦਾਰਥਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਇਸ ਪਹੁੰਚ ਨੂੰ ਵਰਤਣ ਤੋਂ ਰੋਕਣ ਤੋਂ ਰੋਕਦਾ ਹੈ.

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਲਾਗੂ ਕੀਤਾ ਯੂਨਿਟ ਟੈਸਟ ਸਾਡੇ ਹੱਲਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ. ਦੀ ਵਰਤੋਂ ਇਕਠਿਤ ਫਰੇਮਵਰਕ, ਅਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਕਿ ਸਾਡੀਆਂ ਤਬਦੀਲੀਆਂ ਦੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਉਮੀਦ ਕੀਤੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ. ਇਹ ਜਾਂਚ ਪ੍ਰਕਿਰਿਆ ਉਤਪਾਦਨ-ਪੱਧਰ ਦੇ ਕੋਡ ਵਿੱਚ ਜ਼ਰੂਰੀ ਹੈ, ਖ਼ਾਸਕਰ ਜਦੋਂ ਸ਼ਰਤੀਆ ਵਾਪਸੀ ਦੀਆਂ ਕਿਸਮਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ. ਇੱਕ ਅਸਲ-ਸੰਸਾਰ ਸਮਾਨਤਾ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਵਾਲੀ ਇੱਕ ਵਸਤੂ ਸੂਚੀ ਹੋਵੇਗੀ ਕਿ ਲੱਕੜ ਦੇ ਉਤਪਾਦਾਂ ਨੂੰ ਠੋਸ ਸਮੱਗਰੀ ਦੇ ਤਹਿਤ ਕਦੇ ਗਲਤੀ ਨਾਲ ਸ਼੍ਰੇਣੀਬੱਧ ਨਹੀਂ ਹੁੰਦਾ. ਓਵਰਲੋਡਿੰਗ, ਜੈਨਿਸ਼ੀਏਸ ਅਤੇ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਜੋੜ ਕੇ, ਅਸੀਂ ਇਕ ਮਜਬੂਤ ਹੱਲ ਬਣਾਇਆ ਜੋ ਕਿਸਮ ਦੀ ਸੁਰੱਖਿਆ ਅਤੇ ਪ੍ਰਬੰਧਨ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ. 🚀

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()

ਐਡਵਾਂਸਡ ਵਿਧੀ ਓਵਰਲੋਡਿੰਗ ਅਤੇ ਟਾਈਪ-ਸੇਫ ਪਾਈਥਨ ਕੋਡ

ਜਦੋਂ ਗੁੰਝਲਦਾਰ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ ਕਿ Methods ੰਗ ਵਾਪਸ ਕਰਨ ਲਈ ਸਹੀ ਡੇਟਾ ਕਿਸਮ ਕਾਇਮ ਰੱਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕੋਡ ਸਪਸ਼ਟਤਾ ਅਤੇ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਣਾ. ਸਭ ਤੋਂ ਵੱਡੀ ਚੁਣੌਤੀਆਂ ਵਿੱਚੋਂ ਇੱਕ ਡਿਵੈਲਪਰਸ ਦਾ ਚਿਹਰਾ ਕਿਸਮ ਦੀ ਪਛਾਣ ਰੱਖਦੇ ਹੋਏ ਸ਼ਰਤੀਆ ਵਾਪਸੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਸੰਭਾਲ ਰਿਹਾ ਹੈ. ਇਹ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਖਾਸ ਤੌਰ ਤੇ relevant ੁਕਵਾਂ ਹੈ ਜਿੱਥੇ ਇੱਕ ਕਲਾਸ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਵੇਰੀਏਬਲ ਦੇ ਅਧਾਰ ਤੇ ਵੱਖ ਵੱਖ ਇਕਾਈ ਨੂੰ ਵਾਪਸ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ.

ਇਸ ਸਮੱਸਿਆ ਵੱਲ ਘੱਟ-ਖੋਜ ਪਹੁੰਚ ਵਿਚ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਵਿਚ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਡੇਟਾਕਾਟਸ ਓਵਰਲੋਡਿੰਗ ਦੇ ਨਾਲ. ਦੀ ਵਰਤੋਂ @dataclass ਬਾਇਲਰ ਪਲੇਟ ਕੋਡ ਨੂੰ ਘਟਾਉਣ ਵੇਲੇ ਆਬਜੈਕਟ ਆਬਜੈਕਟ ਬਣਾਉਣਾ ਅਤੇ ਲਾਗੂ ਕਰਨ ਦੀ ਸਰਲ ਕਰੋ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਮਲਟੀਪਲ ਕੰਸਟਰਕਚਰਟਰਾਂ ਦੀ ਬਜਾਏ ਹੱਥੀਂ ਪਰਿਭਾਸ਼ਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਆਰਜੀ ਤੌਰ ਤੇ ਸਹੀ ਕਿਸਮ ਬਣਾਉਣ ਲਈ ਡਿਫੌਲਟ ਫੈਕਟਰੀ ਦੇ ਤਰੀਕਿਆਂ ਨਾਲ ਇੱਕ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ.

ਇਕ ਹੋਰ ਆਲੋਚਨਾਤਮਕ ਵਿਚਾਰ ਹੈ ਕਾਰਗੁਜ਼ਾਰੀ ਅਨੁਕੂਲਤਾ. ਵੱਡੇ ਪੈਮਾਨੇ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ, ਬਹੁਤ ਜ਼ਿਆਦਾ ਕਿਸਮ ਦੀ ਚੈਕਿੰਗ ਅਤੇ ਸ਼ਰਤੀਆ ਤਰਕ ਨੂੰ ਹੌਲੀ ਕਰ ਸਕਦਾ ਹੈ. ਪਾਇਥਨ ਦੇ ਲਾਭ ਦੁਆਰਾ @cached_property, ਅਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਸਹੀ ਡੇਟਾ ਕਿਸਮ ਇੱਕ ਵਾਰ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਦੁਬਾਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ. ਇਹ ਬੇਲੋੜੀ ਗਣਨਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਸਾਡੇ ਕੋਡ ਨੂੰ ਕਲੀਨਰ ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉਂਦਾ ਹੈ. 🚀