[Chicago] New member and introducing myself.

Jordan Bettis jordanb at hafd.org
Sat Oct 4 06:55:10 CEST 2014


On 10/03/2014 05:05 PM, Lewit, Douglas wrote:
> Quick question here.  In my Java course we just got done learning 
> about static methods and non-static methods (although I'm still a 
> little confused about their difference ).  I know that Python can be 
> programmed using the OOP paradigm.  Does Python also have static 
> methods and non-static methods?

Think about it like this: You can define a class:

class C(object):
     @staticmethod
     def s():
         print "I'm static method"
     def i(self):
         print "I'm an instance of {}".format(repr(self))

You can instantiate an object of type C:

o = C()

And then you can call your methods:

o.s()
I'm static method

o.i()
I'm an instance of <__main__.C instance at 0x7f607d8f8cf8>

Now here's the important bit: the class you defined (C) *is itself an 
object*, you can pass class definitions around your program and treat 
them just like any other object:

def print_an_object(obj):
     print obj

print_an_object(C)
__main__.C

Suppose you want to bundle some functionality with the class definition, 
but you want it to be available *without creating an instance* of that 
Class, but just by accessing it through the class definition object. You 
can't do that with a regular method, since it takes "self" it wants an 
instance:

C.i()
TypeError: unbound method i() must be called with C instance as first 
argument (got nothing instead)

But you can do that with a static method. Since the static method 
doesn't take a "self" parameter you can just call it the way you'd call 
any function in python, directly from the definition:

C.s()
I'm static method

As it turns out static methods aren't terrificly useful in python but 
they can be nice occasionally for keeping things organized. A much more 
useful construct is the class method:

  class C(object):
     @classmethod
     def cw(cls):
         print cls

Class methods don't take "self" as their magic parameter, instead they 
take the *class definition* as that parameter. They can be called 
directly from the class definition like a static method, and they can 
also be called from an instance, but in either case they end up getting 
passed the class definition:

C.cw()
<class '__main__.C'>

o = C()
o.cw()
<class '__main__.C'>

These functions can be really useful for, for instance, creating factory 
methods that produce custom versions of C instances.

The most important conceptual thing to understand is that the *class 
definition is itself an object.* If that doesn't make sense think about 
it until it does. If it does make sense think about the implications of 
it and then the difference between static methods, instance methods and 
class methods will be clear.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/chicago/attachments/20141003/6fc868c1/attachment.html>


More information about the Chicago mailing list