Python探索之靜態方法和類方法的區別詳解

這篇文章主要介紹了Python探索之靜態方法和類方法的區別詳解，小編覺得還是挺不錯的，這里分享給大家.

面相對象程序設計中，類方法和靜態方法是經常用到的兩個術語。
邏輯上講：類方法是只能由類名調用；靜態方法可以由類名或對象名進行調用。
python staticmethod and classmethod    
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 可以沒有任何參數。

讓我們看幾個例子。

例子 – Boilerplate

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，用于指向已經創建好的對象。

Class Method

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 這個有用的方法。

Static method
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。
總結
以上就是本文關于Python探索之靜態方法和類方法的區別詳解的全部內容，希望對大家有所幫助。