Python Decorators Explained: Paano Ito Gumagana at Mga Halimbawa

Ang Python ay isang malakas at flexible na programming language, at isa sa mga pinaka-kapaki-pakinabang na feature nito ay ang mga decorators. Kung ikaw ay isang developer, maaaring narinig mo na ang salitang "decorator" at nagtataka kung paano ito gumagana at kung paano ito magagamit sa iyong mga proyekto. Huwag mag-alala, sa artikulong ito, tatalakayin natin ang Python decorators, ipapaliwanag ito ng detalyado, at bibigyan ka ng mga halimbawa upang mas maintindihan ang kanilang gamit at kahalagahan.

Ano ang Python Decorator?

Sa pinaka-simple na kahulugan, ang decorator sa Python ay isang function na nagmo-modify o nagpa-paliit ng behavior ng ibang function o method. Sa madaling salita, ang decorator ay isang paraan upang baguhin ang isang function nang hindi binabago ang mismong code nito. Para itong "wrapper" na nilalagay sa ibabaw ng function na gusto mong baguhin. Isipin mo ito bilang isang paraan upang magdagdag ng mga karagdagang functionality sa mga function nang hindi kinakailangang palitan ang kanilang code.

Paano Gumagana ang Decorators?

Ang decorators ay mga function na tumatanggap ng ibang function bilang argumento at nagbabalik ng isang bagong function. Karaniwan, ginagamit natin ang decorators upang madagdagan ang behavior ng mga function nang hindi binabago ang kanilang mga orihinal na code. Sa madaling salita, ang decorators ay nag-aapply ng "wrapper" o "modifier" sa function.

Halimbawa ng Simpleng Decorator

Isang magandang halimbawa upang maipakita kung paano gumagana ang decorators ay ang sumusunod:

def simple_decorator(func):
    def wrapper():
        print("Bago tumawag sa function")
        func()
        print("Pagkatapos tumawag sa function")
    return wrapper

def say_hello():
    print("Hello, World!")

decorated_function = simple_decorator(say_hello)
decorated_function()

Sa halimbawa sa itaas, ang `simple_decorator` ay isang decorator function. Ang `say_hello` ay isang simpleng function na magpi-print ng "Hello, World!". Kapag inilagay natin ang `simple_decorator` sa ibabaw ng `say_hello`, magbabago ang behavior ng `say_hello` function at magdadagdag tayo ng print statements bago at pagkatapos tumawag sa function. Ang output ng code na ito ay:

Bago tumawag sa function
Hello, World!
Pagkatapos tumawag sa function

Ipinapakita ng halimbawa na ito kung paanong ang `simple_decorator` ay nagdagdag ng extra na functionality sa `say_hello` function nang hindi binabago ang mismong function code.

Decorator Syntax gamit ang @

Maaaring medyo magulo ang syntax kapag direktang ginagamit ang decorators, kaya naman ipinakilala ang "@" syntax sa Python upang mas mapadali ito. Ang syntax na ito ay ginagamit upang direktang i-apply ang isang decorator sa isang function nang hindi kailangang i-assign ito sa isang variable.

@simple_decorator
def say_hello():
    print("Hello, World!")
    
say_hello()

Ang code sa itaas ay gagawa ng parehong resulta gaya ng naunang halimbawa, ngunit sa mas simpleng paraan. Ang `@simple_decorator` ay ginagamit upang i-apply ang decorator sa function na `say_hello`. Kapag tinawag mo ang `say_hello()`, ang output ay:

Bago tumawag sa function
Hello, World!
Pagkatapos tumawag sa function

Mga Real-Life na Halimbawa ng Decorators

Ngayon na alam na natin kung paano gumagana ang decorators, tatalakayin natin ang ilang mga real-life na halimbawa kung paano ito ginagamit sa Python programming.

1. Logging

Isa sa mga pinakaginagamit na application ng decorators ay ang pagdagdag ng logging functionality sa mga function. Halimbawa, maaaring nais mong mag-log ng oras kung kailan tinawag ang isang function o ang mga parameters na ipinasa dito. Narito ang isang halimbawa:

import time

def log_function_call(func):
    def wrapper(*args, **kwargs):
        print(f"Tinutawag ang function: {func.__name__}")
        print(f"Oras: {time.time()}")
        return func(*args, **kwargs)
    return wrapper

@log_function_call
def say_hello():
    print("Hello, World!")

say_hello()

Sa halimbawa sa itaas, ang `log_function_call` ay isang decorator na naglalagay ng log na nagpapakita ng pangalan ng function at ang oras kung kailan ito tinawag. Ang output ng code na ito ay:

Tinutawag ang function: say_hello
Oras: 1653602557.728217
Hello, World!

2. Authentication

Ang isa pang magandang halimbawa ng paggamit ng decorators ay para sa authentication ng user. Halimbawa, maaaring gusto mong tiyakin na ang isang user ay authenticated bago payagan silang tumawag ng isang partikular na function. Narito ang isang simpleng halimbawa ng authentication decorator:

def requires_authentication(func):
    def wrapper(*args, **kwargs):
        user_authenticated = True  # Halimbawa lang ito, dapat dito ang tunay na authentication logic
        if user_authenticated:
            return func(*args, **kwargs)
        else:
            print("Hindi authenticated ang user.")
    return wrapper

@requires_authentication
def access_dashboard():
    print("Pumunta sa dashboard!")

access_dashboard()

Sa halimbawa sa itaas, ang `requires_authentication` na decorator ay nagsisigurado na ang user ay authenticated bago makapag-access sa `access_dashboard` function. Kung hindi authenticated ang user, magpi-print ito ng mensahe na hindi sila pinapayagan. Ang output ay:

Pumunta sa dashboard!

3. Caching

Isa pang madalas na gamit ng decorators ay ang pagdagdag ng caching functionality. Halimbawa, kapag isang mahalagang function ay tumatagal ng maraming oras upang makuha ang isang resulta, maaari mong cache ang resulta nito upang hindi na ulitin ang parehong computation.

def cache_results(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

@cache_results
def slow_function(x):
    print("Nagkocompute...")
    time.sleep(2)
    return x * 2

print(slow_function(10))  # Magtatagal ng 2 segundo
print(slow_function(10))  # Agad-agad ang resulta dahil naka-cache

Sa halimbawa sa itaas, ginagamit namin ang `cache_results` decorator upang i-cache ang resulta ng `slow_function`. Kung tatawagin mo ito muli gamit ang parehong argumento, ibabalik ang cached na resulta nang hindi kinakailangan pang i-compute ito muli.

Konklusyon

Ang mga decorators sa Python ay isang napakagandang tool para sa pagdaragdag ng functionality sa mga function nang hindi binabago ang kanilang code. Sa pamamagitan ng paggamit ng decorators, maaari mong i-optimize ang iyong code at gawing mas organisado at madaling basahin. Sa artikulong ito, tinalakay natin ang mga pangunahing konsepto ng decorators, kasama na ang ilang mga halimbawa tulad ng logging, authentication, at caching. Sa mga halimbawang ito, sana ay nakuha mo ang isang malinaw na ideya kung paano gamitin ang decorators sa iyong mga proyekto!