பைத்தானின் திறனைத் திறத்தல்: உலகளாவிய உருவாக்குநர்களுக்கான மேம்பட்ட `functools` அலங்கரிப்பான்கள்

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

உலகளாவிய பார்வையாளர்களுக்கு `functools` அலங்கரிப்பான்கள் ஏன் முக்கியம்

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

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

இந்த அலங்கரிப்பான்கள் ஒவ்வொன்றையும் விரிவாக ஆராய்வோம்.

1. `functools.lru_cache`: செயல்திறன் தேர்வுமுறைக்கான நினைவகம்

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

`lru_cache` என்றால் என்ன?

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

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

`lru_cache` ஐப் பயன்படுத்த, அதை இறக்குமதி செய்து உங்கள் செயல்பாட்டிற்கு அலங்கரிப்பானாகப் பயன்படுத்துங்கள்:

            from functools import lru_cache

@lru_cache(maxsize=128)
def expensive_computation(x, y):
    """A function that simulates an expensive computation."""
    print(f"Performing expensive computation for {x}, {y}...")
    # Simulate some heavy work, e.g., network request, complex math
    return x * y + x / 2

            

              
                Copy
              
            
          

`maxsize` அளவுரு சேமிக்க வேண்டிய முடிவுகளின் அதிகபட்ச எண்ணிக்கையை கட்டுப்படுத்துகிறது. `maxsize` `None` ஆக அமைக்கப்பட்டால், தற்காலிக சேமிப்பகம் காலவரையின்றி வளரக்கூடும். இது ஒரு நேர்மறை முழு எண்ணாக அமைக்கப்பட்டால், அது தற்காலிக சேமிப்பக அளவைக் குறிப்பிடுகிறது. தற்காலிக சேமிப்பகம் நிரம்பியதும், அது கடைசியாகப் பயன்படுத்தப்பட்ட உள்ளீடுகளை நிராகரிக்கிறது. `maxsize` க்கான இயல்புநிலை மதிப்பு 128 ஆகும்.

முக்கிய பரிசீலனைகள் மற்றும் மேம்பட்ட பயன்பாடு

• ஹாஷ் செய்யக்கூடிய வாதங்கள்: தற்காலிகமாக சேமிக்கப்பட்ட செயல்பாட்டிற்கு அனுப்பப்பட்ட வாதங்கள் ஹாஷ் செய்யக்கூடியதாக இருக்க வேண்டும். இதன் பொருள் எண்கள், சரங்கள், டூப்பிள்கள் (ஹாஷ் செய்யக்கூடிய உருப்படிகளை மட்டுமே கொண்டுள்ளது) மற்றும் உறைந்த தொகுப்புகள் போன்ற மாற்ற முடியாத வகைகள் ஏற்றுக்கொள்ளத்தக்கவை. பட்டியல்கள், அகராதிகள் மற்றும் தொகுப்புகள் போன்ற மாற்றக்கூடிய வகைகள் இல்லை.
• `typed=True` அளவுரு: இயல்பாக, `lru_cache` சமமாக ஒப்பிடும் வெவ்வேறு வகைகளின் வாதங்களை ஒரே மாதிரியாகக் கருதுகிறது. உதாரணமாக, `cached_func(3)` மற்றும் `cached_func(3.0)` ஒரே தற்காலிக சேமிப்பக உள்ளீட்டைத் தாக்கக்கூடும். `typed=True` ஐ அமைப்பது வாத வகைகளுக்கு தற்காலிக சேமிப்பகத்தை உணர்திறன் ஆக்குகிறது. எனவே, `cached_func(3)` மற்றும் `cached_func(3.0)` தனித்தனியாக தற்காலிகமாக சேமிக்கப்படும். செயல்பாட்டிற்குள் வகை-குறிப்பிட்ட தர்க்கம் இருக்கும்போது இது பயனுள்ளதாக இருக்கும்.
• தற்காலிக சேமிப்பகத்தை செல்லாததாக்குதல்: தற்காலிக சேமிப்பகத்தை நிர்வகிக்க `lru_cache` முறைகளை வழங்குகிறது. `cache_info()` என்பது தற்காலிக சேமிப்பக வெற்றிகள், தவறுகள், தற்போதைய அளவு மற்றும் அதிகபட்ச அளவு பற்றிய புள்ளிவிவரங்களுடன் பெயரிடப்பட்ட டூப்பிளை வழங்குகிறது. `cache_clear()` முழு தற்காலிக சேமிப்பகத்தையும் அழித்துவிடும்.

            @lru_cache(maxsize=32)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))
print(fibonacci.cache_info())
fibonacci.cache_clear()
print(fibonacci.cache_info())

            

              
                Copy
              
            
          

`lru_cache` இன் உலகளாவிய பயன்பாடு

ஒரு பயன்பாடு நிகழ்நேர நாணய மாற்று விகிதங்களை வழங்கும் ஒரு சூழ்நிலையை கருத்தில் கொள்ளுங்கள். இந்த விகிதங்களை வெளிப்புற API இலிருந்து பெறுவது மெதுவாகவும் வளங்களை உட்கொள்ளவும் முடியும். `lru_cache` இந்த விகிதங்களைப் பெறும் செயல்பாட்டிற்குப் பயன்படுத்தப்படலாம்:

            import requests
from functools import lru_cache

@lru_cache(maxsize=10)
def get_exchange_rate(base_currency, target_currency):
    """Fetches the latest exchange rate from an external API."""
    # In a real-world app, handle API keys, error handling, etc.
    api_url = f"https://api.example.com/rates?base={base_currency}&target={target_currency}"
    try:
        response = requests.get(api_url, timeout=5) # Set a timeout
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        data = response.json()
        return data['rate']
    except requests.exceptions.RequestException as e:
        print(f"Error fetching exchange rate: {e}")
        return None

# User in Europe requests EUR to USD rate
europe_user_rate = get_exchange_rate('EUR', 'USD')
print(f"EUR to USD: {europe_user_rate}")

# User in Asia requests EUR to USD rate
asian_user_rate = get_exchange_rate('EUR', 'USD') # This will hit the cache if within maxsize
print(f"EUR to USD (cached): {asian_user_rate}")

# User in Americas requests USD to EUR rate
americas_user_rate = get_exchange_rate('USD', 'EUR')
print(f"USD to EUR: {americas_user_rate}")

            

              
                Copy
              
            
          

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

2. `functools.singledispatch`: பொதுவான செயல்பாடுகள் மற்றும் பாலிமார்பிசம்

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

`singledispatch` என்றால் என்ன?

`singledispatch` என்பது பொதுவான செயல்பாடுகளை இயக்கும் ஒரு செயல்பாட்டு அலங்கரிப்பான். ஒரு பொதுவான செயல்பாடு என்பது அதன் முதல் வாதத்தின் வகையின் அடிப்படையில் வித்தியாசமாக செயல்படும் ஒரு செயல்பாடு ஆகும். `@singledispatch` உடன் அலங்கரிக்கப்பட்ட ஒரு அடிப்படை செயல்பாட்டை வரையறுத்து, பின்னர் வெவ்வேறு வகைகளுக்கு சிறப்பு செயலாக்கங்களை பதிவு செய்ய `@base_function.register(Type)` அலங்கரிப்பானைப் பயன்படுத்துகிறீர்கள்.

அடிப்படை பயன்பாடு

வெவ்வேறு வெளியீட்டு வடிவங்களுக்கான தரவை வடிவமைக்கும் எடுத்துக்காட்டுடன் விளக்குவோம்:

            from functools import singledispatch

@singledispatch
def format_data(data):
    """Default implementation: formats data as a string."""
    return str(data)

@format_data.register(int)
def _(data):
    """Formats integers with commas for thousands separation."""
    return "{:,.0f}".format(data)

@format_data.register(float)
def _(data):
    """Formats floats with two decimal places."""
    return "{:.2f}".format(data)

@format_data.register(list)
def _(data):
    """Formats lists by joining elements with a pipe '|'."""
    return " | ".join(map(str, data))

            

              
                Copy
              
            
          

பதிவு செய்யப்பட்ட செயலாக்கங்களுக்கான செயல்பாட்டுப் பெயராக `_` ஐப் பயன்படுத்துவதைக் கவனியுங்கள். இது ஒரு பொதுவான மாநாடு, ஏனெனில் பதிவு செய்யப்பட்ட செயல்பாட்டின் பெயர் முக்கியமல்ல; அனுப்புதலுக்கு அதன் வகை மட்டுமே முக்கியம். பொதுவான செயல்பாட்டிற்கு அனுப்பப்பட்ட முதல் வாதத்தின் வகையின் அடிப்படையில் அனுப்புதல் நடக்கிறது.

அனுப்புதல் எவ்வாறு செயல்படுகிறது

`format_data(some_value)` அழைக்கப்படும்போது:

1. பைதான் `some_value` வகையைச் சரிபார்க்கிறது.
2. அந்த குறிப்பிட்ட வகைக்கு ஒரு பதிவு இருந்தால் (எ.கா., `int`, `float`, `list`), தொடர்புடைய பதிவு செய்யப்பட்ட செயல்பாடு அழைக்கப்படுகிறது.
3. குறிப்பிட்ட பதிவு எதுவும் காணப்படவில்லை என்றால், `@singledispatch` உடன் அலங்கரிக்கப்பட்ட அசல் செயல்பாடு (இயல்புநிலை செயலாக்கம்) அழைக்கப்படுகிறது.
4. `singledispatch` பரம்பரையையும் கையாள்கிறது. `Subclass` வகை `BaseClass` இலிருந்து மரபுரிமையாக இருந்தால், `format_data` `BaseClass` க்கான பதிவைக் கொண்டிருந்தால், `Subclass` இன் ஒரு நிகழ்வின் மூலம் `format_data` ஐ அழைப்பது குறிப்பிட்ட `Subclass` பதிவு எதுவும் இல்லை என்றால் `BaseClass` செயலாக்கத்தைப் பயன்படுத்தும்.

`singledispatch` இன் உலகளாவிய பயன்பாடு

சர்வதேச தரவு செயலாக்க சேவையை கற்பனை செய்து பாருங்கள். பயனர்கள் பல்வேறு வடிவங்களில் தரவைச் சமர்ப்பிக்கலாம் (எ.கா., எண் மதிப்புகள், புவியியல் ஆயங்கள், நேர முத்திரைகள், உருப்படிகளின் பட்டியல்கள்). இந்த தரவை செயலாக்கி தரப்படுத்த ஒரு செயல்பாடு `singledispatch` இலிருந்து பெரிதும் பயனடையலாம்.

            from functools import singledispatch
from datetime import datetime

@singledispatch
def process_input(value):
    """Default processing: log unknown types."""
    print(f"Logging unknown input type: {type(value).__name__} - {value}")
    return None

@process_input.register(str)
def _(value):
    """Processes strings, assuming they might be dates or simple text."""
    try:
        # Attempt to parse as ISO format date
        return datetime.fromisoformat(value.replace('Z', '+00:00'))
    except ValueError:
        # If not a date, return as is (or perform other text processing)
        return value.strip()

@process_input.register(int)
def _(value):
    """Processes integers, assuming they are valid product IDs."""
    if value < 100000: # Arbitrary validation for example
        print(f"Warning: Potentially invalid product ID: {value}")
    return f"PID-{value:06d}" # Formats as PID-000001

@process_input.register(tuple)
def _(value):
    """Processes tuples, assuming they are geographical coordinates (lat, lon)."""
    if len(value) == 2 and all(isinstance(coord, (int, float)) for coord in value):
        return {'latitude': value[0], 'longitude': value[1]}
    else:
        print(f"Warning: Invalid coordinate tuple format: {value}")
        return None

# --- Example Usage for a global audience ---

# User in Japan submits a timestamp string
input1 = "2023-10-27T10:00:00Z"
processed1 = process_input(input1)
print(f"Input: {input1}, Processed: {processed1}")

# User in the US submits a product ID
input2 = 12345
processed2 = process_input(input2)
print(f"Input: {input2}, Processed: {processed2}")

# User in Brazil submits geographical coordinates
input3 = ( -23.5505, -46.6333 )
processed3 = process_input(input3)
print(f"Input: {input3}, Processed: {processed3}")

# User in Australia submits a simple text string
input4 = "Sydney Office"
processed4 = process_input(input4)
print(f"Input: {input4}, Processed: {processed4}")

# Some other type
input5 = [1, 2, 3]
processed5 = process_input(input5)
print(f"Input: {input5}, Processed: {processed5}")

            

              
                Copy
              
            
          

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

3. `functools.wraps`: செயல்பாட்டு மெட்டாடேட்டாவைப் பாதுகாத்தல்

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

`wraps` என்றால் என்ன?

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

அடிப்படை பயன்பாடு

எளிய லாக்கிங் அலங்கரிப்பானை உருவாக்கி, `wraps` உடன் மற்றும் இல்லாமல் விளைவைப் பார்ப்போம்.

`wraps` இல்லாமல்

            def simple_logging_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished function: {func.__name__}")
        return result
    return wrapper

@simple_logging_decorator
def greet(name):
    """Greets a person."""
    return f"Hello, {name}!"

print(f"Function name: {greet.__name__}")
print(f"Function docstring: {greet.__doc__}")
print(greet("World"))

            

              
                Copy
              
            
          

நீங்கள் இதை இயக்கினால், `greet.__name__` 'wrapper' ஆகவும், `greet.__doc__` `None` ஆகவும் இருப்பதை நீங்கள் கவனிப்பீர்கள், ஏனெனில் `wrapper` செயல்பாட்டின் மெட்டாடேட்டா `greet` ஐ மாற்றியுள்ளது.

`wraps` உடன்

இப்போது, ​​`wraps` ஐ `wrapper` செயல்பாட்டிற்குப் பயன்படுத்துவோம்:

            from functools import wraps

def robust_logging_decorator(func):
    @wraps(func) # Apply wraps to the wrapper function
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished function: {func.__name__}")
        return result
    return wrapper

@robust_logging_decorator
def greet_properly(name):
    """Greets a person (properly decorated)."""
    return f"Hello, {name}!"

print(f"Function name: {greet_properly.__name__}")
print(f"Function docstring: {greet_properly.__doc__}")
print(greet_properly("World Again"))

            

              
                Copy
              
            
          

இந்த இரண்டாவது எடுத்துக்காட்டை இயக்குவது காண்பிக்கும்:

            Function name: greet_properly
Function docstring: Greets a person (properly decorated).
Calling function: greet_properly
Finished function: greet_properly
Hello, World Again!

            

              
                Copy
              
            
          

`__name__` சரியாக 'greet_properly' என அமைக்கப்பட்டுள்ளது, மேலும் `__doc__` சரம் பாதுகாக்கப்படுகிறது. `wraps` `__module__`, `__qualname__`, மற்றும் `__annotations__` போன்ற பிற தொடர்புடைய பண்புகளையும் நகலெடுக்கிறது.

`wraps` இன் உலகளாவிய பயன்பாடு

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

உதாரணமாக, வெப் API எண்ட்பாயிண்ட் ஹேண்ட்லரை செயல்படுத்துவதற்கு முன் அங்கீகாரச் சோதனைகளைச் சேர்க்கும் அலங்கரிப்பானைக் கவனியுங்கள். `wraps` இல்லாமல், எண்ட்பாயிண்ட்டின் பெயர் மற்றும் டாக்ஸ்ட்ரிங் இழக்கப்படலாம், இது பிற டெவலப்பர்கள் (அல்லது தானியங்கி கருவிகள்) எண்ட்பாயிண்ட் என்ன செய்கிறது அல்லது சிக்கல்களை பிழைதிருத்துவது கடினமாக்குகிறது. `wraps` ஐப் பயன்படுத்துவது எண்ட்பாயிண்ட்டின் அடையாளம் தெளிவாக இருப்பதை உறுதி செய்கிறது.

            from functools import wraps

def require_admin_role(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # In a real app, this would check user roles from session/token
        is_admin = kwargs.get('user_role') == 'admin'
        if not is_admin:
            raise PermissionError("Admin role required")
        return func(*args, **kwargs)
    return wrapper

@require_admin_role
def delete_user(user_id, user_role=None):
    """Deletes a user from the system. Requires admin privileges."""
    print(f"Deleting user {user_id}...")
    # Actual deletion logic here
    return True

# --- Example Usage ---

# Simulating a request from an admin user
try:
    delete_user(101, user_role='admin')
except PermissionError as e:
    print(e)

# Simulating a request from a regular user
try:
    delete_user(102, user_role='user')
except PermissionError as e:
    print(e)

# Inspecting the decorated function
print(f"Function name: {delete_user.__name__}")
print(f"Function docstring: {delete_user.__doc__}")

# Note: __annotations__ would also be preserved if present on the original function.

            

              
                Copy
              
            
          

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

அலங்கரிப்பான்களை இணைத்தல்: ஒரு சக்திவாய்ந்த ஒருங்கிணைப்பு

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

`singledispatch` க்கு அலங்கரிக்கப்பட்ட செயல்பாடு அனுப்புதலுக்கான அடிப்படையாக இருக்க வேண்டும், மேலும் `lru_cache` எந்தவொரு செயல்பாட்டின் execution ஐயும் மேம்படுத்துகிறது, அவை ஒன்றாக வேலை செய்ய முடியும். இருப்பினும், `wraps` என்பது மெட்டாடேட்டாவைப் பாதுகாக்க ஒரு தனிப்பயன் அலங்கரிப்பிற்குள் பயன்படுத்தப்படுகிறது. `lru_cache` மற்றும் `singledispatch` பொதுவாக செயல்பாடுகளுக்கு நேரடியாகவோ அல்லது `singledispatch` விஷயத்தில் அடிப்படை செயல்பாட்டிற்கோ பயன்படுத்தப்படுகின்றன.

ஒரு பொதுவான கலவையானது ஒரு தனிப்பயன் அலங்கரிப்பிற்குள் `lru_cache` மற்றும் `wraps` ஐப் பயன்படுத்துகிறது:

            from functools import lru_cache, wraps

def cached_and_logged(maxsize=128):
    def decorator(func):
        @wraps(func)
        @lru_cache(maxsize=maxsize)
        def wrapper(*args, **kwargs):
            # Note: Logging inside lru_cache might be tricky
            # as it only runs on cache misses. For consistent logging,
            # it's often better to log outside the cached part or rely on cache_info.
            print(f"(Cache miss/run) Executing: {func.__name__} with args {args}, kwargs {kwargs}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@cached_and_logged(maxsize=4)
def complex_calculation(a, b):
    """Performs a simulated complex calculation."""
    print(f"  - Performing calculation for {a}+{b}...")
    return a + b * 2

print(f"Call 1: {complex_calculation(1, 2)}") # Cache miss
print(f"Call 2: {complex_calculation(1, 2)}") # Cache hit
print(f"Call 3: {complex_calculation(3, 4)}") # Cache miss
print(f"Call 4: {complex_calculation(1, 2)}") # Cache hit
print(f"Call 5: {complex_calculation(5, 6)}") # Cache miss, may evict (1,2) or (3,4)

print(f"Function name: {complex_calculation.__name__}")
print(f"Function docstring: {complex_calculation.__doc__}")
print(f"Cache info: {complex_calculation.cache_info()}")

            

              
                Copy
              
            
          

இந்த ஒருங்கிணைந்த அலங்கரிப்பாளரில், `@wraps(func)` `complex_calculation` இன் மெட்டாடேட்டா பாதுகாக்கப்படுவதை உறுதி செய்கிறது. `@lru_cache` அலங்கரிப்பான் உண்மையான கணக்கீட்டை மேம்படுத்துகிறது, மேலும் `wrapper` க்குள் உள்ள அச்சு அறிக்கை தற்காலிக சேமிப்பகம் தவறும்போது மட்டுமே செயல்படுகிறது, இது அண்டர்லயிங் செயல்பாடு உண்மையில் அழைக்கப்படும்போது சில நுண்ணறிவுகளை வழங்குகிறது. `maxsize` அளவுருவை `cached_and_logged` தொழிற்சாலை செயல்பாடு மூலம் தனிப்பயனாக்கலாம்.

முடிவு: உலகளாவிய பைதான் வளர்ச்சியை மேம்படுத்துதல்

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

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

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

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