标签：
对于Python中静态、类、抽象方法的使用，我是一直很迷糊的。最近看到一篇技术文章对这方面解释的很好，在此翻译一下，加深印象，也为有需要的同学提供一个方便。
Python中方法是如何工作的：
方法即函数，作为一个类的属性存储。你能像如下申明和访问一个函数：
>>> class Pizza(object):
... def __init__(self,size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<unbound method Pizza.get_size>
Python在这里告诉我们，Pizza类的get_size属性的访问时没有绑定。这是什么意思呢？我们马上就会知道只要我们继续调用它一下：
>>> Pizza.get_size()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method get_size() must be called with Pizza instance as first
argument (got nothing instead)
我们不能调用它，是因为它没有绑定到任何Pizza的实例。方法需要一个实例作为它的第一个参数（在Python 2中它必须是该类的一个实例，在Python 3中它可以是任何实例），让我们试一下：
>>> Pizza.get_size(Pizza(42))
42
它工作了！我们调用这个方法时，把一个实例作为它的第一个参数，这样就一切正常了。但是你会认同我的观点：这并不是一个方便的方式来调用方法。我们每次想要调用方法的时候都要引用类。如果我们并不知道哪个类使我们的对象，在很长时间内这中方式是行不通的。
因此，Python为我们做了绑定Pizza类的所有方法到该类的任意实例上。这就意味着Pizza类的实例的get_size属性是一个绑定方法：该方法的第一个参数就是实例本身：
>>> Pizza(42).get_size
<bound method Pizza.get_size of <__main__.Pizza object at 0x00000000025B3E48>>
>>> Pizza(42).get_size()
42
意料之中，我们不再需要为get_size提供任何参数了，因为它是绑定的，它的self参数自动设置为我们的Pizza实例。这里有一个更好的证明：
>>> m = Pizza(42).get_size
>>> m()
42
事实上，你甚至不必维持一个到你Pizza对象的引用。它的方法被绑定到对象，所以该方法对自己而言已经足够了。
但是，如果你想知道这个绑定方法绑定的到底是哪个对象？这里有一个小窍门：
>>> m = Pizza(42).get_size
>>> m.__self__
<__main__.Pizza object at 0x0000000002A95CF8>
>>>
>>> m == m.__self__.get_size
True
显然，我们依然有一个到对象的引用，如果有需要可以找回来。
在Python 3中，附加到类的方法不再视为绑定方法了，仅作为简单函数。如果有需要他们绑定到一个对象。原理依然保持不变，但是模型简化了。
>>> class Pizza(object):
... def __init__(self,size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<function Pizza.get_size at 0x0000000002907268>
静态方法：
静态方法是方法的一种特殊情况。有时候，你需要编写属于某个类的代码，但是从不使用对象本身。例如：
>>> class Pizza(object):
... @staticmethod
... def mix_ingredients(x,y):
... return x+y
... def cook(self):
... return self.mix_ingredient(self.cheese,self.vegetables)
...
在这种情况，将mix_ingredients作为非静态函数也能工作，但是必须提供一个self参数（不会被用到）。在这里，装饰器@staticmethod为我们提供了几件事情：
>>> Pizza().cook is Pizza().cook
False
>>> Pizza().mix_ingredients is Pizza.mix_ingredients
True
>>> Pizza().mix_ingredients is Pizza().mix_ingredients
True
类方法：
说了这么多，那么什么是类方法？类方法是不绑定到对象但是绑定到类的方法。（注意我下面标红的部分，与原文有出入，我在Python 2.7.9和Python 3.4.3下运行得到的都是False）
>>> class Pizza(object):
... radius = 42
... @classmethod
... def get_radius(cls):
... return cls.radius
...
>>> Pizza.get_radius
<bound method type.get_radius of <class ‘__main__.Pizza‘>>
>>> Pizza().get_radius
<bound method type.get_radius of <class ‘__main__.Pizza‘>>
>>> Pizza.get_radius is Pizza().get_radius
False
>>> Pizza.get_radius()
42
不管你使用什么方式来访问这个方法，它总是绑定于它依附的类，而且它的第一个参数是类本身（记住类也是对象）。
那么，什么时候时候这种类型的方法呢？class方法常用于一下两种类型的方法中：
>>> class Pizza(object):
... def __init__(self, ingredients):
... self.ingredients = ingredients
...
... @classmethod
... def from_fridge(cls, fridge):
... return cls(fridge.get_cheese() + fridge.get_vegetables())
...
>>> class Pizza(object):
... def __init__(self, radius, height):
... self.radius = radius
... self.height = height
...
... @staticmethod
... def compute_area(radius):
... return math.pi * (radius ** 2)
...
... @classmethod
... def compute_volume(cls, height, radius):
... return height * cls.compute_area(radius)
...
... def get_volume(self):
... return self.compute_volume(self.height, self.radius)
...
抽象方法：
抽象方法定义在一个基类中，但是可能没有提供任何实现。在Java中，这种方法被描述为接口。
在Python中最简单的写一个抽象方法的方式如下：
class Pizza(object):
def get_radius(self):
raise NotImplementedError
任何其他继承自Pizza的类应该实现并且重载get_radius方法。否则一个异常将会抛出。
这种特殊的实现抽闲方法的方式有一个缺点。如果你写一个继承自Pizza的类并且忘记实现get_radius了，错误仅在你打算试用这个方法的时候抛出。
>>> Pizza()
<__main__.Pizza object at 0x0000000002B9C208>
>>> Pizza().get_radius()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in get_radius
NotImplementedError
有一种方法可以早点触发这种方式，当对象被实例化之后，使用Python提供的abc模块。
>>>
... class BasePizza(object):
... __metaclass__ = abc.ABCMeta
...
... @abc.abstractmethod
... def get_radius(self):
... """Method that should do something."""
...
利用abc和它特殊的类，只要你尝试实例化BasePizza或者任意继承自它的类，你都将得到一个类型错误。
>>> BasePizza()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can‘t instantiate abstract class BasePizza with abstract methods get_
radius
混合静态、类和抽象方法：
当构建类和继承的时候，你需要混合使用这些方式装饰的时候一定会到来，在这里有关于它的一些技巧。
请记住声明方法是抽象的，不会冻结该方法的原型。这就意味着，它必须被实现，但是我能用任意参数列表来实现。
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class Calzone(BasePizza):
def get_ingredients(self, with_egg=False):
egg = Egg() if with_egg else None
return self.ingredients + egg
这是有效的，因为Calzone满足我们在BasePizza对象中定义的接口要求。这意味着我们也能作为一个类或者静态方法来实现它。例如：
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class DietPizza(BasePizza):
@staticmethod
def get_ingredients():
return None
这也是正确的，符合我们与抽闲BasePizza类的合约。事实上，该get_ingredients方法并不需要知道返回结果的对象其实是一个实现细节，不是一个让我们合约履行的标准。
因此，你不能强迫你的抽象方法的实现是一个普通的或者类或者静态方法。从Python 3（这在Python 2是行不通的，参照issue5867）开始，它现在可以在@abstractmethod的顶部使用@staticmethod和@classmethod装饰符。
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
ingredient = [‘cheese‘]
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.ingredients
不要误读：如果你觉得这会迫使你的子类把get_ingredients实现为一个类的函数那就错了。这只是意味着你在BasePizza类中实现的get_ingredients是一个类方法。
在一个抽象方法中的实现？是的，在Python中，与Java接口相反，你能在抽象方法中编码并且使用super()调用它：
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
default_ingredients = [‘cheese‘]
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.default_ingredients
class DietPizza(BasePizza):
def get_ingredients(self):
return [‘egg‘] + super(DietPizza, self).get_ingredients()
在这种情况下，你建立的每一个继承自BasePizza的pizza都不得不重载get_ingredients方法，但可以使用默认的机制，通过使用super()来获取成分列表。
原文地址：https://julien.danjou.info/blog/2013/guide-python-static-class-abstract-methods
关于Python中如何使用静态、类、抽象方法的权威指南（译）
标签：
原文地址：http://www.cnblogs.com/hiccup/p/4607216.html
