day24_7.30 反射与元类

一。反射

　　在python中，反射通常是指一个对象应该具备，可以检测修复，增加自身属性的能力。

　　而反射可以通过字符串对其进行操作。

　　其中涉及了4个函数，是四个普通 的函数：

　　hasattr(oop,str,none)判断该对象是否有某个属性，如果有返回其值，如果没有，返回第三参数，默认为none

　　getattr(oop,str) 获取该对象的某个属性的值

　　setattr(oop,str,key)将某个属性添加到该对象中

　　delattr(oop,str)将从对象中删除属性

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

p=Test1('lzx',19)
print(hasattr(p,'lzx'))
print(getattr(p,'name','not this'))
print(setattr(p,'gender','male'))
print(p.__dict__)
print(delattr(p,'age'))
print(p.__dict__)
#False
#lzx
#None
#{'name': 'lzx', 'age': 19, 'gender': 'male'}
#None
#{'name': 'lzx', 'gender': 'male'}

　　如果对其对象的字典进行操作也能达到效果，但是语法复杂，不如函数简洁。

　　练习：制作一个终端指令：

class Windows:
    def cd(self):
        print('执行cd')

    def ls(self):
        print('执行ls')

    def md(self):
        print('执行md')

win=Windows()
def run(oop):
    while True:
        cmd=input('输入你需要执行的指令：')
        if cmd=='exit':
            print('再见')
            break
        if not hasattr(oop,cmd):
            print('没有该指令')
        else:
            getattr(oop,cmd)()

run(win)

　　在程序编写时，不可能知道这个程序以后需要调用什么样的模块，使用什么样的类，在编写后也不易修改，所以，需要使用动态导入模块，对一个字符串中的模块信息进行处理:

import settings
import importlib#动态模块包
def run(oop):
    while True:
        cmd=input('输入你需要执行的指令：')
        if cmd=='exit':
            print('再见')
            break
        if not hasattr(oop,cmd):
            print('没有该指令')
        else:
            getattr(oop,cmd)()
path, class_info = settings.classpath.rsplit('.', 1)#将路径切割成模块路径和类名
mk = importlib.import_module(path)#动态导入模块
cls = getattr(mk, class_info)#通过字符串在模块中寻找该类的名字，获取类
obj = cls()#实例化类
run(obj)#运行

　　以上就是动态导入模块，被导入模块的信息放在了settings中，这样即使在编写这段代码时不知道路径，也可以运行。

　　注意，对于一个模块来说，也是一个类，可以使用反射getattr方法寻找其中的类（名称空间里的值），倒数第三行可以这样使用。

二。元类metaclass

　　在python中，所以的东西都是对象，类可以实例化一个对象，而类也是由元类实例化而来的对象，所以类也是一个对象，默认情况下所有的类的元类都是type，包括object：

class Person:
    pass

p=Person()
print(type(p))
print(type(Person))
print(type(object))
#<class '__main__.Person'>
#<class 'type'>
#<class 'type'>

　　所以可以根据type实例化一个类出来，在源码中，元类 的初始化是这样的：

def __init__(cls, what, bases=None, dict=None): 

　　其中，what表示类的名字，bases表示类的父类，dict表示类的名称空间。

cls_object=type('animal',(),{'name':'dog'})
class cls_object:
    name='dog'

　　这两者都是定义了类。

　　元类的作用就是高度的自定义一个类，

　　例：在定义类时规定使用大写字母开头：

　　1，在源码中修改type，风险太高，不提倡。

　　2，新建一个自己的类，继承type，任何继承了type的类都是一个元类，可以用来自定义一个类。

　　其中可以使用metaclass=元类将一个类的元类指向它。

class Mytype(type):
    def __init__(self,what,bases,dict):
        super().__init__(what,bases,dict)
        if not what.istitle():
            raise Exception('no')

class pdd(metaclass=Mytype):
    pass

　　覆盖了type的初始化方法后就可以当作元类使用，再编写其限制。

　　在元类中，也有__call__方法，这个方法是在该类创建的对象被调用时，执行，而元类的对象是类，类被调用就是将类实例化的过程。

class Mytype1(type):
    def __init__(self,what,bases,dict):
        super().__init__(what,bases,dict)

    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

　　　　　#return super().__call__(*args, **kwargs)

class Per(metaclass=Mytype1): def __init__(self,name,age): self.name=name self.age=age e=Per('lzx',age=10) # print(e.name)

<class '__main__.Per'>
('lzx',)
{'age': 10}

　　如上，将元类终端__call__覆盖，输出其参数self，*args,**kwargs，可以发现self是生成的类对象，args是类实例化中 的任意参数，而kwargs是指定参数。

　　由于覆盖__call__方法后没有对其进行返回值，所以并没有实例化成功，需要调用父类方法。

　　例：在实例化对象时一定要使用指定参数，不能使用位置参数：

class Mytype1(type):
    def __init__(self,what,bases,dict):
        super().__init__(what,bases,dict)

    def __call__(self, *args, **kwargs):
        if args:
            raise Exception('not this')
        return super().__call__(*args,**kwargs)

class Per(metaclass=Mytype1):
    def __init__(self,name,age):
        self.name=name
        self.age=age

e=Per(name='lzx',age=10)

　　在__call__方法中可以以使用__new__方法new一个新的空对象，让对象使用类的初始化方法。这就是call的内部原理：

    def __call__(self, *args, **kwargs):
        obj=object.__new__(self)
        self.__init__(obj,*args, **kwargs)
        return obj

　　注意，一定要返回obj值。

　　补充new。

　　在元类中，也可以使用new方法创建类对象，

当你要创建类对象时,会首先执行元类中的__new__方法,拿到一个空对象,然后会自动调用__init__来对这个类进行初始化操作 。
注意:,如果你覆盖了该方法则必须保证,new方法必须有返回值且必须是,对应的类对象。（如果传入了其他类，就不会运行init函数）

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  #返回对应 的类后会执行init方法
    def __init__(self,a,b,c):
        super().__init__(a,b,c)
        print("init run")
class A(metaclass=Meta):
    pass
print(A)

三。单例设计模式

　　在类中，可以创建很多对象，而当一个类产生的值是一模一样时，就不需要创建那么多的类，所以就有单例设计模式。

　　单例就是一个类只产式一个对象。

　　这样的设计可以节省资源，当一个类的所有对象属性全部相同时，就没必要创建多个对象。

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

    def say_hi(self):
        print('hi')

s1=Single('lzx',24)
s1.say_hi()

s2=Single('lzx',24)
s2.say_hi()

　　可以看到，由single创建的s1，s2都是一样的属性，但是却创建了两个不同的对象，浪费空间，可以使用单例设计模式，将两次实例化的对象变成一个。

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

    def say_hi(self):
        print('hi')

    @classmethod
    def get_single(cls):
        if hasattr(cls,'obj'):
            return getattr(cls,'obj')
        obj=cls('lzx',18)
        cls.obj=obj
        return obj
s3=Single1.get_single()
s3.say_hi()

s4=Single1.get_single()

　　虽然实现了单例，但是不能使用原来的方法调用该类，所以，可以使用该类的元类中 的call完成功能：

class Single2(type):
    def __call__(self, *args, **kwargs):
        if hasattr(self,'obj'):
            return getattr(self,'obj')
        obj=super().__call__( *args, **kwargs)
        self.obj=obj
        print('new')
        return obj

class test_sin(metaclass=Single2):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi')

s5=test_sin('lzx',12)
s5.say_hi()

s6=test_sin('lzx',12)
s6.say_hi()

　　这样就只会创建一个对象了。