python类和对象

面向对象编程（Object-oriented Programming，简称OOP），是一种封装代码的方法。

面向对象中，常用术语包括：

Python中使用类的顺序是：先创建（定义）类，然后再创建类的实例对象，通过实例对象实现特定的功能。

Python中，创建一个类使用**class关键字**实现，其基本语法格式如下：

从上面定义来看，Python的类定义有点像函数定义，都是以**冒号（:）**作为类体的开始，以统一缩进的部分作为类体的。区别只是函数定义使用def关键字，而类定义则使用 class关键字。

在创建类时，我们可以手动添加一个 __init__()方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）。构造方法用于创建对象时使用，每当创建一个类的实例对象时，Python 解释器都会自动调用它。

此方法的方法名中，开头和结尾各有2个下划线，且中间不能有空格。

__init__()方法可以包含多个参数，但必须包含一个名为self的参数，且必须作为第一个参数。也就是说，类的构造方法最少也要有一个self参数。

创建类对象的过程又称为类的实例化。

对已创建的类进行实例化，其语法格式如下：

当创建类时，若没有显式创建__init()__构造方法或者该构造方法中只有一个self参数，则创建类对象时的参数可以省略不写

创建对象之后，接下来即可使用该对象了。Python的对象大致有以下作用：

格式如下：

对象名和变量名以及方法名之间用点"."连接。

Python支持为已创建好的对象动态增加实例变量，方法也很简单，只要为它的新变量赋值即可。

Python也允许为对象动态增加方法。比如上面程序中在定义Person类时只定义了一个say()方法，但程序完全可以为 p 对象动态增加方法。

但需要说明的是，为p对象动态增加的方法，Python不会自动将调用者自动绑定到第一个参数（即使将第一个参数命名为self也没用）。例如如下代码：

上面的第 5 行和第 11 行代码分别使用函数、lambda表达式为 p 对象动态增加了方法，但对于动态增加的方法，Python不会自动将方法调用者绑定到它们的第一个参数，因此程序必须手动为第一个参数传入参数值，如上面程序中①号、②号代码所示。

同一个类可以产生多个对象，当某个对象调用类方法时，该对象会把自身的引用作为第一个参数自动传给该方法，换句话说，Python会自动绑定类方法的第一个参数指向调用该方法的对象。如此，Python解释器就能知道到底要操作哪个对象的方法了。

对于构造方法来说，self参数（第一个参数）代表该构造方法正在初始化的对象。

上面代码中，jump()和run() 中的self代表该方法的调用者，即谁在调用该方法，那么 self就代表谁，因此，该程序的运行结果为：

当Python对象的一个方法调用另一个方法时，不可以省略self。

在InConstructor的构造方法中，self参数总是引用该构造方法正在初始化的对象。程序中将正在执行初始化的InConstructor对象的foo实例变量设为 6，这意味着该构造方法返回的所有对象的foo实例变量都等于 6。

类变量指的是定义在类中，但在各个类方法外的变量。类变量的特点是：所有类的实例化对象都可以共享类变量的值，即类变量可以在所有实例化对象中作为公用资源。

注意，类变量推荐直接用类名访问，但也可以使用对象名访问。

在 Python 中，除了可以通过类名访问类属性之外，还可以动态地为类和对象添加类变量。例如，在上面代码的基础，添加以下代码：

实例变量指的是定义在类的方法中的属性，它的特点是：只作用于调用方法的对象。

注意，实例变量只能通过对象名访问，无法通过类名直接访问。

和类属性可细分为类属性和实例属性一样，类中的方法也可以有更细致的划分，具体可分为类方法、实例方法和静态方法。

通常情况下，在类中定义的方法默认都是实例方法。

Python类方法和实例方法相似，它最少也要包含一个参数，只不过，**类方法中通常将其命名为cls，且Python会自动将类本身绑定给cls参数（而不是类对象）。**因此，在调用类方法时，无需显式为cls参数传参。

除此之外，和实例方法最大的不同在于，类方法需要使用＠classmethod进行修饰，例如：

注意，如果没有＠classmethod，则Python解释器会将fly()方法认定为实例方法，而不是类方法。

类方法推荐使用类名直接调用，当然也可以使用实例对象来调用（不推荐），例如：

静态方法，其实就是我们学过的函数，和函数唯一的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局命名空间）中。

静态方法没有类似self、cls这样的特殊参数，因此Python解释器不会对它包含的参数做任何类或对象的绑定，也正是因为如此，此方法中无法调用任何类和对象的属性和方法，静态方法其实和类的关系不大。

静态方法需要使用＠staticmethod修饰，例如：

在使用Python编程时，一般不需要使用类方法或静态方法，程序完全可以使用函数来代替类方法或静态方法。但是在特殊的场景（比如使用工厂模式）下，类方法或静态方法也是不错的选择。

使用类调用实例方法，那么该方法的第一个参数（self）怎么自动绑定呢？

运行上面代码，程序会报出如下错误：

如果程序依然希望使用类来调用实例方法，则必须手动为方法的第一个参数传入参数值。例如，将上面的最后一行代码改为如下形式：

此代码显式地为walk()方法的第一个参数绑定了参数值，这样的调用效果完全等同于执行u.walk()。

Python中，通过使用描述符，可以让程序员在引用一个对象属性时自定义要完成的工作。

本质上看，描述符就是一个类，只不过它定义了另一个类中属性的访问方式。换句话说，一个类可以将属性管理全权委托给描述符类。

描述符类基于以下 3 个特殊方法，换句话说，这 3 个方法组成了描述符协议：

其中，实现了setter和 getter方法的描述符类被称为数据描述符；反之，如果只实现了getter方法，则称为非数据描述符。

实际上，在每次查找属性时，描述符协议中的方法都由类对象的特殊方法 __getattribute__()调用（注意不要和__getattr__()弄混）。也就是说，每次使用类对象.属性（或者getattr(类对象，属性值)）的调用方式时，都会隐式地调用 __getattribute__()，它会按照下列顺序查找该属性：

运行结果为：

从这个例子可以看到，如果一个类的某个属性有数据描述符，那么每次查找这个属性时，都会调用描述符的__get__()方法，并返回它的值；同样，每次在对该属性赋值时，也会调用__set__()方法。 注意，虽然上面例子中没有使用__del__()方法，但也很容易理解，当每次使用del类对象.属性（或者delattr(类对象，属性)）语句时，都会调用该方法。

在不破坏类封装原则的基础上，为了能够有效操作类中的属性，类中应包含读（或写）类属性的多个getter（或setter）方法，这样就可以通过“类对象.方法(参数)”的方式操作属性，例如：

Python中提供了**property()函数**，可以实现在不破坏类封装原则的前提下，让开发者依旧使用“类对象.属性”的方式操作类中的属性。

property()函数的基本使用格式如下：

其中，fget参数用于指定获取该属性值的类方法；fset参数用于指定设置该属性值的方法；fdel参数用于指定删除该属性值的方法；最后的doc是一个文档字符串，用于提供说明此函数的作用。

开发者调用property()函数时，可以传入 0 个（既不能读，也不能写的属性）、1 个（只读属性）、2 个（读写属性）、3 个（读写属性，也可删除）和 4 个（读写属性，也可删除，包含文档说明）参数。

例如，对前面的Rectangle类做适当的修改，使用property()函数定义一个size属性：

程序中，使用property()函数定义了一个size属性，在定义该属性时一共传入了 4 个参数，这意味着该属性可读、可写、可删除，也有说明文档。所以，该程序尝试对Rectangle对象的size属性进行读、写、删除操作，其实这种读、写、删除操作分别被委托给getsize()、setsize()和delsize()方法来实现。

Python还提供了@property装饰器。通过@property装饰器，可以直接通过方法名来访问方法，不需要在方法名后添加一对“（）”小括号。

@property的语法格式如下：

例如，定义一个矩形类，并定义用 @property 修饰的方法操作类中的 area 私有属性，代码如下：

上面程序中，使用＠property修饰了area()方法，这样就使得该方法变成了area属性的getter方法。需要注意的是，如果类中只包含该方法，那么area属性将是一个只读属性。也就是说，在使用Rect类时，无法对area属性重新赋值，即运行如下代码会报错：

要想实现修改area属性的值，还需要为area属性添加setter方法，就需要用到setter装饰器，它的语法格式如下：

例如，为Rect类中的area方法添加setter方法，代码如下：

还可以使用deleter装饰器来删除指定属性，其语法格式为：

例如，在Rect类中，给area()方法添加deleter方法，实现代码如下：

封装（Encapsulation）是面向对象的三大特征之一（另外两个是继承和多态），它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

封装机制保证了类内部数据结构的完整性，因为使用类的用户无法直接看到类中的数据结构，只能使用类允许公开的数据，很好地避免了外部对内部数据的影响，提高了程序的可维护性。

为了实现良好的封装，需要从以下两个方面来考虑：

因此，实际上封装有两个方面的含义：把该隐藏的隐藏起来，把该暴露的暴露出来。

python中，只要将 Python 类的成员命名为以双下画线开头的，Python 就会把它们隐藏起来。

上面程序将User的两个实例变量分别命名为**__name和__age，这两个实例变量就会被隐藏起来，这样程序就无法直接访问__name、__age**变量，只能通过setname()、getname()、setage()、getage()这些访问器方法进行访问，而setname()、setage()会对用户设置的 name、age进行控制，只有符合条件的name、age才允许设置。

Python其实没有真正的隐藏机制，双下画线只是Python的一个小技巧，Python 会“偷偷”地改变以双下画线开头的方法名，会在这些方法名前添加单下画线和类名。因此上面的__hide()方法其实可以按如下方式调用（通常并不推荐这么干）：

继承是面向对象的三大特征之一，也是实现代码复用的重要手段。继承经常用于创建和现有类功能类似的新类，又或是新类只需要在现有类基础上添加一些成员（属性和方法），但又不想直接将现有类代码复制给新类。

Python 中，实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。子类继承父类的语法是：在定义子类时，将多个父类放在子类之后的圆括号里。语法格式如下：

注意，Python 的继承是多继承机制，即一个子类可以同时拥有多个直接父类。

方法解析顺序（Method Resolution Order），简称**MRO**。对于只支持单继承的编程语言来说，MRO很简单，就是从当前类开始，逐个搜索它的父类；而对于Python，它支持多继承，MRO相对会复杂一些。

Python发展至今，经历了以下 3 种MRO算法，分别是：

此程序中的 4 个类是一个“菱形”继承的关系，当使用 D 类对象访问method()方法时，根据深度优先算法，搜索顺序为 D->B->A->C->A。

因此，使用旧式类的MRO算法最先搜索得到的是基类 A 中的method()方法，即在Python 2.x版本中，此程序的运行结果为：

但是，这个结果显然不是想要的，我们希望搜索到的是 C 类中的method()方法。

Python 2.2版本推出了新的计算新式类MRO的方法，它仍然采用从左至右的深度优先遍历，但是如果遍历中出现重复的类，只保留最后一个。

仍以上面程序为例，通过深度优先遍历，其搜索顺序为 D->B->A->C->A，由于此顺序中有 2 个 A，因此仅保留后一个，简化后得到最终的搜索顺序为 D->B->C->A。

这种MRO方式已经能够解决“菱形”继承的问题，但是可能会违反单调性原则。所谓单调性原则，是指在类存在多继承时，子类不能改变基类的MRO搜索顺序，否则会导致程序发生异常。

通过进行深度遍历，得到搜索顺序为 C->A->X->object->Y->object->B->Y->object->X->object，再进行简化（相同取后者），得到 C->A->B->Y->X->object。

下面来分析这样的搜索顺序是否合理，我们来看下各个类中的MRO：

可以看到，B和C中，X、Y的搜索顺序是相反的，也就是说，当B被继承时，它本身的搜索顺序发生了改变，这违反了单调性原则。

在Python 2.3及后续版本中，运行程序一，得到如下结果：

以程序一为主，C3把各个类的MRO记为如下等式：

注意，以类 A 等式为例，其中merge包含的A称为L[A]的头，剩余元素（这里仅有一个object）称为尾。

这里的关键在于merge，它的运算方式如下：

重复上述步骤，直至列表为空或者不能再找出可以输出的元素。如果是前一种情况，则算法结束；如果是后一种情况，Python会抛出异常。

由此，可以计算出类B的MRO，其计算过程为：

子类扩展了父类，子类是一种特殊的父类。大部分时候，子类总是以父类为基础，额外增加新的方法。但在一些场景中，子类需要重写父类的方法。

这种子类包含与父类同名的方法的现象被称为方法重写（Override），也被称为方法覆盖。可以说子类重写了父类的方法，也可以说子类覆盖了父类的方法。

如果在子类中调用重写之后的方法，Python总是会执行子类重写的方法，不会执行父类中被重写的方法。如果需要在子类中调用父类中被重写的实例方法，则可以通过类名调用。区别在于：在通过类名调用实例方法时，Python 不会为实例方法的第一个参数 self 自动绑定参数值，而是需要程序显式绑定第一个参数 self。这种机制被称为未绑定方法。

Python的子类也会继承得到父类的构造方法，但如果子类有多个直接父类，那么会优先选择排在最前面的父类的构造方法。例如如下代码：

上面程序中第 13 行代码定义了Manager类，该类继承了Employee和Customer两个父类。接下来程序中的Manager类将会优先使用Employee类的构造方法（因为它排在前面），所以程序使用Manager(25000）来创建Manager对象。该构造方法只会初始化 salary实例变量，因此执行上面程序中 ① 号代码是没有任何问题的。

但是当执行到 ② 号代码时就会引发错误，这是由于程序在使用Employee类的构造方法创建Manager对象时，程序并未初始化Customer对象所需的两个实例变量：favorite和address，因此程序引发错误。

为了让 Manager 能同时初始化两个父类中的实例变量，Manager 应该定义自己的构造方法，即重写父类的构造方法。Python 要求，如果子类重写了父类的构造方法，那么子类的构造方法必须调用父类的构造方法。

子类的构造方法调用父类的构造方法有两种方式：

注意，当子类继承多个父类是，super()函数只能用来调用第一个父类的构造方法，而其它父类的构造方法只能使用未绑定的方式调用。

Python 中，由于基类不会在**__init__()**中被隐式地调用，需要程序员显式调用它们。这种情况下，当程序中包含多重继承的类层次结构时，使用super是非常危险的，往往会在类的初始化过程中出现问题。

多态也是一个非常重要的特性，Python是弱类型语言，即在使用变量时，无需为其指定具体的数据类型，这就可能出现，同一个变量会赋值不同的类对象，例如：

可以看到，a 可以被先后赋值为 Bird 类和 Dog 类的对象。而在此基础上，发生多态还要满足以下 2 个前提条件：