Python编程7——面向对象编程2
6 继承
6.1 单继承
在程序中，继承描述的是事物之间的所属关系。例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承自狗，如下图所示：
示例：
import time
# 定义一个父类，如下:
class Cat(object):
# 初始化方法
# 创建完对象后会自动被调用
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("---%s在跑---"%self.name)
# 定义一个子类
class Bosi(Cat):
def setNewName(self, newName):
self.name = newName
def eat(self):
print('---%s在吃---'%self.name)
# 创建对象
bs = Bosi('印度猫')
print('bs的名字是：%s'%bs.name)
print('bs的颜色是：%s'%bs.color)
bs.eat()
bs.setNewName('波斯猫')
bs.run()
运行结果：
bs的名字是：印度猫
bs的颜色是：白色
---印度猫在吃---
---波斯猫在跑---
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法。
总结：
（1）子类在继承的时候，在定义类时，小括号()中为父类的名字，如Bosi(Cat)；
（2）父类的属性、方法，会被继承给子类。
注意：
（1）私有的属性，不能通过对象直接访问，但是可以通过方法访问；
（2）私有的方法，不能通过对象直接访问；
（3）私有的属性、方法，不会被子类继承，也不能被访问；
（4）一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用。
比如：如果把上述程序中的 .name 改为 .__name，程序会报错。
6.2 多继承
多继承，指的是子类有多个父类，并且具有它们的特征。即父类中的方法、属性，子类会继承。比如：
多继承的格式如下：
# 定义一个父类
class A:
def printA(self):
print('----A----')
# 定义一个父类
class B:
def printB(self):
print('----B----')
# 定义一个子类，继承自A、B
class C(A,B):
def printC(self):
print('----C----')
obj_C = C()
obj_C.printA()
obj_C.printB()
obj_C.printC()
运行结果：
----A----
----B----
----C----
问题：如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？
#coding=utf-8
class base(object):
def test(self):
print('----base test----')
class A(base):
def test(self):
print('----A test----')
# 定义一个父类
class B(base):
def test(self):
print('----B test----')
# 定义一个子类，继承自A、B
class C(A,B):
pass
obj_C = C()
obj_C.test()
print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序
运行结果：
----A test----
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.base'>, <class 'object'>)
重写父类方法：
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法。比如：如果把上述程序中的C类改为以下内容：
# 定义一个子类，继承自A、B
class C(A,B):
def test(self):
print('----C test----')
运行结果：
----C test----
6.3 调用父类方法
有三种方法：
#coding=utf-8
class Cat(object):
def __init__(self,name):
self.name = name
self.color = 'yellow'
class Bosi(Cat):
def __init__(self,name):
# 调用父类的__init__方法1(python2)
# Cat.__init__(self,name)
# 调用父类的__init__方法2
# super(Bosi,self).__init__(name)
# 调用父类的__init__方法3
super().__init__(name)
def getName(self):
return self.name
bosi = Bosi('xiaohu')
print(bosi.name)
print(bosi.color)
7 多态
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。
多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
Python中的鸭子类型：
鸭子类型（Duck Typing）是一种在动态类型语言中常见的编程范式。它的核心理念是基于对象的行为而非其显式类型来判断对象的类型。换句话说，如果一个对象具有某种行为，那么它就可以被视为具有该行为的类型对象。
鸭子类型的概念：
鸭子类型的名字来源于这样一个说法：“如果看起来像鸭子，叫声像鸭子，行为像鸭子，那么它就是鸭子”。在Python中，这意味着我们不关心对象的实际类型，而是关注它是否具有我们需要的方法和属性。
示例：
class F1(object):
def show(self):
print('Fshow')
class S1(F1):
def show(self):
print('Sshow')
class S2(F1):
def show(self):
print('Sshow')
def Func(obj):
print(obj.show())
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
运行结果：
Sshow
None
Sshow
None
说明：如果把上述程序中Func的定义改为如下，则不会输出None。
def Func(obj):
obj.show()
运行结果：
Sshow
Sshow
8 类属性、实例（对象）属性
类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本。对于公有的类属性，在类外可以通过类对象和实例对象访问
实例属性又名对象属性。
class People(object):
address = '山东' #公有的类属性
__postcode = 250000 # 私有的类属性
def __init__(self):
self.name = 'xiaowang' #实例属性
self.age = 20 #实例属性
p = People()
p.age =12 # 实例属性
print(p.address) #正确，运行结果：山东
print(p.__postcode) #错误，不能在类外通过实例对象访问私有的类属性
print(p.name) #正确
print(p.age) #正确，运行结果：12
print(People.address) #正确
print(People.__postcode) #错误，不能在类外通过类对象访问私有的类属性
print(People.name) #错误
print(People.age) #错误
p.address = '河南' # 通过实例(对象)去修改类属性
print(p.address) # 运行结果：河南
print(People.address) # 运行结果：山东
People.address = '河南' # 通过类去修改类属性
print(People.address) # 运行结果：河南
总结：
如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。
如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
9 类方法和静态方法
9.1 类方法
类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法。对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（也可以用其他名称的变量，但是大部分人都习惯用'cls'作为第一个参数的名字），能够通过实例对象和类对象去访问。
类方法还有一个用途就是可以对类属性进行修改：
class People(object):
country = 'China'
#类方法，用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country
@classmethod
def setCountry(cls,country):
cls.country = country
p = People()
print(p.getCountry()) # 可以用过实例对象引用，运行结果：China
print(People.getCountry()) # 可以通过类对象引用，运行结果：China
p.setCountry('Japan')
print(p.getCountry()) # 运行结果：Japan
print(People.getCountry()) # 运行结果：Japan
9.2 静态方法
通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数。
class People(object):
country = 'China'
# 静态方法，用staticmethod来进行修饰
@staticmethod
def getCountry():
return People.country
p = People()
print(p.getCountry()) # 运行结果：China
print(People.getCountry()) # 运行结果：China
9.3 __new__方法
Python 设计上将 __new__ 定义为静态方法（尽管不需要显式使用 @staticmethod 修饰器）。
__new__ 是创建实例时第一个被调用的方法，用于构造实例。
class A(object):
def __init__(self):
print("这是 init 方法")
def __new__(cls):
print("这是 new 方法")
return object.__new__(cls)
A()
运行结果：
这是 new 方法
这是 init 方法
__new__方法和__init__方法的区别：
（1）__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供；__new__ 的第一个参数是 cls（类本身），而不是实例（self）。
（2）__new__必须要有返回值，返回实例化出来的实例，这点在实现__new__时要特别注意，可以返回父类的__new__出来的实例，或者直接是object的__new__出来的实例；
（3）__init__需要依赖已存在的实例（通过 self 访问），而 __new__ 的职责是创建实例本身；
（4）__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。
总结：
我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节。
class A(object):
def __init__(self):
print("---这是 init 方法---")
print(self)
def __new__(cls):
print("---这是 new 方法---")
print(id(cls))
ret = object.__new__(cls)
print(ret)
return ret
a = A()
print('id(A) = %s'%id(A))
运行结果：
---这是 new 方法---
2168996376512
<__main__.A object at 0x000001F90490F2B0>
---这是 init 方法---
<__main__.A object at 0x000001F90490F2B0>
id(A) = 2168996376512
9.4 实例方法、类方法、静态方法的区别
从定义形式可以看出，
实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。实例方法需要依赖已存在的实例（通过 self 访问）。
类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；
静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。
class People(object):
country = 'China'
# 实例方法
def getCountry(self):
return self.country
# 类方法，用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country
# 静态方法，用staticmethod来进行修饰
@staticmethod
def getCountry():
return People.country
10 单例模式
定义：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。
比如：电脑上的回收站，整个操作系统有且只有一个，即整个系统都使用这个唯一的实例，而且回收站自行提供自己的实例。
（1）创建单例——保证只有1个对象：
# 实例化一个单例
class Singleton(object):
__instance = None
def __new__(cls, age, name):
#如果类属性__instance的值为None，
#那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
#能够知道之前已经创建过对象了，这样就保证了只有1个对象
if not cls.__instance:
cls.__instance = object.__new__(cls)
return cls.__instance
a = Singleton(18, "xiaoHu")
b = Singleton(8, "xiaoZhou")
print(a.age) #报错，'Singleton' object has no attribute 'age'
print(b.age) #报错，'Singleton' object has no attribute 'age'
print(id(a))
print(id(b))
a.age = 19 #给a指向的对象添加一个属性
print(a.age) #获取b指向的对象的age属性
print(b.age) #获取b指向的对象的age属性
b.name = 'xiaoWang'
print(a.name)
print(b.name)
运行结果：
2198662955792
2198662955792
19
19
xiaoWang
xiaoWang
（2）创建单例时，只执行1次__init__方法
# 实例化一个单例
class Singleton(object):
__instance = None
__first_init = False
def __new__(cls, age, name):
#如果类属性__instance的值为None，
#那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
#能够知道之前已经创建过对象了，这样就保证了只有1个对象
if not cls.__instance:
cls.__instance = object.__new__(cls)
return cls.__instance
def __init__(self, age, name):
if not self.__first_init:
self.age = age
self.name = name
Singleton.__first_init = True
a = Singleton(18, "xiaoHu")
b = Singleton(8, "xiaoZhou")
print(id(a))
print(id(b))
print(a.age) #获取b指向的对象的age属性
print(b.age) #获取b指向的对象的age属性
a.age = 19
print(a.age)
print(b.age)
运行结果：
1282879920448
1282879920448
18
18
19
19
参考：
Python官方文档：https://docs.python.org/3/library/
https://blog.csdn.net/swan777/article/details/89040802