✍️7.30 反射元类生命周期

最新推荐文章于 2024-09-27 10:11:28 发布

weixin_30768661

最新推荐文章于 2024-09-27 10:11:28 发布

阅读量116

点赞数

文章标签： python 测试设计模式

原文链接：http://www.cnblogs.com/PowerTips/p/11268169.html

版权

反射 reflect

什么是反射：其实是反省，自省的意思(框架的基石)

反射指的是一个对象应该具备，可以检测修改，增加自身属性的能力

框架要通过反射去找到类找到对象检测对象是不是想要的

反射就是通过字符串操作属性

涉及的四个函数

hasattr getattr setattr delattr

这些和带双下的魔法函数不一样，这几个都是普通的内置函数，与print...没有区别

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


p = Person("bitten",18,"man")

print(hasattr(p,'name'))  # 判断某个对象中是否存在某个属性
if hasattr(p,'name'):
    print(getattr(p,'name',None))
    # 从对象中取出值，第三个位置默认值，不存在时返回默认值



setattr(p,'id',123)
# setattr  # 为对象添加、修改新的属性
print(p.id)

# delattr(p,"id")
# 为对象删除属性
# print(p.id)

使用场景：

反射其实就是对属性的增删改查，但是如果直接使用内置的__dict__来操作，语法繁琐，不好理解

另外一个最主要的问题是，如过对象不是我自己写的是另一方提供的，我就必须判断这个对象是否满足需要的属性和方法

'''
反射被称为框架的基石，
因为框架的设计者，不可能提前知道你的对象到底是怎么设计的
所以你提供给框架的对象 必须通过判断验证之后才能正常使用
判断验证就是反射要做的事情
当然通过__dict__也是可以实现的，其实这些方法就是对__dict__的操作进行了封装

需求：要实现一个用于处理用户的终端指令的小框架
框架就是已经实现了最基础的框架，就是所有的项目都一样的部分
'''

简易框架

执行文件

myframework.py

"""
需求:要实现一个用于处理用户的终端指令的小框架
    框架就是已经实现了最基础的构架,就是所有项目都一样的部分
"""
from libs import plugins


# 框架已经实现的部分
def run(plugin):
    while True:
        cmd = input("请输入指令:")
        if cmd == "exit":
            break
        # 因为无法确定框架使用者是否传入正确的对象所以需要使用反射来检测
        # 判断对象是否具备处理这个指令的方法
        if hasattr(plugin,cmd):
            # 取出对应方法方法
            func = getattr(plugin,cmd)
            func() # 执行方法处理指令
        else:
            print("该指令不受支持...")
    print("see you la la!")


# 创建一个插件对象 调用框架来使用它
# wincmd = plugins.WinCMD()
# 框架之外的部分就由自定义对象来完成
linux = plugins.LinuxCMD()
run(linux)

可选用的插件

libs/plugins.py

class WinCMDHandler:
    def cd(self):
        print('wincmd 切换目录')

    def delete(self):
        print('wincmd 要不要删库')

    def dir(self):
        print('wincmd 列出目录')



class LinuxCMDHandler:
    def cd(self):
        print('linuxcmd 切换目录')

    def rm(self):
        print('linuxcmd 要不要删库')

    def list(self):
        print('linuxcmd 列出目录')

动态导入

因为在开发过程中，我们往往不能提前知道对方的类在什么地方以及类叫什么，所以我们应该为框架的使用者提供一个配置文件，要求对方将类的信息写入配置文件，然后框架自己去加载需要的模块。

使用动态导入，不需要知道类，只需要告诉路径，然后自己去找。

'''
在框架设计中 我们不可能提前知道 框架的用户要提供类相关的信息
'''
import importlib
import abc

# 拿到模块 根据模块的路径
pl = importlib.import_module("libs.plugins")
print(pl)
# 从模块中取出类
cls = getattr(pl,"WinCMD")
print(cls)


# 实例化产生对象
obj = cls()
obj.cd()


######当你的框架中类相关路径保存在settings中时######
################myframework.py#############
from conf import settings
import importlib  # 1.动态导入模块

# 框架已经实现的部分
def run(plugin):
    while True:
        cmd = input("请输入指令:")
        if cmd == "exit":
            break
        # 因为无法确定框架使用者是否传入正确的对象所以需要使用反射来检测
        # 判断对象是否具备处理这个指令的方法
        if hasattr(plugin,cmd):
            # 取出对应方法方法
            func = getattr(plugin,cmd)
            func() # 执行方法处理指令
        else:
            print("该指令不受支持...")
    print("see you la la!")


# 框架 得根据配置文件拿到需要的类
path = settings.CLASS_PATH
# 从配置中单独拿出来 模块路径和 类名称
module_path, class_name = path.rsplit(".", 1)
# 2.拿到并导入模块
mk = importlib.import_module(module_path)
# 拿到类
cls = getattr(mk,class_name)
# 用类实例化出对象
obj = cls()
# 调用框架
run(obj)
############conf/settings.py中####################
# 作为框架使用者 在配置文件中指定你配合框架的类是哪个
CLASS_PATH = 'lib.plugin.WinCMD'
# 这样就实现了插件的热插拔，需要更换时，把WinCMD换成LinuxCMD就行

元类 metaclass

元类是什么：用于创建类的类

万物皆对象，类当然也是对象

对象是通过类实例化产生的，如果类也是对象的话，那么类也是另一个

class Person:
    pass


p = Person()
print(type(p), type(Person), type(object))
# <class '__main__.Person'> <class 'type'> <class 'type'>
# Person类是通过type类实例化产生的（object类内部是由C语言实现的）

# 直接调用type类来产生类对象（默认情况下所有类的元类都是type）
class Student:
    pass


print(type(Student))
# <class 'type'>

一个类的基本组成

类的名字（字符类型）
类的父类们（是一个元组或列表）
类的名称空间（字典）

cls_obj = type("ClassDog", (), {})
print(cls_obj)
# <class '__main__.ClassDog'>


class Dog:
    pass


print(Dog)
# <class '__main__.Dog'>

学习元类目的

目的：可以高度地自定义类，例如控制一个类的名字必须以大驼峰的方式来书写

类也是对象，也有自己的类

我们的需求是创建类对象做一些限制

想到了初始化方法，我们只要找到了类对象的类（元类），覆盖其中__init__方法就能实现需求
当然我们不能修改源代码，所以应该继承type来编写自己的元类，同时覆盖__init__来完成需求

'''
只要继承了type， 那么这个类就变成了一个元类

'''


class MyType(type):  # 定义一个元类
    def __init__(self, cls_name, bases, dict):
        print(cls_name, bases, dict)
        # Pig () {'__module__': '__main__', '__qualname__': 'Pig'}
        if not cls_name.istitle():
            raise Exception("好好写类名！")
        super().__init__(cls_name, bases, dict)

    pass


# class pig(metaclass=MyType):  # 为Pig类指定了元类为MyType
    # 直接报错，Exception: 好好写类名！
class Pig(metaclass=MyType):

    pass


# # MyType("pig", (), {})  # Exception: 好好写类名！
print(MyType("Pig", (), {}))
# <class '__main__.Pig'>
__call__

元类中的call方法

# 当你调用类对象时，会自动执行元类中的__call__方法，并将这个类作为第一个参数传入，以及后面的一堆参数

# 覆盖元类中的call之后，这个类就无法产生对象对象无法实例化，必须调用super().__call__()来完成对象的创建并返回其返回值

`call 与 init`的使用场景：

想要控制对象的创建过程用__call__
想要控制类的创建过程用__init__

'''
需求：想要把对象的所有属性变成大写
'''
class MyType(type):
    def __call__(self, *args, **kwargs):
        new_args = [item.upper() for item in args]
        return super().__call__(*new_args, **kwargs)


class Person(metaclass=MyType):  # ---> Person = MyType("Person", (), {})
    def __init__(self, name):
        self.name = name


p = Person('jack')
print(p.name)
# JACK

# 要求创建对象时必须以关键字传参
#   覆盖元类的__call__
#   判断有没有传非关键字参数，有就不行
class MyMeta(type):
    # def __call__(self, *args, **kwargs):
    #     obj = object.__new__(self)
    #     self.__init__(obj, *args, **kwargs)
    #     return obj

    def __call__(self, *args, **kwargs):
        if args:
            raise Exception("非法传参（只能以关键字的形式传参！）")
        return super().__call__(*args, **kwargs)


class MyClass(metaclass=MyMeta):
    def __init__(self, name):
        self.name = name


# my_class_obj = MyClass('123')
# # 报错Exception: 非法传参（只能以关键字的形式传参！）
my_class_obj = MyClass(name='123')
print(my_class_obj)
# <__main__.MyClass object at 0x000002161DD187B8>

注意：一旦覆盖了__call__必须调用父类的__call__方法来产生对象并返回这个对象

补充__new__方法

当你要创建类对象时（类 + ()），会首先执行元类中的__new__方法，拿到一个空对象，然后会自动调用__init__方法来对这个类进行初始化操作

class MyMeta(type):
    # def __call__(self, *args, **kwargs):
    #     obj = object.__new__(self)
    #     self.__init__(obj, *args, **kwargs)
    #     return obj
    pass

注意：如果你覆盖了__new__方法，则必须保证__new__方法必须有返回值，且必须是对应的类对象

class Meta(type):

    def __new__(cls, *args, **kwargs):
        print(cls)  # 元类自己
        print(args)  # 创建类需要的几个参数  类名,基类,名称空间
        print(kwargs)  # 空的
        print("__new__ run")
        # return super().__new__(cls,*args,**kwargs)  # 等同于下面这句
        obj = type.__new__(cls, *args, **kwargs)
        return obj

    def __init__(self, a, b, c):
        super().__init__(a, b, c)
        print("__init__ run")


class A(metaclass=Meta):
    pass


print(A)
# <class '__main__.Meta'>
# ('A', (), {'__module__': '__main__', '__qualname__': 'A'})
# {}
# __new__ run
# __init__ run
# <class '__main__.A'>

总结：__new__和__init__都可以实现控制类的创建过程，还是__init__更简单

单例设计模式

'''
设计模式？
    用于解决某种固定问题的套路
    如：MVC、MTV.......

单例：指的是一个类只能产生一个对象，可以节省空间

为什么要单例：
    是为了节省空间，节省资源
    当一个类的所有对象属性全部相同时则没有必要创建多个对象
'''

class Single(type):
    def __call__(self, *args, **kwargs):
        if hasattr(self, 'obj'):  # 判断是否存在已经有了的对象
            return getattr(self, 'obj')  # 有就把那个对象返回

        obj = super().__call__(*args, **kwargs)  # 没有则创建
        print("new 了")
        self.obj = obj  # 并存入类中
        return obj


class Student(metaclass=Single):
    def __init__(self, name):
        self.name = name


class Person(metaclass=Single):
    pass


# 只会创建一个对象
Person()  # 只会执行一次
# new 了
Person()
Person()
Person()
Person()