Decorator

[Lad]

I use Python 2.3.
I have heard about decorators in Python 2.4.
What is the decorator useful for?
Thanks for reply
L.

[Sybren Stuvel]

Lad enlightened us with:

I use Python 2.3.
I have heard about decorators in Python 2.4.
What is the decorator useful for?

A whole lot of stuff. I've used them for:
- Logging all calls to a function, including its arguments.
- Ensuring there is a database connection before the function is
called.
- Casting the arguments to certain types before passing them to
the function.

And there is much more possible...

Sybren
--
The problem with the world is stupidity. Not saying there should be a
capital punishment for stupidity, but why don't we just take the
safety labels off of everything and let the problem solve itself?
Frank Zappa

[Paul McGuire]

"Lad" <py****@hope.cz > wrote in message
news:11******** **************@ i39g2000cwa.goo glegroups.com.. .

I use Python 2.3.
I have heard about decorators in Python 2.4.
What is the decorator useful for?
Thanks for reply
L.

Check out these examples on the Python wiki:
http://wiki.python.org/moin/PythonDecoratorLibrary

I've gotten to be a big fan of memoize.

-- Paul

[bruno at modulix]

Lad wrote:

I use Python 2.3.
I have heard about decorators in Python 2.4.
What Python 2.4 adds is only syntactic sugar for decorators. You can do
the same - somewhat more explicitely - in 2.3.
What is the decorator useful for?

FWIW, I'm not sure the name 'decorator' is such a great idea. A
decorator (read 'function decorator') is mainly a callable that takes a
callable as param and returns another callable, usually wrapping the
passed callable and adding some responsabilitie s (tracing, logging,
pre-post condition checks, etc). Two well-known examples are classmethod
and staticmethod.

The whole things looks like this:

def deco(func):
print "decorating %s" % func.__name__
def _wrapper(*args, **kw):
print "%s called " % func.__name__
res = func(*args, **kw)
print "%s returned %s" % (func.__name__, str(res))
return _wrapper

# python < 2.4
def somefunc():
print "in somefunc"
return 42

somefunc = deco(somefunc)

The syntactic sugar added in 2.4 allows you to avoid the explicit call
to deco():

# python >= 2.4
@deco
def someotherfunc() :
return "the parrot is dead"
As you see, apart from the syntactic sugar, there's nothing new here.
It's just plain old higher order function, well known in any functional
language.

HTH
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[Martin Blume]

"bruno at modulix" schrieb

What Python 2.4 adds is only syntactic sugar for decorators.
You can do the same - somewhat more explicitely - in 2.3.

What is the decorator useful for?

The whole things looks like this:

def deco(func):
print "decorating %s" % func.__name__
def _wrapper(*args, **kw):
print "%s called " % func.__name__
res = func(*args, **kw)
print "%s returned %s" % (func.__name__, str(res))

return res
^^^^^^^^^^
Shouldn't here be a return res, so that wrapper
behaves like the original function?
return _wrapper

# python < 2.4
def somefunc():
print "in somefunc"
return 42

somefunc = deco(somefunc)

Thanks for the explanation.
Another question: Isn't decorating / wrapping usually
done at runtime, so that the @deco notation is pretty
useless (because you'd have to change the original
code)?
What do I miss here?

Martin

[Sybren Stuvel]

Martin Blume enlightened us with:

Another question: Isn't decorating / wrapping usually done at
runtime, so that the @deco notation is pretty useless (because you'd
have to change the original code)?

Please explain why that would make the @deco notation pretty useless.

Sybren
--
The problem with the world is stupidity. Not saying there should be a
capital punishment for stupidity, but why don't we just take the
safety labels off of everything and let the problem solve itself?
Frank Zappa

[bruno at modulix]

Martin Blume wrote:

"bruno at modulix" schrieb
(snip)

def deco(func):
print "decorating %s" % func.__name__
def _wrapper(*args, **kw):
print "%s called " % func.__name__
res = func(*args, **kw)
print "%s returned %s" % (func.__name__, str(res))

return res
^^^^^^^^^^
Shouldn't here be a return res, so that wrapper
behaves like the original function?

oops, my bad :(
And yes, of course.

return _wrapper

# python < 2.4
def somefunc():
print "in somefunc"
return 42

somefunc = deco(somefunc)

Thanks for the explanation.
Another question: Isn't decorating / wrapping usually
done at runtime,

It is. I mean, using decorator syntax, this is done during import, which
happens at runtime.
so that the @deco notation is pretty
useless (because you'd have to change the original
code)?
I don't understand your question.
What do I miss here?

Ok, I get it (well, I think...).

The use case for @decorator is for wrapping functions or method *in the
module/class itself*. It's not for module client code (but this of
course doesn't prevent client code to dynamically add other wrappers...)

One of the primary use case makes this pretty clear IHMO : classmethod
and staticmethod :

# python < 2.4:
class Cleese(object):
def doSillyWalk(cls ):
pass
doSillyWalk = classmethod(doS illyWalk)

# python >= 2.4:
class Cleese(object):
@classmethod
def doSillyWalk(cls ):
pass

Another example : CherryPy uses decorators to mark methods which are
'published' (ie: are action controllers responding to a given URL)
HTH
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[Martin Blume]

"Sybren Stuvel" schrieb

Martin Blume enlightened us with:

Don't know if I enlightened anybody ... :-)

Another question: Isn't decorating / wrapping
usually done at runtime, so that the @deco
notation is pretty useless (because you'd
have to change the original code)?

Please explain why that would make the @deco
notation pretty useless.

Well, if you're changing the original module, you
might as well insert the needed functionality in
the original function, no?
Or rename the original function, write a function
having this original name and calling from it the
original functionality?

Isn't the point of a decorator to change the
behavior externally, at runtime, possibly changing
it in different ways at different places at different
times?

So why this @deco notation? Can you apply it externally?
Meaning to
import module
first, then
@deco(module.fu nc)
somewhere later?
Martin

[Martin Blume]

"bruno at modulix" schrieb

[snip]

The use case for @decorator is for wrapping functions
or method *in the module/class itself*. That was the question. What's the use of doing it
like that in the module *itself* (I mean, you change
directly the original function)?
It's not for module client code (but this of
course doesn't prevent client code to dynamically
add other wrappers...)

How do the clients it? The "oldfashion ed"
deco(doSillyWal k)
way?

Martin

[bruno at modulix]

Martin Blume wrote:

"Sybren Stuvel" schrieb

Martin Blume enlightened us with:
Don't know if I enlightened anybody ... :-)

Not sure...

But let's hope someone else having doubts about @decorator will find
this thread, so we won't have to point him/her to the documentation.

Another question: Isn't decorating / wrapping
usually done at runtime, so that the @deco
notation is pretty useless (because you'd
have to change the original code)?

Please explain why that would make the @deco
notation pretty useless.

Well, if you're changing the original module,

Who's talking about "changing the original module" ?
you
might as well insert the needed functionality in
the original function, no?
higher order functions allow to keep orthogonal responsabilitie s
separated.

(snip)
Isn't the point of a decorator to change the
behavior externally, at runtime, possibly changing
it in different ways at different places at different
times?
You're confusing the python specific @decorator syntax with the OO
design pattern by the same name. This syntax is purely syntactic sugar
for a specific use case of higher order functions.
So why this @deco notation?
To improve readability.

@decorator
def my_one_hundred_ locs_func():
...

is much more readable than:
def my_one_hundred_ locs_func():
...
# 100 LOCS later
my_one_hundred_ locs_func = decorator(my_on e_hundred_locs_ func)
Can you apply it externally?

No. It doesn't make sens to replace:
mymodule.func = decorator(mymod ule.myfunc)
with
@decorator
mymodule.func

Note that all this should be clear for anyone having read the doc...

HTH
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"