摘要：盡管和非常相似，但在用法上依然有一些明顯的區別。所以，從靜態方法的使用中可以看出，我們不會訪問到本身它基本上只是一個函數，在語法上就像一個方法一樣，但是沒有訪問對象和它的內部字段和其他方法，相反會訪問，會訪問。

Though classmethod and staticmethod are quite similar, there"s a slight difference in usage for both entities: classmethod must have a reference to a class object as the first parameter, whereas staticmethod can have no parameters at all.
Let"s look at all that was said in real examples.

盡管 classmethod 和 staticmethod 非常相似，但在用法上依然有一些明顯的區別。classmethod 必須有一個指向 類對象 的引用作為第一個參數，而 staticmethod 可以沒有任何參數。

讓我們看幾個例子。

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

class Date(object):

    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).

很明顯，這個類的對象可以存儲日期信息（不包括時區，假設他們都存儲在 UTC）。

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

這里的 init 方法用于初始化對象的屬性，它的第一個參數一定是 self，用于指向已經創建好的對象。

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.

利用 classmethod 可以做一些很棒的東西。

比如我們可以支持從特定格式的日期字符串來創建對象，它的格式是 ("dd-mm-yyyy")。很明顯，我們只能在其他地方而不是 init 方法里實現這個功能。

So what we must do here is:
Parse a string to receive day, month and year as three integer variables or a 3-item tuple consisting of that variable.
Instantiate Date by passing those values to initialization call.
This will look like:

大概步驟：

解析字符串，得到整數 day， month， year。

使用得到的信息初始化對象

代碼如下

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

理想的情況是 Date 類本身可以具備處理字符串時間的能力，解決了重用性問題，比如添加一個額外的方法。

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

C++ 可以方便的使用重載來解決這個問題，但是 python 不具備類似的特性。 所以接下來我們要使用 classmethod 來幫我們實現。

@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:
We"ve implemented date string parsing in one place and it"s reusable now.
Encapsulation works fine here (if you think that you could implement string parsing as a single function elsewhere, this solution fits OOP paradigm far better).
cls is an object that holds class itself, not an instance of the class. It"s pretty cool because if we inherit our Date class, all children will have from_string defined also.

讓我們在仔細的分析下上面的實現，看看它的好處。

我們在一個方法中實現了功能，因此它是可重用的。 這里的封裝處理的不錯（如果你發現還可以在代碼的任意地方添加一個不屬于 Date 的函數來實現類似的功能，那很顯然上面的辦法更符合 OOP 規范）。 cls 是一個保存了 class 的對象（所有的一切都是對象）。 更妙的是， Date 類的衍生類都會具有 from_string 這個有用的方法。

What about staticmethod? It"s pretty similar to classmethod but doesn"t take any obligatory parameters (like a class method or instance method 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 沒有任何必選參數，而 classmethod 第一個參數永遠是 cls， instancemethod 第一個參數永遠是 self。

@staticmethod
def is_date_valid(date_as_string):
  day, month, year = map(int, date_as_string.split("-"))
  return day <= 31 and month <= 12 and year <= 3999

# usage:
is_date = Date.is_date_valid("11-09-2012")

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.

所以，從靜態方法的使用中可以看出，我們不會訪問到 class 本身 - 它基本上只是一個函數，在語法上就像一個方法一樣，但是沒有訪問對象和它的內部（字段和其他方法），相反 classmethod 會訪問 cls， instancemethod 會訪問 self。

Meaning of @classmethod and @staticmethod for beginner?