第7章 再谈抽象

​ 在前几章，你学习了Python内置的主要对象类型（数、字符串、列表、元组和字典），大致了解了众多的内置函数和标准库，还创建了自定义函数。不过有一点还没有学习，那就是创建自定义对象，而这正是本章的主题。你可能会问，自定义对象到底多有用呢？创建自定义对象好像很酷，但能使用它们来做什么呢？你有字典、序列、数和字符串可用，难道仅使用它们不能创建出满足需求的函数吗？当然能，但创建自定义对象（尤其是对象类型或类）是一个Python核心概念。事实上，这个概念非常重要，以至于Python与Smalltalk、C++、Java等众多语言一样，被视为一种面向对象的语言。在本章中，你将学习如何创建对象，还将学习多态、封装、方法、属性、超类和继承。需要学习的内容很多，现在就开始吧。

1、对象魔法

​ 在面向对象编程中，术语对象大致意味着一系列数据（属性）以及一套访问和操作这些数据的方法。使用对象而非全局变量和函数的原因有多个，下面列出了使用对象的最重要的好处。

• 多态：可对不同类型的对象执行相同的操作，而这些操作就像“被施了魔法”一样能够正常运行。
• 封装：对外部隐藏有关对象工作原理的细节。
• 继承：可基于通用类创建出专用类。

1.1 多态

​ 术语多态（polymorphism）源自希腊语，意思是“有多种形态”。这大致意味着即便你不知道变量指向的是哪种对象，也能够对其执行操作，且操作的行为将随对象所属的类型（类）而异。例如，假设你要为一个销售食品的电子商务网站创建在线支付系统，程序将接收来自系统另一部分（或之后设计的类似系统）的购物车。因此你只需计算总价并从信用卡扣除费用即可。你首先想到的可能是，指定程序收到商品时必须如何表示。例如，你可能要求用元组表示收到的商品，如下所示：

('SPAM', 2.50)

​ 如果你只需要描述性标签和价格，这样的表示很好，但不太灵活。假设该网站新增了拍卖服务，即不断降低商品的价格，直到有人购买为止。在这种情况下，如果能够允许用户像下面这样做就好了：将商品放入购物车并进入结算页面（你所开发系统的一部分），等到价格合适时再单击“支付”按钮。然而，使用简单的元组表示商品无法做到这一点。要做到这一点，表示商品的对象必须在你编写的代码询问价格时通过网络检查其当前价格，也就是说不能像在元组中那样固定价格。要解决这个问题，可创建一个函数。

# 不要像下面这样做：
def get_price(object):
	if isinstance(object, tuple):
		return object[1]
	else:
		return magic_network_method(object)

---

注意 这里使用isinstance来执行类型/类检查旨在说明：使用类型检查通常是馊主意，应尽可能避免。函数isinstance将在7.2.7节介绍。

---

​ 前面的代码使用函数isinstance来检查object是否是元组。如果是，就返回其第二个元素，否则调用一个神奇的网络方法。如果网络方法已就绪，问题就暂时解决了。但这种解决方案还是不太灵活。如果有位程序员很聪明，决定用十六进制的字符串表示价格，并将其存储在字典的’price’键下呢？没问题，你只需更新相应的函数。

# 不要像下面这样做：
def get_price(object):
	if isinstance(object, tuple):
		return object[1]
	elif isinstance(object, dict):
		return int(object['price'])
	else:
		return magic_network_method(object)

​ 你确定现在考虑到了所有的可能性吗？假设有人决定添加一种新字典，并在其中将价格存储在另一个键下，你该如何办呢？当然，可再次更新get_price，但这种应对之策能在多长时间内有效呢？每当有人以不同的方式实现对象时，你都需要重新实现你的模块。如果你将该模块卖给了别人，转而从事其他项目的开发，客户该如何办呢？显然，这种实现不同行为的方式既不灵活也不切实际。

​ 那么该如何做呢？让对象自己去处理这种操作。这好像没什么大不了，但仔细想想将发现，这样事情将简单得多：每种新对象都能够获取或计算其价格并返回结果，而你只需向它们询问价格即可。这正是多态（从某种程度上说还有封装）的用武之地。

1.2 多态和方法

​ 你收到一个对象，却根本不知道它是如何实现的——它可能是众多“形态”中的任何一种。你只知道可以询问其价格，但这就够了。至于询问价格的方式，你应该很熟悉。

>>> object.get_price()
2.5

​ 像这样与对象属性相关联的函数称为方法。你在本书前面见过这样的函数：字符串、列表和字典的方法。多态你其实也见过。

>>> 'abc'.count('a')
1
>>> [1, 2, 'a'].count('a')
1

​ 如果有一个变量x，你无需知道它是字符串还是列表就能调用方法count：只要你向这个方法提供一个字符作为参数，它就能正常运行。

​ 每当无需知道对象是什么样的就能对其执行操作时，都是多态在起作用。这不仅仅适用于方法，我们还通过内置运算符和函数大量使用了多态。请看下面的代码：

>>> 1 + 2
3
>>> 'Fish' + 'license'
'Fishlicense'

​ 上述代码表明，加法运算符（+）既可用于数（这里是整数），也可用于字符串（以及其他类型的序列）。很多函数和运算符都是多态的，你编写的大多数函数也可能如此，即便你不是有意为之。每当你使用多态的函数和运算符时，多态都将发挥作用。事实上，要破坏多态，唯一的办法是使用诸如type、issubclass等函数显式地执行类型检查，但你应尽可能避免以这种方式破坏多态。重要的是，对象按你希望的那样行事，而非它是否是正确的类型（类）。

---

注意 这里讨论的多态形式是Python编程方式的核心，有时称为鸭子类型。这个术语源自如下说法：“如果走起来像鸭子，叫起来像鸭子，那么它就是鸭子。”有关鸭子类型的详细信息，请参阅http://en.wikipedia.org/wiki/Duck_typing。

---

1.3 封装

​ 封装（encapsulation）指的是向外部隐藏不必要的细节。这听起来有点像多态（无需知道对象的内部细节就可使用它）。这两个概念很像，因为它们都是抽象的原则。它们都像函数一样，可帮助你处理程序的组成部分，让你无需关心不必要的细节。

​ 但封装不同于多态。多态让你无需知道对象所属的类（对象的类型）就能调用其方法，而封装让你无需知道对象的构造就能使用它。听起来还是有点像？下面来看一个使用了多态但没有使用封装的示例。假设你有一个名为OpenObject的类（如何创建类将在本章后面介绍）。

>>> o = OpenObject() # 对象就是这样创建的
>>> o.set_name('Sir Lancelot')
>>> o.get_name()
'Sir Lancelot'

​ 你（通过像调用函数一样调用类）创建一个对象，并将其关联到变量o，然后就可以使用方法set_name和get_name了（假设OpenObject支持这些方法）。一切都看起来完美无缺。然而，如果o将其名称存储在全局变量global_name中呢？

>>> global_name
'Sir Lancelot'

​ 这意味着使用OpenObject类的实例（对象）时，你需要考虑global_name的内容。事实上，必须确保无人能修改它。

>>> global_name = 'Sir Gumby'
>>> o.get_name()
'Sir Gumby'

​ 如果尝试创建多个OpenObject对象，将出现问题，因为它们共用同一个变量。

>>> o1 = OpenObject()
>>> o2 = OpenObject()
>>> o1.set_name('Robin Hood')
>>> o2.get_name()
'Robin Hood'

​ 如你所见，设置一个对象的名称时，将自动设置另一个对象的名称。这可不是你想要的结果。基本上，你希望对象是抽象的：当调用方法时，无需操心其他的事情，如避免干扰全局变量。如何将名称“封装”在对象中呢？没问题，将其作为一个属性即可。

​ 属性是归属于对象的变量，就像方法一样。实际上，方法差不多就是与函数相关联的属性（7.2.3节将介绍方法和函数之间的一个重要差别）。如果你使用属性而非全局变量重新编写前面的类，并将其重命名为ClosedObject，就可像下面这样使用它：

>>> c = ClosedObject()
>>> c.set_name('Sir Lancelot')
>>> c.get_name()
'Sir Lancelot'

​ 到目前为止一切顺利，但这并不能证明名称不是存储在全局变量中的。下面再来创建一个对象。

>>> r = ClosedObject()
>>> r.set_name('Sir Robin')
r.get_name()
'Sir Robin'

​ 从中可知正确地设置了新对象的名称（这可能在你的意料之中），但第一个对象现在怎么样了呢？

>>> c.get_name()
'Sir Lancelot'

​ 其名称还在！因为这个对象有自己的状态。对象的状态由其属性（如名称）描述。对象的方法可能修改这些属性，因此对象将一系列函数（方法）组合起来，并赋予它们访问一些变量（属性）的权限，而属性可用于在两次函数调用之间存储值。7.2.4节将更详细地讨论Python的封装机制。

1.4 继承

​ 继承是另一种偷懒的方式（这里是褒义）。程序员总是想避免多次输入同样的代码。本书前面通过创建函数来达成这个目标，但现在要解决一个更微妙的问题。如果你已经有了一个类，并要创建一个与之很像的类（可能只是新增了几个方法），该如何办呢？创建这个新类时，你不想复制旧类的代码，将其粘贴到新类中。

​ 例如，你可能已经有了一个名为Shape的类，它知道如何将自己绘制到屏幕上。现在你想创建一个名为Rectangle的类，但它不仅知道如何将自己绘制到屏幕上，而且还知道如何计算其面积。你不想重新编写方法draw，因为Shape已经有一个这样的方法，且效果很好。那么该如何办呢？让Rectangle继承Shape的方法，使得对Rectangle对象调用方法draw时，将自动调用Shape类的这个方法（参见7.2.6节）。

2、类

2.1 类到底是什么

​ 本书前面反复提到了类，并将其用作类型的同义词。从很多方面来说，这正是类的定义——一种对象。每个对象都属于特定的类，并被称为该类的实例。

​ 例如，如果你在窗外看到一只鸟，这只鸟就是“鸟类”的一个实例。鸟类是一个非常通用（抽象）的类，它有多个子类：你看到的那只鸟可能属于子类“云雀”。你可将“鸟类”视为由所有鸟组成的集合，而“云雀”是其一个子集。一个类的对象为另一个类的对象的子集时，前者就是后者的子类。因此“云雀”为“鸟类”的子类，而“鸟类”为“云雀”的超类。

---

注意 在英语日常交谈中，使用复数来表示类，如birds（鸟类）和larks（云雀）。在Python中，约定使用单数并将首字母大写，如Bird和Lark。

---

​ 通过这样的陈述，子类和超类就很容易理解。但在面向对象编程中，子类关系意味深长，因为类是由其支持的方法定义的。类的所有实例都有该类的所有方法，因此子类的所有实例都有超类的所有方法。有鉴于此，要定义子类，只需定义多出来的方法（还可能重写一些既有的方法）。
​ 例如，Bird类可能提供方法fly，而Penguin类（Bird的一个子类）可能新增方法eat_fish。创建Penguin类时，你还可能想重写超类的方法，即方法fly。鉴于企鹅不能飞，因此在Penguin的实例中，方法fly应什么都不做或引发异常（参见第8章）。

2.2 创建自定义类

__metaclass__ = type # 如果你使用的是Python 2，请包含这行代码
class Person:
	def set_name(self, name):
		self.name = name
	def get_name(self):
		return self.name
	def greet(self):
		print("Hello, world! I'm {}.".format(self.name))

​ 这个示例包含三个方法定义，它们类似于函数定义，但位于class语句内。Person当然是类的名称。class语句创建独立的命名空间，用于在其中定义函数（参见7.2.5节）。一切看起来都挺好，但你可能想知道参数self是什么。它指向对象本身。那么是哪个对象呢？下面通过创建两个实例来说明这一点。

>>> foo = Person()
>>> bar = Person()
>>> foo.set_name('Luke Skywalker')
>>> bar.set_name('Anakin Skywalker')
>>> foo.greet()
Hello, world! I'm Luke Skywalker.
>>> bar.greet()
Hello, world! I'm Anakin Skywalker.

​ 这个示例可能有点简单，但澄清了self是什么。对foo调用set_name和greet时，foo都会作为第一个参数自动传递给它们。我将这个参数命名为self，这非常贴切。实际上，可以随便给这个参数命名，但鉴于它总是指向对象本身，因此习惯上将其命名为self。显然，self很有用，甚至必不可少。如果没有它，所有的方法都无法访问对象本身——要操作的属性所属的对象。与以前一样，也可以从外部访问这些属性。

>>> foo.name
'Luke Skywalker'
>>> bar.name = 'Yoda'
>>> bar.greet()
Hello, world! I'm Yoda.

---

提示 如果foo是一个Person实例，可将foo.greet()视为Person.greet(foo)的简写，但后者的多态性更低。

---

2.3 属性、函数和方法

​ 实际上，方法和函数的区别表现在前一节提到的参数self上。方法（更准确地说是关联的方法）将其第一个参数关联到它所属的实例，因此无需提供这个参数。无疑可以将属性关联到一个普通函数，但这样就没有特殊的self参数了。

>>> class Class:
... def method(self):
... print('I have a self!')
...
>>> def function():
... print("I don't...")
...
>>> instance = Class()
>>> instance.method() I have a self!
>>> instance.method = function
>>> instance.method() I don't...

​ 请注意，有没有参数self并不取决于是否以刚才使用的方式（如instance.method）调用方法。实际上，完全可以让另一个变量指向同一个方法。

>>> class Bird:
... song = 'Squaawk!'
... def sing(self):
... print(self.song)
...
>>> bird = Bird()
>>> bird.sing()
Squaawk!
>>> birdsong = bird.sing
>>> birdsong()
Squaawk!

​ 虽然最后一个方法调用看起来很像函数调用，但变量birdsong指向的是关联的方法bird.sing，这意味着它也能够访问参数self（即它也被关联到类的实例）。

2.4 再谈隐藏

​ 默认情况下，可从外部访问对象的属性。再来看一下前面讨论封装时使用的示例。

>>> c.name
'Sir Lancelot'
>>> c.name = 'Sir Gumby'
>>> c.get_name()
'Sir Gumby'

​ 有些程序员认为这没问题，但有些程序员（如Smalltalk之父）认为这违反了封装原则。他们认为应该对外部完全隐藏对象的状态（即不能从外部访问它们）。你可能会问，为何他们的立场如此极端？由每个对象管理自己的属性还不够吗？为何要向外部隐藏属性？毕竟，如果能直接访问ClosedObject（对象c所属的类）的属性name，就不需要创建方法setName和getName了。关键是其他程序员可能不知道（也不应知道）对象内部发生的情况。例如，ClosedObject可能在对象修改其名称时向管理员发送电子邮件。这种功能可能包含在方法set_name中。但如果直接设置c.name，结果将如何呢？什么都不会发生——根本不会发送电子邮件。为避免这类问题，可将属性定义为私有。私有属性不能从对象外部访问，而只能通过存取器方法（如get_name和set_name）来访问。

---

注意 第9章将介绍特性（property），这是一种功能强大的存取器替代品。

---

​ Python没有为私有属性提供直接的支持，而是要求程序员知道在什么情况下从外部修改属性是安全的。毕竟，你必须在知道如何使用对象之后才能使用它。然而，通过玩点小花招，可获得类似于私有属性的效果。要让方法或属性成为私有的（不能从外部访问），只需让其名称以两个下划线打头即可。

class Secretive:
	def __inaccessible(self):
		print("Bet you can't see me ...")
	def accessible(self):
		print("The secret message is:")
		self.__inaccessible()

​ 现在从外部不能访问__inaccessible，但在类中（如accessible中）依然可以使用它。

>>> s = Secretive()
>>> s.__inaccessible()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: Secretive instance has no attribute '__inaccessible'
>>> s.accessible()
The secret message is:
Bet you can't see me ...

​ 虽然以两个下划线打头有点怪异，但这样的方法类似于其他语言中的标准私有方法。然而，幕后的处理手法并不标准：在类定义中，对所有以两个下划线打头的名称都进行转换，即在开头加上一个下划线和类名。

>>> Secretive._Secretive__inaccessible
<unbound method Secretive.__inaccessible>

​ 只要知道这种幕后处理手法，就能从类外访问私有方法，然而不应这样做。

>>> s._Secretive__inaccessible()
Bet you can't see me ...

​ 总之，你无法禁止别人访问对象的私有方法和属性，但这种名称修改方式发出了强烈的信号，让他们不要这样做。如果你不希望名称被修改，又想发出不要从外部修改属性或方法的信号，可用一个下划线打头。这虽然只是一种约定，但也有些作用。例如，from module import *不会导入以一个下划线打头的名称。

2.5 类的命名空间

​ 下面两条语句大致等价：

def foo(x): return x * x
foo = lambda x: x * x

​ 它们都创建一个返回参数平方的函数，并将这个函数关联到变量foo。可以在全局（模块）作用域内定义名称foo，也可以在函数或方法内定义。定义类时情况亦如此：在class语句中定义的代码都是在一个特殊的命名空间（类的命名空间）内执行的，而类的所有成员都可访问这个命名空间。类定义其实就是要执行的代码段，并非所有的Python程序员都知道这一点，但知道这一点很有帮助。例如，在类定义中，并非只能包含def语句。

class MemberCounter:
	members = 0
	def init(self):
		MemberCounter.members += 1
>>> m1 = MemberCounter()
>>> m1.init()
>>> MemberCounter.members
1
>>> m2 = MemberCounter()
>>> m2.init()
>>> MemberCounter.members
2

​ 上述代码在类作用域内定义了一个变量，所有的成员（实例）都可访问它，这里使用它来计算类实例的数量。注意到这里使用了init来初始化所有实例，第9章将把这个初始化过程自动化，也就是将init转换为合适的构造函数。每个实例都可访问这个类作用域内的变量，就像方法一样。

>>> m1.members
2
>>> m2.members
2

​ 如果你在一个实例中给属性members赋值，结果将如何呢？

>>> m1.members = 'Two'
>>> m1.members
'Two'
>>> m2.members
2

​ 新值被写入m1的一个属性中，这个属性遮住了类级变量。这类似于第6章的旁注“遮盖的问题”所讨论的，函数中局部变量和全局变量之间的关系。

2.6 指定超类

​ 本章前面讨论过，子类扩展了超类的定义。要指定超类，可在class语句中的类名后加上超类名，并将其用圆括号括起。

class Filter:
	def init(self):
		self.blocked = []
	def filter(self, sequence):
		return [x for x in sequence if x not in self.blocked]
class SPAMFilter(Filter): # SPAMFilter是Filter的子类
	def init(self): # 重写超类Filter的方法init
		self.blocked = ['SPAM']

​ Filter是一个过滤序列的通用类。实际上，它不会过滤掉任何东西。

>>> f = Filter()
>>> f.init()
>>> f.filter([1, 2, 3])
[1, 2, 3]

​ Filter类的用途在于可用作其他类（如将’SPAM’从序列中过滤掉的SPAMFilter类）的基类（超类）。

>>> s = SPAMFilter()
>>> s.init()
>>> s.filter(['SPAM', 'SPAM', 'SPAM', 'SPAM', 'eggs', 'bacon', 'SPAM'])
['eggs', 'bacon']

​ 请注意SPAMFilter类的定义中有两个要点。

• 以提供新定义的方式重写了Filter类中方法init的定义。
• 直接从Filter类继承了方法filter的定义，因此无需重新编写其定义。

​ 第二点说明了继承很有用的原因：可以创建大量不同的过滤器类，它们都从Filter类派生而来，并且都使用已编写好的方法filter。这就是懒惰的好处。

2.7 深入探讨继承

​ 要确定一个类是否是另一个类的子类，可使用内置方法issubclass。

>>> issubclass(SPAMFilter, Filter)
True
>>> issubclass(Filter, SPAMFilter)
False

​ 如果你有一个类，并想知道它的基类，可访问其特殊属性__ bases__。

>>> SPAMFilter.__bases__
(<class __main__.Filter at 0x171e40>,)
>>> Filter.__bases__
(<class 'object'>,)

​ 同样，要确定对象是否是特定类的实例，可使用isinstance。

>>> s = SPAMFilter()
>>> isinstance(s, SPAMFilter)
True
>>> isinstance(s, Filter)
True
>>> isinstance(s, str)
False

---

注意 使用isinstance通常不是良好的做法，依赖多态在任何情况下都是更好的选择。一个重要的例外情况是使用抽象基类和模块abc时。

---

​ 如你所见，s是SPAMFilter类的（直接）实例，但它也是Filter类的间接实例，因为SPAMFilter是Filter的子类。换而言之，所有SPAMFilter对象都是Filter对象。从前一个示例可知，isinstance也可用于类型，如字符串类型（str）。如果你要获悉对象属于哪个类，可使用属性__ class__。

>>> s.__class__
<class __main__.SPAMFilter at 0x1707c0>

---

注意 对于新式类（无论是通过使用__ metaclass__ = type还是通过从object继承创建的）的实例，还可使用type(s)来获悉其所属的类。对于所有旧式类的实例，type都只是返回instance。

---

2.8 多个超类

​ 在前一节，你肯定注意到了一个有点奇怪的细节：复数形式的__ bases__。前面说过，你可使用它来获悉类的基类，而基类可能有多个。为说明如何继承多个类，下面来创建几个类。

class Calculator:
	def calculate(self, expression):
		self.value = eval(expression)
class Talker:
	def talk(self):
		print('Hi, my value is', self.value)
class TalkingCalculator(Calculator, Talker):
	pass

​ 子类TalkingCalculator本身无所作为，其所有的行为都是从超类那里继承的。关键是通过从Calculator那里继承calculate，并从Talker那里继承talk，它成了会说话的计算器。

>>> tc = TalkingCalculator()
>>> tc.calculate('1 + 2 * 3')
>>> tc.talk()
Hi, my value is 7

​ 这被称为多重继承，是一个功能强大的工具。然而，除非万不得已，否则应避免使用多重继承，因为在有些情况下，它可能带来意外的“并发症”。

​ 使用多重继承时，有一点务必注意：如果多个超类以不同的方式实现了同一个方法（即有多个同名方法），必须在class语句中小心排列这些超类，因为位于前面的类的方法将覆盖位于后面的类的方法。因此，在前面的示例中，如果Calculator类包含方法talk，那么这个方法将覆盖Talker类的方法talk（导致它不可访问）。如果像下面这样反转超类的排列顺序：

class TalkingCalculator(Talker, Calculator): pass

​ 将导致Talker的方法talk是可以访问的。多个超类的超类相同时，查找特定方法或属性时访问超类的顺序称为方法解析顺序（MRO），它使用的算法非常复杂。所幸其效果很好，你可能根本无需担心。

2.9 接口和内省

​ 接口这一概念与多态相关。处理多态对象时，你只关心其接口（协议）——对外暴露的方法和属性。在Python中，不显式地指定对象必须包含哪些方法才能用作参数。例如，你不会像在Java中那样显式编写接口，而是假定对象能够完成你要求它完成的任务。如果不能完成，程序将失败。

​ 通常，你要求对象遵循特定的接口（即实现特定的方法），但如果需要，也可非常灵活地提出要求：不是直接调用方法并期待一切顺利，而是检查所需的方法是否存在；如果不存在，就改弦易辙。

>>> hasattr(tc, 'talk')
True
>>> hasattr(tc, 'fnord')
False

​ 在上述代码中，你发现tc（本章前面介绍的TalkingCalculator类的实例）包含属性talk（指向一个方法），但没有属性fnord。如果你愿意，还可以检查属性talk是否是可调用的。

>>> callable(getattr(tc, 'talk', None))
True
>>> callable(getattr(tc, 'fnord', None))
False

​ 请注意，这里没有在if语句中使用hasattr并直接访问属性，而是使用了getattr（它让我能够指定属性不存在时使用的默认值，这里为None），然后对返回的对象调用callable。

---

注意 setattr与getattr功能相反，可用于设置对象的属性：

>>> setattr(tc, 'name', 'Mr. Gumby')
>>> tc.name
'Mr. Gumby'

---

​ 要查看对象中存储的所有值，可检查其__ dict__属性。如果要确定对象是由什么组成的，应研究模块inspect。这个模块主要供高级用户创建对象浏览器（让用户能够以图形方式浏览Python对象的程序）以及其他需要这种功能的类似程序。有关对象和模块的详细信息，请参阅10.2节。

2.10 抽象基类

​ 然而，有比手工检查各个方法更好的选择。在历史上的大部分时间内，Python几乎都只依赖于鸭子类型，即假设所有对象都能完成其工作，同时偶尔使用hasattr来检查所需的方法是否存在。很多其他语言（如Java和Go）都采用显式指定接口的理念，而有些第三方模块提供了这种理念的各种实现。最终，Python通过引入模块abc提供了官方解决方案。这个模块为所谓的抽象基类提供了支持。一般而言，抽象类是不能（至少是不应该）实例化的类，其职责是定义子类应实现的一组抽象方法。下面是一个简单的示例：

from abc import ABC, abstractmethod
class Talker(ABC):
	@abstractmethod
	def talk(self):
		pass

​ 形如@this的东西被称为装饰器，其用法将在第9章详细介绍。这里的要点是你使用@abstractmethod来将方法标记为抽象的——在子类中必须实现的方法。

---

注意 如果你使用的是较旧的Python版本，将无法在模块abc中找到ABC类。在这种情况下，需要导入ABCMeta，并在类定义开头包含代码行__ metaclass__ = ABCMeta（紧跟在class语句后面并缩进）。如果你使用的是3.4之前的Python 3版本，也可使用Talker(metaclass=ABCMeta)代替Talker(ABC)。

---

​ 抽象类（即包含抽象方法的类）最重要的特征是不能实例化。

>>> Talker()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Talker with abstract methods talk

​ 假设像下面这样从它派生出一个子类：

class Knigget(Talker):
	pass

​ 由于没有重写方法talk，因此这个类也是抽象的，不能实例化。如果你试图这样做，将出现类似于前面的错误消息。然而，你可重新编写这个类，使其实现要求的方法。

class Knigget(Talker):
	def talk(self):
		print("Ni!")

​ 现在实例化它没有任何问题。这是抽象基类的主要用途，而且只有在这种情形下使用isinstance才是妥当的：如果先检查给定的实例确实是Talker对象，就能相信这个实例在需要的情况下有方法talk。

>>> k = Knigget()
>>> isinstance(k, Talker)
True
>>> k.talk()
Ni!

​ 然而，还缺少一个重要的部分——让isinstance的多态程度更高的部分。正如你看到的，抽象基类让我们能够本着鸭子类型的精神使用这种实例检查！我们不关心对象是什么，只关心对象能做什么（它实现了哪些方法）。因此，只要实现了方法talk，即便不是Talker的子类，依然能够通过类型检查。下面来创建另一个类。

class Herring:
	def talk(self):
		print("Blub.")

​ 这个类的实例能够通过是否为Talker对象的检查，可它并不是Talker对象。

>>> h = Herring()
>>> isinstance(h, Talker)
False

​ 诚然，你可从Talker派生出Herring，这样就万事大吉了，但Herring可能是从他人的模块中导入的。在这种情况下，就无法采取这样的做法。为解决这个问题，你可将Herring注册为Talker（而不从Herring和Talker派生出子类），这样所有的Herring对象都将被视为Talker对象。

>>> Talker.register(Herring)
<class '__main__.Herring'>
>>> isinstance(h, Talker)
True
>>> issubclass(Herring, Talker)
True

​ 然而，这种做法存在一个缺点，就是直接从抽象类派生提供的保障没有了。

>>> class Clam:
... pass
...
>>> Talker.register(Clam)
<class '__main__.Clam'>
>>> issubclass(Clam, Talker)
True
>>> c = Clam()
>>> isinstance(c, Talker)
True
>>> c.talk()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Clam' object has no attribute 'talk'

​ 换而言之，应将isinstance返回True视为一种意图表达。在这里，Clam有成为Talker的意图。本着鸭子类型的精神，我们相信它能承担Talker的职责，但可悲的是它失败了。

​ 标准库（如模块collections.abc）提供了多个很有用的抽象类，有关模块abc的详细信息，请参阅标准库参考手册。

3、关于面向对象设计的一些思考

​ 专门探讨面向对象程序设计的图书很多，虽然这并非本书的重点，但还是要提供一些指南。

• 将相关的东西放在一起。如果一个函数操作一个全局变量，最好将它们作为一个类的属性和方法。
• 不要让对象之间过于亲密。方法应只关心其所属实例的属性，对于其他实例的状态，让它们自己去管理就好了。
• 慎用继承，尤其是多重继承。继承有时很有用，但在有些情况下可能带来不必要的复杂性。要正确地使用多重继承很难，要排除其中的bug更难。
• 保持简单。让方法短小紧凑。一般而言，应确保大多数方法都能在30秒内读完并理解。对于其余的方法，尽可能将其篇幅控制在一页或一屏内。

​ 确定需要哪些类以及这些类应包含哪些方法时，尝试像下面这样做。

(1) 将有关问题的描述（程序需要做什么）记录下来，并给所有的名词、动词和形容词加上标记。

(2) 在名词中找出可能的类。

(3) 在动词中找出可能的方法。

(4) 在形容词中找出可能的属性。

(5) 将找出的方法和属性分配给各个类。

​ 有了面向对象模型的草图后，还需考虑类和对象之间的关系（如继承或协作）以及它们的职责。为进一步改进模型，可像下面这样做。

(1) 记录（或设想）一系列用例，即使用程序的场景，并尽力确保这些用例涵盖了所有的功能。

(2) 透彻而仔细地考虑每个场景，确保模型包含了所需的一切。如果有遗漏，就加上；如果有不太对的地方，就修改。不断地重复这个过程，直到对模型满意为止。

​ 有了你认为行之有效的模型后，就可以着手编写程序了。你很可能需要修改模型或程序的某些部分，所幸这在Python中很容易，请不用担心。只管按这里说的去做就好。（如果你需要更详细的面向对象编程指南，请参阅第19章的推荐书目。）

4、小结

​ 本章不仅介绍了有关Python语言的知识，还介绍了多个你可能一点都不熟悉的概念。下面来总结一下。

• 对象：对象由属性和方法组成。属性不过是属于对象的变量，而方法是存储在属性中的函数。相比于其他函数，（关联的）方法有一个不同之处，那就是它总是将其所属的对象作为第一个参数，而这个参数通常被命名为self。
• 类：类表示一组（或一类）对象，而每个对象都属于特定的类。类的主要任务是定义其实例将包含的方法。
• 多态：多态指的是能够同样地对待不同类型和类的对象，即无需知道对象属于哪个类就可调用其方法。
• 封装：对象可能隐藏（封装）其内部状态。在有些语言中，这意味着对象的状态（属性）只能通过其方法来访问。在Python中，所有的属性都是公有的，但直接访问对象的状态时程序员应谨慎行事，因为这可能在不经意间导致状态不一致。
• 继承：一个类可以是一个或多个类的子类，在这种情况下，子类将继承超类的所有方法。你可指定多个超类，通过这样做可组合正交（独立且不相关）的功能。为此，一种常见的做法是使用一个核心超类以及一个或多个混合超类。
• 接口和内省：一般而言，你无需过于深入地研究对象，而只依赖于多态来调用所需的方法。然而，如果要确定对象包含哪些方法或属性，有一些函数可供你用来完成这种工作。
• 抽象基类：使用模块abc可创建抽象基类。抽象基类用于指定子类必须提供哪些功能，却不实现这些功能。
• 面向对象设计：关于该如何进行面向对象设计以及是否该采用面向对象设计，有很多不同的观点。无论你持什么样的观点，都必须深入理解问题，进而创建出易于理解的设计。

本章介绍的新函数

函 数	描 述
callable(object)	判断对象是否是可调用的（如是否是函数或方法）
getattr(object,name[,default])	获取属性的值，还可提供默认值
hasattr(object, name)	确定对象是否有指定的属性
isinstance(object, class)	确定对象是否是指定类的实例
issubclass(A, B)	确定A是否是B的子类
random.choice(sequence)	从一个非空序列中随机地选择一个元素
setattr(object, name, value)	将对象的指定属性设置为指定的值
type(object)	返回对象的类型