பைத்தானில் ஃபங்ஷன் டெக்கரேட்டர்களை உருவாக்குதல் மற்றும் சங்கிலி செய்தல்

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

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

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

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

வழங்கப்பட்ட ஸ்கிரிப்ட்கள், செயல்பாடுகளின் நடத்தையை மாற்ற பைத்தானில் செயல்பாடுகளை அலங்கரிப்பவர்களை எவ்வாறு உருவாக்குவது மற்றும் தொடர்வது என்பதை விளக்குகிறது. பைத்தானில் ஒரு அலங்கரிப்பவர் இதைப் பயன்படுத்தி வரையறுக்கப்படுகிறது def மற்றொரு செயல்பாட்டை ஒரு வாதமாக எடுத்து புதிய செயல்பாட்டை வழங்கும் செயல்பாட்டை உருவாக்குவதற்கான முக்கிய சொல். தி make_bold f-ஸ்ட்ரிங் வடிவமைப்பைப் பயன்படுத்தி HTML தடிமனான குறிச்சொற்கள் மூலம் அலங்கரிக்கும் செயல்பாட்டின் முடிவை டெக்கரேட்டர் மூடுகிறது: f"<b>{func()}</b>". இதேபோல், தி make_italic அலங்கரிப்பாளர் முடிவை சாய்வு குறிச்சொற்களில் மூடுகிறார்: f"<i>{func()}</i>". இந்த அலங்கரிப்பாளர்களைப் பயன்படுத்தி ஒரு செயல்பாட்டிற்குப் பயன்படுத்தப்படும் போது @decorator_name தொடரியல், அவை அந்தந்த HTML குறிச்சொற்களைச் சேர்ப்பதன் மூலம் செயல்பாட்டின் வெளியீட்டை மாற்றியமைக்கின்றன.

இரண்டாவது ஸ்கிரிப்ட் உயர்-வரிசை செயல்பாட்டை உருவாக்குவதன் மூலம் மிகவும் பல்துறை அணுகுமுறையை அறிமுகப்படுத்துகிறது, add_html_tag, இது எந்த குறிப்பிட்ட HTML குறிச்சொல்லுக்கும் டெக்கரேட்டர்களை உருவாக்குகிறது. இந்தச் செயல்பாடு ஒரு HTML குறிச்சொல்லை ஒரு வாதமாக எடுத்துக்கொள்கிறது மற்றும் குறிப்பிட்ட குறிச்சொல்லில் செயல்பாட்டின் வெளியீட்டை மறைக்கும் அலங்காரத்தை வழங்குகிறது: f"<{tag}>{func()}</{tag}>". பயன்படுத்தி @add_html_tag("b") மற்றும் @add_html_tag("i"), இந்த டெக்கரேட்டர்களின் வெளியீட்டை மடிக்க நாம் சங்கிலியால் இணைக்கலாம் say_hello தடிமனான மற்றும் சாய்வு குறிச்சொற்களில் செயல்படும், இதன் விளைவாக விரும்பிய "வணக்கம்". இந்த எடுத்துக்காட்டுகள், பைதான் அலங்கரிப்பாளர்களின் சக்தி மற்றும் நெகிழ்வுத்தன்மையை மேம்படுத்தி, தூய்மையான மற்றும் மீண்டும் பயன்படுத்தக்கூடிய வகையில் செயல்பாடு நடத்தையை தனிப்பயனாக்குகிறது.

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper

def make_italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper

@make_bold
@make_italic
def say():
    return "Hello"

print(say())

def add_html_tag(tag):
    def decorator(func):
        def wrapper():
            return f"<{tag}>{func()}</{tag}>"
        return wrapper
    return decorator

@add_html_tag("b")
@add_html_tag("i")
def say_hello():
    return "Hello"

print(say_hello())

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

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

அலங்கரிப்பாளர்களின் மற்றொரு முக்கிய அம்சம், செயல்பாட்டு மெட்டாடேட்டாவை பராமரிக்கும் திறன் ஆகும். ஒரு செயல்பாடு அலங்காரத்தால் மூடப்பட்டிருக்கும் போது, ​​அதன் பெயர் மற்றும் டாக்ஸ்ட்ரிங் போன்ற மெட்டாடேட்டாவை இழக்க நேரிடும். இந்த மெட்டாடேட்டாவைப் பாதுகாக்க, பைதான் functools.wraps அலங்காரத்தில் பயன்படுத்தப்படுகிறது. விண்ணப்பிப்பதன் மூலம் @functools.wraps ரேப்பர் செயல்பாட்டிற்கு, அசல் செயல்பாட்டின் மெட்டாடேட்டா நகலெடுக்கப்படுகிறது, இந்த மெட்டாடேட்டாவை நம்பியிருக்கும் கருவிகள், ஆவணப்படுத்தல் ஜெனரேட்டர்கள், தொடர்ந்து சரியாக வேலை செய்வதை உறுதி செய்கிறது. கூடுதலாக, அலங்கரிப்பாளர்களை அடுக்கி வைக்கலாம் @make_bold மற்றும் @make_italic எடுத்துக்காட்டுகள், ஒரு சுத்தமான மற்றும் படிக்கக்கூடிய முறையில் நடத்தை மாற்றத்தின் பல அடுக்குகளைப் பயன்படுத்துதல்.