十三、类特性
不光是 Python，大多数面向对象编程语言（诸如 C++、Java 等）都具备 3 个典型特征，即封装、继承和多态。
13.1 类的封装
本节重点讲解 Python 类的封装特性，继承和多态会在后续章节给大家做详细讲解。
简单的理解封装（Encapsulation），即在设计类时，刻意地将一些属性和方法隐藏在类的内部，这样在使用此类时，将无法直接以“类对象.属性名”（或者“类对象.方法名(参数)”）的形式调用这些属性（或方法），而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。
就好比使用电脑，我们只需要学会如何使用键盘和鼠标就可以了，不用关心内部是怎么实现的，因为那是生产和设计人员该操心的。
注意，封装绝不是将类中所有的方法都隐藏起来，一定要留一些像键盘、鼠标这样可供外界使用的类方法。
那么，类为什么要进行封装，这样做有什么好处呢？
首先，封装机制保证了类内部数据结构的完整性，因为使用类的用户无法直接看到类中的数据结构，只能使用类允许公开的数据，很好地避免了外部对内部数据的影响，提高了程序的可维护性。
除此之外，对一个类实现良好的封装，用户只能借助暴露出来的类方法来访问数据，我们只需要在这些暴露的方法中加入适当的控制逻辑，即可轻松实现用户对类中属性或方法的不合理操作。
并且，对类进行良好的封装，还可以提高代码的复用性。
- Python 类如何进行封装？
和其它面向对象的编程语言（如 C++、Java）不同，Python 类中的变量和函数，不是公有的（类似 public 属性），就是私有的（类似 private），这 2 种属性的区别如下：
- public：公有属性的类变量和类函数，在类的外部、类内部以及子类（后续讲继承特性时会做详细介绍）中，都可以正常访问；
- private：私有属性的类变量和类函数，只能在本类内部使用，类的外部以及子类都无法使用。
但是，Python 并没有提供 public、private 这些修饰符。为了实现类的封装，Python 采取了下面的方法：
默认情况下，Python 类中的变量和方法都是公有（public）的，它们的名称前都没有下划线（_）；
如果类中的变量和函数，其名称以双下划线“__”开头，则该变量（函数）为私有变量（私有函数），其属性等同于 private。
除此之外，还可以定义以单下划线“_”开头的类属性或者类方法（例如 name、display(self)），这种类属性和类方法通常被视为私有属性和私有方法，虽然它们也能通过类对象正常访问，但这是一种约定俗称的用法，初学者一定要遵守。
注意，Python 类中还有以双下划线开头和结尾的类方法（例如类的构造函数__init(self)），这些都是 Python 内部定义的，用于 Python 内部调用。我们自己定义类属性或者类方法时，不要使用这种格式。
例如，如下程序示范了 Python 的封装机制：
class CLanguage :
def setname(self, name):
if len(name) < 3:
raise ValueError('名称长度必须大于3！')
self.__name = name
def getname(self):
return self.__name
#为 name 配置 setter 和 getter 方法
name = property(getname, setname)
def setadd(self, add):
if add.startswith("http://"):
self.__add = add
else:
raise ValueError('地址必须以 http:// 开头')
def getadd(self):
return self.__add
#为 add 配置 setter 和 getter 方法
add = property(getadd, setadd)
#定义个私有方法
def __display(self):
print(self.__name,self.__add)
clang = CLanguage()
clang.name = "python学习"
print(clang.name)
print(clang.add)
程序运行结果为：
python学习上面程序中，CLanguage 将 name 和 add 属性都隐藏了起来，但同时也提供了可操作它们的“窗口”，也就是各自的 setter 和 getter 方法，这些方法都是公有（public）的。
不仅如此，以 add 属性的 setadd() 方法为例，通过在该方法内部添加控制逻辑，即通过调用 startswith() 方法，控制用户输入的地址必须以“http://”开头，否则程序将会执行 raise 语句抛出 ValueError 异常。
有关 raise 的具体用法，后续章节会做详细的讲解，这里可简单理解成，如果用户输入不规范，程序将会报错。
通过此程序的运行逻辑不难看出，通过对 CLanguage 类进行良好的封装，使得用户仅能通过暴露的 setter() 和 getter() 方法操作 name 和 add 属性，而通过对 setname() 和 setadd() 方法进行适当的设计，可以避免用户对类中属性的不合理操作，从而提高了类的可维护性和安全性。
细心的读者可能还发现，CLanguage 类中还有一个 __display() 方法，由于该类方法为私有（private）方法，且该类没有提供操作该私有方法的“窗口”，因此我们无法在类的外部使用它。换句话说，如下调用 __display() 方法是不可行的：
#尝试调用私有的 display() 方法
clang.__display()
这会导致如下错误：
Traceback (most recent call last):
File "D:\python3.6\1.py", line 33, in <module>
clang.__display()
AttributeError: 'CLanguage' object has no attribute '__display'那么，类似 __display() 这样的类方法，就没有办法调用了吗？
其实并非如此，只是当我们使用双下划线开头创建私有属性或者方法时，Python解释器会在内部将此变量进行了变形，示例如下：
>>> class MyClass:
... _x=1
... __y=2
... def __z(self):
... print("这是一个私有方法")
...
>>> m=MyClass()
>>> dir(m)
['_MyClass__y', '_MyClass__z', '__class__', '__delattr__', '__dict__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
'__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', '_x']
>>>我们可以看到：
_x依然是_x访问；
__y (私有变量）在对象中变成了 _MyClass__y；
__z (私有方法）在对象中变成了 _MyClass__z；
因此，如果需要访问私有属性/方法，需要带上_类名
13.2 类的继承
13.2.1 继承含义
Python 类的封装、继承、多态 3 大特性，前面章节已经详细介绍了 Python 类的封装，本节继续讲解 Python 类的继承机制。
继承机制经常用于创建和现有类功能类似的新类，又或是新类只需要在现有类基础上添加一些成员（属性和方法），但又不想直接将现有类代码复制给新类。也就是说，通过使用继承这种机制，可以轻松实现类的重复使用。
举个例子，假设现有一个 Shape 类，该类的 draw() 方法可以在屏幕上画出指定的形状，现在需要创建一个 Form 类，要求此类不但可以在屏幕上画出指定的形状，还可以计算出所画形状的面积。要创建这样的类，笨方法是将 draw() 方法直接复制到新类中，并添加计算面积的方法。实现代码如下所示：
class Shape:
def draw(self,content):
print("画",content)
class Form:
def draw(self,content):
print("画",content)
def area(self):
#....
print("此图形的面积为...")当然还有更简单的方法，就是使用类的继承机制。实现方法为：让 From 类继承 Shape 类，这样当 From 类对象调用 draw() 方法时，Python 解释器会先去 From 中找以 draw 为名的方法，如果找不到，它还会自动去 Shape 类中找。如此，我们只需在 From 类中添加计算面积的方法即可，示例代码如下：
class Shape:
def draw(self,content):
print("画",content)
class Form(Shape):
def area(self):
#....
print("此图形的面积为...")上面代码中，class From(Shape) 就表示 From 继承 Shape。
Python 中，实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。因此在上面这个样例中，From 是子类，Shape 是父类。
子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。语法格式如下：
class 类名(父类1, 父类2, ...)：
#类定义部分注意，如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）。另外，Python 的继承是多继承机制（和 C++ 一样），即一个子类可以同时拥有多个直接父类。
注意，有读者可能还听说过“派生”这个词汇，它和继承是一个意思，只是观察角度不同而已。换句话话，继承是相对子类来说的，即子类继承自父类；而派生是相对于父类来说的，即父类派生出子类。
了解了继承机制的含义和语法之后，下面代码演示了继承机制的用法：
class People:
def say(self):
print("我是一个人，名字是：",self.name)
class Animal:
def display(self):
print("人也是高级动物")
#同时继承 People 和 Animal 类
#其同时拥有 name 属性、say() 和 display() 方法
class Person(People, Animal):
pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
zhangsan.display()
运行结果，结果为：
我是一个人，名字是： 张三
人也是高级动物可以看到，虽然 Person 类为空类，但由于其继承自 People 和 Animal 这 2 个类，因此实际上 Person 并不空，它同时拥有这 2 个类所有的属性和方法。
没错，子类拥有父类所有的属性和方法，即便该属性或方法是私有（private）的。
事实上，大部分面向对象的编程语言，都只支持单继承，即子类有且只能有一个父类。而 Python 却支持多继承（C++也支持多继承）。
和单继承相比，多继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 等干脆取消了多继承。
使用多继承经常需要面临的问题是，多个父类中包含同名的类方法。对于这种情况，Python 的处置措施是：根据子类继承多个父类时这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。
举个例子：
class People:
def __init__(self):
self.name = People
def say(self):
print("People类",self.name)
class Animal:
def __init__(self):
self.name = Animal
def say(self):
print("Animal类",self.name)
#People中的 name 属性和 say() 会遮蔽 Animal 类中的
class Person(People, Animal):
pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
程序运行结果为：
People类 张三可以看到，当 Person 同时继承 People 类和 Animal 类时，People 类在前，因此如果 People 和 Animal 拥有同名的类方法，实际调用的是 People 类中的。
虽然 Python 在语法上支持多继承，但逼不得已，建议大家不要使用多继承。
13.2.2 父类方法重写
前面讲过在 Python 中，子类继承了父类，那么子类就拥有了父类所有的类属性和类方法。通常情况下，子类会在此基础上，扩展一些新的类属性和类方法。
但凡事都有例外，我们可能会遇到这样一种情况，即子类从父类继承得来的类方法中，大部分是适合子类使用的，但有个别的类方法，并不能直接照搬父类的，如果不对这部分类方法进行修改，子类对象无法使用。针对这种情况，我们就需要在子类中重复父类的方法。
举个例子，鸟通常是有翅膀的，也会飞，因此我们可以像如下这样定义个和鸟相关的类：
class Bird:
#鸟有翅膀
def isWing(self):
print("鸟有翅膀")
#鸟会飞
def fly(self):
print("鸟会飞")但是，对于鸵鸟来说，它虽然也属于鸟类，也有翅膀，但是它只会奔跑，并不会飞。针对这种情况，可以这样定义鸵鸟类：
class Ostrich(Bird):
# 重写Bird类的fly()方法
def fly(self):
print("鸵鸟不会飞")可以看到，因为 Ostrich 继承自 Bird，因此 Ostrich 类拥有 Bird 类的 isWing() 和 fly() 方法。其中，isWing() 方法同样适合 Ostrich，但 fly() 明显不适合，因此我们在 Ostrich 类中对 fly() 方法进行重写。
重写，有时又称覆盖，是一个意思，指的是对类中已有方法的内部实现进行修改。
在上面 2 段代码的基础上，添加如下代码并运行：
class Bird:
#鸟有翅膀
def isWing(self):
print("鸟有翅膀")
#鸟会飞
def fly(self):
print("鸟会飞")
class Ostrich(Bird):
# 重写Bird类的fly()方法
def fly(self):
print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Ostrich 类中重写的 fly() 类方法
ostrich.fly()
运行结果为：
鸵鸟不会飞显然，ostrich 调用的是重写之后的 fly() 类方法。
事实上，如果我们在子类中重写了从父类继承来的类方法，那么当在类的外部通过子类对象调用该方法时，Python 总是会执行子类中重写的方法。
这就产生一个新的问题，即如果想调用父类中被重写的这个方法，该怎么办呢？
很简单，前面讲过，Python 中的类可以看做是一个独立空间，而类方法其实就是出于该空间中的一个函数。而如果想要全局空间中，调用类空间中的函数，只需要在调用该函数时备注类名即可。举个例子：
class Bird:
#鸟有翅膀
def isWing(self):
print("鸟有翅膀")
#鸟会飞
def fly(self):
print("鸟会飞")
class Ostrich(Bird):
# 重写Bird类的fly()方法
def fly(self):
print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Bird 类中的 fly() 方法
Bird.fly(ostrich)
程序运行结果为：
鸟会飞此程序中，需要大家注意的一点是，使用类名调用其类方法，Python 不会为该方法的第一个 self 参数自定绑定值，因此采用这种调用方法，需要手动为 self 参数赋值。
通过类名调用实例方法的这种方式，又被称为未绑定方法。
13.2.3 父类构造方法调用super（）
前面不止一次讲过，Python 中子类会继承父类所有的类属性和类方法。严格来说，类的构造方法其实就是实例方法，因此毫无疑问，父类的构造方法，子类同样会继承。
但我们知道，Python 是一门支持多继承的面向对象编程语言，如果子类继承的多个父类中包含同名的类实例方法，则子类对象在调用该方法时，会优先选择排在最前面的父类中的实例方法。显然，构造方法也是如此。
举个例子：
class People:
def __init__(self,name):
self.name = name
def say(self):
print("我是人，名字为：",self.name)
class Animal:
def __init__(self,food):
self.food = food
def display(self):
print("我是动物,我吃",self.food)
#People中的 name 属性和 say() 会遮蔽 Animal 类中的
class Person(People, Animal):
pass
per = Person("zhangsan")
per.say()
#per.display()
运行结果，结果为：
我是人，名字为： zhangsan上面程序中，Person 类同时继承 People 和 Animal，其中 People 在前。这意味着，在创建 per 对象时，其将会调用从 People 继承来的构造函数。因此我们看到，上面程序在创建 per 对象的同时，还要给 name 属性进行赋值。
但如果去掉最后一行的注释，运行此行代码，Python 解释器会报如下错误：
Traceback (most recent call last):
File "D:\python3.6\Demo.py", line 18, in <module>
per.display()
File "D:\python3.6\Demo.py", line 11, in display
print("我是动物,我吃",self.food)
AttributeError: 'Person' object has no attribute 'food'这是因为，从 Animal 类中继承的 display() 方法中，需要用到 food 属性的值，但由于 People 类的构造方法“遮蔽”了Animal 类的构造方法，使得在创建 per 对象时，Animal 类的构造方法未得到执行，所以程序出错。
反过来也是如此，如果将第 13 行代码改为如下形式：
class Person(Animal, People)则在创建 per 对象时，会给 food 属性传值。这意味着，per.display() 能顺序执行，但 per.say() 将会报错。
针对这种情况，正确的做法是定义 Person 类自己的构造方法（等同于重写第一个直接父类的构造方法）。但需要注意，如果在子类中定义构造方法，则必须在该方法中调用父类的构造方法。
在子类中的构造方法中，调用父类构造方法的方式有 2 种，分别是：
- 类可以看做一个独立空间，在类的外部调用其中的实例方法，可以向调用普通函数那样，只不过需要额外备注类名（此方式又称为未绑定方法）；
- 使用 super() 函数。但如果涉及多继承，该函数只能调用第一个直接父类的构造方法。
也就是说，涉及到多继承时，在子类构造函数中，调用第一个父类构造方法的方式有以上 2 种，而调用其它父类构造方法的方式只能使用未绑定方法。
值得一提的是，Python 2.x 中，super() 函数的使用语法格式如下：
super(Class, obj).__init__(self,...)
其中，Class 值是子类的类名，obj 通常指的就是 self但在 Python 3.x 中，super() 函数有一种更简单的语法格式，推荐大家使用这种格式：
super().__init__(self,...)在掌握 super() 函数用法的基础上，我们可以尝试修改上面的程序：
class People:
def __init__(self,name):
self.name = name
def say(self):
print("我是人，名字为：",self.name)
class Animal:
def __init__(self,food):
self.food = food
def display(self):
print("我是动物,我吃",self.food)
class Person(People, Animal):
#自定义构造方法
def __init__(self,name,food):
#调用 People 类的构造方法
super().__init__(name)
#super(Person,self).__init__(name) #执行效果和上一行相同
#People.__init__(self,name)#使用未绑定方法调用 People 类构造方法
#调用其它父类的构造方法，需手动给 self 传值
Animal.__init__(self,food)
per = Person("zhangsan","熟食")
per.say()
per.display()
运行结果为：
我是人，名字为： zhangsan
我是动物,我吃 熟食可以看到，Person 类自定义的构造方法中，调用 People 类构造方法，可以使用 super() 函数，也可以使用未绑定方法。但是调用 Animal 类的构造方法，只能使用未绑定方法。
13.2.4 限制类实例动态添加属性和方法__slots__属性
通过学习《Python类变量和实例变量》一节，了解了如何动态的为单个实例对象添加属性，甚至如果必要的话，还可以为所有的类实例对象统一添加属性（通过给类添加属性）。
那么，Python 是否也允许动态地为类或实例对象添加方法呢？答案是肯定的。我们知道，类方法又可细分为实例方法、静态方法和类方法，Python 语言允许为类动态地添加这 3 种方法；但对于实例对象，则只允许动态地添加实例方法，不能添加类方法和静态方法。
为单个实例对象添加方法，不会影响该类的其它实例对象；而如果为类动态地添加方法，则所有的实例对象都可以使用。
举个例子：
class CLanguage:
pass
#下面定义了一个实例方法
def info(self):
print("正在调用实例方法")
#下面定义了一个类方法
@classmethod
def info2(cls):
print("正在调用类方法")
#下面定义个静态方法
@staticmethod
def info3():
print("正在调用静态方法")
#类可以动态添加以上 3 种方法，会影响所有实例对象
CLanguage.info = info
CLanguage.info2 = info2
CLanguage.info3 = info3
clang = CLanguage()
#如今，clang 具有以上 3 种方法
clang.info()
clang.info2()
clang.info3()
#类实例对象只能动态添加实例方法，不会影响其它实例对象
clang1 = CLanguage()
clang1.info = info
#必须手动为 self 传值
clang1.info(clang1)
程序输出结果为：
正在调用实例方法
正在调用类方法
正在调用静态方法
正在调用实例方法显然，动态给类或者实例对象添加属性或方法，是非常灵活的。但与此同时，如果胡乱地使用，也会给程序带来一定的隐患，即程序中已经定义好的类，如果不做任何限制，是可以做动态的修改的。
庆幸的是，Python 提供了 slots 属性，通过它可以避免用户频繁的给实例对象动态地添加属性或方法。
再次声明，slots 只能限制为实例对象动态添加属性和方法，而无法限制动态地为类添加属性和方法。
slots 属性值其实就是一个元组，只有其中指定的元素，才可以作为动态添加的属性或者方法的名称。举个例子：
class CLanguage:
__slots__ = ('name','add','info')可以看到， CLanguage 类中指定了 slots 属性，这意味着，该类的实例对象仅限于动态添加 name、add、info 这 3 个属性以及 name()、add() 和 info() 这 3 个方法。
注意，对于动态添加的方法，slots 限制的是其方法名，并不限制参数的个数。
比如，在 CLanguage 类的基础上，添加如下代码并运行：
def info(self,name):
print("正在调用实例方法",self.name)
clang = CLanguage()
clang.name = "python学习"
#为 clang 对象动态添加 info 实例方法
clang.info = info
clang.info(clang,"Python教程")
程序运行结果为：
正在调用实例方法 python学习还是在 CLanguage 类的基础上，添加如下代码并运行：
def info(self,name):
print("正在调用实例方法",self.name)
clang = CLanguage()
clang.name = "python学习"
clang.say = info
clang.say(clang,"Python教程")
运行程序，显示如下信息：
Traceback (most recent call last):
File "D:\python3.6\1.py", line 9, in <module>
clang.say = info
AttributeError: 'CLanguage' object has no attribute 'say'显然，根据 slots 属性的设置，CLanguage 类的实例对象是不能动态添加以 say 为名称的方法的。
另外本节前面提到，slots 属性限制的对象是类的实例对象，而不是类，因此下面的代码是合法的：
def info(self):
print("正在调用实例方法")
CLanguage.say = info
clang = CLanguage()
clang.say()
程序运行结果为：
正在调用实例方法当然，还可以为类动态添加类方法和静态方法，这里不再给出具体实例，读者可自行编写代码尝试。
此外，slots 属性对由该类派生出来的子类，也是不起作用的。例如如下代码：
class CLanguage:
__slots__ = ('name','add','info')
#Clanguage 的空子类
class CLangs(CLanguage):
pass
#定义的实例方法
def info(self):
print("正在调用实例方法")
clang = CLangs()
#为子类对象动态添加 say() 方法
clang.say = info
clang.say(clang)
运行结果为：
正在调用实例方法显然，slots 属性只对当前所在的类起限制作用。
因此，如果子类也要限制外界为其实例对象动态地添加属性和方法，必须在子类中设置 slots 属性。
注意，如果为子类也设置有 slots 属性，那么子类实例对象允许动态添加的属性和方法，是子类中 slots 属性和父类 slots 属性的和。
13.3 类的多态
在面向对象程序设计中，除了封装和继承特性外，多态也是一个非常重要的特性，本节就带领大家详细了解什么是多态。
我们都知道，Python 是弱类型语言，其最明显的特征是在使用变量时，无需为其指定具体的数据类型。这会导致一种情况，即同一变量可能会被先后赋值不同的类对象，例如：
class CLanguage:
def say(self):
print("赋值的是 CLanguage 类的实例对象")
class CPython:
def say(self):
print("赋值的是 CPython 类的实例对象")
a = CLanguage()
a.say()
a = CPython()
a.say()
运行结果为：
赋值的是 CLanguage 类的实例对象
赋值的是 CPython 类的实例对象可以看到，a 可以被先后赋值为 CLanguage 类和 CPython 类的对象，但这并不是多态。类的多态特性，还要满足以下 2 个前提条件：
继承：多态一定是发生在子类和父类之间；
重写：子类重写了父类的方法。
下面程序是对上面代码的改写：
class CLanguage:
def say(self):
print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
def say(self):
print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
def say(self):
print("调用的是 CLinux 类的say方法")
a = CLanguage()
a.say()
a = CPython()
a.say()
a = CLinux()
a.say()
程序执行结果为：
调用的是 Clanguage 类的say方法
调用的是 CPython 类的say方法
调用的是 CLinux 类的say方法可以看到，CPython 和 CLinux 都继承自 CLanguage 类，且各自都重写了父类的 say() 方法。从运行结果可以看出，同一变量 a 在执行同一个 say() 方法时，由于 a 实际表示不同的类实例对象，因此 a.say() 调用的并不是同一个类中的 say() 方法，这就是多态。
但是，仅仅学到这里，读者还无法领略 Python 类使用多态特性的精髓。其实，Python 在多态的基础上，衍生出了一种更灵活的编程机制。
继续对上面的程序进行改写：
class WhoSay:
def say(self,who):
who.say()
class CLanguage:
def say(self):
print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
def say(self):
print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
def say(self):
print("调用的是 CLinux 类的say方法")
a = WhoSay()
#调用 CLanguage 类的 say() 方法
a.say(CLanguage())
#调用 CPython 类的 say() 方法
a.say(CPython())
#调用 CLinux 类的 say() 方法
a.say(CLinux())
程序执行结果为：
调用的是 Clanguage 类的say方法
调用的是 CPython 类的say方法
调用的是 CLinux 类的say方法此程序中，通过给 WhoSay 类中的 say() 函数添加一个 who 参数，其内部利用传入的 who 调用 say() 方法。这意味着，当调用 WhoSay 类中的 say() 方法时，我们传给 who 参数的是哪个类的实例对象，它就会调用那个类中的 say() 方法。
在其它教程中，Python 这种由多态衍生出的更灵活的编程机制，又称为“鸭子模型”或“鸭子类型”。
