हम पायथन में सज्जाकारों को समझते हैं, कदम से कदम। चरण 1

डेकोरेटर्स के विषय पर कई बार हैबे पर चर्चा की गई है, हालांकि, मेरी राय में, यह लेख (स्टैकओवरफ्लो पर एक प्रश्न से बाहर निकला) इस विषय का सबसे स्पष्ट रूप से वर्णन करता है और, महत्वपूर्ण बात यह है कि डेकोरेटर के उपयोग पर एक "चरण-दर-चरण गाइड" है, जो इस तकनीक को तुरंत मास्टर करने की अनुमति देता है। सभ्य स्तर।

तो डेकोरेटर क्या है?

आगे एक लंबा लेख है, इसलिए यदि कोई जल्दी में है, तो यहां एक उदाहरण है कि सज्जाकार कैसे काम करते हैं:

def makebold(fn): def wrapped(): return "<b>" + fn() + "</b>" return wrapped def makeitalic(fn): def wrapped(): return "<i>" + fn() + "</i>" return wrapped @makebold @makeitalic def hello(): return "hello habr" print hello() ##  <b><i>hello habr</i></b> 

आप में से जो लोग कुछ समय बिताने के इच्छुक हैं, उन्हें लंबी पोस्ट पढ़ने के लिए आमंत्रित किया जाता है।

पायथन में कार्य वस्तुएं हैं

यह समझने के लिए कि सज्जाकार कैसे काम करते हैं, सबसे पहले, आपको महसूस करना चाहिए कि पायथन फ़ंक्शन भी ऑब्जेक्ट हैं।
आइए देखें कि इस से क्या होता है:

 def shout(word=""): return word.capitalize()+"!" print shout() # : '!' #    -  ,     , #      scream = shout # ,     :     "shout", #      "scream".  ,    #   "shout"  "scream": print scream() # : '!' #  ,  ,     "shout",     #     "scream" del shout try: print shout() except NameError, e: print e #: "name 'shout' is not defined" print scream() # : '!' 

इस तथ्य को याद रखें, हम जल्द ही इस पर लौटेंगे, लेकिन इसके अलावा, यह समझने लायक है कि पायथन में एक फ़ंक्शन को किसी अन्य फ़ंक्शन के अंदर परिभाषित किया जा सकता है ...!

 def talk(): #    "talk"    ... def whisper(word=""): return word.lower()+"..."; # ...     ! print whisper() # ,     "talk",      #    "whisper". talk() # : "..." #    "talk"     "whisper": try: print whisper() except NameError, e: print e # : "name 'whisper' is not defined" 

समारोह लिंक

अच्छा, क्या आप अभी भी यहाँ हैं? :)

अब हम जानते हैं कि कार्य पूर्ण वस्तु हैं, जिसका अर्थ है:

• एक चर के साथ जुड़ा हो सकता है;
• एक दूसरे के अंदर परिभाषित किया जा सकता है।

खैर, जिसका अर्थ है कि एक फ़ंक्शन दूसरे फ़ंक्शन को वापस कर सकता है!
आइए देखें:

 def getTalk(type="shout"): #      def shout(word=""): return word.capitalize()+"!" def whisper(word="") : return word.lower()+"..."; #    if type == "shout": # ,     "()",     , #     return shout else: return whisper #     ? #        talk = getTalk() #    , "talk"  -  "function": print talk # : <function shout at 0xb7ea817c> #   ,   ,  " ": print talk() #    -       : print getTalk("whisper")() # : ... 

रुको, चूंकि हम एक फ़ंक्शन वापस कर सकते हैं, फिर हम इसे एक अन्य फ़ंक्शन को एक पैरामीटर के रूप में पास कर सकते हैं:

 def doSomethingBefore(func): print "  - ,     ,    " print func() doSomethingBefore(scream) #: #   - ,     ,     # ! 

खैर, अब हमारे पास यह समझने के लिए सभी आवश्यक ज्ञान हैं कि सज्जाकार कैसे काम करते हैं।
जैसा कि आप अनुमान लगा सकते हैं, सज्जाकार वास्तव में, एक प्रकार का "रैपर" है जो हमें सजाए गए कार्य को बदलने के बिना और उसके पहले कुछ करने का अवसर देता है।

चलो अपने डेकोरेटर "मैन्युअल रूप से" बनाएं

 #  -  ,       def my_shiny_new_decorator(a_function_to_decorate): #     -"". #   (   ?..)   , #         . def the_wrapper_around_the_original_function(): #   ,       #   print " - ,     " #     a_function_to_decorate() #    ,       #   print "  - ,  " #     "a_function_to_decorate"     # ,  -,     #  ,  ,      . #  ! return the_wrapper_around_the_original_function #  ,     ,      . def a_stand_alone_function(): print "   ,      ?.." a_stand_alone_function() # :    ,      ?.. # ,    ,    ,   #   ,       , #   ,   ,    : a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function) a_stand_alone_function_decorated() #: #  - ,      #    ,      ?.. #   - ,   

शायद अब हम प्रत्येक बार के लिए चाहते हैं, a_stand_alone_function के कॉल के दौरान, a_stand_alone_function _decorated को इसके बजाय कहा जाता है । कुछ भी आसान नहीं है, बस a_stand_alone_function को उस फ़ंक्शन के साथ फिर से लिखें , जो my_shiny_new_decorator हमारे पास लौटा है :

 a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function) a_stand_alone_function() #: #  - ,      #    ,      ?.. #   - ,   

आपने पहले ही अनुमान लगाया कि यह ठीक वैसी ही बात है जैसी @ डेकोरेटर्स करते हैं। :)

सज्जाकारों के आसपास रहस्य के प्रभामंडल को नष्ट करना

इस तरह से पिछले उदाहरण को डेकोरेटर सिंटैक्स का उपयोग करके लिखा जा सकता है:

 @my_shiny_new_decorator def another_stand_alone_function(): print "   " another_stand_alone_function() #: #  - ,      #     #   - ,   

हाँ, सब कुछ वास्तव में इतना आसान है! डेकोरेटर सिर्फ निर्माण के लिए कृत्रिम चीनी है :

 another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function) 

डेकोरेटर्स डेकोरेटर डिजाइन पैटर्न के सिर्फ एक पायथनिक कार्यान्वयन हैं। पायथन में कुछ क्लासिक डिज़ाइन पैटर्न शामिल हैं , जैसे कि इस लेख में चर्चा की गई सज्जाकार, या किसी भी Paytonist से परिचित चलने वाले।

बेशक, आप डेकोरेटर को एक-दूसरे में घोंसला दे सकते हैं, उदाहरण के लिए इस तरह:

 def bread(func): def wrapper(): print "</------\>" func() print "<\______/>" return wrapper def ingredients(func): def wrapper(): print "##" func() print "~~" return wrapper def sandwich(food="----"): print food sandwich() #: ---- sandwich = bread(ingredients(sandwich)) sandwich() #: # </------\> # ## # ---- # ~~ # <\______/> 

और डेकोरेटर सिंटैक्स का उपयोग करना:

 @bread @ingredients def sandwich(food="----"): print food sandwich() #: # </------\> # ## # ---- # ~~ # <\______/> 

यह याद रखना चाहिए कि सजावट आदेश महत्वपूर्ण है:

 @ingredients @bread def sandwich(food="----"): print food sandwich() #: # ## # </------\> # ---- # <\______/> # ~~ 

इस बिंदु पर, आप खुशी से छोड़ सकते हैं, इस एहसास के साथ कि आप समझते हैं कि सज्जाकार क्या हैं और वे क्या खाते हैं।
जो लोग अपने मस्तिष्क को थोड़ा और पीड़ा देना चाहते हैं, उनके लिए कल डेकोरेटर के उन्नत उपयोग पर लेख के दूसरे भाग का फिर से अनुवाद किया जाएगा।

सामग्री:

• चरण 1. सज्जाकारों की बुनियादी समझ (आप सिर्फ इस लेख को पढ़ें)
• चरण 2. सज्जाकारों का उन्नत उपयोग

लगभग। अनुवाद:
आपका ध्यान देने के लिए धन्यवाद। मैं अनुवाद और डिजाइन पर किसी भी टिप्पणी के लिए आभारी रहूंगा, मैं अनुवाद के दूसरे भाग में उन सभी को ध्यान में रखने की कोशिश करूंगा।
UPD: दूसरे भाग में, इस तरह के प्रश्न: सजाए गए कार्यों के लिए तर्क पारित करना, सजाने के तरीके, मापदंडों के साथ सज्जाकार, आदि।
UPD2: लेख का दूसरा भाग पोस्ट किया गया है ।