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

और फिर से, सभी पाठकों को शुभ दिन!
अनुवाद के पहले भाग में आपकी रुचि के लिए धन्यवाद, मुझे उम्मीद है कि दूसरा भी आपको निराश नहीं करेगा।

इसलिए, इस लेख के पहले भाग में, हमने डेकोरेटर्स, उनके काम के सिद्धांतों के साथ एक बुनियादी परिचित बनाया, और यहां तक ​​कि अपना खुद का भी लिखा।
हालांकि, सभी सज्जाकार जिन्हें हमने पहले जांचा था, उनके पास एक बहुत महत्वपूर्ण कार्यात्मक नहीं था - समारोह में सजाए गए तर्क।
खैर, इस गलतफहमी को सुधारें!

पासिंग ("अग्रेषण") सजाए गए फ़ंक्शन के लिए तर्क

कोई काला जादू नहीं, हमें बस जरूरत है, वास्तव में, तर्कों को पारित करने की!

def a_decorator_passing_arguments(function_to_decorate): def a_wrapper_accepting_arguments(arg1, arg2): #    print ",   :", arg1, arg2 function_to_decorate(arg1, arg2) return a_wrapper_accepting_arguments # ,    ,   , #    "",         #      @a_decorator_passing_arguments def print_full_name(first_name, last_name): print " ", first_name, last_name print_full_name("", "") # : # ,   :   #     # * 

* - नोट अनुवादक: पीटर वेंकमैन - घोस्टबस्टर्स में से एक का नाम, उसी नाम की पंथ फिल्म का नायक।

ड्रेसिंग तरीके

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

 def method_friendly_decorator(method_to_decorate): def wrapper(self, lie): lie = lie - 3 # ,  -     :-) return method_to_decorate(self, lie) return wrapper class Lucy(object): def __init__(self): self.age = 32 @method_friendly_decorator def sayYourAge(self, lie): print " %s,     ?" % (self.age + lie) l = Lucy() l.sayYourAge(-3) # :  26,     ? 

बेशक, अगर हम सबसे सामान्य डेकोरेटर बनाते हैं और चाहते हैं कि यह किसी भी फ़ंक्शन या विधि पर लागू हो, तो यह इस तथ्य का उपयोग करने के लायक है कि * args की सूची को unpacks, और ** kwargs kwargs शब्दकोश को unpacks:

 def a_decorator_passing_arbitrary_arguments(function_to_decorate): #  ""    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs): print "   -?:" print args print kwargs #    *args  **kwargs #        ,    : # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/ function_to_decorate(*args, **kwargs) return a_wrapper_accepting_arbitrary_arguments @a_decorator_passing_arbitrary_arguments def function_with_no_argument(): print "Python is cool, no argument here." #   ,   :) function_with_no_argument() # : #    -?: # () # {} # Python is cool, no argument here. @a_decorator_passing_arbitrary_arguments def function_with_arguments(a, b, c): print a, b, c function_with_arguments(1,2,3) # : #    -?: # (1, 2, 3) # {} # 1 2 3 @a_decorator_passing_arbitrary_arguments def function_with_named_arguments(a, b, c, platypus=" ?"): print "  %s, %s  %s ? %s" %\ (a, b, c, platypus) function_with_named_arguments("", "", "", platypus="!") # : #    -?: # ('', '', '') # {'platypus': '!'} #   ,    ? ! class Mary(object): def __init__(self): self.age = 31 @a_decorator_passing_arbitrary_arguments def sayYourAge(self, lie=-3): #        print " %s,     ?" % (self.age + lie) m = Mary() m.sayYourAge() # : #    -?: # (<__main__ .Mary object at 0xb7d303ac>,) # {} #  28,     ? 

विभिन्न तर्कों के साथ एक डेकोरेटर को बुलाना

महान, इसे हल किया। अलग-अलग तर्कों के साथ डेकोरेटर को बुलाने की कोशिश के बारे में अब आप क्या कहते हैं

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

 #  -    def my_decorator(func): print "  " def wrapper(): print " - ,  " func() return wrapper #  ,    ,   "@"-: def lazy_function(): print "zzzzzzzz" decorated_function = my_decorator(lazy_function) # :    #    "  ",     ,   : #  .   @my_decorator def lazy_function(): print "zzzzzzzz" # :    

जैसा कि हम देखते हैं, ये दो समान कार्य हैं। जब हम लिखते हैं

 @my_decorator 

- हम सिर्फ दुभाषिया को " my_decorator " नामक फ़ंक्शन को कॉल करने के लिए कहते हैं। यह एक महत्वपूर्ण बिंदु है, क्योंकि यह नाम हमें सीधे डेकोरेटर तक ले जा सकता है ... नहीं!
चलो कुछ डरावना है :)!

 def decorator_maker(): print "  !     : "+\ "      ." def my_decorator(func): print " - !     :    ." def wrapped(): print (" -    . " "         . " "     .") return func() print "   ." return wrapped print "  ." return my_decorator #    .        new_decorator = decorator_maker() # : #   !     :       . #   . #    def decorated_function(): print " -  ." decorated_function = new_decorator(decorated_function) # : #  - !     :    . #    . #    : decorated_function() # : #  -    .          . #      . #  -  . 

लांग? लांग। हम मध्यवर्ती चर का उपयोग किए बिना इस कोड को फिर से लिखते हैं:

 def decorated_function(): print " -  ." decorated_function = decorator_maker()(decorated_function) # : #   !     :       . #   . #  - !     :    . #    . # : decorated_function() # : #  -    .          . #      . #  -  . 

और अब फिर से, और भी छोटा:

 @decorator_maker() def decorated_function(): print "I am the decorated function." # : #   !     :       . #   . #  - !     :    . #    . #  : decorated_function() # : #  -    .          . #      . #  -  . 

क्या आपने देखा कि हमने "@" चिन्ह के बाद फ़ंक्शन को बुलाया? :)

अंत में, डेकोरेटर्स के तर्कों पर वापसी करें, क्योंकि यदि हम फ्लाई पर डेकोरेटर्स बनाने के लिए किसी फ़ंक्शन का उपयोग करते हैं, तो हम इसके लिए कोई भी तर्क पारित कर सकते हैं, है ना?

 def decorator_maker_with_arguments(decorator_arg1, decorator_arg2): print "  !     :", decorator_arg1, decorator_arg2 def my_decorator(func): print " - .         :", decorator_arg1, decorator_arg2 #       ! def wrapped(function_arg1, function_arg2) : print (" -    .\n" "      : \n" "\t-  : {0} {1}\n" "\t-  : {2} {3}\n" "      " .format(decorator_arg1, decorator_arg2, function_arg1, function_arg2)) return func(function_arg1, function_arg2) return wrapped return my_decorator @decorator_maker_with_arguments("", "") def decorated_function_with_arguments(function_arg1, function_arg2): print (" -         : {0}" " {1}".format(function_arg1, function_arg2)) decorated_function_with_arguments("", "") # : #   !     :   #  - .         :   #  -    . #       : # -  :   # -  :   #        #  -         :   

* - नोट अनुवादक: इस उदाहरण में, लेखक ने लोकप्रिय श्रृंखला द बिग बैंग थ्योरी के नायक के नामों का उल्लेख किया है।
यहाँ यह है, मांग करने वाले सज्जाकार के लिए जिसे मनमाने तर्क दिए जा सकते हैं।
बेशक, कोई भी चर तर्क हो सकता है:

 c1 = "" c2 = "" @decorator_maker_with_arguments("", c1) def decorated_function_with_arguments(function_arg1, function_arg2): print (" -         : {0}" " {1}".format(function_arg1, function_arg2)) decorated_function_with_arguments(c2, "") # : #   !     :   #  - .         :   #  -    . #       : # -  :   # -  :   #        #  -         :   

इस प्रकार, हम डेकोरेटर के लिए किसी भी तर्क को पारित कर सकते हैं, एक साधारण फ़ंक्शन की तरह। यदि आवश्यक हो तो हम * args और ** kwargs के माध्यम से unpacking का उपयोग कर सकते हैं।
लेकिन आपको हमेशा ध्यान रखना चाहिए कि डेकोरेटर को एक बार ही कहा जाता है । ठीक उसी क्षण जब पायथन आपकी स्क्रिप्ट आयात करता है। उसके बाद, हम अब उन तर्कों को नहीं बदल सकते हैं जिनके साथ।
जब हम " आयात x " लिखते हैं , तो x से सभी फ़ंक्शन तुरंत सज जाते हैं , और हम अब कुछ भी नहीं बदल सकते हैं।

थोड़ी प्रैक्टिस: डेकोरेटर डेकोरेटिंग डेकोरेटर लिखें

यदि आप इस बिंदु तक पढ़ते हैं और अभी भी रैंकों में हैं - तो यहां मेरी ओर से एक बोनस है।
यह छोटा सा ट्रिक आपको किसी भी साधारण डेकोरेटर को एक डेकोरेटर में बदल देगा, जो बहस करता है।
प्रारंभ में, एक डेकोरेटर पाने के लिए जो तर्क लेता है, हमने इसे दूसरे फ़ंक्शन का उपयोग करके बनाया।
हमने अपने डेकोरेटर को लपेट लिया।
क्या हमारे पास फ़ंक्शन को लपेटने के लिए कुछ भी है?
बिल्कुल, सज्जाकार!

चलो कुछ मज़े करें और सज्जाकारों के लिए एक डेकोरेटर लिखें:

 def decorator_with_args(decorator_to_enhance): """        .     ,    .    .        ,       ,    ,  ,    . """ #     ,      : def decorator_maker(*args, **kwargs): #    ,      # ,    ,   "" def decorator_wrapper(func): #   ,     , ,    #   ( ). #    ,        # decorator(func, *args, **kwargs) # ,     return decorator_to_enhance(func, *args, **kwargs) return decorator_wrapper return decorator_maker 

इसका उपयोग इस तरह किया जा सकता है:

 #   ,         :-) #   ,      "decorator(func, *args, **kwargs)" @decorator_with_args def decorated_decorator(func, *args, **kwargs): def wrapper(function_arg1, function_arg2): print "  ...:", args, kwargs return func(function_arg1, function_arg2) return wrapper #       ,   : @decorated_decorator(42, 404, 1024) def decorated_function(function_arg1, function_arg2): print "", function_arg1, function_arg2 decorated_function(" ", " ") # : #   ...: (42, 404, 1024) {} #      # ! 

मुझे लगता है कि मुझे पता है कि आप अब कैसा महसूस करते हैं।
पिछली बार जब आप इस अनुभूति का अनुभव करते थे, तो यह सुनकर कि वे आपसे कैसे कहते हैं: "पुनरावृत्ति को समझने के लिए, आपको पहले पुनर्विचार को समझना होगा।"
लेकिन अब आपको खुशी है कि आपने इसका पता लगा लिया ?;;

सज्जाकार के साथ काम करने के लिए सिफारिशें

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

अंतिम समस्या को मानक लाइब्रेरी में फंक्शनलबुलवैप्स सहित फंक्शनलबूल मॉड्यूल को जोड़कर पाइथन 2.5 में आंशिक रूप से हल किया गया था, जो लपेटे जाने वाले फ़ंक्शन के बारे में सभी जानकारी की प्रतिलिपि बनाता है (इसका नाम, जिससे मॉड्यूल क्षेत्र, इसका डॉकस्ट्रिंग, आदि) आवरण फ़ंक्शन के लिए। ।
मज़ेदार तथ्य यह है कि फंक्शनलबुलस्वैप्स अपने आप में एक डेकोरेटर है।

 #   ,     __name__ . def foo(): print "foo" print foo.__name__ # : foo # ,     : def bar(func): def wrapper(): print "bar" return func() return wrapper @bar def foo(): print "foo" print foo.__name__ # : wrapper # "functools"      import functools def bar(func): #  "wrapper"  "func" #   : @functools.wraps(func) def wrapper(): print "bar" return func() return wrapper @bar def foo(): print "foo" print foo.__name__ # : foo 

डेकोरेटर्स का उपयोग कैसे किया जा सकता है?

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

 def benchmark(func): """ ,  ,     . """ import time def wrapper(*args, **kwargs): t = time.clock() res = func(*args, **kwargs) print func.__name__, time.clock() - t return res return wrapper def logging(func): """ ,   . (,    ,      !) """ def wrapper(*args, **kwargs): res = func(*args, **kwargs) print func.__name__, args, kwargs return res return wrapper def counter(func): """ ,       . """ def wrapper(*args, **kwargs): wrapper.count += 1 res = func(*args, **kwargs) print "{0}  : {1}x".format(func.__name__, wrapper.count) return res wrapper.count = 0 return wrapper @benchmark @logging @counter def reverse_string(string): return str(reversed(string)) print reverse_string("     ") print reverse_string("A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!") # : # reverse_string ('     ',) {} # wrapper 0.0 # reverse_string  : 1x #       # reverse_string ('A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!',) {} # wrapper 0.0 # reverse_string  : 2x # !amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A 

इस प्रकार, डेकोरेटर को किसी भी फ़ंक्शन पर लागू किया जा सकता है, इसकी कार्यक्षमता का विस्तार और कोड की एक भी पंक्ति को फिर से लिखे बिना!

 import httplib @benchmark @logging @counter def get_random_futurama_quote(): conn = httplib.HTTPConnection("slashdot.org:80") conn.request("HEAD", "/index.html") for key, value in conn.getresponse().getheaders(): if key.startswith("xb") or key.startswith("xf"): return value return ", ...  !" print get_random_futurama_quote() print get_random_futurama_quote() #outputs: #get_random_futurama_quote () {} #wrapper 0.02 #get_random_futurama_quote  : 1x #The laws of science be a harsh mistress. #get_random_futurama_quote () {} #wrapper 0.01 #get_random_futurama_quote  : 2x #Curse you, merciful Poseidon! 

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

सामग्री:

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

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