Python Cookbook question re 5.6

[Joe]

The recipe in question is "Implementing Static Methods". It shows how to
use staticmethod(). This sentence in the Discussion section isn't clear to
me: "An attribute of a class object that starts out as a Python function
implicitly mutates into an unbound method." I'm not sure what this means,
exactly. Can anyone elaborate?

Thanks,
Chris

 

[Sean Ross]

The recipe in question is "Implementing Static Methods". It shows how to
use staticmethod(). This sentence in the Discussion section isn't clear to
me: "An attribute of a class object that starts out as a Python function
implicitly mutates into an unbound method." I'm not sure what this means,
exactly. Can anyone elaborate?

Thanks,
Chris

Here's an example that may help show what's going on:

class C:
def f():
print "f"
print type(f)

print type(C.f)
try:
C.f()
except TypeError, e:
print e
try:
c = C()
C.f(c)
except TypeError, e:
print e


# OUTPUT
<type 'function'>
<type 'instancemethod'>
unbound method f() must be called with C instance as first argument (got
nothing instead)
f() takes no arguments (1 given)


When the class C is evaluated the "print type(f)" statement is executed. It
shows that, at that moment, f's type is 'function'.
But when you ask, "type(C.f)" it tells you that f is an instance method.
When you try to call f using "C.f()" you're told that f is an unbound
method, that must be called with an instance of C as the first argument.
When you make a method, you usually specify the first argument as being
"self". In this case "self" would be an instance of C. So, anyway, now f
appears to expect an argument when it's called. So, we try passing in what
it appears to expect "C.f(c)", and it tells us that "f() takes no arguments
(1 given)". Heh.

I'm not exactly sure what Python's doing behind the scenes but I imagine
that it's wrapping all function definitions inside the class body: something
like

for all functions in the class:
function = unbound_method(function)

where unbound_method is a callable that maintains the original function as
an attribute. When you call the unbound_method, it delegates the call to
this function f. It's the unbound_method that expects the "instance of C as
the first argument", but when it passes the argument to its delegate
function f - well, f doesn't take any arguments, so we get an exception.

Like I said, I don't know exactly what mechanism are being employed behind
the scenes, but this is the way I try to understand what's going on.

Hopefully this is somewhat correct, and helpful,
Sean

 

[Bengt Richter]

First, you might cite the actual recipe here, so people can go look:


The way a class is constructed consists of:
1) open a scope at the point where the class definition starts.
2) Collect each definition in the scope (value an name). At this
point (during the collection), you are building "normal"
functions with def.
3) When the end of the class definition is found, all of the
definitions collected in (2), along with the class name and
superclasses are used to build the actual class. This is the
moment when the normal functions created in step 2 are used
to build "unbound methods" -- the magic used to make objects
work.

UIAM that is not quite accurate. The defined "normal functions" you mention
remain so until dynamically accessed as attributes of the relevant class. If you bypass the
getattr mechanism (e.g., looking in the class dict), you find that the functions are still "normal":
... def meth(*args): print 'meth args:', args
... <bound method C.meth of <__main__.C object at 0x00902410>>

but this way you see the plain old function:

>>> C.__dict__['meth']

<function meth at 0x009050B0>

if you use getattr, you can see the attribute magic: <unbound method C.meth>

and via an instance: <bound method C.meth of <__main__.C object at 0x00902410>>

calling the plain function:

>>> C.__dict__['meth'](1,2,3)

meth args: (1, 2, 3)

trying the same as class attribute, which gets you the unbound method: Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: unbound method meth() must be called with C instance as first argument (got int insta
nce instead)

you can pass the instance explicitly:

>>> getattr(C,'meth')(c,1,2,3)

>>> gm = C.__dict__['meth']
>>> gm(1,2,3)

meth args: (1, 2, 3)

you can add a method dynamically to the class:
and the getattr magic will do its thing: Traceback (most recent call last):
File "<stdin>", line 1, in ?
(<__main__.C object at 0x00902410>, 1, 2, 3)

You can also define descriptors that will intercept the getattr magic and alter the behavior,
if you want to.

Regards,
Bengt Richter

 

[Michele Simionato]

I'm not exactly sure what Python's doing behind the scenes

http://users.rcn.com/python/download/Descriptor.htm

 

[Scott David Daniels]

The recipe in question is "Implementing Static Methods". It shows how to
use staticmethod(). This sentence in the Discussion section isn't clear to
me: "An attribute of a class object that starts out as a Python function
implicitly mutates into an unbound method." I'm not sure what this means,
exactly. Can anyone elaborate?

Thanks,
Chris

First, you might cite the actual recipe here, so people can go look:


The way a class is constructed consists of:
1) open a scope at the point where the class definition starts.
2) Collect each definition in the scope (value an name). At this
point (during the collection), you are building "normal"
functions with def.
3) When the end of the class definition is found, all of the
definitions collected in (2), along with the class name and
superclasses are used to build the actual class. This is the
moment when the normal functions created in step 2 are used
to build "unbound methods" -- the magic used to make objects
work.

Here's some code that, once you understand it, illustrates this:

class SomeClass(object):
def function(self, other):
print 'called with self=%s, and other =%s' % (self, other)
return self, other

pair = function(1,2) # normal during class construction
print pair # We can even see the pair.
statmeth = staticmethod(function)# uses, not changes, function
pair2 = function(2,3) # Demonstrate function still works

print SomeClass.pair, SomeClass.pair2 # The class vars are there
obj = SomeClass() # make an instance
pair3 = obj.function(4) # Note only 1 arg is accepted.
print obj, pair3 # the object was used as the first arg
pair4 = SomeClass.statmeth(4, 5) # The old function behavior
pair5 = obj.statmeth(5, 6)# Also the old function behavior

pair6 = SomeClass.function(obj, 7) # An "unbound method" can
# be used on the right kind of object
pair7 = SomeClass.function(7, 8) # Raises an exception! An
# "unbound method" needs the correct
# kind of object as its first argument.

-Scott David Daniels
(e-mail address removed)