Python Decorators

பைத்தான் டெக்கரேட்டர்களைப் புரிந்துகொள்ளுங்கள்

பைத்தான் டெக்கரேட்டர்கள்

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

ஒரு டெக்கரேட்டர் என்பது மற்றொரு செயல்பாட்டை உள்ளீடாக எடுத்துக்கொண்டு, புதிய செயல்பாட்டைத் திருப்பித் தரும் ஒரு செயல்பாடு ஆகும்.

டெக்கரேட்டர் எவ்வாறு செயல்படுகிறது:

அசல் செயல்பாடு
டெக்கரேட்டர்
மேம்படுத்தப்பட்ட செயல்பாடு

டெக்கரேட்டர் அசல் செயல்பாட்டை "மூடுகிறது" மற்றும் புதிய செயல்பாட்டை வழங்குகிறது

அடிப்படை டெக்கரேட்டர்

முதலில் டெக்கரேட்டரை வரையறுக்கவும், பின்னர் செயல்பாட்டிற்கு மேலே @decorator_name உடன் அதைப் பயன்படுத்தவும்.

எடுத்துக்காட்டு

அலங்கரிக்கப்பட்ட செயல்பாட்டின் திரும்பும் மதிப்பைப் பெரிய எழுத்துகளாக மாற்றும் ஒரு அடிப்படை டெக்கரேட்டர்.

def changecase(func):
  def myinner():
    return func().upper()
  return myinner

@changecase
def myfunction():
  return "Hello Sally"

print(myfunction())
வெளியீடு:
HELLO SALLY

@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())
வெளியீடு:
HELLO SALLY
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"))
வெளியீடு:
HELLO 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())
வெளியீடு:
hello linus

பல டெக்கரேட்டர்கள்

ஒரு செயல்பாட்டில் பல டெக்கரேட்டர்களைப் பயன்படுத்தலாம்.

இது ஒன்றையொன்று மேலே வைப்பதன் மூலம் செய்யப்படுகிறது.

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

எடுத்துக்காட்டு

பெரிய எழுத்துக்களுக்கு ஒரு டெக்கரேட்டர் மற்றும் வாழ்த்தைச் சேர்ப்பதற்கு ஒரு டெக்கரேட்டர்:

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())
வெளியீடு:
HELLO TOBIAS HAVE A GOOD DAY!

கவனிக்கவும்: டெக்கரேட்டர்கள் கீழிருந்து மேல் வரை செயல்படுகின்றன:
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__)
வெளியீடு:
myfunction

பயிற்சி

பைத்தானில் ஒரு டெக்கரேட்டரின் முக்கிய நோக்கம் என்ன?

ஒரு செயல்பாட்டின் மூல குறியீட்டை நிரந்தரமாக மாற்ற
✗ தவறு! டெக்கரேட்டர்கள் அசல் செயல்பாட்டின் குறியீட்டை மாற்றுவதில்லை. அவை செயல்பாட்டை மூடி புதிய செயல்பாட்டை வழங்குகின்றன.
அனைத்து திரும்பும் மதிப்புகளையும் தானாக பெரிய எழுத்துகளாக மாற்ற
✗ தவறு! இது changecase டெக்கரேட்டரின் ஒரு குறிப்பிட்ட பயன்பாட்டிற்கு மட்டுமே. டெக்கரேட்டர்கள் பல்வேறு நோக்கங்களுக்காகப் பயன்படுத்தப்படலாம்.
ஒரு செயல்பாட்டை மூடி அதன் மூல குறியீட்டை மாற்றாமல் அதன் நடத்தையை விரிவாக்க/மாற்ற
✓ சரி! இது டெக்கரேட்டர்களின் சரியான வரையறை. அவை செயல்பாட்டை மூடி, கூடுதல் செயல்பாட்டைச் சேர்ப்பதன் மூலம் அதன் நடத்தையை மாற்றுகின்றன, அதே நேரத்தில் அசல் குறியீட்டைத் தொடாமல் விடுகின்றன.
செயல்திறனுக்காக பைத்தான் குறியீட்டை C க்கு தொகுக்க
✗ தவறு! டெக்கரேட்டர்கள் தொகுப்பு அல்லது செயல்திறன் மேம்பாட்டுடன் தொடர்பு இல்லை. அவை செயல்பாட்டு நடத்தையை மாற்றுவதற்கான ஒரு முறையாகும்.