How to make function decorators and chain them together

Question

How can I make two decorators in Python that would do the following    makebold  makeitalic def say       return  Hello       which should return     lt b gt  lt i gt Hello lt  i gt  lt  b gt     I m not trying to make HTML this way in a real application - just trying to understand how decorators and decorator chaining works

User · Answer

Speaking of the counter example - as given above, the counter will be shared between all functions that use the decorator:

def counter(func):
    def wrapped(*args, **kws):
        print 'Called #%i' % wrapped.count
        wrapped.count += 1
        return func(*args, **kws)
    wrapped.count = 0
    return wrapped

That way, your decorator can be reused for different functions (or used to decorate the same function multiple times: func_counter1 = counter(func); func_counter2 = counter(func)), and the counter variable will remain private to each.

User · Answer

decorator py def makeHtmlTag tag   args    kwds       def real decorator fn           css class     class   0    format kwds  css class                                       if  css class  in kwds else            def wrapped  args    kwds               return   lt   tag css class   gt     fn  args    kwds      lt    tag   gt           return wrapped       return decorator dont call it     return real decorator   makeHtmlTag tag  b   css class  bold css    makeHtmlTag tag  i   css class  italic css   def hello        return  hello world   print hello     You can also write decorator in Class   class py class makeHtmlTagClass object       def   init   self  tag  css class              self  tag   tag         self  css class     class   0    format css class                                           if css class       else         def   call   self  fn           def wrapped  args    kwargs               return   lt     self  tag   self  css class   gt                               fn  args    kwargs      lt      self  tag     gt           return wrapped   makeHtmlTagClass tag  b   css class  bold css    makeHtmlTagClass tag  i   css class  italic css   def hello name       return  Hello      format name   print hello  Your name

User · Answer

How can I make two decorators in Python that would do the following    You want the following function  when called     makebold  makeitalic def say        return  Hello     To return     lt b gt  lt i gt Hello lt  i gt  lt  b gt     Simple solution  To most simply do this  make decorators that return lambdas  anonymous functions  that close over the function  closures  and call it   def makeitalic fn       return lambda    lt i gt     fn       lt  i gt    def makebold fn       return lambda    lt b gt     fn       lt  b gt     Now use them as desired    makebold  makeitalic def say        return  Hello    and now    gt  gt  gt  say     lt b gt  lt i gt Hello lt  i gt  lt  b gt     Problems with the simple solution  But we seem to have nearly lost the original function     gt  gt  gt  say  lt function  lt lambda gt  at 0x4ACFA070 gt    To find it  we d need to dig into the closure of each lambda  one of which is buried in the other    gt  gt  gt  say   closure   0  cell contents  lt function  lt lambda gt  at 0x4ACFA030 gt   gt  gt  gt  say   closure   0  cell contents   closure   0  cell contents  lt function say at 0x4ACFA730 gt    So if we put documentation on this function  or wanted to be able to decorate functions that take more than one argument  or we just wanted to know what function we were looking at in a debugging session  we need to do a bit more with our wrapper   Full featured solution - overcoming most of these problems  We have the decorator wraps from the functools module in the standard library    from functools import wraps  def makeitalic fn         must assign update attributes from wrapped function to wrapper         module      name      doc    and   dict   by default      wraps fn    explicitly give function whose attributes it is applying     def wrapped  args    kwargs           return   lt i gt     fn  args    kwargs      lt  i gt       return wrapped  def makebold fn        wraps fn      def wrapped  args    kwargs           return   lt b gt     fn  args    kwargs      lt  b gt       return wrapped   It is unfortunate that there s still some boilerplate  but this is about as simple as we can make it    In Python 3  you also get   qualname   and   annotations   assigned by default   So now    makebold  makeitalic def say           This function returns a bolded  italicized  hello         return  Hello    And now    gt  gt  gt  say  lt function say at 0x14BB8F70 gt   gt  gt  gt  help say  Help on function say in module   main     say  args    kwargs      This function returns a bolded  italicized  hello    Conclusion  So we see that wraps makes the wrapping function do almost everything except tell us exactly what the function takes as arguments    There are other modules that may attempt to tackle the problem  but the solution is not yet in the standard library

User · Answer

A decorator takes the function definition and creates a new function that executes this function and transforms the result    deco def do              is equivalent to   do   deco do    Example   def deco func       def inner letter           return func letter  upper     upper     return inner   This   deco def do number       return chr number     number to letter   is equivalent to this  def do2 number       return chr number   do2   deco do2    65  lt     a   print do 65   print do2 65    gt  gt  gt  B  gt  gt  gt  B   To understand the decorator  it is important to notice  that decorator created a new function do which is inner that executes function and transforms the result

User · Answer

And of course you can return lambdas as well from a decorator function   def makebold f        return lambda    lt b gt     f       lt  b gt   def makeitalic f        return lambda    lt i gt     f       lt  i gt     makebold  makeitalic def say        return  Hello   print say

User · Answer

You could make two separate decorators that do what you want as illustrated directly below  Note the use of  args    kwargs in the declaration of the wrapped   function which supports the decorated function having multiple arguments  which isn t really necessary for the example say   function  but is included for generality    For similar reasons  the functools wraps decorator is used to change the meta attributes of the wrapped function to be those of the one being decorated  This makes error messages and embedded function documentation  func   doc    be those of the decorated function instead of wrapped   s   from functools import wraps  def makebold fn        wraps fn      def wrapped  args    kwargs           return   lt b gt     fn  args    kwargs      lt  b gt       return wrapped  def makeitalic fn        wraps fn      def wrapped  args    kwargs           return   lt i gt     fn  args    kwargs      lt  i gt       return wrapped   makebold  makeitalic def say        return  Hello   print say       - gt   lt b gt  lt i gt Hello lt  i gt  lt  b gt    Refinements  As you can see there s a lot of duplicate code in these two decorators  Given this similarity it would be better for you to instead make a generic one that was actually a decorator factory   in other words  a decorator function that makes other decorators  That way there would be less code repetition   and allow the DRY principle to be followed   def html deco tag       def decorator fn            wraps fn          def wrapped  args    kwargs               return   lt  s gt     tag   fn  args    kwargs      lt   s gt     tag         return wrapped     return decorator   html deco  b    html deco  i   def greet whom          return  Hello           whom  if whom else     print greet  world       - gt   lt b gt  lt i gt Hello world lt  i gt  lt  b gt    To make the code more readable  you can assign a more descriptive name to the factory-generated decorators   makebold   html deco  b   makeitalic   html deco  i     makebold  makeitalic def greet whom          return  Hello           whom  if whom else     print greet  world       - gt   lt b gt  lt i gt Hello world lt  i gt  lt  b gt    or even combine them like this   makebolditalic   lambda fn  makebold makeitalic fn     makebolditalic def greet whom          return  Hello           whom  if whom else     print greet  world       - gt   lt b gt  lt i gt Hello world lt  i gt  lt  b gt    Efficiency  While the above examples do all work  the code generated involves a fair amount of overhead in the form of extraneous function calls when multiple decorators are applied at once  This may not matter  depending the exact usage  which might be I O-bound  for instance    If speed of the decorated function is important  the overhead can be kept to a single extra function call by writing a slightly different decorator factory-function which implements adding all the tags at once  so it can generate code that avoids the addtional function calls incurred by using separate decorators for each tag   This requires more code in the decorator itself  but this only runs when it s being applied to function definitions  not later when they themselves are called  This also applies when creating more readable names by using lambda functions as previously illustrated  Sample   def multi html deco  tags       start tags  end tags              for tag in tags          start tags append   lt  s gt     tag          end tags append   lt   s gt     tag      start tags      join start tags      end tags      join reversed end tags        def decorator fn            wraps fn          def wrapped  args    kwargs               return start tags   fn  args    kwargs    end tags         return wrapped     return decorator  makebolditalic   multi html deco  b    i     makebolditalic def greet whom          return  Hello           whom  if whom else     print greet  world       - gt   lt b gt  lt i gt Hello world lt  i gt  lt  b gt

User · Answer

Alternatively  you could write a factory function which return a decorator which wraps the return value of the decorated function in a tag passed to the factory function  For example   from functools import wraps  def wrap in tag tag       def factory func            wraps func          def decorator                return   lt   tag s gt   rv s lt    tag s gt                         tag   tag   rv   func             return decorator     return factory   This enables you to write    wrap in tag  b    wrap in tag  i   def say        return  hello    or  makebold   wrap in tag  b   makeitalic   wrap in tag  i     makebold  makeitalic def say        return  hello    Personally I would have written the decorator somewhat differently   from functools import wraps  def wrap in tag tag       def factory func            wraps func          def decorator val               return func   lt   tag s gt   val s lt    tag s gt                               tag   tag   val   val           return decorator     return factory   which would yield    wrap in tag  b    wrap in tag  i   def say val       return val say  hello     Don t forget the construction for which decorator syntax is a shorthand   say   wrap in tag  b   wrap in tag  i   say

User · Answer

To explain the decorator in a simple way   With    decor1  decor2 def func  args    kwargs       pass   When do   func  args    kwargs    You really do   decor1 decor2 func    args    kwargs

User · Answer

Another way of doing the same thing   class bol object     def   init   self  f       self f   f   def   call   self       return   lt b gt    lt  b gt   format self f     class ita object     def   init   self  f       self f   f   def   call   self       return   lt i gt    lt  i gt   format self f      bol  ita def sayhi      return  hi    Or  more flexibly   class sty object     def   init   self  tag       self tag   tag   def   call   self  f       def newf          return   lt  tag  gt  res  lt   tag  gt   format res f    tag self tag      return newf   sty  b    sty  i   def sayhi      return  hi

User · Answer

Decorate functions with different number of arguments  def frame tests fn       def wrapper  args           print  quot  nStart   s quot    fn   name            fn  args          print  quot End   s n quot    fn   name        return wrapper   frame tests def test fn1        print  quot This is only a test  quot    frame tests def test fn2 s1       print  quot This is only a test   s quot    s1    frame tests def test fn3 s1  s2       print  quot This is only a test   s  s quot    s1  s2   if   name       quot   main   quot       test fn1       test fn2  OK        test fn3  OK     Just a test     Result  Start  test fn1   This is only a test    End  test fn1         Start  test fn2   This is only a test  OK    End  test fn2         Start  test fn3   This is only a test  OK  Just a test    End  test fn3

User · Answer

Check out the documentation to see how decorators work  Here is what you asked for  from functools import wraps  def makebold fn        wraps fn      def wrapper  args    kwargs           return  quot  lt b gt  quot    fn  args    kwargs     quot  lt  b gt  quot      return wrapper  def makeitalic fn        wraps fn      def wrapper  args    kwargs           return  quot  lt i gt  quot    fn  args    kwargs     quot  lt  i gt  quot      return wrapper   makebold  makeitalic def hello        return  quot hello world quot    makebold  makeitalic def log s       return s  print hello            returns  quot  lt b gt  lt i gt hello world lt  i gt  lt  b gt  quot  print hello   name     with functools wraps   this returns  quot hello quot  print log  hello       returns  quot  lt b gt  lt i gt hello lt  i gt  lt  b gt  quot

User · Answer

Paolo Bergantino s answer has the great advantage of only using the stdlib  and works for this simple example where there are no decorator arguments nor decorated function arguments    However it has 3 major limitations if you want to tackle more general cases    as already noted in several answers  you can not easily modify the code to add optional decorator arguments  For example creating a makestyle style  bold   decorator is non-trivial  besides  wrappers created with  functools wraps do not preserve the signature  so if bad arguments are provided they will start executing  and might raise a different kind of error than the usual TypeError  finally  it is quite difficult in wrappers created with  functools wraps to access an argument based on its name  Indeed the argument can appear in  args  in   kwargs  or may not appear at all  if it is optional     I wrote decopatch to solve the first issue  and wrote makefun wraps to solve the other two  Note that makefun leverages the same trick than the famous decorator lib   This is how you would create a decorator with arguments  returning truly signature-preserving wrappers   from decopatch import function decorator  DECORATED from makefun import wraps   function decorator def makestyle st  b   fn DECORATED       open tag     lt  s gt     st     close tag     lt   s gt     st       wraps fn      def wrapped  args    kwargs           return open tag   fn  args    kwargs    close tag      return wrapped   decopatch provides you with two other development styles that hide or show the various python concepts  depending on your preferences  The most compact style is the following   from decopatch import function decorator  WRAPPED  F ARGS  F KWARGS   function decorator def makestyle st  b   fn WRAPPED  f args F ARGS  f kwargs F KWARGS       open tag     lt  s gt     st     close tag     lt   s gt     st     return open tag   fn  f args    f kwargs    close tag   In both cases you can check that the decorator works as expected    makestyle  makestyle  i   def hello who       return  hello  s    who  assert hello  world        lt b gt  lt i gt hello world lt  i gt  lt  b gt         Please refer to the documentation for details

User · Answer

It looks like the other people have already told you how to solve the problem  I hope this will help you understand what decorators are   Decorators are just syntactical sugar   This   decorator def func              expands to      def func            func   decorator func

User · Answer

Here is a simple example of chaining decorators   Note the last line - it shows what is going on under the covers                                                                       decorators                                                                 def bold fn       def decorate              surround with bold tags before calling original function         return   lt b gt     fn       lt  b gt       return decorate   def uk fn       def decorate              swap month and day         fields   fn   split              date   fields 1          fields 0          fields 2          return date     return decorate  import datetime def getDate        now   datetime datetime now       return   d  d  d     now day  now month  now year    bold def getBoldDate         return getDate     uk def getUkDate        return getDate     bold  uk def getBoldUkDate        return getDate     print getDate   print getBoldDate   print getUkDate   print getBoldUkDate     what is happening under the covers print bold uk getDate       The output looks like   17 6 2013  lt b gt 17 6 2013 lt  b gt  6 17 2013  lt b gt 6 17 2013 lt  b gt   lt b gt 6 17 2013 lt  b gt

User · Answer

If you are not into long explanations  see Paolo Bergantino   s answer   Decorator Basics  Python   s functions are objects  To understand decorators  you must first understand that functions are objects in Python  This has important consequences  Let   s see why with a simple example    def shout word  yes        return word capitalize        print shout      outputs    Yes      As an object  you can assign the function to a variable like any other object  scream   shout    Notice we don t use parentheses  we are not calling the function    we are putting the function  shout  into the variable  scream     It means you can then call  shout  from  scream    print scream      outputs    Yes      More than that  it means you can remove the old name  shout      and the function will still be accessible from  scream   del shout try      print shout    except NameError as e      print e       outputs   name  shout  is not defined   print scream      outputs   Yes     Keep this in mind  We   ll circle back to it shortly    Another interesting property of Python functions is they can be defined inside another function   def talk           You can define a function on the fly in  talk          def whisper word  yes            return word lower                    and use it right away      print whisper       You call  talk   that defines  whisper  EVERY TIME you call it  then    whisper  is called in  talk    talk     outputs      yes        But  whisper  DOES NOT EXIST outside  talk    try      print whisper    except NameError as e      print e       outputs    name  whisper  is not defined        Python s functions are objects   Functions references  Okay  still here  Now the fun part     You   ve seen that functions are objects  Therefore  functions    can be assigned to a variable can be defined in another function   That means that a function can return another function   def getTalk kind  shout           We define functions on the fly     def shout word  yes            return word capitalize            def whisper word  yes             return word lower                 Then we return one of them     if kind     shout             We don t use       we are not calling the function            we are returning the function object         return shout       else          return whisper    How do you use this strange beast     Get the function and assign it to a variable talk   getTalk            You can see that  talk  is here a function object  print talk   outputs    lt function shout at 0xb7ea817c gt     The object is the one returned by the function  print talk     outputs   Yes     And you can even use it directly if you feel wild  print getTalk  whisper       outputs   yes      There   s more    If you can return a function  you can pass one as a parameter   def doSomethingBefore func        print  I do something before then I call the function you gave me       print func     doSomethingBefore scream   outputs    I do something before then I call the function you gave me  Yes    Well  you just have everything needed to understand decorators  You see  decorators are    wrappers     which means that they let you execute code before and after the function they decorate without modifying the function itself   Handcrafted decorators  How you   d do it manually     A decorator is a function that expects ANOTHER function as parameter def my shiny new decorator a function to decorate          Inside  the decorator defines a function on the fly  the wrapper        This function is going to be wrapped around the original function       so it can execute code before and after it      def the wrapper around the original function               Put here the code you want to be executed BEFORE the original function is called         print  Before the function runs              Call the function here  using parentheses          a function to decorate              Put here the code you want to be executed AFTER the original function is called         print  After the function runs          At this point   a function to decorate  HAS NEVER BEEN EXECUTED        We return the wrapper function we have just created        The wrapper contains the function and the code to execute before and after  It   s ready to use      return the wrapper around the original function    Now imagine you create a function you don t want to ever touch again  def a stand alone function        print  I am a stand alone function  don t you dare modify me    a stand alone function     outputs  I am a stand alone function  don t you dare modify me    Well  you can decorate it to extend its behavior    Just pass it to the decorator  it will wrap it dynamically in    any code you want and return you a new function ready to be used   a stand alone function decorated   my shiny new decorator a stand alone function  a stand alone function decorated    outputs   Before the function runs  I am a stand alone function  don t you dare modify me  After the function runs   Now  you probably want that every time you call a stand alone function  a stand alone function decorated is called instead  That   s easy  just overwrite a stand alone function with the function returned by my shiny new decorator   a stand alone function   my shiny new decorator a stand alone function  a stand alone function    outputs   Before the function runs  I am a stand alone function  don t you dare modify me  After the function runs    That   s EXACTLY what decorators do    Decorators demystified  The previous example  using the decorator syntax    my shiny new decorator def another stand alone function        print  Leave me alone    another stand alone function      outputs     Before the function runs  Leave me alone  After the function runs   Yes  that   s all  it   s that simple   decorator is just a shortcut to   another stand alone function   my shiny new decorator another stand alone function    Decorators are just a pythonic variant of the decorator design pattern  There are several classic design patterns embedded in Python to ease development  like iterators    Of course  you can accumulate decorators   def bread func       def wrapper            print   lt          gt            func           print   lt          gt        return wrapper  def ingredients func       def wrapper            print   tomatoes            func           print   salad        return wrapper  def sandwich food  --ham--        print food   sandwich    outputs  --ham-- sandwich   bread ingredients sandwich   sandwich    outputs    lt          gt     tomatoes    --ham--    salad    lt          gt    Using the Python decorator syntax    bread  ingredients def sandwich food  --ham--        print food   sandwich    outputs    lt          gt     tomatoes    --ham--    salad    lt          gt    The order you set the decorators MATTERS    ingredients  bread def strange sandwich food  --ham--        print food   strange sandwich    outputs    tomatoes    lt          gt    --ham--   lt          gt     salad      Now  to answer the question     As a conclusion  you can easily see how to answer the question     The decorator to make it bold def makebold fn         The new function the decorator returns     def wrapper              Insertion of some code before and after         return   lt b gt     fn       lt  b gt       return wrapper    The decorator to make it italic def makeitalic fn         The new function the decorator returns     def wrapper              Insertion of some code before and after         return   lt i gt     fn       lt  i gt       return wrapper   makebold  makeitalic def say        return  hello   print say     outputs   lt b gt  lt i gt hello lt  i gt  lt  b gt     This is the exact equivalent to  def say        return  hello  say   makebold makeitalic say    print say     outputs   lt b gt  lt i gt hello lt  i gt  lt  b gt    You can now just leave happy  or burn your brain a little bit more and see advanced uses of decorators     Taking decorators to the next level  Passing arguments to the decorated function    It   s not black magic  you just have to let the wrapper    pass the argument   def a decorator passing arguments function to decorate       def a wrapper accepting arguments arg1  arg2           print  I got args  Look   0    1   format arg1  arg2           function to decorate arg1  arg2      return a wrapper accepting arguments    Since when you are calling the function returned by the decorator  you are   calling the wrapper  passing arguments to the wrapper will let it pass them to    the decorated function   a decorator passing arguments def print full name first name  last name       print  My name is  0   1   format first name  last name    print full name  Peter    Venkman     outputs   I got args  Look  Peter Venkman  My name is Peter Venkman   Decorating methods  One nifty thing about Python is that methods and functions are really the same   The only difference is that methods expect that their first argument is a reference to the current object  self     That means you can build a decorator for methods the same way  Just remember to take self into consideration   def method friendly decorator method to decorate       def wrapper self  lie           lie   lie - 3   very friendly  decrease age even more  -          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  I am  0   what did you think   format self age   lie    l   Lucy   l sayYourAge -3   outputs  I am 26  what did you think    If you   re making general-purpose decorator--one you   ll apply to any function or method  no matter its arguments--then just use  args    kwargs   def a decorator passing arbitrary arguments function to decorate         The wrapper accepts any arguments     def a wrapper accepting arbitrary arguments  args    kwargs           print  Do I have args             print args          print kwargs            Then you unpack the arguments  here  args    kwargs           If you are not familiar with unpacking  check            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    outputs  Do I have args            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   outputs  Do I have args     1  2  3       1 2 3    a decorator passing arbitrary arguments def function with named arguments a  b  c  platypus  Why not          print  Do  0    1  and  2  like platypus   3   format a  b  c  platypus    function with named arguments  Bill    Linus    Steve   platypus  Indeed     outputs  Do I have args        Bill    Linus    Steve      platypus    Indeed     Do Bill  Linus and Steve like platypus  Indeed   class Mary object        def   init   self           self age   31       a decorator passing arbitrary arguments     def sayYourAge self  lie -3     You can now add a default value         print  I am  0   what did you think   format self age   lie    m   Mary   m sayYourAge    outputs   Do I have args      lt   main   Mary object at 0xb7d303ac gt         I am 28  what did you think    Passing arguments to the decorator  Great  now what would you say about passing arguments to the decorator itself    This can get somewhat twisted  since a decorator must accept a function as an argument  Therefore  you cannot pass the decorated function   s arguments directly to the decorator   Before rushing to the solution  let   s write a little reminder      Decorators are ORDINARY functions def my decorator func       print  I am an ordinary function       def wrapper            print  I am function returned by the decorator           func       return wrapper    Therefore  you can call it without any      def lazy function        print  zzzzzzzz    decorated function   my decorator lazy function   outputs  I am an ordinary function    It outputs  I am an ordinary function   because that   s just what you do    calling a function  Nothing magic    my decorator def lazy function        print  zzzzzzzz     outputs  I am an ordinary function   It   s exactly the same   my decorator  is called  So when you  my decorator  you are telling Python to call the function  labelled by the variable  my decorator      This is important  The label you give can point directly to the decorator   or not    Let   s get evil     def decorator maker         print  I make decorators  I am executed only once               when you make me create a decorator         def my decorator func            print  I am a decorator  I am executed only when you decorate a function             def wrapped                print  I am the wrapper around the decorated function                       I am called when you call the decorated function                       As the wrapper  I return the RESULT of the decorated function                return func            print  As the decorator  I return the wrapped function             return wrapped      print  As a decorator maker  I return a decorator       return my decorator    Let   s create a decorator  It   s just a new function after all  new decorator   decorator maker           outputs   I make decorators  I am executed only once  when you make me create a decorator   As a decorator maker  I return a decorator    Then we decorate the function  def decorated function        print  I am the decorated function     decorated function   new decorator decorated function   outputs   I am a decorator  I am executed only when you decorate a function   As the decorator  I return the wrapped function    Let   s call the function  decorated function    outputs   I am the wrapper around the decorated function  I am called when you call the decorated function   As the wrapper  I return the RESULT of the decorated function   I am the decorated function    No surprise here    Let   s do EXACTLY the same thing  but skip all the pesky intermediate variables   def decorated function        print  I am the decorated function    decorated function   decorator maker   decorated function   outputs   I make decorators  I am executed only once  when you make me create a decorator   As a decorator maker  I return a decorator  I am a decorator  I am executed only when you decorate a function   As the decorator  I return the wrapped function     Finally  decorated function        outputs   I am the wrapper around the decorated function  I am called when you call the decorated function   As the wrapper  I return the RESULT of the decorated function   I am the decorated function    Let   s make it even shorter    decorator maker   def decorated function        print  I am the decorated function     outputs   I make decorators  I am executed only once  when you make me create a decorator   As a decorator maker  I return a decorator  I am a decorator  I am executed only when you decorate a function   As the decorator  I return the wrapped function    Eventually   decorated function        outputs   I am the wrapper around the decorated function  I am called when you call the decorated function   As the wrapper  I return the RESULT of the decorated function   I am the decorated function    Hey  did you see that  We used a function call with the     syntax   -   So  back to decorators with arguments  If we can use functions to generate the decorator on the fly  we can pass arguments to that function  right   def decorator maker with arguments decorator arg1  decorator arg2        print  I make decorators  And I accept arguments   0    1   format decorator arg1  decorator arg2        def my decorator func             The ability to pass arguments here is a gift from closures            If you are not comfortable with closures  you can assume it   s ok            or read  https   stackoverflow com questions 13857 can-you-explain-closures-as-they-relate-to-python         print  I am the decorator  Somehow you passed me arguments   0    1   format decorator arg1  decorator arg2              Don t confuse decorator arguments and function arguments          def wrapped function arg1  function arg2                print  I am the wrapper around the decorated function  n                     I can access all the variables n                      t- from the decorator   0   1  n                      t- from the function call   2   3  n                     Then I can pass them to the decorated function                     format decorator arg1  decorator arg2                            function arg1  function arg2               return func function arg1  function arg2           return wrapped      return my decorator   decorator maker with arguments  Leonard    Sheldon   def decorated function with arguments function arg1  function arg2       print  I am the decorated function and only knows about my arguments   0                 1   format function arg1  function arg2    decorated function with arguments  Rajesh    Howard    outputs   I make decorators  And I accept arguments  Leonard Sheldon  I am the decorator  Somehow you passed me arguments  Leonard Sheldon  I am the wrapper around the decorated function    I can access all the variables      - from the decorator  Leonard Sheldon      - from the function call  Rajesh Howard   Then I can pass them to the decorated function  I am the decorated function and only knows about my arguments  Rajesh Howard   Here it is  a decorator with arguments  Arguments can be set as variable   c1    Penny  c2    Leslie    decorator maker with arguments  Leonard   c1  def decorated function with arguments function arg1  function arg2       print  I am the decorated function and only knows about my arguments                 0   1   format function arg1  function arg2    decorated function with arguments c2   Howard    outputs   I make decorators  And I accept arguments  Leonard Penny  I am the decorator  Somehow you passed me arguments  Leonard Penny  I am the wrapper around the decorated function    I can access all the variables      - from the decorator  Leonard Penny      - from the function call  Leslie Howard   Then I can pass them to the decorated function  I am the decorated function and only know about my arguments  Leslie Howard   As you can see  you can pass arguments to the decorator like any function using this trick  You can even use  args    kwargs if you wish  But remember decorators are called only once  Just when Python imports the script  You can t dynamically set the arguments afterwards  When you do  import x   the function is already decorated  so you can t change anything     Let   s practice  decorating a decorator  Okay  as a bonus  I ll give you a snippet to make any decorator accept generically any argument  After all  in order to accept arguments  we created our decorator using another function    We wrapped the decorator   Anything else we saw recently that wrapped function   Oh yes  decorators   Let   s have some fun and write a decorator for the decorators   def decorator with args decorator to enhance                This function is supposed to be used as a decorator      It must decorate an other function  that is intended to be used as a decorator      Take a cup of coffee      It will allow any decorator to accept an arbitrary number of arguments      saving you the headache to remember how to do that every time                 We use the same trick we did to pass arguments     def decorator maker  args    kwargs              We create on the fly a decorator that accepts only a function           but keeps the passed arguments from the maker          def decorator wrapper func                  We return the result of the original decorator  which  after all                 IS JUST AN ORDINARY FUNCTION  which returns a function                 Only pitfall  the decorator must have this specific signature or it won t work              return decorator to enhance func   args    kwargs           return decorator wrapper      return decorator maker   It can be used as follows     You create the function you will use as a decorator  And stick a decorator on it  -    Don t forget  the signature is  decorator func   args    kwargs    decorator with args  def decorated decorator func   args    kwargs        def wrapper function arg1  function arg2           print  Decorated with  0   1   format args  kwargs           return func function arg1  function arg2      return wrapper    Then you decorate the functions you wish with your brand new decorated decorator    decorated decorator 42  404  1024  def decorated function function arg1  function arg2       print  Hello  0   1   format function arg1  function arg2    decorated function  Universe and    everything    outputs   Decorated with  42  404  1024      Hello Universe and everything    Whoooot    I know  the last time you had this feeling  it was after listening a guy saying   before understanding recursion  you must first understand recursion   But now  don t you feel good about mastering this     Best practices  decorators   Decorators were introduced in Python 2 4  so be sure your code will be run on    2 4   Decorators slow down the function call  Keep that in mind  You cannot un-decorate a function   There are hacks to create decorators that can be removed  but nobody uses them   So once a function is decorated  it   s decorated for all the code  Decorators wrap functions  which can make them hard to debug    This gets better from Python    2 5  see below     The functools module was introduced in Python 2 5  It includes the function functools wraps    which copies the name  module  and docstring of the decorated function to its wrapper     Fun fact  functools wraps   is a decorator        For debugging  the stacktrace prints you the function   name   def foo        print  foo    print foo   name     outputs  foo    With a decorator  it gets messy     def bar func       def wrapper            print  bar           return func       return wrapper   bar def foo        print  foo    print foo   name     outputs  wrapper     functools  can help for that  import functools  def bar func         We say that  wrapper   is wrapping  func        and the magic begins      functools wraps func      def wrapper            print  bar           return func       return wrapper   bar def foo        print  foo    print foo   name     outputs  foo     How can the decorators be useful   Now the big question  What can I use decorators for    Seem cool and powerful  but a practical example would be great  Well  there are 1000 possibilities  Classic uses are extending a function behavior from an external lib  you can t modify it   or for debugging  you don t want to modify it because it   s temporary     You can use them to extend several functions in a DRY   s way  like so   def benchmark func               A decorator that prints the time a function takes     to execute              import time     def wrapper  args    kwargs           t   time clock           res   func  args    kwargs          print   0   1   format func   name    time clock  -t           return res     return wrapper   def logging func               A decorator that logs the activity of the script       it actually just prints it  but it could be logging               def wrapper  args    kwargs           res   func  args    kwargs          print   0   1   2   format func   name    args  kwargs           return res     return wrapper   def counter func               A decorator that counts and prints the number of times a function has been executed             def wrapper  args    kwargs           wrapper count   wrapper count   1         res   func  args    kwargs          print   0  has been used   1 x  format func   name    wrapper count           return res     wrapper count   0     return wrapper   counter  benchmark  logging def reverse string string       return str reversed string    print reverse string  Able was I ere I saw Elba    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       outputs   reverse string   Able was I ere I saw Elba        wrapper 0 0  wrapper has been used  1x   ablE was I ere I saw elbA  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  wrapper has been used  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   Of course the good thing with decorators is that you can use them right away on almost anything without rewriting  DRY  I said    counter  benchmark  logging def get random futurama quote        from urllib import urlopen     result   urlopen  http   subfusion net cgi-bin quote pl quote futurama   read       try          value   result split   lt br gt  lt b gt  lt hr gt  lt br gt    1  split   lt br gt  lt br gt  lt hr gt    0          return value strip       except          return  No  I m     doesn t     print get random futurama quote    print get random futurama quote      outputs   get random futurama quote        wrapper 0 02  wrapper has been used  1x  The laws of science be a harsh mistress   get random futurama quote        wrapper 0 01  wrapper has been used  2x  Curse you  merciful Poseidon    Python itself provides several decorators  property  staticmethod  etc     Django uses decorators to manage caching and view permissions   Twisted to fake inlining asynchronous functions calls    This really is a large playground

User · Answer

Python decorators add extra functionality to another function  An italics decorator could be like  def makeitalic fn       def newFunc            return   lt i gt     fn       lt  i gt       return newFunc   Note that a function is defined inside a function  What it basically does is replace a function with the newly defined one  For example  I have this class  class foo      def bar self           print  hi      def foobar self           print  hi again    Now say  I want both functions to print  ---  after and before they are done  I could add a print  ---  before and after each print statement  But because I don t like repeating myself  I will make a decorator  def addDashes fn     notice it takes a function as an argument     def newFunction self     define a new function         print  ---          fn self    call the original function         print  ---      return newFunction       Return the newly defined function - it will  replace  the original   So now I can change my class to   class foo       addDashes     def bar self           print  hi        addDashes     def foobar self           print  hi again    For more on decorators  check http   www ibm com developerworks linux library l-cpdecor html

User · Answer

This answer has long been answered  but I thought I would share my Decorator class which makes writing new decorators easy and compact   from abc import ABCMeta  abstractclassmethod  class Decorator metaclass ABCMeta           Acts as a base class for all decorators          def   init   self           self method   None      def   call   self  method           self method   method         return self call       abstractclassmethod     def call self   args    kwargs           return self method  args    kwargs    For one I think this makes the behavior of decorators very clear  but it also makes it easy to define new decorators very concisely  For the example listed above  you could then solve it as   class MakeBold Decorator       def call            return   lt b gt     self method       lt  b gt    class MakeItalic Decorator       def call            return   lt i gt     self method       lt  i gt     MakeBold    MakeItalic   def say       return  Hello    You could also use it to do more complex tasks  like for instance a decorator which automatically makes the function get applied recursively to all arguments in an iterator   class ApplyRecursive Decorator       def   init   self   types           super     init             if not len types               types    dict  list  tuple  set          self  types   types      def call self  arg           if dict in self  types and isinstance arg  dict               return  key  self call value  for key  value in arg items             if set in self  types and isinstance arg  set               return set self call value  for value in arg           if tuple in self  types and isinstance arg  tuple               return tuple self call value  for value in arg           if list in self  types and isinstance arg  list               return list self call value  for value in arg           return self method arg     ApplyRecursive tuple  set  dict  def double arg       return 2 arg  print double 1   print double   a   1   b   2    print double  1  2  3    print double  1  2  3  4    print double  1  2  3  4  5      Which prints   2   a   2   b   4   2  4  6   2  4  6  8   1  2  3  4  5  1  2  3  4  5    Notice that this example didn t include the list type in the instantiation of the decorator  so in the final print statement the method gets applied to the list itself  not the elements of the list

[python] How to make function decorators and chain them together?

Examples related to python

Examples related to decorator

Examples related to python-decorators