面向对象之反射、元类

1.反射

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

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

涉及四个函数,这四个函数就是普通的内置函数,没有双下划线,与print等在使用方法上没有区别

hasattr,getattr,setattr,delattr(他们的具体使用方法和作用见下列代码)

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

p = Person('sxc',18)

if hasattr(p,'name'):  # 判断某个对象是否存在某个属性
    print(getattr(p,'name'))  # 把这个值当做返回值返回出来

print(getattr(p,'gender',None))  # 如果没有这个值后面还可以赋予他一个默认值

setattr(p,'id',177)  # 可以为该对象赋予新的属性
print(p.id)

delattr(p,'id')  # 也可以删除的对象的属性
print(p.id)

使用场景:

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

如果是另一方提供的,无法判断是否是我需要的属性和方法

 

简单的框架设计

框架就是已经实现了最基础的构架,就是所有项目都一样的部分已经完成了。反射被称为框架的基石,框架的设计者不可能提前知道使用者的对象到底是怎么设计的,所以使用者提供给框架的对象必须通过判断验证之后才能正常使用,判断验证就是反射要做的事

需求:实现一个用于处理用户的终端指令的小框架

# 框架部分
def run(plugin):
    while True:
        cmd = input('请输入您的指令>>>:').strip()
        if cmd == 'exit':
            break
        #  无法判断传入的参数,需要加入反射加以判断
        if hasattr(plugin,cmd):  # 取出对应的指令
            func = getattr(plugin,cmd)
            func()  # 执行指令处理
        else:
            print('请输入正确的指令')
    print('退出程序')

# 从系统配置文件中截取模块路径和类名
module_path, class_name = settings.CLASS_PATH.rsplit('.',1)
# 拿到模块
mk = importlib.import_module(module_path)
# 拿到类
cls = getattr(mk,class_name)
# 实例化对象
obj = cls()
# 调用框架
run(obj)

# 配置文件路径

CLASS_PATH = 'lib.plugin.WinCmd'

class WinCmd:
    def cd(self):
        print('进入文件')

    def delate(self):
        print('删库跑路')

    def dir(self):
        print('文件列表')


class LinuxCmd:
    def cd(self):
        print('进入文件')

    def rm(self):
        print('删库跑路')

    def ls(self):
        print('文件列表')

2.元类 metaclass

用于创建类的类就叫做元类

在python中万物皆对象,类也是对象

对象是通过类实例化产生的,如果类也是对象的话,必然类对象也是由另一个类实例化产生的

默认情况下所有类的元类都是type

元类的验证:

# 元类的验证
class Person:
    pass

p = Person()

# type方法可以查看对象的类型
print(type(p))
print(type(Person))

学习元类的目的:

可以高度自定义一个类,具体到可以控制类的名字必须以固定的格式书写

我们可以通过初始化方法,只要继承元类并覆盖其中的__init__方法就能实现需求

案例,通过元类限制类的名字必须以大驼峰的方式命名

# 继承元类可以高度定义一个子类
class MyType(type):
    def __init__(self,cls,bases,dict):
        super().__init__(cls,bases,dict)
        if not cls.istitle():
            raise Exception('请小写')
# 生成两个子类
class Pig(metaclass= MyType):
    pass

class duck(metaclass= MyType):
    pass

Pig类可以通过,duck类并未大写,报错

 

元类中call方法

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

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

# __call__是用来实例化对象返回值的
class MyType(type):
    def __call__(self, *args, **kwargs):
        print('元类call')
        print(args)
        print(kwargs)

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

p = Person('sxc',age = 18)
print(p)

当我们覆盖了元类的__call__方法,他的返回值就变成了None,说明__call__是用来实例化对象传值的

案例1:把子类中的所有属性都改为大写

# 把子类的所有属性都改成大写
class MyType(type):
    def __call__(self, *args, **kwargs):
        new_args = []  # 定义一个新列表
        for a in args:  # 循环输出旧列表中的内容
            new_args.append(a.upper())  # 添加到新列表中
        return super().__call__(*new_args,**kwargs)


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


p = Person('sxc')
p1 = Person('aabbcceeff')
print(p.name)
print(p1.name)

案例2:要求创建对象时只能关键字传参

# 要求:只允许关键字传参
class MyType(type):
    def __call__(self, *args, **kwargs):  # 覆盖元类的__call__方法
        if args:
            raise Exception('不允许直接传参')  # 当直接传参时报错
        return super().__call__(*args,**kwargs)

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

p1 = Person(name = 'sxc',age = 18)
print(p1.name,p1.age)
p = Person('sxc',18)

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

__init__方法和__call__方法的使用场景:

　　当想要控制对象的创建过程时,就覆盖call方法

　　当想要控制类的创建过程时,就覆盖init方法

补充new方法

当创建类对象时,会首先窒息感元类中的__new__方法,拿到一个空对象,然后自动调用__init__来初始化

# new方法
class Mytype(type):
    def __new__(cls, *args, **kwargs):
        print(cls)  # 元类自己
        print(args)  # 创建类需要的几个参数  类名,基类,名称空间
        print(kwargs)  # 空的值
        print('new run')
        return super().__new__(cls, *args, **kwargs)

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

class A(metaclass= Mytype):  # new方法和call方法在类生成时自动执行
    pass

print(A)  # 类对象本身

注意:当我们覆盖了__call__方法必须保证new方法有返回值并且是对应的类对象

 

单例设计模式

单例是为了节省资源,当一个类的所有对象属性全部相同时,没有必要创建多个对象

单例实现

# 单例的实现
class Single(type):
    def __call__(self, *args, **kwargs):
        if hasattr(self,'obj'):  # 判断是否有已存在的对象
            return getattr(self,'obj')  # 有就返回
        obj = super().__call__(*args,**kwargs)  # 没有就创建
        self.obj = obj  # 存到类中,方便下次查找
        return obj

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

# 只会创建初始的对象
p = Person('sxc')
print(p.name)
p1 = Person('zzj')
print(p1.name)
p2 = Person('zzp')
print(p2.name)
p3 = Person('lzx')
print(p3.name)
p4 = Person('zkj')
print(p4.name)

元类练习:

'''
1.使用元类实现检测类中的所有属性 包括类属性和方法,将名字存储到类的名称空间中
例如:有student类  有eat函数 和school属性  ,获取这两个名字 存储到一个叫做attrs的列表中,并将列表作为student类的属性
使得student类可以通过访问attrs来获取自身所有的属性名字
'''
class MyType(type):
    def __init__(self,cls,bases,dict):
        attr = []
        for i in dict:  # 遍历字典中的类属性
            if i == 'school' or i == 'eat':
                attr.append(i)  # 把他添加到新的列表中去
        self.attr = attr  # 添加到类属性中
        super().__init__(cls,bases,dict)

class Student(metaclass=MyType):
    school = 'oldboy'

    def eat(self):
        print('吃东西')

stu = Student()
print(stu.attr)

 24