Python 面向对象进阶

目录

• Python 面向对象进阶
  • 面向对象三大特征介绍
  • 继承
    • 语法格式
    • 类成员的继承和重写
    • 查看类的继承层次结构与根类属性
    • 重写__str__()方法
    • 多重继承
    • MRO()
    • super()获得父类定义
  • 多态
  • 特殊方法和运算符重载
    • 运算符重载
    • 特殊属性
  • 对象的浅拷贝和深拷贝
  • 组合
  • 设计模式_工厂模式实现
  • 设计模式_单例模式实现

Python 面向对象进阶

面向对象三大特征介绍#

Python 是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

1. 封装（隐藏）

隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。
通过前面学习的“私有属性、私有方法”的方式，实现“封装”。Python 追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。

2. 继承

继承可以让子类具有父类的特性，提高了代码的重用性。
从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

3. 多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。

继承#

继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。

如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。

语法格式#

Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：

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

如果在类定义中没有指定父类，则默认父类是 object 类。也就是说，object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如：__new__()。

定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：

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

class Person(object):

    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


s = Student("陈浩", 18, 95)

s.say_age() #调用父类方法
# 我的年纪我也不知道

print(s.name,s.score)
# 陈浩 95

print(dir(s))   # 查看子类属性
# ['_Person__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_age', 'score']

print(s._Person__age) #调用父类私有属性
# 18

类成员的继承和重写#

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

【操作】继承和重写的案例

class Person:

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

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

    def say_name(self):
        print("我是",self.name)


class Student(Person):
    
    def __init__(self,name,age,score):
        self.score = score
        Person.__init__(self,name,age) #构造函数中包含调用父类构造函数

    def say_score(self):
        print(self.name,"的分数是：",self.score)

    def say_name(self): #重写父类的方法
        print("报告老师，我是",self.name)

s1 = Student("张三",15,85)

s1.say_score()
# 张三 的分数是： 85

s1.say_name()
# 报告老师，我是 张三

s1.say_age()
# 张三 的年龄是： 15

查看类的继承层次结构与根类属性#

通过类的方法 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'>] 从左往右依次继承
 
print(dir(object))

"""
Object(根类)对象属性：

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getstate__', 
'__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', 
'__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__setattr__', '__sizeof__', '__str__', '__subclasshook__']

"""

重写__str__()方法#

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

class Preson:

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

p = Preson("chenhao")
print(p)  

# 重写前输出：<__main__.Preson object at 0x000001AABBF9EB10>

class Preson:

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

    def __str__(self):
        """将对象信息重新定义成一个新的字符串"""
        
        return "我是重写__str__方法后的输出"

p = Preson("chenhao")
print(p)
# 重写后输出： 我是重写__str__方法后的输出

多重继承#

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() # cc
c.bb() # bb
c.aa() # aa

MRO()#

Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将
“从左向右”按顺序搜索。

MRO（Method Resolution Order）：方法解析顺序。 我们可以通过 mro()方法获“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

class A():

    def say(self):
        print("AAA")

class B():

    def say(self):
        print("BBB")

class C(A, B): #父类A在前，父类B在后
    pass

c = C()
c.say() # AAA #调用的是父类 A 的方法
print(C.mro()) # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>] # 搜索顺序 C > A > B

class C(B, A): #父类B在前，父类A在后
    pass

c = C()
c.say() # BBB #调用的是父类 B 的方法
print(C.mro()) # [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>] # 搜索顺序 C > B > A

super()获得父类定义#

在子类中，如果想要获得父类的方法时，我们可以通过 super()来做。

super()代表父类的定义，不是父类对象。

class A:

    def say(self):
        print("A:",self)


class B(A):

    def say(self):
        #A.say(self)
        super().say()
        print("B:",self)

B().say() 
#A: <__main__.B object at 0x000002446688ED10>
#B: <__main__.B object at 0x000002446688ED10>

多态#

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。在现实生活中，我们有很多例子。比如：同样是调用人的休息方法，张三的休息是睡觉，李四的休息是玩游戏，高淇老师是敲代码。同样是吃饭的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

关于多态要注意以下 2 点：

1. 多态是方法的多态，属性没有多态。
2. 多态的存在有 2 个必要条件：继承、方法重写

class A():
    def some(self):
        print('我是父类')

class A1(A):
    def some(self):
        print("我是子类A1")

class A2(A):
    def some(self):
        print("我是子类A2")

class A3(A):
    def some(self):
        print("我是子类A3")


def result(m):
    if isinstance(m, A):
        m.some()            #多态，一个方法调用，根据对象不同，调用不同的方法
    else:
        print("我什么也不是")

result(A1())    # 我是子类A1
result(A2())    # 我是子类A2

特殊方法和运算符重载#

常见的特殊方法统计如下：

方法	说明	例子
__init__	构造方法	对象创建：p = Person()
__del__	析构方法	对象回收
__repr__,__str__	打印，转换	print(a)
__call__	函数调用	a()
__getattr__	点号运算	a.xxx
__setattr__	属性赋值	a.xxx = value
__getitem__	索引运算	a[key]
__setitem__	索引赋值	a[key]=valu
__len__	长度	len(a)

每个运算符实际上都对应了相应的方法，统计如下：

运算符	特殊方法	说明
运算符+	__add__	加法
运算符-	__sub__	减法
<,<=,==	__lt__, __le__，__eq__	比较运算符
>,>=,!=	__gt__, __ge__, __ne__	比较运算符
|,^,&	__or__, __xor__, __and__	或、异或、与
<<,>>	__lshift__, __rshift__	左移、右移
*,/,%,//	__mul__, __truediv__, __mod__, __floordiv__	乘、浮点除、模运算（取余）、整数除
**	__pow__	指数运算

运算符重载#

class Person:

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

    def __add__(self,m):
        if isinstance(m, Person):
            return "{0}--{1}".format(m.name,self.name)
        else:
            return "类型不同不能相加"

    def __mul__(self,n):
        if isinstance(n, int):
            return self.name * n
        else:
            return "类型不同不能相除"


p1 = Person("chenhao")
p2 = Person("Hovey")

x = p1.__add__(p2)
print(x)                # Hovey--chenhao

y = p1 + p2
print(y)                # Hovey--chenhao

z = p1 * 10
print(z)                # chenhaochenhaochenhaochenhaochenhaochenhaochenhaochenhaochenhaochenhao

c = p1.__mul__(5)
print(c)                # chenhaochenhaochenhaochenhaochenhao

特殊属性#

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

特殊方法	含义
obj.__dict__	对象的属性字典
obj.__class__	对象所属的类
class.__bases__	类的基类元组（多继承）
class.__base__	类的基类
class.__mro__	类层次结构
class.__subclasses__()	子类列表

class A:
    pass

class B:
    pass

class C(A, B):

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


c = C(1)

print(c.__dict__) # {'n': 1} 对象的属性字典

print(c.__class__) # <class '__main__.C'> 对象所属的类

print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>) 类的基类元组

print(C.__base__) # <class '__main__.A'> 类的基类  

print(C.__mro__) # (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>) 类层次结构

print(A.__subclasses__()) # [<class '__main__.C'>] 子类列表

对象的浅拷贝和深拷贝#

1. 变量的赋值操作

只是形成两个变量，实际还是指向同一个对象。

2. 浅拷贝

Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。

3. 深拷贝

使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同

import copy

class MobilePhone():
    
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen


class Cpu():
    
    def calulate(self):
        print("正在计算...")
        print("cpu: ",self)


class Screen():

    def show(self):
        print("小电影...")
        print("screen:",self)

# 测试变量赋值
c1 = Cpu()
c2 = c1
print(c1)       # <__main__.Cpu object at 0x0000021919FA49D0>
print(c2)       # <__main__.Cpu object at 0x0000021919FA49D0>

# 测试浅拷贝（实例对象物理地址不同，但是实例方法与属性相同）
m1 = MobilePhone(Cpu(), Screen())
m2 = copy.copy(m1)
print(m1, m1.cpu, m1.screen)       # <__main__.MobilePhone object at 0x00000209729EBD50> <__main__.Cpu object at 0x00000209729E89D0> <__main__.Screen object at 0x00000209729E8B90>     
print(m2, m2.cpu, m2.screen)       # <__main__.MobilePhone object at 0x00000209729E9ED0> <__main__.Cpu object at 0x00000209729E89D0> <__main__.Screen object at 0x00000209729E8B90>   

# 测试深拷贝（实例对象物理地址不同，实例方法与属性也不相同)
m3 = copy.deepcopy(m1)
print(m1, m1.cpu, m1.screen)       # <__main__.MobilePhone object at 0x0000023658B8BD90> <__main__.Cpu object at 0x0000023658B88050> <__main__.Screen object at 0x0000023658B88BD0>        
print(m3, m3.cpu, m3.screen)       # <__main__.MobilePhone object at 0x0000023658BA3710> <__main__.Cpu object at 0x0000023658BA36D0> <__main__.Screen object at 0x0000023658BA3610>        

组合#

“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。

“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU

class MobilePhone():
    
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen


class Cpu():
    
    def calulate(self):
        print("正在计算...")
        print("cpu: ",self)


class Screen():

    def show(self):
        print("小电影...")
        print("screen:",self)

m = MobilePhone(Cpu(), Screen())
m.cpu.calulate()
# 正在计算...
# cpu:  <__main__.Cpu object at 0x000001D22603FE90>

m.screen.show()
# 小电影...
# screen: <__main__.Screen object at 0x000001D22603FED0> 

设计模式_工厂模式实现#

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

class Benz():
    pass

class BMW():
    pass

class BYD():
    pass

class CarFactory():
    
    def create_car(self, brand):
        if brand == "Benz":
            return Benz()
        elif brand == "BMW":
            return BMW()
        elif brand == "BYD":
            return BYD()
        else:
            return "品牌不存在，无法创建Car"

c = CarFactory()

c1 = c.create_car("Benz")
print(c1)       # <__main__.Benz object at 0x0000019322CDFC50>

c2 = c.create_car("BMW")
print(c2)       # <__main__.BMW object at 0x000001BF982DFD50>

c3 = c.create_car("Ford")
print(c3)       # 品牌不存在，无法创建Car

设计模式_单例模式实现#

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。

单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。

重写__new__()方法实现单例模式

# 实例化一个单例

class MySingleton(object):
    __instance = None
    __first_init = False

    def __new__(cls, name, age):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, name, age):
        if not self.__first_init:
            print("init.....")
            self.age = age
            self.name = name
            MySingleton.__first_init = True


a = MySingleton("chenhao", 18)
b = MySingleton("wanghao", 28)
print(a)
print(b)

'''
result

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

'''