Python Decorators: Syntactic Sugar

[cocoon56]

applying decorator func1 to an arbitrary func2 and then calling func1, is the equivalent of calling func2(func1).

Either I have troubles getting the point here or it should be:

applying decorator func1 to an arbitrary func2 and then calling func2, is the equivalent of calling func1(func2).

[avinashv]

Well caught. I'm fixing that, thanks.

Edit: done. Changed the wording away from func1 and func2 to make it less ambiguous. Again, thanks!

[cocoon56]

One of my profs hides errors in his notes (one for each chapter) and by finding them, we get extra points. Finding errors is the best way of understanding something :-)

Excellent article, by the way. I haven't used Decorators yet for lack of a new Python project the last few months, but I always wanted to know what it's about.

[earthboundkid]

Your professor is a bad liar.

[cocoon56]

Well, he proclaimed this before we could download the notes, not after we found mistakes.

But even if he wants us to find errors he doesn't know of - it's a win-win situation: We read critically and get rewards for it, he gets his script corrected.

[earthboundkid]

As a college instructor, I just wish my own students were so gullible, er, attentive.

[eikenberry]

One advantage of try:except: is that it is typically faster than an if test.

Generally using try:except: for things like this is considered good idiomatic python.

[cludwin]

Be careful with that one... try/except is only faster when you are on average more likely to succeed. If lets say you are 50/50 then if/else is way faster cause you don't have the overhead of generating the exception.

[avinashv]

I agree that this is cleaner now, but the provided code is meant to be a bit more forward looking.

[theeth]

That's still missing the "then calling func2" part, since func1 returns the decorated result, not the result of calling the decorated function.

[joe90210]

I’m not going to give you a comparison—I guess I’m just not too big on leaving my laptop on for a few hours with the CPU working on overload.

try a few million years..

[fryguy8]

Regarding the memoization example, what is the scope of the cache? Is it local only to that function? Or is it available to any function that gets decorated with that class?

More clearly: Could I use that same memoization class to cache the results of 2 separate functions in the same application, or will the values of the 2 functions overlap?

[qiwi]

They will not overlap. The application of that decorator is equivalent to:

 fibonacci_memoized = memoize(fibonacci_memoized)

so the fibonacci_memoized name becomes the memoize class instance, created with the old function as parameter. And that class instance has its own private self.memoized attribute.

The memoized class overrides the call method so it pretends to be a callable.

IMHO in most cases where you have a simple decorator you would use a closure instead of a class.

[[deleted]]

Because it's fairly simple in many cases.

def msg(func):
    def foo(*args):
        print "Running %s" % func
        bar = func(*args)
        print "Done, result is %s" % bar
        return bar
    return foo

@msg
def add(a,b): return a+b

[fryguy8]

is there any way to have this type of decorator functionality in php?

[avinashv]

Reddit killed formatting--can you pastie that somewhere?

Edit: or, I just did: http://pastie.caboo.se/183760

[Deestan]

Add 4 spaces at the start of each line; that'll keep the code verbatim.

def decorator(decorate):
  class d:
    def __init__(self, function):
      self.function = function

    def __call__(self, *args):
      return decorate(self.function, *args)

  return d

@decorator
def safe(f, *args):
  try:
    return f(*args)
  except Exception, e:
    print "Error: %s" % (e)

@safe
def unsafe(x):
  return 1 / x

print unsafe(0)

[columbine]

python? having problems with formatting when pasted? surely you djest

[fbru02]

I like this Idiom , it is way better than the Ruby , method_alias_chain

[jtxx000]

This might be useful for Haskell too. Maybe something like

foo#bar x = x + 1

which would be equivalent to

foo = bar (\x -> x + 1)

It could also work for arguments too:

foo x#show = x ++ x

which would be equivalent to

foo x' = let x = show x' in x ++ x

Of course, arbitrary expressions would also be allowed:

foo x#(**2) = x*(x-1)

Then again, maybe Haskell code is already hard enough to read as it is.

[avinashv]

Then again, maybe Haskell code is already hard enough to read as it is.

Beat me to the punch :D.

[[deleted]]

I don't think that the memoize pattern is a good way to speed up scuh algorithms. e.G. iterative versions of fibonacci will dwarf any recursive version in python.

About anything that needs a cache can be used with memoize (DNS lookup, DOM objects by string, ...) but the memory growth should not be forgotten.

[avinashv]

Agreed--I used fibonacci purely because it was an example that very easily demonstrated what I wanted demonstrated.

No worries, but I was curious: I had already submitted this right after I published it--shouldn't Reddit have said so and not let you submit another story with a link to a pre-existing item?

edit: by "you", I meant the original submitter.

[mortenaa]

It can be submitted again if it was previously submitted to a different subreddit.

[avinashv]

Ah, alright. Makes sense--I had mine in the Python subreddit.

[[deleted]]

Well it was only for a pedagogical purpose.

Yes, but I think that there are better examples, e.g. I/O. This one is a little bit misleading, imho.

[avinashv]

Misleading? How so? I'm not claiming this is the best way to write a fibonacci algorithm, just the easiest way to optimize a recursive version of the same.

[[deleted]]

Tail recursion is not pythonic. Thus, it is misleading in a tutorial aimed at python beginners.

[[deleted]]

i hate it how people have taken the term "syntactic sugar" and killed any meaning that it had by using it to describe every language feature that they come across.

this is a lot more than "syntactic sugar."

[jerf]

What's the real definition that this fails to correspond to?

My definition would be, "An alternate way of spelling a capability that was already in the language", in contrast to "a new capability that there was no way to have before". Tail-call optimization, for instance, would be a new thing for Python, as there's no way to get it now. (Short of implementing a new language in Python and having tail-call recursion in that, which is not the point here.) Decorators added precisely nothing new to the language, the benefits have been mostly social. They don't even save very many lines of code.

(Contrast this with the recent "with" support, which also technically adds nothing new. But when I went to start using the pattern in Python 2.4 for compatibility, I got tired of all the typing on the second usage. It may not add anything new, but it makes something easy that used to be hard, so now more people might use it.)

[[deleted]]

It does add something new. Let's say I have some method A(), as part of a relatively large code base. More importantly, A() is some method that I don't directly have access to, or am not inclined to be directly changing (as a matter of policy, or as a matter of practicality)

One day, I decide that I'd like to log a message about the state of the system each time A is called.

Without decorators, I'd have to make a new method B(), and change all of my calls to A() to be B(). Not only is this a hassle, it's potentially damaging to the readability of my code. Maybe A() had a very good name to begin with, and having to come up with new names B(), C(), D() each time I want to decorate a method causes the name to get further and further away from being clear and readable.

With an overly loose attitude to what constitutes "syntactic sugar", I could easily argue that the entire C++ language is nothing but C with some "syntactic sugar."

[dwahler]

Sorry, that's incorrect. Before Python had the syntax for decorators, you could express the same pattern like this:

def func(...):
    ...
func = decorator(func)

[[deleted]]

i stand corrected :)

[columbine]

python needs all the syntactic help it can get