Python-dekoratörer

I den här artikeln ska vi diskutera Python Decorators.

Definition: Dekoratör är ett designmönster i Python. Det är en funktion som tar en annan funktion som ett argument, lägger till lite funktionalitet i den utan att ändra den och returnerar en annan funktion.

Detta kallas att använda “(@)” och placeras innan du definierar en funktion som vi vill dekorera.

syntax:

@decorator namn
Funktionsdefinition

För att förstå dekoratörer måste vi känna till begreppen nedan.
Funktioner är förstklassiga objekt. Det betyder att en funktion kan skickas som ett argument, kan returneras från en annan funktion, kan tilldelas en variabel, kan definieras i en annan funktion. För en bättre förståelse, se nedanstående exempel.

En funktion kan skickas som ett argument
Ex:
def inkrement (n):
returnera n + 1
def demo_funcall (funktion):
num = 5
returfunktion (num)
demo_funcall (inkrement)
Här passerade inkrementfunktionen som ett argument

exempel1.py:

Produktion:

>> python-exempel1.py
Funktion kan returneras från en annan funktion
Ex:
def önskan ():
def say_wish ():
returnera "Grattis på födelsedagen"
återvänd say_wish
hej = önskar ()
Hej()
exempel2.py:

Produktion:

>> python exempel2.py

Här say_wish-funktion återvände från önskningsfunktionen
Funktionen kan modifieras och tilldelas en variabel
Ex:
def add (a, b):
returnera a + b
sum2nos = lägg till # Här har funktionen lägg till tilldelats variabeln
sum2nos (5,11)
exempel3.py:

Produktion:
>> python exempel3.py
Definiera funktion i en annan funktion
Ex:
def add (a, b):
def sum2 (a, b):
returnera a + b
res = sum2 (a, b)
returres
lägg till (10,15)
exempel4.py:

Produktion:
>> python exempel4.py

Stängning:

Python tillåter en kapslad funktion att få tillgång till det yttre omfånget för den omslutande funktionen.

def hälsning (meddelande):
"Enclosong-funktion"
def send_greeting ():
"Nestad funktion"
skriv ut (meddelande)
skicka hälsning()
hälsning ("God morgon")

exempel5.py:

Produktion:

>> python exempel5.py

Efter att ha förstått ovanstående begrepp nu kommer vi att skriva ett dekoratörsexempel.

Ex1: Här kommer vi att dekorera meddelandefunktionen. Skriva ut msg inuti **** utan att ändra den ursprungliga funktionen, dvs.e., meddelandefunktion.

#decorator start
def print_msg (funktion):
def-omslag ():
fungera()
returomslag
#decorator slutet
def-meddelande ():
tryck ("Detta är det första exemplet för att visa dekoratör")
hej = print_msg (meddelande)
Hej()

exempel6.py:

Produktion:

>> python-exempel6.py

I den enklaste formen kan vi placera dekoratör ovanpå funktionsdefinitionen och kalla funktionen som visas nedan:

Här, oavsett vilken sträng vi vill dekorera inuti ***, använd denna dekoratör.

Produktion:

Flera dekoratörer:

Vi kan ha flera dekoratörer för en enda funktion. Här appliceras dekoratören i den ordning vi ringde.
syntax:
@ dekoratör2
@ dekoratör1
Funktionsdefinition

Här tillämpas 1: a dekoratör, sedan 2: a dekoratör.

Vidarebefordra argument till dekoratörsfunktioner:

Vi kan skicka argument till wrapper-funktionen. Argumenten skickades till den funktion som vi vill dekorera för.

Ex:

def deco_wish (funktion):
def-omslag (arg1, arg2):
skriv ut ('De godkända argumenten är', arg1, arg2)
skriva ut ('*********************')
funktion (arg1, arg2)
skriva ut ('*********************')
returomslag
@deco_wish
def önskan (a1, a2):
skriva ut (a1, a2)
önskar ('Bra', 'Morgon')
önskar ('Bra', 'Eftermiddag')

exempel7.py:

Produktion:

>> python-exempel7.py

Skicka variabelt antal argument till dekoratörsfunktionen:

Vi kan skicka valfritt antal argument med * args (icke-sökordsargument som siffror) och ** kwargs (nyckelordsargument som en ordlista). Båda är positionella argument och lagrar argumenten i args- och kwargs-variabler.

Obs: Här kan vi använda vilket namn som helst istället för args och kwargs, men dessa namn rekommenderas att använda.

Ex:

def dec_var_args (funtion):
def-omslag (* args, ** kwargs):
skriv ut ('Argumenten som inte är nyckelord är', args)
skriv ut ('Nyckelordsargumenten är', kwargs)
funktion (* args)
returomslag
@ dec_var_args
def fun_non_key_args (* args):
för jag i args:
skriva ut (i)
@ dec_var_args
def fun_key_args ():
skriva ut (“Nyckelordargument”)
fun_non_key_args ((4,5,6))
fun_key_args (fname = 'Anand', lname = 'Math')

exempel8.py:

Produktion:

>> python-exempel8.py

Ex2: Antag att vi har två funktioner
Funktion1: Beräkna summan av siffror från listan
Funktion2: Multiplicera varje nummer med 2 och lägg till dem i den angivna siffralistan
Om vi vill beräkna den tid det tar för var och en för körning kan vi göra det på två sätt

Placera koden mellan start- och sluttiden i varje funktion
Skriv dekoratör för att beräkna tid

Se nedan kod löst med dekoratör:

#decorator start
exe_time_calc (func):
def-omslag (arg):
starttid = datetid.datum Tid.nu()
funk (arg)
end_time = datetime.datum Tid.nu()
skriv ut ("Det tar tid att köra funktionen" + funk.__name__ + "är" + str (sluttid - sluttid))
returomslag
#decorator slutet
@exe_time_calc
def cal_avg (data):
summa = 0
för jag i data:
summa + = i
skriv ut ("Medelvärdet för en given nummerlista är", sum // len (data))
@exe_time_calc
def mul_by_2 (data):
summa = 0
för jag i data:
summa + = + (i * 2)
skriva ut ("Summan av alla tal efter multiplicera med 2 är", summa)
cal_avg ([10,20,30,40,50])
mul_by_2 ([10,20,30,40,50])

exempel 9.py:

Produktion:

>> python exempel9.py

Ovanstående dekoratör kan användas för att beräkna exekveringstid för någon av funktionerna. Genom att använda en dekoratör kan vi undvika upprepad kod när vi har ett krav på att beräkna exekveringstiden för att placera dekoratören ovanför funktionsdefinitionen.

Slutsats:

Dekoratörer ändrar funktionaliteten hos en funktion / metod utan att ändra den ursprungliga koden för funktionen som dekoreras. Med detta kan vi undvika att skriva upprepad kod. Att känna dekoratörskonceptet kommer att göra oss starka i python. Vi kan använda dekoratör i nedanstående fall:

Auktorisering i Python-ramar Ex: Flask och Django
Skogsavverkning
Mät körtid