面向对象有三个特征：封装、继承、多态。
封装：将一些列功能和属性集合在对象中，以实现代码复用和功能的解耦。
继承：每个类都可以有父类，父类中定义了常用的方法，子类可以对这些方法进行扩展，并可以定义自己的方法。
多态：子类都可以对父类的方法进行覆写，同样继承于父类的方法，不同的子类可以有不同的表现形式，这就是多态。

定义类

使用 class 关键字定义类，一般建议类名采用大驼峰式写法：

class Demo:
    pass

定义方法

定义方法和定义函数一样，都采用 def 关键字，每个方法都至少需要接受一个参数，该参数为调用当前方法的实例对象的一个引用：

class Demo:
    def __init__(self,name):
        self.name = name
    def show(self):
        print("My name is %s"%self.name)

继承

Python 中没有 extends 关键字，使用继承时直接在类名后加上括号，括号中写上需要继承的父类，支持多继承。

class Father(object):
    pass
class Mother(object):
    pass
class Son(Father,Mother):
    pass

__mro__ 属性

在调用实例方法时，首先看子类中有没有该方法，如果没有，则去看父类中有没有该方法，如果父类中也没有该方法，则去看父类的父类中有没有该方法，一直追溯到 object 类为止。
使用类的 __mro__ 属性，可以帮助我们明确方法的查找顺序：

class Father(object):
    pass
class Mother(object):
    pass
class Son(Father,Mother):
    pass
print(Son.__mro__)

执行结果如下：

(<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)

私有属性和私有方法

Python 中没有 private 关键字，要定义实例的私有属性和私有方法，只需在相应的属性名或方法名前面加上两根下划线：

class XiaoMei:
    def __init__(self,age):
        self.__age = age    

私有属性和方法只能在当前类的内部被调用，无法在类的外部或者子类中被调用，如需调用私有属性和方法，只需暴露出一个公共方法，在公共方法内部对私有属性和方法进行访问：

class XiaoMei:
    def __init__(self,age):
        self.__age = age

    def getAge(self):
        return self.__age

print(XiaoMei(18).getAge())

__del__ 方法

__del__ 方法在对象被销毁前调用，对象被销毁有两种情况：

• 程序运行结束后自动销毁对象
• 手动通过 del 关键字销毁对象

下面分别看下这几种情况：

class 领导:
    def __del__(self):
        print("SB 领导要被销毁啦！")

领导1 = 领导()
print("="*50)

运行结果为：

==================================================
SB 领导要被销毁啦！

上面是程序运行结束自动销毁对象的情况，下面看一下手动销毁对象的情况：

class 领导:
    def __del__(self):
        print("SB 领导要被销毁啦！")

领导1 = 领导()
del 领导1
print("="*50)

运行结果如下：

SB 领导要被销毁啦！
==================================================

可见，手动使用 del 关键字删除对象也会执行 __del__ 方法。

对象的引用

Python 中的一切赋值都是按引用传递的，如果一个实例有多个引用，那么 __del__ 方法将在所有的引用断开后再执行。这是因为 Python 中的垃圾回收是按照引用计数来的，当一份内存没有任何引用时，其就会被垃圾回收。

class 领导:
    def __del__(self):
        print("SB 领导要被销毁啦！")

领导1 = 领导()
领导2 = 领导1
del 领导1
print("="*50)

运行结果如下：

==================================================
SB 领导要被销毁啦！

稍微修改一下代码：

class 领导:
    def __del__(self):
        print("SB 领导要被销毁啦！")

领导1 = 领导()
领导2 = 领导1
del 领导1
del 领导2
print("="*50)

运行结果如下：

SB 领导要被销毁啦！
==================================================

__del__ 方法在 print 之前被调用，这是因为我们调用两次 del 方法后删除了对象所在内存空间的所有引用，当这片内存不再被引用时，其就会被垃圾回收了。

获取对象的引用计数

我们可以通过 sys 模块下的 getrefcount 方法来查看对象的引用计数：

import sys
class 领导:
    pass

领导1 = 领导()
领导2 = 领导1

print(sys.getrefcount(领导1))
print(sys.getrefcount(领导2))

运行结果如下：

3
3

我们知道领导类的实例有两份引用，但为什么调用 getrefcount 方法的返回值是 3 呢？这是因为我们会将实例作为参数传入 getrefcount 方法中，该参数也是实例的一份引用，我们向函数中传参传入的都是引用，所以这里的引用数量就是 3，没毛病。

子类调用父类中被覆写的方法

子类调用父类中被覆写的方法有两种方式：

• 通过父类类名调用
• 通过 super 关键字

通过父类类名调用，需要传入传入当前对象的引用 self：

class Animal(object):
    def walk(self):
        print("走走~")

class Cat(Animal):
    def walk(self):
        Animal.walk(self)
        print("跳着走走~")

Cat().walk()

通过 super 关键字调用无需传入当前对象的引用：

class Animal(object):
    def walk(self):
        print("走走~")

class Cat(Animal):
    def walk(self):
        super().walk()
        print("跳着走走~")

Cat().walk()

多态

前面说到过，多态就是对于父类的同一份方法，不同的子类有不同的实现，在执行时会产生不同的结果。

class Animal(object):
    def eat(self):
        print("我需要吃点什么……")

class Jerry(Animal):
    def eat(self):
        print("我喜欢吃奶酪")

class Tom(Animal):
    def eat(self):
        print("我喜欢吃 Jerry")

def eatSomeThing(animal):
    animal.eat()

eatSomeThing(Animal())
eatSomeThing(Jerry())
eatSomeThing(Tom())

执行结果如下：

我需要吃点什么……
我喜欢吃奶酪
我喜欢吃 Jerry

多态的本质就是继承和方法覆写。

类属性和类方法

类属性和类方法直接从属于类，而不是类的实例对象。
定义类的属性，直接在类中进行声明赋值操作即可。
定义类的方法，需要在方法上加上 @classmethod 装饰器，方法的首参数表示当前的类对象。

class Demo:
    # 定义类属性
    count = 0
    def __init__(self):
        Demo.count += 1

    # 定义类方法
    @classmethod
    def getCount(cls):
        print("已经创建了 %d 个实例"%cls.count)

Demo()
Demo()
Demo()
Demo()
Demo()
Demo.getCount()

运行结果如下：

已经创建了 5 个实例

类实例和类方法可以被类对象调用，也可以被类对象的实例对象调用。

类对象和实例对象

对象可以看作是一系列属性和方法的集合体，除了我们新建的实例对象外，类本身也可以拥有自身的属性和方法，那么这个类也可以叫做对象。我们可以把类叫做类对象，把类的实例叫做实例对象。

类对象和实例对象之间的关系

实例对象之间是相互独立的，比如，它们都有自己独特的属性，修改某一实例的属性并不会影响到其他的实例：

class Animal(object):
    def __init__(self,name):
        self.name = name
    def showName(self):
        print(self.name)

tom = Animal("Tom")
jerry = Animal("Jerry")

tom.showName()
jerry.showName()

运行结果：

Tom
Jerry

调用 tom 实例的 showName 方法并不会打印 jerry 实例的 name 属性，这是因为这两个实例是独立的。
实例的属性和方法从哪里来呢？一般认为是在新建实例对象的时候，实例对象向类对象索取一份方法的拷贝，每个实例内部都保存有自身的方法和属性，因此实例之间调用方法时不会相互影响。
让每个实例对象内部保存一份类对象中方法的拷贝，确实是很直接的一种方式，但这会增加内存空间的消耗，比如我们做一个打飞机的游戏，我们会一直新建敌机，那就会一直拷贝类对象中的属性和方法，增加内存的消耗。
事实上，实例对象在调用方法时，并不是调用自身内存空间中的方法，新建实例时也不会有方法的拷贝，而是去调用类对象中的方法。实例对象怎么找到其对应的类对象呢？我们可以认为在新建实例对象时，其内部保存了一份类对象的引用，在调用方法时，通过这个引用找到类对象，并调用类对象中的方法。同时，将实例对象的一份引用传递给类对象中的方法，在方法中通过改实例对象的引用对实例对象进行一些操作。
示意图如下：

类对象和实例对象之间的引用关系.png

__new__ 方法和单例模式

__new__ 方法用来在新建对象时调用，Python 中创建对象分为两个阶段：

• 新建对象引用（分配内存空间）
• 初始化对象

新建对象引用由 __new__ 方法完成，初始化对象由 __init__ 方法完成。__init__ 方法需要接收 __new__ 方法返回的新对象引用作为参数，否则无法完成初始化操作。__new__ 方法接收当前类对象作为参数。
看下面的代码：

class Demo(object):
    def __new__(cls):
        print("__new__")

    def __init__(self):
        print("__init__")

    def __del__(self):
        print("__del__")

Demo()

运行结果如下：

__new__

只有 __new__ 方法被调用了，其余的 __init__ 方法和 __del__ 方法并未被调用。因为我们重写了 __new__ 方法，但在该方法中并未返回新建对象的引用，创建对象的第一步都没有完成，因此不会再执行后续的方法了。

调用超类的 __new__ 方法

由于我们并不知道 __new__ 方法的实现细节，我们可以直接调用超类的 __new__ 方法：

class Demo(object):
    def __new__(cls):
        print("__new__")
        # 返回新建对象的引用
        return object.__new__(cls)

    def __init__(self):
        print("__init__")

    def __del__(self):
        print("__del__")

Demo()

执行结果如下：

__new__
__init__
__del__

可见其余的两个方法也被调用了。

__init__ 并不是构造方法

构造方法是创建并初始化对象的方法，因为 Python 中创建和初始化对象是使用两个方法完成的，因此 Python 中是没有构造方法的。

利用 __new__ 实现单例模式

单例模式就是一个实例的模式，只初始化类对象一次。可以借助 __new__ 方法来实现单例模式：

class Demo(object):
    __singleInstance = None
    def __new__(cls):
        # 判断类的单例属性是否存在
        if cls.__singleInstance:
            return cls.__singleInstance
        else:
            cls.__singleInstance = object.__new__(cls)
            return cls.__singleInstance

print(id(Demo()))
print(id(Demo()))
print(id(Demo()))

运行结果如下：

14965232
14965232
14965232

可见，这些实例对象的地址都是一样的，这就是单例模式。

更好的单例模式

上面的单例模式有个小问题，就是可以重复初始化：

class Demo(object):
    __singleInstance = None
    def __new__(cls,name):
        # 判断类的单例属性是否存在
        if cls.__singleInstance:
            return cls.__singleInstance
        else:
            cls.__singleInstance = object.__new__(cls)
            return cls.__singleInstance

    def __init__(self,name):
        self.name = name

d1 = Demo("D1")
d2 = Demo("D2")
d3 = Demo("D3")

print(d1.name,d2.name,d3.name)

运行结果如下：

D3 D3 D3

每次初始化实例的时候都会对实例的 name 属性进行覆盖，我们想要单例在创建后无法进行更改，可以在 __init__ 方法中加上一个判断：

class Demo(object):
    __singleInstance = None
    __created = False
    def __new__(cls,name):
        # 判断类的单例属性是否存在
        if cls.__singleInstance:
            return cls.__singleInstance
        else:
            cls.__singleInstance = object.__new__(cls)
            return cls.__singleInstance

    def __init__(self,name):
        if not Demo.__created:
            self.name = name
            Demo.__created = True

d1 = Demo("D1")
d2 = Demo("D2")
d3 = Demo("D3")

print(d1.name,d2.name,d3.name)

运行结果如下：

D1 D1 D1

单例对象的属性再也不会被覆盖了。

总结

本文谈到了 Python 中面向对象的一些知识，包括：

• 类的定义、继承
• 使用 __mro__ 属性查看某类的方法调用序列
• 私有属性和私有方法，以及如何访问私有属性和私有方法
• 对象的 __del__ 方法以及查看对象引用计数的 getrefcount 方法
• 子类中调用父类被覆写的方法
• 多态的实现以及其本质就是继承和方法覆写
• 类属性和类方法
• 类对象和实例对象，以及他们之间的关系
• __new__ 方法的作用，以及基于该方法实现单例模式

完。