(For anyone else out there reading who doesn't already know this,
Steven D'Aprano's comments are easily explained by noting that the
__get__ method of staticmethod objects returns functions, and classes
always call the __get__ methods of descriptors when those descriptors
are class attributes:
Steven D'Aprano wrote: Why all the indirection to implement something which is, conceptually,
the same as an ordinary function?
While I wasn't around when descriptors and new-style classes were
introduced, my guess is that it's mainly because what you *usually* want
when defining a function in a class is for that function to be an
instance method. That is, the following code::
class C(object):
def foo(self):
pass
c = C()
c.foo()
should be much more common than::
class C(object):
def foo():
pass
C.foo()
because the whole point of creating a class is to allow you to create
instances. But if ``C.foo`` and ``c.foo`` are just regular functions,
then how will ``c.foo()`` get the ``self`` argument? Certainly a normal
``foo()`` shouldn't be inserting a magical ``self`` argument. So *some*
indirection has to happen when a function is used in a class.
Python's solution to this problem is to introduce descriptors, which are
the "something" that classes have to do. All classes invoke __get__
whenever any of their attributes are accessed. With a normal function
object, invoking __get__ turns it into an instance method:
class C(object): .... pass
.... def foo(self): .... pass
.... foo <function foo at 0x00E69530> foo.__get__(C() , C) <bound method C.foo of <__main__.C object at 0x00E738F0>> class C(object): .... def foo(self):
.... pass
.... C().foo
<bound method C.foo of <__main__.C object at 0x00E59C50>>
As a result, if you want to have a callable as a class attribute and you
don't want that callable to give you an instance method when you access
it, you can't use a regular Python function. Personally, I think that's
pretty reasonable since 99% of the time, I *do* want an instance method[1].
STeVe
[1] The other 1% of the time, I pretty much always want a classmethod.
I'm still convinced that staticmethods are basically silly when I can
just declare a module level function. ;)
