Class Methods Vs Any Other Callable

[Arnaud Delobelle]

FWIW, I wonder why the BDFL choosed to implement __new__ as a
staticmethod - there are probably some pretty good reasons, but not
knowing them, it looks like __new__ would have been a perfect
candidate for a classmethod.

So far, the only reason I can think of is that making it a classmethod
would have required the use of super(Parent, cls) to call the parent's
class __new__, which may (or may not - never had the case) be
problematic (any guru on this ?)

Don't know but I remember something about this in 'Unifying types and
classes'. There it is:

Factoid: __new__ is a static method, not a class method. I
initially thought it would have to be a class method, and that's
why I added the classmethod primitive. Unfortunately, with class
methods, upcalls don't work right in this case, so I had to make
it a static method with an explicit class as its first
argument. Ironically, there are now no known uses for class
methods in the Python distribution (other than in the test
suite). I might even get rid of classmethod in a future release if
no good use for it can be found!

(http://www.python.org/download/releases/2.2/descrintro/)

I don't have the time to try to figure it out

 

[bruno.desthuilliers]

Don't know but I remember something about this in 'Unifying types and
classes'. There it is:

Factoid: __new__ is a static method, not a class method. I
initially thought it would have to be a class method, and that's
why I added the classmethod primitive. Unfortunately, with class
methods, upcalls don't work right in this case, so I had to make
it a static method with an explicit class as its first
argument. Ironically, there are now no known uses for class
methods in the Python distribution (other than in the test
suite). I might even get rid of classmethod in a future release if
no good use for it can be found!

(http://www.python.org/download/releases/2.2/descrintro/)

Thanks Arnaud. I knew there was something about this, but just
couldn't remember what. Now at least this factoid makes sense to
me

Strange enough, it happened that classmethods ended being much more
used that staticmethods...

I don't have the time to try to figure it out

class Foo(object):
@classmethod
def dothis(cls):
print "Foo.dothis, cls is %s" % cls

@staticmethod
def dothat(cls):
print "Foo.dothat, cls is %s" % cls

class Bar(Foo):
@classmethod
def dothis(cls):
print "Bar.dothis, cls is %s" % cls
try:
Foo.dothis(cls)
except Exception, e:
print "trying direct call to Foo.dothis(cls), got %s" % e
try:
super(Bar, cls).dothis()
except Exception, e:
print "trying call to super(Bar, cls).dothis(), got %s" %
e

@staticmethod
def dothat(cls):
print "Bar.dothat, cls is %s" % cls
try:
Foo.dothat(cls)
except Exception, e:
print "trying direct call to Foo.dothat(cls), got %s" % e
try:
super(Bar, cls).dothat(cls)
except Exception, e:
print "trying call to super(Bar, cls).dothat(), got %s" %
e

For classmethods, you *need* to use super to call the parent's class
classmethod from within the overridden child class classmethod. Which
sometimes may not be what you want for __new__. While this is a kind
of a corner case (that I never met so far, hence my interrogations
about why is __new__ a staticmethod taking the class as argument
instead of a classmethod), it is still a potential showstopper.