பைத்தான் டெக்கரேட்டர்கள்
டெக்கரேட்டர்கள் ஒரு செயல்பாட்டின் குறியீட்டை மாற்றாமல், அதற்கு கூடுதல் நடத்தையைச் சேர்க்க உங்களை அனுமதிக்கின்றன.
ஒரு டெக்கரேட்டர் என்பது மற்றொரு செயல்பாட்டை உள்ளீடாக எடுத்துக்கொண்டு, புதிய செயல்பாட்டைத் திருப்பித் தரும் ஒரு செயல்பாடு ஆகும்.
டெக்கரேட்டர் எவ்வாறு செயல்படுகிறது:
டெக்கரேட்டர் அசல் செயல்பாட்டை "மூடுகிறது" மற்றும் புதிய செயல்பாட்டை வழங்குகிறது
அடிப்படை டெக்கரேட்டர்
முதலில் டெக்கரேட்டரை வரையறுக்கவும், பின்னர் செயல்பாட்டிற்கு மேலே @decorator_name உடன் அதைப் பயன்படுத்தவும்.
எடுத்துக்காட்டு
அலங்கரிக்கப்பட்ட செயல்பாட்டின் திரும்பும் மதிப்பைப் பெரிய எழுத்துகளாக மாற்றும் ஒரு அடிப்படை டெக்கரேட்டர்.
def changecase(func):
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Hello Sally"
print(myfunction())
@changecase ஐ செயல்பாட்டு வரையறைக்கு நேரடியாக மேலே வைப்பதன் மூலம், myfunction செயல்பாடு changecase செயல்பாட்டுடன் "அலங்கரிக்கப்படுகிறது".
changecase
டெக்கரேட்டர் செயல்பாடு. இது ஒரு செயல்பாட்டை வாதமாக எடுத்துக்கொண்டு, புதிய செயல்பாட்டைத் திருப்பித் தரும்.
@changecase
டெக்கரேட்டர் தொடரியல். இது பைத்தானுக்கு myfunction ஐ changecase டெக்கரேட்டருடன் அலங்கரிக்க வேண்டும் என்று கூறுகிறது.
myfunction
அலங்கரிக்கப்படும் செயல்பாடு. இது அலங்காரத்திற்குப் பிறகு புதிய செயல்பாட்டை வழங்குகிறது.
பல டெக்கரேட்டர் அழைப்புகள்
ஒரு டெக்கரேட்டரை பல முறை அழைக்கலாம். நீங்கள் அலங்கரிக்க விரும்பும் செயல்பாட்டிற்கு மேலே டெக்கரேட்டரை வைக்கவும்.
எடுத்துக்காட்டு
இரண்டு செயல்பாடுகளில் @changecase டெக்கரேட்டரைப் பயன்படுத்துதல்:
def changecase(func):
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Hello Sally"
@changecase
def otherfunction():
return "I am speed!"
print(myfunction())
print(otherfunction())
I AM SPEED!
அலங்கரிக்கப்பட்ட செயல்பாட்டில் வாதங்கள்
வாதங்கள் தேவைப்படும் செயல்பாடுகளையும் அலங்கரிக்க முடியும், வார்ப்பர் செயல்பாட்டிற்கு வாதங்களை அனுப்புவதை உறுதிப்படுத்தவும்:
எடுத்துக்காட்டு
def changecase(func):
def myinner(x):
return func(x).upper()
return myinner
@changecase
def myfunction(nam):
return "Hello " + nam
print(myfunction("John"))
*args மற்றும் **kwargs
சில நேரங்களில் டெக்கரேட்டர் செயல்பாட்டிற்கு அலங்கரிக்கப்பட்ட செயல்பாட்டிலிருந்து அனுப்பப்படும் வாதங்களின் மீது கட்டுப்பாடு இருக்காது, இந்த சிக்கலைத் தீர்க்க, வார்ப்பர் செயல்பாட்டிற்கு (*args, **kwargs) சேர்க்கவும், இந்த வழியில் வார்ப்பர் செயல்பாடு எந்த எண்ணிக்கையிலான, எந்த வகையிலான வாதங்களையும் ஏற்றுக்கொள்ளலாம், மற்றும் அவற்றை அலங்கரிக்கப்பட்ட செயல்பாட்டிற்கு அனுப்பலாம்.
எடுத்துக்காட்டு
*args மற்றும் **kwargs வாதங்களுடன் செயல்பாட்டைப் பாதுகாத்தல்:
def changecase(func):
def myinner(*args, **kwargs):
return func(*args, **kwargs).upper()
return myinner
@changecase
def myfunction(nam):
return "Hello " + nam
print(myfunction("John"))
உதவிக்குறிப்பு:
*args எந்த எண்ணிக்கையிலான நிலை வாதங்களையும் ஏற்கிறது, **kwargs எந்த எண்ணிக்கையிலான விசைசொல் வாதங்களையும் ஏற்கிறது. இது டெக்கரேட்டர்களை மிகவும் நெகிழ்வானதாக ஆக்குகிறது.
வாதங்களுடன் டெக்கரேட்டர்
டெக்கரேட்டர்கள் மற்றொரு வார்ப்பர் நிலையைச் சேர்ப்பதன் மூலம் தங்கள் சொந்த வாதங்களை ஏற்றுக்கொள்ள முடியும்.
எடுத்துக்காட்டு
ஒரு வாதத்தை எடுத்துக்கொண்டு, வாத மதிப்பின் அடிப்படையில் வழக்கை மாற்றும் ஒரு டெக்கரேட்டர் தொழிற்சாலை.
def changecase(n):
def changecase(func):
def myinner():
if n == 1:
a = func().lower()
else:
a = func().upper()
return a
return myinner
return changecase
@changecase(1)
def myfunction():
return "Hello Linus"
print(myfunction())
பல டெக்கரேட்டர்கள்
ஒரு செயல்பாட்டில் பல டெக்கரேட்டர்களைப் பயன்படுத்தலாம்.
இது ஒன்றையொன்று மேலே வைப்பதன் மூலம் செய்யப்படுகிறது.
டெக்கரேட்டர்கள் தலைகீழ் வரிசையில் அழைக்கப்படுகின்றன, செயல்பாட்டிற்கு மிக அருகில் உள்ள ஒன்றிலிருந்து தொடங்குகின்றன.
எடுத்துக்காட்டு
பெரிய எழுத்துக்களுக்கு ஒரு டெக்கரேட்டர் மற்றும் வாழ்த்தைச் சேர்ப்பதற்கு ஒரு டெக்கரேட்டர்:
def changecase(func):
def myinner():
return func().upper()
return myinner
def addgreeting(func):
def myinner():
return "Hello " + func() + " Have a good day!"
return myinner
@changecase
@addgreeting
def myfunction():
return "Tobias"
print(myfunction())
கவனிக்கவும்: டெக்கரேட்டர்கள் கீழிருந்து மேல் வரை செயல்படுகின்றன:
1. முதலில் addgreeting செயல்படுகிறது: "Hello Tobias Have a good day!"
2. பின்னர் changecase செயல்படுகிறது: "HELLO TOBIAS HAVE A GOOD DAY!"
செயல்பாட்டு மெட்டாடேட்டாவைப் பாதுகாத்தல்
பைத்தானில் உள்ள செயல்பாடுகள் __name__ மற்றும் __doc__ பண்புகளைப் பயன்படுத்தி அணுகலாம் என்ற மெட்டாடேட்டாவைக் கொண்டுள்ளன.
முக்கியமான குறிப்பு:
ஒரு செயல்பாடு அலங்கரிக்கப்படும் போது, அசல் செயல்பாட்டின் மெட்டாடேட்டா இழக்கப்படுகிறது.
எடுத்துக்காட்டு 3: functools.wraps உடன் பாதுகாத்தல்
இதை சரிசெய்ய, பைத்தானில் அசல் செயல்பாட்டின் பெயர் மற்றும் டாக்ஸ்ட்ரிங்கைப் பாதுகாக்க பயன்படுத்தக்கூடிய ஒரு உள்ளமை செயல்பாடு functools.wraps உள்ளது.
import functools
def changecase(func):
@functools.wraps(func)
def myinner():
return func().upper()
return myinner
@changecase
def myfunction():
return "Have a great day!"
print(myfunction.__name__)