I've been doing a lot of reading about static methods in Python, and I'm not exactly sure what they are useful for or why they were introduced.
Here is a typical description of them, this one from Guido: "The new descriptor API makes it possible to add static methods and class methods. Static methods are easy to describe: they behave pretty much like static methods in C++ or Java." http://www.python.org/2.2.3/descrintro.html Great. So I have learn an entire new language to understand static methods. Perhaps not -- hence this cry for help. As near as I can see it, static methods are object methods that act just like functions. Er. I always thought that object methods *were* functions, except they had some runtime magic that passed the object itself as the first argument. >From Guido's example: >>> class C: ... def foo(x, y): ... print "staticmethod", x, y ... foo = staticmethod(foo) ... >>> C.foo(1, 2) staticmethod 1 2 >>> c = C() >>> c.foo(1, 2) staticmethod 1 2 So I compare with an ordinary class function, er, method: >>> class D: ... def foo(self, x, y): ... print "method", x, y ... >>> D.foo(1, 2) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: unbound method foo() must be called with D instance as first argument (got int instance instead) Okay, that is to be expected. Actually, I expected an exception that I hadn't passed enough arguments (2 arguments when foo expects 3), but in hindsight it is obvious enough. First point of confusion. In the above exception, foo is called an unbound method. But type(D.foo) returns <type 'instancemethod'> even though foo is being access through the class, not an instance. And type(D().foo) returns the same. Can I assume that in Python "unbound method" is just another way of saying "a method of a class that expects to be called via an instance"? I next tried this: >>> D.foo(D(), 1, 2) method 1 2 >>> D().foo(1, 2) method 1 2 Clear as mud. An ordinary method called from an instance is the same as a static method called from anywhere, provided you don't -- or rather, can't -- try to access self from the static method. When would you use a static method instead of an ordinary method? It has been suggested that you might use it for functions that don't need to access self. But that doesn't seem very convincing to me, because there is already a perfectly good idiom for that: >>> class E: ... def foo(): # returns calculated value ... return 1 ... foo = staticmethod(foo) ... def bar(self): ... return 1 # just ignore the value of self ... >>> E.foo() 1 >>> e = E() >>> e.bar() 1 What are some usage cases for using Class.StaticMethod() instead of instance.method()? Everything I've read seems to just assume that the benefits of static methods are so obvious that they don't need explaining. Unfortunately, I haven't come from a background in OO and I'm easily confused, hence this post. -- Steven. -- http://mail.python.org/mailman/listinfo/python-list