பைதான் வகை குறிப்புகள் பரிணாமம்: பொதுவான வகைகள் எதிராக நெறிமுறை பயன்பாடு

பைதான், அதன் மாறும் தட்டச்சுக்காக அறியப்படுகிறது, குறியீடு வாசிப்புத்திறன், பராமரிப்பு மற்றும் வலிமையை மேம்படுத்த PEP 484 (பைதான் 3.5) இல் வகை குறிப்புகளை அறிமுகப்படுத்தியது. ஆரம்பத்தில் அடிப்படை என்றாலும், வகை குறிப்புகள் அமைப்பு கணிசமாக வளர்ச்சியடைந்துள்ளது, பொதுவான வகைகள் மற்றும் நெறிமுறைகள் அதிநவீன மற்றும் நன்கு தட்டச்சு செய்யப்பட்ட பைதான் குறியீட்டை எழுதுவதற்கான அத்தியாவசிய கருவிகளாக மாறியுள்ளன. இந்த வலைப்பதிவு இடுகை பைதான் வகை குறிப்புகளின் பரிணாமத்தை ஆராய்கிறது, பொதுவான வகைகள் மற்றும் நெறிமுறை பயன்பாட்டில் கவனம் செலுத்துகிறது, இந்த சக்திவாய்ந்த அம்சங்களைப் பயன்படுத்த உங்களுக்கு உதவ நடைமுறை எடுத்துக்காட்டுகள் மற்றும் நுண்ணறிவுகளை வழங்குகிறது.

வகை குறிப்புகளின் அடிப்படைகள்

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

இதோ ஒரு எளிய எடுத்துக்காட்டு:

            def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet("Alice"))

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், name: str என்பது name வாதம் ஒரு சரமாக இருக்க வேண்டும் என்பதையும், -> str செயல்பாடு ஒரு சரத்தை வழங்கும் என்பதையும் குறிக்கிறது. நீங்கள் greet()க்கு ஒரு முழு எண்ணை அனுப்பினால், mypy அதை ஒரு வகை பிழையாகக் கொடியிடும்.

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

வகை பாதுகாப்பை தியாகம் செய்யாமல் பல தரவு வகைகளுடன் வேலை செய்யும் குறியீட்டை எழுத பொதுவான வகைகள் உங்களை அனுமதிக்கின்றன. பட்டியல்கள், அகராதிகள் மற்றும் தொகுப்புகள் போன்ற சேகரிப்புகளுடன் பணிபுரியும் போது அவை மிகவும் பயனுள்ளதாக இருக்கும். பொதுவான வகைகளுக்கு முன், நீங்கள் typing.List, typing.Dict மற்றும் typing.Set ஐப் பயன்படுத்தலாம், ஆனால் அந்தக் சேகரிப்புகளுக்குள் இருக்கும் கூறுகளின் வகைகளை நீங்கள் குறிப்பிட முடியவில்லை.

அவற்றின் உறுப்புகளின் வகைகளுடன் சேகரிப்பு வகைகளை அளவுருவாக்க உங்களை அனுமதிப்பதன் மூலம் பொதுவான வகைகள் இந்த வரம்புக்கு முகவரியை வழங்குகின்றன. உதாரணமாக, List[str] சரங்களின் பட்டியலைக் குறிக்கிறது, மேலும் Dict[str, int] சரக் விசைகள் மற்றும் முழு எண் மதிப்புகள் கொண்ட அகராதியைக் குறிக்கிறது.

பட்டியல்களுடன் பொதுவான வகைகளைப் பயன்படுத்துவதற்கான ஒரு எடுத்துக்காட்டு இங்கே:

            from typing import List

def process_names(names: List[str]) -> List[str]:
    upper_case_names: List[str] = [name.upper() for name in names]
    return upper_case_names

names = ["Alice", "Bob", "Charlie"]
upper_case_names = process_names(names)
print(upper_case_names)

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், List[str] என்பது names வாதம் மற்றும் upper_case_names மாறி ஆகிய இரண்டும் சரங்களின் பட்டியல்களாக இருப்பதை உறுதி செய்கிறது. இந்த பட்டியல்களில் ஏதேனும் ஒன்றுக்கு நீங்கள் ஒரு சரமற்ற உறுப்பைச் சேர்க்க முயன்றால், mypy ஒரு வகை பிழையைப் புகாரளிக்கும்.

தனிப்பயன் வகுப்புகளுடன் பொதுவான வகைகள்

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

இதோ ஒரு எடுத்துக்காட்டு:

            from typing import TypeVar, Generic

T = TypeVar('T')

class Box(Generic[T]):
    def __init__(self, content: T):
        self.content = content

    def get_content(self) -> T:
        return self.content

box_int = Box[int](10)
box_str = Box[str]("Hello")

print(box_int.get_content())
print(box_str.get_content())

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், T = TypeVar('T') என்பது T என்ற வகை மாறியை வரையறுக்கிறது. Box வகுப்பு பின்னர் Generic[T] ஐப் பயன்படுத்தி T உடன் அளவுருவாக்கப்படுகிறது. இது Box[int] மற்றும் Box[str] போன்ற வெவ்வேறு உள்ளடக்க வகைகளுடன் Box நிகழ்வுகளை உருவாக்க உங்களை அனுமதிக்கிறது. get_content() முறை உள்ளடக்கத்தின் அதே வகையின் மதிப்பை வழங்குகிறது.

`Any` மற்றும் `TypeAlias` ஐப் பயன்படுத்துதல்

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

            from typing import Any

def process_data(data: Any):
    # We don't know the type of 'data', so we can't perform type-specific operations
    print(f"Processing data: {data}")

process_data(10)
process_data("Hello")
process_data([1, 2, 3])

            

              
                Copy
              
            
          

Any சில சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும்போது, முடிந்தால் அதைத் தவிர்ப்பது பொதுவாக நல்லது, ஏனெனில் இது வகை சரிபார்ப்பின் நன்மைகளை பலவீனப்படுத்தும்.

TypeAlias சிக்கலான வகை குறிப்புகளுக்கு புனைப்பெயர்களை உருவாக்க உங்களை அனுமதிக்கிறது, இது உங்கள் குறியீட்டை மிகவும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் ஆக்குகிறது.

            from typing import List, Tuple, TypeAlias

Point: TypeAlias = Tuple[float, float]
Line: TypeAlias = Tuple[Point, Point]

def calculate_distance(line: Line) -> float:
    x1, y1 = line[0]
    x2, y2 = line[1]
    return ((x2 - x1)**2 + (y2 - y1)**2)**0.5

my_line: Line = ((0.0, 0.0), (3.0, 4.0))
distance = calculate_distance(my_line)
print(f"The distance is: {distance}")

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், Point என்பது Tuple[float, float] க்கான புனைப்பெயர், மற்றும் Line என்பது Tuple[Point, Point] க்கான புனைப்பெயர். இது calculate_distance() செயல்பாட்டில் வகை குறிப்புகளை மிகவும் படிக்கக்கூடியதாக ஆக்குகிறது.

நெறிமுறைகளைப் புரிந்துகொள்வது

நெறிமுறைகள் PEP 544 (பைதான் 3.8) இல் அறிமுகப்படுத்தப்பட்ட ஒரு சக்திவாய்ந்த அம்சமாகும், இது கட்டமைப்பு துணை வகையின் அடிப்படையில் இடைமுகங்களை வரையறுக்க உங்களை அனுமதிக்கிறது (வாத்து தட்டச்சு என்றும் அழைக்கப்படுகிறது). ஜாவா அல்லது சி# போன்ற மொழிகளில் உள்ள பாரம்பரிய இடைமுகங்களைப் போலன்றி, நெறிமுறைகளுக்கு வெளிப்படையான பரம்பரை தேவையில்லை. மாறாக, ஒரு வர்க்கம் தேவையான முறைகள் மற்றும் பண்புகளை சரியான வகைகளுடன் வழங்கினால், அது ஒரு நெறிமுறையை செயல்படுத்துவதாக கருதப்படுகிறது.

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

நெறிமுறைக்கு எளிய எடுத்துக்காட்டு இங்கே:

            from typing import Protocol

class SupportsRead(Protocol):
    def read(self, size: int) -> str:
        ...

def process_data(reader: SupportsRead) -> str:
    data = reader.read(1024)
    return data.upper()

class FileReader:
    def read(self, size: int) -> str:
        with open("data.txt", "r") as f:
            return f.read(size)

class NetworkReader:
    def read(self, size: int) -> str:
        # Simulate reading from a network connection
        return "Network data..."

file_reader = FileReader()
network_reader = NetworkReader()

data_from_file = process_data(file_reader)
data_from_network = process_data(network_reader)

print(f"Data from file: {data_from_file}")
print(f"Data from network: {data_from_network}")

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், SupportsRead என்பது ஒரு நெறிமுறையாகும், இது ஒரு முழு எண் size ஐ உள்ளீடாக எடுத்து ஒரு சரத்தை வழங்கும் read() முறையை வரையறுக்கிறது. process_data() செயல்பாடு SupportsRead நெறிமுறைக்கு இணங்கும் எந்தவொரு பொருளையும் ஏற்றுக்கொள்கிறது.

FileReader மற்றும் NetworkReader வகுப்புகள் இரண்டும் சரியான கையொப்பத்துடன் read() முறையை செயல்படுத்துகின்றன, எனவே அவை வெளிப்படையாக அதிலிருந்து மரபுரிமையாக இல்லாவிட்டாலும், SupportsRead நெறிமுறைக்கு இணங்குவதாகக் கருதப்படுகிறது. இது இந்த வகுப்புகளில் ஏதேனும் ஒன்றின் நிகழ்வுகளை process_data() செயல்பாட்டிற்கு அனுப்ப உங்களை அனுமதிக்கிறது.

பொதுவான வகைகள் மற்றும் நெறிமுறைகளை இணைத்தல்

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

இதோ ஒரு எடுத்துக்காட்டு:

            from typing import Protocol, TypeVar, Generic

T = TypeVar('T')

class SupportsConvert(Protocol, Generic[T]):
    def convert(self) -> T:
        ...

class StringConverter:
    def convert(self) -> str:
        return "Hello"

class IntConverter:
    def convert(self) -> int:
        return 10

def process_converter(converter: SupportsConvert[int]) -> int:
    return converter.convert() + 5

int_converter = IntConverter()
result = process_converter(int_converter)
print(result)

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், SupportsConvert என்பது ஒரு வகை மாறியான T உடன் அளவுருவாக்கப்பட்ட ஒரு நெறிமுறையாகும். convert() முறை T வகையின் மதிப்பை வழங்க வேண்டும். process_converter() செயல்பாடு SupportsConvert[int] நெறிமுறைக்கு இணங்கும் எந்தவொரு பொருளையும் ஏற்றுக்கொள்கிறது, அதாவது அதன் convert() முறை ஒரு முழு எண்ணை வழங்க வேண்டும்.

நெறிமுறைகளுக்கான நடைமுறை பயன்பாட்டு வழக்குகள்

நெறிமுறைகள் பல்வேறு சூழ்நிலைகளில் குறிப்பாக பயனுள்ளதாக இருக்கும்:

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

வகை குறிப்புகளைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

பைதான் வகை குறிப்புகளை அதிகம் பயன்படுத்த, பின்வரும் சிறந்த நடைமுறைகளை கவனியுங்கள்:

• தொடர்ச்சியாக இருங்கள்: உங்கள் குறியீட்டுத் தளம் முழுவதும் வகை குறிப்புகளைத் தொடர்ந்து பயன்படுத்தவும். வகை குறிப்புகளைத் தவறாமல் பயன்படுத்துவது குழப்பத்திற்கு வழிவகுக்கும் மற்றும் வகை பிழைகளைக் கண்டறிவதை கடினமாக்கும்.
• சிறியதாகத் தொடங்குங்கள்: ஏற்கனவே உள்ள குறியீட்டுத் தளத்திற்கு வகை குறிப்புகளை அறிமுகப்படுத்தினால், குறியீட்டின் சிறிய, நிர்வகிக்கக்கூடிய பகுதியுடன் தொடங்கி, காலப்போக்கில் வகை குறிப்புகளின் பயன்பாட்டை படிப்படியாக விரிவுபடுத்துங்கள்.
• நிலையான பகுப்பாய்வு கருவிகளைப் பயன்படுத்தவும்: வகை பிழைகளுக்கு உங்கள் குறியீட்டை சரிபார்க்க mypy போன்ற நிலையான பகுப்பாய்வு கருவிகளைப் பயன்படுத்தவும். இயக்க நேரத்தில் சிக்கல்களை ஏற்படுத்துவதற்கு முன்பு, அபிவிருத்தி செயல்பாட்டின் ஆரம்பத்தில் பிழைகளை பிடிக்க இந்த கருவிகள் உங்களுக்கு உதவும்.
• தெளிவான மற்றும் சுருக்கமான வகை குறிப்புகளை எழுதுங்கள்: புரிந்து கொள்ளவும் பராமரிக்கவும் எளிதான வகை குறிப்புகளை எழுதுங்கள். உங்கள் குறியீட்டைப் படிக்க கடினமாக்கும் அதிகப்படியான சிக்கலான வகை குறிப்புகளைத் தவிர்க்கவும்.
• வகை புனைப்பெயர்களைப் பயன்படுத்தவும்: சிக்கலான வகை குறிப்புகளை எளிதாக்க மற்றும் உங்கள் குறியீட்டை மிகவும் படிக்கக்கூடியதாக மாற்ற வகை புனைப்பெயர்களைப் பயன்படுத்தவும்.
• `Any` ஐ அதிகமாகப் பயன்படுத்த வேண்டாம்: முற்றிலும் அவசியம் எனில் தவிர Any ஐப் பயன்படுத்துவதைத் தவிர்க்கவும். Any ஐ அதிகமாகப் பயன்படுத்துவது வகை சரிபார்ப்பின் நன்மைகளை பலவீனப்படுத்தும்.
• உங்கள் வகை குறிப்புகளை ஆவணப்படுத்தவும்: ஒவ்வொரு வகையின் நோக்கத்தையும் அது பொருந்தும் எந்த கட்டுப்பாடுகளையும் அனுமானங்களையும் விளக்கி, உங்கள் வகை குறிப்புகளை ஆவணப்படுத்த ஆவண சரங்களைப் பயன்படுத்தவும்.
• இயக்க நேர வகை சரிபார்ப்பைக் கவனியுங்கள்: பைதான் நிலையான முறையில் தட்டச்சு செய்யப்படாவிட்டாலும், `beartype` போன்ற நூலகங்கள் இயக்க நேரத்தில் வகை குறிப்புகளை செயல்படுத்த இயக்க நேர வகை சரிபார்ப்பை வழங்குகின்றன, குறிப்பாக வெளிப்புற தரவு அல்லது மாறும் குறியீடு உருவாக்கத்துடன் பணிபுரியும் போது கூடுதல் பாதுகாப்பு அடுக்கை வழங்குகிறது.

எடுத்துக்காட்டு: உலகளாவிய இ-காமர்ஸ் பயன்பாட்டில் வகை குறிப்புகள்

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

            from typing import List, Dict, Protocol, TypeVar, Generic

# Define data types
UserID = str  # Example: UUID string
ProductID = str  # Example: SKU string
CurrencyCode = str  # Example: "USD", "EUR", "JPY"


class Product(Protocol):
    product_id: ProductID
    name: str
    price: float  # Base price in a standard currency (e.g., USD)


class DiscountRule(Protocol):
    def apply_discount(self, product: Product, user_id: UserID) -> float:  # Returns discount amount
        ...


class TaxCalculator(Protocol):
    def calculate_tax(self, product: Product, user_id: UserID, currency: CurrencyCode) -> float:
        ...


class PaymentGateway(Protocol):
    def process_payment(self, user_id: UserID, amount: float, currency: CurrencyCode) -> bool:
        ...


# Concrete implementations (examples)
class BasicProduct:
    def __init__(self, product_id: ProductID, name: str, price: float):
        self.product_id = product_id
        self.name = name
        self.price = price

class PercentageDiscount:
    def __init__(self, discount_percentage: float):
        self.discount_percentage = discount_percentage

    def apply_discount(self, product: Product, user_id: UserID) -> float:
        return product.price * (self.discount_percentage / 100)


class EuropeanVATCalculator:
    def calculate_tax(self, product: Product, user_id: UserID, currency: CurrencyCode) -> float:
        # Simplified EU VAT calculation (replace with actual logic)
        vat_rate = 0.20  # Example: 20% VAT
        return product.price * vat_rate


class CreditCardGateway:
    def process_payment(self, user_id: UserID, amount: float, currency: CurrencyCode) -> bool:
        # Simulate credit card processing
        print(f"Processing payment of {amount} {currency} for user {user_id} using credit card...")
        return True


# Type-hinted shopping cart function
def calculate_total(
    products: List[Product],
    user_id: UserID,
    currency: CurrencyCode,
    discount_rules: List[DiscountRule],
    tax_calculator: TaxCalculator,
    payment_gateway: PaymentGateway,
) -> float:
    total = 0.0
    for product in products:
        discount = 0.0
        for rule in discount_rules:
            discount += rule.apply_discount(product, user_id)

        tax = tax_calculator.calculate_tax(product, user_id, currency)
        total += product.price - discount + tax

    # Process payment
    if payment_gateway.process_payment(user_id, total, currency):
        return total
    else:
        raise Exception("Payment failed")


# Example usage
product1 = BasicProduct(product_id="SKU123", name="Awesome T-Shirt", price=25.0)
product2 = BasicProduct(product_id="SKU456", name="Cool Mug", price=15.0)

discount1 = PercentageDiscount(10)

vat_calculator = EuropeanVATCalculator()
payment_gateway = CreditCardGateway()

shopping_cart = [product1, product2]
user_id = "user123"
currency = "EUR"

final_total = calculate_total(
    products=shopping_cart,
    user_id=user_id,
    currency=currency,
    discount_rules=[discount1],
    tax_calculator=vat_calculator,
    payment_gateway=payment_gateway,
)

print(f"Total cost: {final_total} {currency}")

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில்:

• படிக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய தன்மையை மேம்படுத்த UserID, ProductID மற்றும் CurrencyCode போன்ற வகை புனைப்பெயர்களைப் பயன்படுத்துகிறோம்.
• வெவ்வேறு கூறுகளுக்கான இடைமுகங்களைக் குறிக்க நெறிமுறைகளை (Product, DiscountRule, TaxCalculator, PaymentGateway) வரையறுக்கிறோம். இது முக்கிய calculate_total செயல்பாட்டை மாற்றாமல் வெவ்வேறு செயலாக்கங்களை (எடுத்துக்காட்டாக, வெவ்வேறு பிராந்தியத்திற்கான வேறு வரி கால்குலேட்டர்) எளிதாக மாற்ற அனுமதிக்கிறது.
• சேகரிப்புகளின் வகைகளை வரையறுக்க ஜெனரிக்ஸைப் பயன்படுத்துகிறோம் (எடுத்துக்காட்டாக, List[Product]).
• calculate_total செயல்பாடு முழுமையாக வகை-குறிப்பிடப்பட்டுள்ளது, இது அதன் உள்ளீடுகள் மற்றும் வெளியீடுகளைப் புரிந்துகொள்வதையும் வகை பிழைகளை ஆரம்பத்தில் பிடிப்பதையும் எளிதாக்குகிறது.

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

முடிவுரை

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