Skip to main content

How well do you know Python, part 7

Given the following two classes,

class A:
    def foo(self):
        print self.__class__.__name__

class B:
    pass

why does this work,

def bar(self):
    print self.__class__.__name__

B.foo = bar
b = B()
b.foo()

while this does not?

B.foo = A.foo
b = B()
b.foo()

Comments

Anonymous said…
the second one is like exactly the same as calling

A.foo()

calling the instance method on the class not an instance.

what of course does work is:

a=A()
b=B()
b.foo = a.foo
b.foo()

because now the method is bound to an instance and not the class.
Anonymous said…
Because Python distinguishes unbound methods from global functions.

You can unwrap the function object from the unbound method and get it working this way:

B.foo = A.foo.im_func
b = B()
b.foo()
Jonathan Ellis said…
Marius is correct. I think Mark has the right idea too, just without the standard terminology. :)
Ian Bicking said…
Well, to be technical, it's more the standard metaclass that distinguishes function objects and unbound methods.

When you do ClassObject.attr, the ClassObject looks up 'attr' in its dictionary, and maybe munges that value, and returns it. It doesn't munge many values. It turns functions into UnboundMethods, and with new-style classes it looks for a __get__ method on the object and uses that if present.

The order and function is slightly different for instances; first you ask the instance in that case, then the class, and the class uses a different process (returning a BoundMethod or calling __get__ with slightly different arguments).

That second example (B.foo = A.foo) puts an UnboundMethod in B's __dict__. The standard metaclass doesn't rebind UnboundMethods, it just returns them. And UnboundMethods aren't entirely unbound -- they are bound to a class, but not an instance.

But we're not actually interested in that example in what B.foo returns, we're interested in what b.foo returns. In that case B returns the function foo bound to the class A (an UnboundMethod object), and then tries to bind that method to the instance b. Internally to UnboundMethods there is a check that the object it is bound to ("self") is an instance of the class the method is bound to. And that's why you get the error -- in fact, if an explicit check wasn't built into UnboundMethod, there's no underlying reason that it couldn't work (but it's there because it's typically a bug, and would result in the kind of bug that would drive you absolutely nuts).
Anonymous said…
B.bar=A.__dict__['bar']
B().bar()

works too :)

Basically this allows "ugly" things like
Runtime assembly of classes:

B.__dict__.update(A.__dict__)

which makes B acquire all the interesting stuff from A.

Andreas
Anonymous said…
That is so great!
It's also possible to run python in parallel on SMP: Parallel Python

Popular posts from this blog

Why schema definition belongs in the database

Earlier, I wrote about how ORM developers shouldn't try to re-invent SQL . It doesn't need to be done, and you're not likely to end up with an actual improvement. SQL may be designed by committee, but it's also been refined from thousands if not millions of man-years of database experience. The same applies to DDL. (Data Definition Langage -- the part of the SQL standard that deals with CREATE and ALTER.) Unfortunately, a number of Python ORMs are trying to replace DDL with a homegrown Python API. This is a Bad Thing. There are at least four reasons why: Standards compliance Completeness Maintainability Beauty Standards compliance SQL DDL is a standard. That means if you want something more sophisticated than Emacs, you can choose any of half a dozen modeling tools like ERwin or ER/Studio to generate and edit your DDL. The Python data definition APIs, by contrast, aren't even compatibile with other Python tools. You can't take a table definition

Python at Mozy.com

At my day job, I write code for a company called Berkeley Data Systems. (They found me through this blog, actually. It's been a good place to work.) Our first product is free online backup at mozy.com . Our second beta release was yesterday; the obvious problems have been fixed, so I feel reasonably good about blogging about it. Our back end, which is the most algorithmically complex part -- as opposed to fighting-Microsoft-APIs complex, as we have to in our desktop client -- is 90% in python with one C extension for speed. We (well, they, since I wasn't at the company at that point) initially chose Python for speed of development, and it's definitely fulfilled that expectation. (It's also lived up to its reputation for readability, in that the Python code has had 3 different developers -- in serial -- with very quick ramp-ups in each case. Python's succinctness and and one-obvious-way-to-do-it philosophy played a big part in this.) If you try it out, pleas

A review of 6 Python IDEs

(March 2006: you may also be interested the updated review I did for PyCon -- http://spyced.blogspot.com/2006/02/pycon-python-ide-review.html .) For September's meeting, the Utah Python User Group hosted an IDE shootout. 5 presenters reviewed 6 IDEs: PyDev 0.9.8.1 Eric3 3.7.1 Boa Constructor 0.4.4 BlackAdder 1.1 Komodo 3.1 Wing IDE 2.0.3 (The windows version was tested for all but Eric3, which was tested on Linux. Eric3 is based on Qt, which basically means you can't run it on Windows unless you've shelled out $$$ for a commerical Qt license, since there is no GPL version of Qt for Windows. Yes, there's Qt Free , but that's not exactly production-ready software.) Perhaps the most notable IDEs not included are SPE and DrPython. Alas, nobody had time to review these, but if you're looking for a free IDE perhaps you should include these in your search, because PyDev was the only one of the 3 free ones that we'd consider using. And if you aren