डेकोरेटर निष्पादन आदेश

Question 1

def make_bold(fn):
    return lambda : "<b>" + fn() + "</b>"

def make_italic(fn):
    return lambda : "<i>" + fn() + "</i>"

@make_bold
@make_italic
def hello():
  return "hello world"

helloHTML = hello()

आउटपुट: "<b><i>hello world</i></b>"

मैं सज्जाकारों के बारे में मोटे तौर पर समझता हूं और यह सबसे उदाहरणों में से एक के साथ कैसे काम करता है।

इस उदाहरण में, इसके 2 हैं। आउटपुट से, ऐसा लगता है कि @make_italicपहले निष्पादित होता है , फिर @make_bold।

क्या इसका मतलब यह है कि सजाए गए कार्यों के लिए, यह पहले फ़ंक्शन को चलाएगा फिर अन्य सज्जाकारों के लिए शीर्ष की ओर बढ़ेगा? @make_italicपहले की तरह फिर @make_bold, इसके विपरीत।

तो इसका मतलब है कि यह सबसे प्रोग्रामिंग लैंग में टॉप-डाउन दृष्टिकोण के मानदंड से अलग है? सिर्फ डेकोरेटर के इस मामले के लिए? या मैं गलत हूँ?

Question 2

सज्जाकार उस फ़ंक्शन को लपेटते हैं जो वे सजा रहे हैं। इसलिए डेकोरेटर make_boldके परिणाम को make_italicसजाया, जिसने सजायाhello फ़ंक्शन को ।

@decoratorवाक्य रचना वास्तव में सिर्फ वाक्यात्मक चीनी है, निम्नलिखित:

@decorator
def decorated_function():
    # ...

वास्तव में के रूप में निष्पादित किया जाता है:

def decorated_function():
    # ...
decorated_function = decorator(decorated_function)

मूल decorated_functionवस्तु की जगह जो भी decorator()लौटे।

स्टैकिंग डेकोरेटर्स उस प्रक्रिया को बाहर की ओर दोहराते हैं ।

तो आपका नमूना:

@make_bold
@make_italic
def hello():
  return "hello world"

इसका विस्तार किया जा सकता है:

def hello():
  return "hello world"
hello = make_bold(make_italic(hello))

जब आप hello()अभी कॉल करते हैं, तो आप make_bold()वास्तव में, द्वारा लौटाए गए ऑब्जेक्ट को कॉल कर रहे हैं । make_bold()एक lambdaहै make_boldजो लिपटे फ़ंक्शन को कॉल करता है, जो कि रिटर्न वैल्यू है make_italic(), जो कि एक लैम्ब्डा भी है जो मूल कॉल करता है hello()। आपको मिलने वाली इन सभी कॉल्स का विस्तार करना:

hello() = lambda : "<b>" + fn() + "</b>" #  where fn() ->
    lambda : "<i>" + fn() + "</i>" # where fn() -> 
        return "hello world"

तो उत्पादन हो जाता है:

"<b>" + ("<i>" + ("hello world") + "</i>") + "</b>"