Python Decorators Explained: Kiel Uzi Dekoratorojn en Python

Se vi estas programisto aŭ komencanto en la mondo de Python, verŝajne vi jam aŭdis pri dekoratoroj. Sed kio eksakte estas Python-dekoratoro, kaj kial ĝi tiel potenca? Ne zorgu! En ĉi tiu artikolo, ni klarigos, kio estas Python-dekoratoroj, kiel ili funkcias, kaj kiel vi povas uzi ilin en via kodo por igi viajn aplikojn pli elegantaj kaj efikaj.

Kio estas Python Dekoratoroj?

En Python, dekoratoro estas funkcio kiu aldonas novajn funkciojn aŭ kondiĉojn al ekzistanta funkcio aŭ metodo sen modifi ĝian internan kodon. Ili estas speciale utilaj kiam vi volas uzi la saman funkcion en multaj lokoj, sed kun kelkaj modifoj aŭ etendaĵoj. Dekoratoroj povas esti uzataj por plibonigi la legiblecon de la kodo, kaj eĉ por aldoni aŭtomekanismojn kiel aŭtentikigon aŭ logadon sen ripetado de la sama kodo.

Kiel Dekoratoroj Funkcias?

En Python, dekoratoro estas simple funkcio kiu prenas funkcion kiel argumenton kaj redonas novan funkcion kiu "dekoras" la originalan funkcion. Tio signifas, ke dekoratoro ne ŝanĝas la originalan funkcion rekte, sed ĝi aldonas al ĝi novajn trajtojn aŭ funkciojn. Dekoratoroj estas uzataj per la simbolo @, sekvata de la nomo de la dekoratoro, antaŭ la deklaro de funkcio.

Basaj Ekzemploj de Dekoratoroj

Nun, ni montros kelkajn simplajn ekzemplojn por kompreni kiel dekoratoroj funkcias en Python. La sekvaj ekzemploj estas bazaj, sed ili montras la plej fundamentajn principojn de dekoratoroj.

1. Simplaj Dekoratoroj

Ni komencu per la plej simpla ekzemplo de dekoratoro. Ĉi tiu dekoratoro simple aldonas "Saluton" antaŭ la funkcio kiun ĝi dekora:

def simple_decorator(func):
    def wrapper():
        print("Saluton!")
        func()
    return wrapper

@simple_decorator
def greet():
    print("Bonan tagon!")

greet()

En ĉi tiu kazo, la dekoratoro simple_decorator aldonas la vorton "Saluton!" antaŭ la ekzekuto de la funkcio greet. Kiam vi rulas la funkcion greet(), ĝi nun unue elŝovas "Saluton!" kaj poste "Bonan tagon!".

2. Dekoratoro kun Argumentoj

Se via funkcio postulas argumentojn, vi bezonos modifi vian dekoratoron por akcepti tiujn argumentojn. Jen ekzemplo de dekoratoro kiu akceptas argumentojn:

def decorator_with_args(func):
    def wrapper(*args, **kwargs):
        print("Dekoratoro estas aldonita!")
        return func(*args, **kwargs)
    return wrapper

@decorator_with_args
def greet_with_name(name):
    print(f"Bonan tagon, {name}!")

greet_with_name("Maria")

En ĉi tiu ekzemplo, la dekoratoro decorator_with_args aldonas mesaĝon antaŭ la ekzekuto de la funkcio greet_with_name. Ĉi tiu dekoratoro estas kapabla akcepti argumentojn, ĉar ĝi uzas *args kaj **kwargs por permesi al ĝi akcepti ajnajn argumentojn senditajn al la funkcio.

Avantaĝoj de Uzi Dekoratorojn

Nun, ni vidos kelkajn el la ĉefaj avantaĝoj de uzado de dekoratoroj en Python.

1. Kodo Reuzo

La ĉefa avantaĝo de dekoratoroj estas, ke ili permesas al vi reuzi la saman funkcion en multaj lokoj de via kodo sen ripetado. Ĉu vi iam volis aldoni logadon, aŭtentikigon aŭ aliaj mekanismoj al pluraj funkcioj sen modifi ilin? Dekoratoroj faras tion ebla!

2. Pli Bona Legibleco

Uzante dekoratorojn, vi povas plibonigi la legiblecon de via kodo. Anstataŭ meti komunan logikon en ĉiun funkcion, vi povas meti ĝin en apartan dekoratoron. Tio ne nur igas la kodon pli mallongan, sed ankaŭ pli facile kompreneblan.

3. Malpli da Eraroj

Kiel dekoratoroj permesas centrigi komunajn funkciojn, vi malpliigas la ŝancon fari erarojn. Ĉiufoje kiam vi bezonas aldoni io speciala al la funkcio, vi povas reuzi la dekoratoron sen kopii kaj alglui similajn blokojn de kodo en ĉiun funkcion.

Advanced Ekzemploj de Dekoratoroj

Kiam vi iĝas pli spertaj en Python, vi eble volos eksperimenti kun pli kompleksaj dekoratoroj. Jen kelkaj pli kompleksaj ekzemploj de dekoratoroj:

1. Dekoratoro por Tempo-Numbrado

Jen dekoratoro kiu mezuras kiom da tempo prenas al funkcio por esti plenumita:

import time

def timeit(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Tempo: {end_time - start_time} sekundoj")
        return result
    return wrapper

@timeit
def long_task():
    time.sleep(2)
    print("Tasko finita!")

long_task()

Ĉi tiu dekoratoro timeit mezuras la tempon kiun prenas funkcio por finiĝi. Kiam vi rulas la funkcion long_task, ĝi dormos dum 2 sekundoj kaj poste montros kiom da tempo ĝi prenis por finiĝi.

2. Dekoratoro kun Klaso

Ĉi tiu ekzemplo montras, kiel dekoratoroj povas esti uzataj kun klasoj. Vi povas uzi dekoratorojn por aldoni al novaj klasoj iujn metodojn aŭ komportojn:

def add_method(cls):
    def new_method(self):
        print("Nova metodo!")
    cls.new_method = new_method
    return cls

@add_method
class MyClass:
    pass

obj = MyClass()
obj.new_method()

En ĉi tiu ekzemplo, la dekoratoro add_method aldonas novan metodon al la klaso MyClass. Kiam vi kreas objekton de MyClass, ĝi povas uzi la novan metodon, kiun la dekoratoro aldonis.

Konkludo

Python-dekoratoroj estas tre potenca kaj eleganta maniero por aldoni novajn funkciojn al via kodo sen modifi ekzistantajn funkciojn. Ili permesas vin plibonigi la legiblecon de via kodo, reuzi kodon kaj malpliigi erarojn. Se vi estas komencanto en Python, dekoratoroj povas ŝajni iom komplike, sed kun tempo kaj praktiko, vi komprenos ilin kaj uzos ilin por krei pli bonan kodon. Do, kio vi atendas? Provu ilin hodiaŭ!