面向对象高阶-描述符与设计模式

描述符

当一个类中，包含了三个魔术方法(__get__,__set__,__delete__)之一，或者全部时，那么这个类就称为描述符类

作用

描述符的作用就是对一个类中的某个成员进行一个详细的管理操作（获取，赋值，删除）
描述符就是代理了一个类中的成员的操作，描述符属于类，只能定义为类的属性

三个魔术方法

  1. '''
  2. __get__(self, instance, owner)
  3.     触发机制：在访问对象成员属性时自动触发(当该成员已经交给描述符管理时)
  4.     作用：设置当前属性获取的值
  5.     参数：1. self 描述符对象 2.被管理成员的类的对象。3.被管理成员的类
  6.     返回值：返回值作为成员属性获取的值
  7.     注意事项：无
  8. __set__(self, instance, value)
  9.     触发机制：在设置对象成员属性时自动触发(当该成员已经交给描述符管理时)
  10.     作用：对成员的赋值进行管理
  11.     参数：1. self 描述符对象 2.被管理成员的类的对象。3.要设置的值
  12.     返回值：无
  13.     注意事项：无
  14. __delete__(self, instance)
  15.     触发机制：在删除对象成员属性时自动触发(当该成员已经交给描述符管理时)
  16.     作用：对成员属性的删除进行管理
  17.     参数：1. self 描述符对象 2.被管理成员的类的对象。
  18.     返回值：无
  19.     注意事项：无
  20. '''

数据描述符：（完整）

同时具备三个魔术方法的类就是 数据描述符

非数据描述符：（不完整）

没有同时具备三个魔术方法的类就是 非描述符类

基本使用格式

把当前的描述符类赋值给一个需要代理的类中的成员属性

代码示例：

  1. # 定义描述符类
  2. class PersonName():
  3.     __name = 'abc'
  5.     def __get__(self, instance, owner):
  6.         # print(self,instance,owner)
  7.         return self.__name
  9.     def __set__(self, instance, value):
  10.         # print(self,instance,value)
  11.         self.__name = value
  13.     def __delete__(self, instance):
  14.         # print(self,instance)
  15.         # del self.__name
  16.         print('不允许删除')
  18. # 定义的普通类
  19. class Person():
  20.     # 把类中的一个成员属性交给一个描述符类来实现
  21.     # 一个类中的成员的值是另一个描述符类的对象()
  22.     # 那么当对这个类中得成员进行操作时，可以理解为就是对另一个对象的操作
  23.     name = PersonName()
  25. # 实例化对象
  26. zs = Person()
  27. print(zs.name)
  28. zs.name = '张三'
  29. print(zs.name)
  30. del zs.name
  31. print(zs.name)

描述符应用解析

  1. #定义一个学生类，需要记录 学员的id，名字，分数
  2. class Student():
  3.     def __init__(self,id,name,score):
  4.         self.id = id
  5.         self.name = name
  6.         self.score = score
  8.     def returnMe(self):
  9.         info =  f'''
  10.         学员编号:{self.id}
  11.         学员姓名:{self.name}
  12.         学员分数:{self.score}
  13.         '''
  14.         print(info)
  15. '''
  16. # 要求：学员的分数只能在0-100范围中
  17. 解决方法：
  18.     1。在__init__方法中检测当前分数范围
  19.          # 检测分数范围
  20.         if score >= 0 and score <= 100:
  21.             self.score = score
  22.         这个解决方案只能在对象初始化时有效。
  23.     2。 定义一个setattr魔术方法检测
  24.         检测如果给score分数进行赋值时，进行分数的检测判断
  25.             def __setattr__(self, key, value):
  26.         # 检测是否是给score进行赋值操作
  27.         if key == 'score':
  28.             # 检测分数范围
  29.             if value >= 0 and value <= 100:
  30.                 object.__setattr__(self, key, value)
  31.             else:
  32.                 print('当前分数不符合要求')
  33.         else:
  34.             object.__setattr__(self,key,value)
  36.         假如 学员的分数不止一个时怎么办，比如 语文分数，数学分数，英语分数
  37.         另外就是当前这个类中的代码是否就比较多了呢？
  39.     3。可以思考使用描述符来代理我们的分数这个属性
  40.         1.定义Score描述符类
  41.         2.把学生类中的score这个成员交给描述符类进行代理
  42.         3.只要在代理的描述符类中对分数进行赋值和获取就ok了
  43. '''
  45. #定义描述符类 代理分数的管理
  46. class Score():
  47.     def __get__(self, instance, owner):
  48.         return self.__score
  49.     def __set__(self, instance, value):
  50.         if value >= 0 and value <= 100:
  51.             self.__score = value
  52.         else:
  53.             print('分数不符合要求')
  55. # 使用描述符类代理score分数属性
  56. class Student():
  57.     score = Score()
  58.     def __init__(self,id,name,score):
  59.         self.id = id
  60.         self.name = name
  61.         self.score = score
  63.     def returnMe(self):
  64.         info =  f'''
  65.         学员编号:{self.id}
  66.         学员姓名:{self.name}
  67.         学员分数:{self.score}
  68.         '''
  69.         print(info)
  73. # 实例化对象
  74. zs = Student(1011,'张三疯',99)
  75. zs.returnMe()
  76. zs.score = -20
  77. zs.score = 88
  78. zs.returnMe()

描述符的三种定义格式

  1. # 格式一 通过定义 描述符类来实现  推荐
  2. '''
  3. class ScoreManage():
  4.     def __get__(self, instance, owner):
  5.         pass
  6.     def __set__(self, instance, value):
  7.         pass
  8.     def __delete__(self, instance):
  9.         pass
  11. class Student():
  12.     score = ScoreManage()
  13. '''
  15. # 格式二， 使用 property 函数 来实现
  16. '''
  17. class Student():
  19.     # 在当前需要被管理的类中 直接定义类似下面三个方法
  20.     def getscore(self):
  21.         print('getscore')
  23.     def setscore(self,value):
  24.         print('setscore',value)
  26.     def delscore(self):
  27.         print('delscore')
  29.     # 在 property 函数中指定对应的三个方法,对应的方法 1。__get__，2。__set__,3。__delete__
  30.     score = property(getscore,setscore,delscore)
  32. zs = Student()
  33. # print(zs.score)
  34. # zs.score = 200
  35. # del zs.score
  36. '''
  38. # 格式三 使用 @property 装饰器语法来实现
  39. '''
  40. class Student():
  41.     __score = None
  43.     @property
  44.     def score(self):
  45.         print('get')
  46.         return self.__score
  48.     @score.setter
  49.     def score(self,value):
  50.         print('set')
  51.         self.__score = value
  53.     @score.deleter
  54.     def score(self):
  55.         print('delete')
  56.         del self.__score
  58. zs = Student()
  59. # print(zs.score)
  60. zs.score = 199
  61. print(zs.score)
  62. del zs.score
  63. '''

设计模式

设计模式是前人为完成某个功能或需求，根据经验和总结，对实现的代码步骤和代码设计进行了总结和归纳，成为了实现某个需求的经典模式。

设计模式并不是固定的代码格式，而是一种面向对象编程的设计

单例(单态)设计模式

在当前脚本中，同一个类只能创建出一个对象去使用。这种情况就成为单例(单态)。

  1. '''
  2. 实现单例的案例，思考：
  3. 单例和婚姻法的关系，特别像，一个人只能有一个结婚对象
  4. 在社会中是如何完成一夫一妻制的？
  5. 如果要结婚，必须要到 民政局 登记
  6. 民政局 需要检测两个人的户口本，看上面是否属于 结婚的状态
  7. 如果是已婚，肯定就撵出去了。
  8. 如果没有结婚，可以给盖个章了，开始登记。
  10. 那么按照这样的思路如何去实现 python中的单例设计模式呢？
  12. 1。需要有一个方法，可以去控制当前对象的创建过程？
  13.     构造方法 __new__
  14. 2。需要有一个标示来存储和表示是否有对象
  15.     创建一个私有属性 进行存储，默认值为None
  16. 3。在创建对象的方法中去检测和判断是否有对象？
  17.     如果没有对象，则创建对象，并且把对象存储起来，返回对象
  18.     如果存储的是对象，则直接返回对象，就不需要创建新的对象了
  19. '''
  21. class Demo():
  22.     # 2.定义私有属性存储对象，默认值为None
  23.     __obj = None
  25.     # 1.定义构造方法
  26.     def __new__(cls, *args, **kwargs):
  27.         # 3。在创建对象的过程中，判断是否有对象
  28.         if not cls.__obj:
  29.             # 判断如果没有对象，则创建对象，并且存储起来
  30.             cls.__obj = object.__new__(cls)
  31.         # 直接把存储的对象返回
  32.         return cls.__obj
  35. # 实例化对象
  36. a = Demo()
  37. b = Demo()
  38. print(a)
  39. print(b)
  40. '''
  41. <__main__.Demo object at 0x106f4d850>
  42. <__main__.Demo object at 0x106f4d850>
  43. '''

Mixin 混合设计模式

Mixin类

  • Mixin 必须是表示一种功能，而不是一个对象。
  • Mixin 的功能必须单一，如果有多个功能，那就多定义Mixin类
  • python 中的Mixin是通过多继承实现的
  • Mixin 这个类通常不单独使用，而是混合到其它类中，去增加功能的
  • Mixin 类不依赖子类的实现，即便子类没有继承这个Mixin,子类也能正常运行，可能就是缺少了一些功能。。

使用Mixin混入类的好处？

  1. Mixin 这个混入类的设计模式，在不对类的内容修改的前提下，扩展了类的功能

  2. Mixin 混入类为了提高代码的重用性，使得代码结构更加简单清晰

  3. 可以根据开发需要任意调整功能（创建新的Mixin混入类）避免设计多层次的复杂的继承关系。

示例：

  1. '''
  2. 继承需要有一个必要的前提，继承应该是一个 'is-a' 的关系
  3. 例如：
  4.     苹果可以去继承水果，因为苹果就是一个水果
  5.     苹果不能继承午饭，因为午饭可以有苹果也可以没有
  7.     比如 汽车可以继承 交通工具，因为汽车本身就是一个交通工具
  9. 交通工具有哪些？
  10. 汽车，飞机，直升机，这些都属于 交通工具
  11. 那么如何去设计这些类的关系呢？
  12. 比如创建一个交通工具类，然后属于交通工具的都来继承，再去实现。。。
  13. 但是，飞机和直升机都有飞行的功能，而汽车并没有，那么在交通工具中如果去定义 飞行这个功能，那就不太合适了。。
  14. 能不能在飞机和直升机类中分别实现 飞行 这个功能呢？可以，但是代码又无法重用。
  16. 怎么办？
  17. 单独去定义交通工具类，和 飞行器 这个两个父类，这样飞机和直升机就可以去继承这两个类.
  18. '''
  20. # 交通工具 vehicle
  21. class vehicle():
  22.     # 运输货物
  23.     def huo(self):
  24.         print('运输货物')
  25.     # 搭载乘客
  26.     def ren(self):
  27.         print('搭载乘客')
  29. # 飞行器
  30. class FlyingMixin():
  31.     def fly(self):
  32.         print('可以起飞了。。。')
  34. # 定义汽车类
  35. class cart(vehicle):
  36.     pass
  38. # 定义飞机
  39. class airplane(vehicle,FlyingMixin):
  40.     pass
  42. # 定义直升机
  43. class helicopter(vehicle,FlyingMixin):
  44.     pass
  46. # 此时去定义一个飞行器的类 Flying，让需要飞行的交通工具，直接继承这个类。可以解决这个问题。
  47. # 但是，1。出现类多继承，违背了'is-a'  2。飞行器这个类很容易被误解
  48. # 解决方案也是使用多继承，但是给飞行器这个类，定义成为一个 Mixin 混合类,
  49. # 此时就是等于把飞行器这个类，作为了一个扩展的功能，来扩展其它类
  51. '''
  52. 在上面的代码中，虽然直升机和飞机都使用了多继承，也就是继承了FlyingMixin
  53. 但是由于 FlyingMixin 类加了 Minin这个名，就告诉了后面阅读代码的人，这个类是一个Mixin类
  54. '''

抽象类（了解）

抽象类是一个特殊的类：
    1. 抽象类不能用，不能直接实例化成为一个对象。
    2. 抽象类中包含了抽象方法，抽象方法就是没有实现代码的方法。
    3. 抽象类需要子类继承，并重写父类的抽象方法。才可以使用。

抽象类，一般应用在程序设计，程序设计中一般是要对功能和需求进行规划，其中有一些需求是明确的并且可以完成的，
但是也可能会有一些需求是不明确的，或者不确定具体需要怎么实现，
那么此时就可以把这个不确定怎么实现或者需要后面再去实现的方法，定义为抽象方法（只定义方法名，不写具体代码）

抽象类的应用：
    例如要开发一个框架，这个框架要有一些基本功能和扩展功能。。。。
    但是你具体用这个框架开发什么样的产品，开发框架的人并不清楚或者确定。
    因此框架就具备一定的功能，并且留下来一些方法的定义，剩下的就是需要自己在方法中具体实现自己业务逻辑。

抽象类的定义：

import abc

# 如果要定义为抽象类，那么这个类的 metaclass属性必须是 metaclass=abc.ABCMeta
class WriteCode(metaclass=abc.ABCMeta):

    #需要抽象的方法，使用装饰器进行装饰
    @abc.abstractmethod
    def write_php(self):
        pass

    def write_java(self):
        print('实现了java代码的开发')

    def write_python(self):
        print('实现了python代码的开发')


# 抽象类不能直接实例化对象
# obj = WriteCode()
# print(obj)
#TypeError: Can't instantiate abstract class WriteCode with abstract methods write_php


# 定义子类，继承抽象类，并实现抽象类中的抽象方法
class Demo(WriteCode):
    def write_php(self):
        print('实现了php代码的开发')

a = Demo()
print(a)
a.write_java()
a.write_php()
a.write_python()