அலங்கரிப்பவர்கள்: செயல்பாடுகளை மாற்றியமைக்கும் செயல்பாடுகள்

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

மதிப்புகளாக செயல்படுகிறது

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

def saluta():
    print("ciao")

f = saluta   # NIENTE parentesi: assegno la funzione
f()          # 'ciao'

ஒரு குறைந்தபட்ச அலங்கரிப்பாளர்

def log(func):
    def wrapper(*args, **kwargs):
        print(f"chiamo {func.__name__}")
        risultato = func(*args, **kwargs)
        print(f"ho finito {func.__name__}")
        return risultato
    return wrapper

def somma(a, b):
    return a + b

somma = log(somma)   # ora somma è "wrapper"
somma(2, 3)
# chiamo somma
# ho finito somma
# 5

@decorator தொடரியல்

somma = log(somma) பணியானது @ உடன் மிகவும் நேர்த்தியாக எழுதப்பட்டுள்ளது:

@log
def somma(a, b):
    return a + b

இது சரியாக அதே விஷயம். வரையறைக்கு மேலே @log இதற்குச் சமம்: "இந்த செயல்பாடு வரையறுக்கப்பட்டவுடன், அதை log(function) என மாற்றவும்".

*args, **kwargs: எந்த கையொப்பத்தையும் ஏற்கவும்

def wrapper(*args, **kwargs):
    return func(*args, **kwargs)

*args நிலை வாதங்களை சேகரிக்கிறது, **kwargs முக்கிய வாதங்கள். அவர்கள் அனுமதித்தனர் நீங்கள் எந்த செயல்பாட்டிலும் வேலை செய்யும் ரேப்பர்களை எழுதுகிறீர்கள்.

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

wraps இல்லாமல், அலங்கரிக்கப்பட்ட செயல்பாடு __name__, __doc__, குறிப்புகள்:

from functools import wraps

def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        ...
        return func(*args, **kwargs)
    return wrapper

எடுத்துக்காட்டு: @timeit

from functools import wraps
import time

def timeit(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        risultato = func(*args, **kwargs)
        dt = time.perf_counter() - t0
        print(f"{func.__name__} ha impiegato {dt*1000:.2f} ms")
        return risultato
    return wrapper

@timeit
def somma_grande():
    return sum(range(10**6))

somma_grande()

stdlib இலிருந்து அலங்கரிப்பவர்கள்

from functools import lru_cache

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

fib(100)  # istantaneo grazie alla cache

• @lru_cache — தூய செயல்பாட்டின் முடிவுகளை நினைவூட்டுகிறது.
• @property — ஒரு முறையை ஒரு பண்புக்கூறாக வெளிப்படுத்துகிறது (OOP தொகுதியில் காணப்படுகிறது).
• @staticmethod, @classmethod — self கடந்து செல்லும் முறையை மாற்றவும்.

வாதங்களுடன் அலங்கரிப்பவர்கள்

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

நீங்களே முயற்சி செய்து பாருங்கள்

மதிப்பாய்வு பயிற்சி

கூடுதல் சவால்