面向对象反射、元类

一、什么是反射

       反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

二、为什么要反射

　　一个类在定义的时候,可能一些属性的设计并不是很完美,而后期需要作出修改,或是增加新属性时,使用反射的方式可以不需要修改源代码

　　反射的另一个优势：可插拔设计

三、反射的四个方法的使用

使用场景：反射其实就是对属性的增删改查，但是如果直接使用内置的__dict__来操作，语法繁琐，语法不好理解。另外一个最主要的问题是，如果对象不是我自己写的是另一方提供的，我就必须判断这个对象是否满足的要求，也就是是否我需要的属性和方法

hasattr、getattr、setattr、delattr

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

p = Person('zzj',18,'man')

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

四、反射的应用案例

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

import importlib
import settings

def run(plugins):
    while True:
        cmd = input('请输入指令： ').strip()
        if cmd == 'exit':
            break
        #因为无法确定框架使用者是否传入正确的对象所以需要使用反射来检测
        #判断对象是否具备处理这个指令的方法
        if hasattr(plugins,cmd):
            func = getattr(plugins,cmd)
            func()
        else:
            print('该指令不受支持...')
    print('goodbye')
#框架得根据配置文件拿到需要的类
path = settings.CLASS_PATH
#从配置中单独拿出来，模块路径和类名称
module_path,class_name = path.rsplit('.',1)
#拿到模块
mk = importlib.import_module(module_path)
#拿到类
cls = getattr(mk,class_name)
#实例化对象
obj = cls()
#调用框架
run(obj)

plugins插件

class WinCMD:

    def cd(self):
        print("wincmd 切换目录....")

    def delete(self):
        print("wincmd 要不要删库跑路?")

    def dir(self):
        print("wincmd 列出所有文件....")

class LinuxCMD:

    def cd(self):
        print("Linuxcmd 切换目录....")

    def rm(self):
        print("Linuxcmd 要不要删库跑路?")

    def ls(self):
        print("Linuxcmd 列出所有文件....")

settings配置文件

CLASS_PATH = 'libs.plugins.WinCmd'

五、元类

一个类的三个基本组成部分：1.类的名字(字符类型) 2.类的父类们(是一个元组或列表) 3.类的名称空间字典类型

1.元类是什么？用于创建类的类

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

3.对象时用过类实例化产生的，如果类也是对象的话，必然类对象也是有另一个类实例化产生的

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

5.验证：

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

6.学习元类的目的：1.高度的自定义一个类，例如控制类的名字必须以大驼峰的方式来书写

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

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

　　　　　　　　4.想到了初始化方法，我们只要找到类对象的类(元素)，覆盖其中init方法就能实现需求

　　　　　　　　5.当然我们不能修改源代码，所以应该继承type来编写自己的元类，同时覆盖init来完成需求

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

class MyType(type):
    def __init__(self,class_name,bases,dict):
        super().__init__(class_name,bases,dict)
        print(class_name,bases,dict)
        if not class_name.istitle():
            raise Exception('好好写类名！')
class Pig(metaclass=MyType):
    pass

class duck(metaclass=MyType):
    pass

7.元类中call方法

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

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

使用场景：当你想要控制对象的创建过程时，就覆盖call方法

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

案例：实现将对象的所有属性名称转为大写

class MyType(type):
    def __call__(self, *args, **kwargs):
        new_args = []
        for i in args:
            new_args.append(i.upper)
        return super().__call__(*new_args,**kwargs)

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

p = Person('zzj','man')
print(p.name())
print(p.gender())

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

案例2：要求创建对象时必须以关键字参数形式来传参

class Mate(type):
    def __call__(self,*args,**kwargs):
        if args:
            raise Exception('请使用关键字形式参数来传参！')
        return super().__call__(*args,**kwargs)

class A(metaclass=Mate):
    def __init__(self,name):
        self.name = name

a = A(name='jack')
print(a.name)

a = A('rose')

　　

8.new方法（补充）

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

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

class Meta(type):
    def __new__(cls, *args, **kwargs):
        print(cls)
        print(args)
        print(kwargs)
        print('new run')
        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)

　　总结：new方法和init 都可以实心控制类的创建过程，init更简单

9.单例设计模式

单例：指的是一个类产生一个对象

为什么要使用单例：

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

class Single(type):
    def __call__(self, *args, **kwargs):
        if hasattr(self,'obj'): #判断是否存在已经有的对象
            return getattr(self,'obj') #有就返回
        obj = super().__call__(*args,**kwargs) #没有则创建
        print('new le')
        self.obj = obj #并存入类中
        return obj

class Student(metaclass=Single):
    def __init__(self,name):
        self.name = name
    def say_hi(self):
        return 'hello my name is %s'%self.name

class Person(metaclass=Single):
    def __init__(self,name):
        self.name = name
    def say_hi(self):
        return 'hello my name is %s'%self.name

#只会创建一个对象
stu = Student('zzj')
print(stu.say_hi())

stu2 = Student('zkj')
print(stu.say_hi())

stu3 = Student('zzp')
print(stu.say_hi())

stu4 = Student('lzx')
print(stu.say_hi())

p1 = Person('lzx')#创建新对象
print(p1.say_hi())