Python Cookbook question re 5.6

Discussion in 'Python' started by Joe, Dec 14, 2003.

  1. Joe

    Joe Guest

    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
     
    Joe, Dec 14, 2003
    #1
    1. Advertising

  2. Joe

    Sean Ross Guest

    "Joe" <> wrote in message
    news:SX%Cb.548624$Fm2.517912@attbi_s04...
    > 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
     
    Sean Ross, Dec 14, 2003
    #2
    1. Advertising

  3. On Mon, 15 Dec 2003 08:51:07 -0800, Scott David Daniels <> wrote:

    >Joe wrote:
    >> 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.

    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":

    >>> class C(object):

    ... def meth(*args): print 'meth args:', args
    ...
    >>> c = C()
    >>> C.meth

    <unbound method C.meth>
    >>> c.meth

    <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:
    >>> getattr(C,'meth')

    <unbound method C.meth>

    and via an instance:
    >>> getattr(c,'meth')

    <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:
    >>> getattr(C,'meth')(1,2,3)

    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)

    meth args: (<__main__.C object at 0x00902410>, 1, 2, 3)

    you can make a global binding to the plain function:
    >>> gm = C.__dict__['meth']
    >>> gm(1,2,3)

    meth args: (1, 2, 3)

    you can add a method dynamically to the class:
    >>> C.m2 = lambda *args:args


    and the getattr magic will do its thing:
    >>> C.m2

    <unbound method C.<lambda>>
    >>> c.m2

    <bound method C.<lambda> of <__main__.C object at 0x00902410>>
    >>> c.m2(1,2,3)

    (<__main__.C object at 0x00902410>, 1, 2, 3)
    >>> C.m2(1,2,3)

    Traceback (most recent call last):
    File "<stdin>", line 1, in ?
    TypeError: unbound method <lambda>() must be called with C instance as first argument (got int i
    nstance instead)
    >>> C.m2(c,1,2,3)

    (<__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
     
    Bengt Richter, Dec 14, 2003
    #3
  4. Michele Simionato, Dec 15, 2003
    #4
  5. Joe wrote:
    > 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
     
    Scott David Daniels, Dec 15, 2003
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. dody
    Replies:
    4
    Views:
    389
    Tony C
    Aug 26, 2004
  2. Alex Martelli
    Replies:
    0
    Views:
    310
    Alex Martelli
    Aug 26, 2004
  3. Jonathan Gennick
    Replies:
    2
    Views:
    334
    Jonathan Gennick
    Oct 22, 2004
  4. RickMuller
    Replies:
    2
    Views:
    303
    Nick Vargish
    Apr 6, 2005
  5. Daniel Mark
    Replies:
    1
    Views:
    310
    Thomas Heller
    Sep 22, 2006
Loading...

Share This Page