2021-03-04-Python学习笔记之8-面向对象进阶

一、面向对象三大特征介绍
Python是面向对象的语言，也支持面向对象编程的三大特性：继承、封装(隐藏)、多态。

• 封装(隐藏)
  隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。
• 继承
  继承可以让子类具有父类的特性，提高了代码的重用性。从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。
• 多态
  多态是指同一个方法调用由于对象不同会产生不同的行为。

二、继承
1.已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。
2.Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：

class 子类类名(父类1，父类2，...)：
		类体

3.如果在类定义中没有指定父类，则默认父类是object类。也就是说，object是所有类的父类，里面定义了一些所有类共有的默认实现，比如：new()。
4.定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：

父类名.__init__(self, 参数列表)

代码示例：

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

    def say_age(self):
        print('年龄，年龄，我也不知道')

class Student(Person):
    def __init__(self,name,age,score):
        # 子类必须显示的调用父类初始化方法，不然解释器不会去调用
        Person.__init__(self,name,age)
        self.score = score

print(Student.mro())    # 获得“类的层次结构”
s = Student('张三',18,60)
s.say_age()
print(s.name)
# print(s.age)    # 子类不能直接访问父类私有的方法和属性
print(dir(s))       # 列出s所有的方法
print(s._Person__age)   # 子类访问父类的私有属性

输出：

[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
年龄，年龄，我也不知道
张三
['_Person__age', '__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__', 'name', 'say_age', 'score']
18

三、类成员的继承和重写

1. 成员继承：子类继承了父类除构造方法之外的所有成员。（包括私有方法私有属性）
2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”。

代码示例：

# 测试方法的重写
class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def say_age(self):
        print('我的年龄：',self.__age)

    def say_name(self):
        print('我的名字是：{0}'.format(self.name))

class Student(Person):
    def __init__(self,name,age,score):
        # 子类必须显示的调用父类初始化方法，不然解释器不会去调用
        Person.__init__(self,name,age)
        self.score = score

    # 重写父类方法
    def say_name(self):
        print('报告老师，我的名字是：{0}'.format(self.name))

s = Student('张三',18,60)
s.say_age()
s.say_name()

输出：

我的年龄： 18
报告老师，我的名字是：张三

四、查看类的继承层次结构

• 通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

代码示例：

class A: pass
class B(A): pass
class C(B): pass

print(C.mro())

输出：

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

五、object根类

• object类是所有类的父类，因此所有的类都有object类的属性和方法。
• dir()查看对象所有属性
  代码示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name, "的年龄是：", self.age)


obj = object()
print(dir(obj))

s2 = Person("张三", 18)
print(dir(s2))

输出：

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
['__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__', 'age', 'name', 'say_age']

上面代码示例说明：Person包含了object类的所有属性。

六、重写__str__()方法

• object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息。str()可以重写。
  代码示例1：

# 重写__str__()方法
class Person:
    def __init__(self,name):
        self.name = name

p = Person('张三')
print(p)

输出：

<__main__.Person object at 0x0000027AA9FAE280>

代码示例2：

# 重写__str__()方法
class Person:
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return '名字是：{0}'.format(self.name)

p = Person('张三')
print(p)

输出：

名字是：张三

七、多重继承

• Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。
  代码示例：

class A:
    def aa(self):
        print('aa')

class B:
    def bb(self):
        print('bb')

class C(B,A):
    def cc(self):
        print('cc')
c = C()
c.cc()
c.bb()
c.aa()

输出：

cc
bb
aa

八、MRO()

• Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。
• MRO(Method Resolution Order)：方法解析顺序。 我们可以通过mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

代码示例：

class A:
    def aa(self):
        print('aa')
    def say(self):
        print('say AAA!')
class B:
    def bb(self):
        print('bb')
    def say(self):
        print('say BBB!')
class C(A,B):
    def cc(self):
        print('cc')

c = C()
print(C.mro())
c.say()

输出：

[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
say AAA!

九、super()获得父类定义

• 要获得父类的方法时，我们可以通过super()来做。
• super()代表父类的定义，不是父类对象。
  代码示例：

class A:
    def say(self):
        print('A:',self)
        print('say AAA')
class B(A):
    def say(self):
        A.say(self) # 调用父类的say方法
        super().say() # 通过super()调用父类的方法
        print('say BBB')
b = B()
b.say()

输出：

A: <__main__.B object at 0x0000028CC2582FA0>
say AAA
A: <__main__.B object at 0x0000028CC2582FA0>
say AAA
say BBB

十、多态

• 多态(polymorphism)是指同一个方法调用由于对象不同可能会产生不同的行为。
• 关于多态要注意以下2点：
  • 多态是方法的多态，属性没有多态。
  • 多态的存在有2个必要条件：继承、方法重写。

代码示例：

class Man:
    def eat(self):
        print('饿了，吃饭啦！')
class Chinese(Man):
    def eat(self):
        print('中国人用筷子吃饭')
class English(Man):
    def eat(self):
        print('英国人用叉子吃饭')
class Indian(Man):
    def eat(self):
        print('印度人用右手吃饭')

def manEat(m):
    if isinstance(m,Man):
        m.eat()     # 多态，一个方法调用，根据传进来的对象不同调用不同的方法！
    else:
        print('不能吃饭')

manEat(Chinese())
manEat(English())
manEat(Indian())
manEat(1)

输出：

中国人用筷子吃饭
英国人用叉子吃饭
印度人用右手吃饭
不能吃饭

十一、特殊方法和运算符重载

• Python的运算符实际上是通过调用对象的特殊方法实现的。比如：

a = 20
b = 30
c = a+b
d = a.__add__(b)    # 本质
print("c=",c)
print("d=",d)

输出：

c= 50
d= 50

• 每个运算符实际上都对应了相应的方法，统计如下：
  
• 常见的特殊方法统计如下：
  
  代码示例：

# 运算符的重载
class Person:
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        if isinstance(other,Person):
            return '{0}--{1}'.format(self.name,other.name)
        else:
            return '不是同类对象，不能相加'
    def __mul__(self, other):
        if isinstance(other,int):
            return self.name*other
        else:
            return '不是同类对象，不能相加'

p1 = Person('张三')
p2 = Person('李四')
x = p1 + p2     # 相当于 p1.add(p2)，调用了__add__(self, other)
print(x)
print(p1*5)     # 调用了 __mul__(self, other)

输出：

张三--李四
张三张三张三张三张三

十二、特殊属性

• Python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这里我们列出常见的特殊属性：
  
  代码示例：

# 测试特殊属性
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name):
        self.name = name

    def cc(self):
        print('cc')

c = C('张三')
print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())

输出：

['__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__', 'cc', 'name']
{'name': '张三'}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
[<class '__main__.C'>]

十三、对象的浅拷贝和深拷贝

• 变量的赋值操作
  只是形成两个变量，实际还是指向同一个对象。
• 浅拷贝
  Python拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
• 深拷贝
  使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。

代码示例：

import copy
class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def caculate(self):
        print('算你个12345')
        print('cpu对象：',self)
class Screen:
    def show(self):
        print('显示画面')
        print('screen对象：', self)

# 测试变量赋值
print('测试变量赋值')
c1 = CPU()
c2 = c1     # 变量赋值，实际还是指向同一个对象
print(c1)
print(c2)

# 测试浅复制
print('测试浅复制...')
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)  # 浅复制
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

# 深复制
print('测试深复制...')
m3 = copy.deepcopy(m1)     # 深复制
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

输出：

测试变量赋值
<__main__.CPU object at 0x00000196CC636FD0>
<__main__.CPU object at 0x00000196CC636FD0>
测试浅复制...
<__main__.MobilePhone object at 0x00000196CC636F70> <__main__.CPU object at 0x00000196CC636FD0> <__main__.Screen object at 0x00000196CC636FA0>
<__main__.MobilePhone object at 0x00000196CC636C70> <__main__.CPU object at 0x00000196CC636FD0> <__main__.Screen object at 0x00000196CC636FA0>
测试深复制...
<__main__.MobilePhone object at 0x00000196CC636F70> <__main__.CPU object at 0x00000196CC636FD0> <__main__.Screen object at 0x00000196CC636FA0>
<__main__.MobilePhone object at 0x00000196CC636610> <__main__.CPU object at 0x00000196CC64EF40> <__main__.Screen object at 0x00000196CC64EF70>

十四、组合

• “is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
• “has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有CPU。 MobilePhone has a CPU。
• 都可以起到代码复用的作用

代码示例1：

# 测试组合
# 继承实现代码复用
print('继承...')
class A1:
    def say_a1(self):
        print('a1 a1 a1')
class B1(A1):   # 继承
    pass
b1 = B1()
b1.say_a1()

# 组合实现代码复用
print('组合...')
class A2:
    def say_a2(self):
        print('a2 a2 a2')
class B2:
    def __init__(self,a):
        self.a = a
a2 = A2()
b2 = B2(a2)     # 组合
b2.a.say_a2()

输出：

继承...
a1 a1 a1
组合...
a2 a2 a2

代码示例2：

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def calculate(self):
        print('算你个12345')
        print('cpu对象：',self)
class Screen:
    def show(self):
        print('显示画面')
        print('screen对象：', self)

m = MobilePhone(CPU(),Screen())
m.cpu.calculate()
m.screen.show()

输出：

算你个12345
cpu对象： <__main__.CPU object at 0x0000022EF7212FD0>
显示画面
screen对象： <__main__.Screen object at 0x0000022EF7212FA0>

十五、设计模式_工厂模式实现

• 工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
  代码示例：

# 测试工厂模式
# 定义工厂类
class CarFactory:
    def create_car(self,bread):
        if bread == '奔驰':
            return Benz()
        elif bread == '宝马':
            return BMV()
        elif bread == '比亚迪':
            return BYD()
        else:
            print('未知品牌，无法创建！')
class Benz:
    pass
class BMV:
    pass
class BYD:
    pass

factory = CarFactory()
c1 = factory.create_car('奔驰')
c2 = factory.create_car('比亚迪')
print(c1)
print(c2)

输出：

<__main__.Benz object at 0x000001F1A8A22FA0>
<__main__.BYD object at 0x000001F1A8A22F70>

十六、设计模式_单例模式实现（这个需要多练习）

• 单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
• 单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
• 单例模式有多种实现的方式，这里推荐重写__new__()的方法。

代码示例1：

# 测试单例模式
# 通常需要重写new方法和构造方法，将创建好的单例用属性保存起来
class MySingleton:
    __obj = None
    __init_flag = True
    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:   # 完成创建单例对象
            cls.__obj = object.__new__(cls)
        return cls.__obj
    def __init__(self,name):
        if MySingleton.__init_flag == True:     # 确保单例对象只初始化一次
            print('init...')
            self.name = name
            MySingleton.__init_flag = False
a = MySingleton('aa')
b = MySingleton('bb')
print(a)
print(b)
c = MySingleton('cc')
print(c)

输出：

init...
<__main__.MySingleton object at 0x000001CC180A6FA0>
<__main__.MySingleton object at 0x000001CC180A6FA0>
<__main__.MySingleton object at 0x000001CC180A6FA0>

代码示例2：

# 测试工厂模式和单例模式的复合使用
class CarFactory:
    __obj = None
    __init_flag = True
    def create_car(self,bread):
        if bread == '奔驰':
            return Benz()
        elif bread == '宝马':
            return BMV()
        elif bread == '比亚迪':
            return BYD()
        else:
            print('未知品牌，无法创建！')


    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:  # 完成创建单例对象
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self):
        if CarFactory.__init_flag == True:  # 确保单例对象只初始化一次
            print('init CarFactory...')
            CarFactory.__init_flag = False
class Benz:
    pass
class BMV:
    pass
class BYD:
    pass

factory = CarFactory()
c1 = factory.create_car('奔驰')
c2 = factory.create_car('比亚迪')
print(c1)
print(c2)
factory2 = CarFactory()
print(factory)
print(factory2)

输出：

init CarFactory...
<__main__.Benz object at 0x00000222D23667F0>
<__main__.BYD object at 0x00000222D23667C0>
<__main__.CarFactory object at 0x00000222D2366880>
<__main__.CarFactory object at 0x00000222D2366880>