Python @staticmethod vs @classmethod

区别

Being educated under Java background, static method and class method are the same thing.

But not so in Python, there is subtle difference:

Say function a() is defined in Parent Class, while Sub Class extends Parent Class

• If function a() has @staticmethod decorator, Sub.a() still refers to definition inside Parent Class. Whereas,
• If function a() has @classmethod decorator, Sub.a() will points definition inside Sub Class.

Let’s talk about some definitions here:

@staticmethod function is nothing more than a function defined inside a class. It is callable without instantiating the class first. It’s definition is immutable via inheritance.

@classmethod function also callable without instantiating the class, but its definition follows Sub class, not Parent class, via inheritance. That’s because the first argument for @classmethod function must always be cls (class).

c++和java中的类方法和类静态方法都是同一个意思，也是python中的@classmethod。

 

class A(object):
  def foo(self,x):
    print "A--> foo(%s,%s)"%(self,x)

  @classmethod
  def class_foo(cls,x):
    print "A--> class_foo(%s,%s)"%(cls,x)

  @staticmethod
  def static_foo(x):
    print "A--> static_foo(%s)"%x    


A().foo(1)
A().class_foo(2)
A().static_foo(3)

A.class_foo(2)
A.static_foo(3)

A--> foo(<__main__.A object at 0x7f75c0d93c50>,1)
A--> class_foo(<class '__main__.A'>,2)
A--> static_foo(3)
A--> class_foo(<class '__main__.A'>,2)
A--> static_foo(3)

　　cls, 这不是一个关键字, 像self一样, cls是python的一个built-in变量. self表示类的实例, 而cls表示类,

cls一般用于static method, 因为static method无须实例化就可以调用, 所以传递cls给static method. 然后调用cls()

可以创建对象. 就像调用IOLoop()一样. 

最后两句话:

Always use 'self' for the first argument to instance methods.

Always use 'cls' for the first argument to class methods.

那他们分别有什么用呢？

Let's assume an example of a class, dealing with date information (this is what will be our boilerplate to cook on):

classDate(object):

    day =0
    month =0
    year =0

　　def __init__(self, day=0, month=0, year=0):self.day = day
        self.month = month
        self.year = year

This class obviously could be used to store information about certain dates (without timezone information; let's assume all dates are presented in UTC).

Here we have __init__, a typical initializer of Python class instances, which receives arguments as a typicalinstancemethod, having the first non-optional argument (self) that holds reference to a newly created instance.

Classmethod

We have some tasks that can be nicely done using classmethods.

Let's assume that we want to create a lot of Date class instances having date information coming from outer source encoded as a string of next format ('dd-mm-yyyy'). We have to do that in different places of our source code in project.

So what we must do here is:

1. Parse a string to receive day, month and year as thee integer variables or a 3-item tuple consisting of that variable.
2. Instantiate Date by passing those values to initialization call.

This will look like:

day, month, year = map(int, string_date.split('-'))
date1 =Date(day, month, year)

For this purpose, C++ has such feature as overloading, but Python lacks that feature- so here's whenclassmethod applies. Lets create another "constructor".

@classmethod
def from_string(cls, date_as_string):
        day, month, year = map(int, date_as_string.split('-'))
        date1 = cls(day, month, year)return date1

date2 =Date.from_string('11-09-2012')

Let's look more carefully at the above implementation, and review what advantages we have here:

1. We've implemented date string parsing in one place and it's reusable now.
2. Encapsulation works fine here (if you think that you could implement string parsing as a single function elsewher, this solution fits OOP paradigm far better).
3. cls is an object that holds class itself, not an instance of the class. It's pretty cool because if we inherit ourDate class, all children will have from_string defined also.

Staticmethod

What about staticmethod? It's pretty similar to classmethod but doesn't take any obligatory parameters (likeclassmethod or instancemethod does).

Let's look at the next use case.

We have a date string that we want to validate somehow. This task is also logically bound to Date class we've used so far, but still doesn't require instantiation of it.

Here is where staticmethod can be useful. Let's look at the next piece of code:

@staticmethod
def is_date_valid(date_as_string):
        day, month, year = map(int, date_as_string.split('-'))try:assert0<= day <=31assert0<= month <=12assert0<= year <=3999exceptAssertionError:returnFalsereturnTrue

So, as we can see from usage of staticmethod, we don't have any access to what the class is- it's basically just a function, called syntactically like a method, but without access to the object and it's internals (fields and another methods), while classmethod does.