面向对象有三个特征：封装、继承、多态。
封装：将一些列功能和属性集合在对象中，以实现代码复用和功能的解耦。
继承：每个类都可以有父类，父类中定义了常用的方法，子类可以对这些方法进行扩展，并可以定义自己的方法。
多态：子类都可以对父类的方法进行覆写，同样继承于父类的方法，不同的子类可以有不同的表现形式，这就是多态。
定义类
使用 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__)
执行结果如下：
(, , , )
私有属性和私有方法
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 属性，这是因为这两个实例是独立的。
实例的属性和方法从哪里来呢？一般认为是在新建实例对象的时候，实例对象向类对象索取一份方法的拷贝，每个实例内部都保存有自身的方法和属性，因此实例之间调用方法时不会相互影响。
让每个实例对象内部保存一份类对象中方法的拷贝，确实是很直接的一种方式，但这会增加内存空间的消耗，比如我们做一个打飞机的游戏，我们会一直新建敌机，那就会一直拷贝类对象中的属性和方法，增加内存的消耗。
事实上，实例对象在调用方法时，并不是调用自身内存空间中的方法，新建实例时也不会有方法的拷贝，而是去调用类对象中的方法。实例对象怎么找到其对应的类对象呢？我们可以认为在新建实例对象时，其内部保存了一份类对象的引用，在调用方法时，通过这个引用找到类对象，并调用类对象中的方法。同时，将实例对象的一份引用传递给类对象中的方法，在方法中通过改实例对象的引用对实例对象进行一些操作。
示意图如下：
现在知道为什么实例对象的方法至少需要一个实例的引用参数，以及在继承中可以通过
父类类名.父类中的方法( 实例引用 ) 调用父类对象中的方法的原因了吧。
__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__方法的作用，以及基于该方法实现单例模式
完。