元类

反射 reflect:
反射 其实不是我们字面意思的折射,而是反省,自检的意思
反射指的是一个对象应具备,可以检测,修改,增加自身属性的能力
反射就是通过字符串操作属性
涉及了四个函数,这四个函数其实就是普通的内置函数,没有双下划线
和print() len()一样没有什么其他的特殊区别
这四个函数分别是:
hasattr: 判断某个对象是否存在某种属性
getattr: 从对象中获取属性,第三个值为默认值,当属性不存在时返回默认值
setattr: 往对象里面添加新的属性
delattr: 从对象里面删除属性

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

p = Person("哨兵", 18)
# print(p.name)
if hasattr(p,"name"):
    print("对象P里面存在'name'这个属性") # >>>对象P里面存在'name'这个属性
    print(getattr(p,'age',None))   # 执行结果>>>哨兵  最后的返回值None属性存在时不写也可以
    print(getattr(p, 'asd',None))  #  当属性不存在时,会返回None,如果这个时候没有写None会报错
setattr(p,"id",23456)  # setattr 为对象添加新的属性
setattr(p,"age",23456) # 当属性存在时,会覆盖老的值
print(p.age)

delattr(p,"age")  # 从对象里面删除指定的值
print(p.age)   #>>>  AttributeError: 'Person' object has no attribute 'age'

　　

使用场景:
反射其实就是对属性的增删改查,但是如果直接使用内置的dict来操作,语法繁琐,而且不便于阅读理解
另外最重要的问题是:
    如果对象不是我们自己写的是另外一方提供的,那么我们就要必须判断这个对象是否可以满足我们的需求
    也就是说是否使我们所需要的属性和方法
框架设计方式:
    框架代码:

#反射的四个函数实例:
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("哨兵", 18)
# print(p.name)
if hasattr(p,"name"):
    print("对象P里面存在'name'这个属性") # >>>对象P里面存在'name'这个属性
    print(getattr(p,'age',None))   # 执行结果>>>哨兵  最后的返回值None属性存在时不写也可以
    print(getattr(p, 'asd',None))  #  当属性不存在时,会返回None,如果这个时候没有写None会报错
setattr(p,"id",23456)  # setattr 为对象添加新的属性
setattr(p,"age",23456) # 当属性存在时,会覆盖老的值
print(p.age)

delattr(p,"age")  # 从对象里面删除指定的值 
print(p.age)   #>>>  AttributeError: 'Person' object has no attribute 'age'
'''
"""

　　

反射被称之为框架基石,因为框架的设计者不可能提前知道你的对象到底是怎么设计的
所以你提供框架的对象,必须通过判断验证之后才可以正常使用,而3判断和验证就是反射需要做的事情
当然也可以使用__dict__来实现,期是这种方法就是把__dict__的操作进行了封装
实例说明:
需求: 要实现一个用于处理用户终端指令的模拟小框架
首先分为框架部分
插件部分
配置文件部分

#框架部分:
import importlib
import settings

def run(plugin):
    while True:
        cmd = input("请输入命令").strip()
        if cmd == "exit":
            break
        if hasattr(plugin,cmd): # 判断对象是否具有处理这个指令的方法
            # 如果有
            func = getattr(plugin,cmd)
            func()
        else:
            print("该指令不存在")
    # print("see you la la ")
    return "hahaha"

path = settings.CLASS_PATH
# 从配置文件setings中拿到模块的路径和类的名字
module_path, class_name = path.rsplit(".",1)
#拿到模块
lk = importlib.import_module(module_path)
# 拿到类
cls = getattr(lk,class_name)
res = cls()
run(res)

配置文件部分settings文件
###这个文件作为框架的配置文件###
CLASS_PATH = "lib.plugins.LinuxCMD"
插件部分在LIB文件下的plugins


属于插件部分

class WinCMD:
    def cd(self):
        print("wincod 切换目录")

    def delete(self):
        print("wincod 删除文件")

    def dir(self):
        print("wincod 列出所有文件")
class LinuxCMD:

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

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

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

　　

元类:
元类就是用于创建类的类,也就是原始类,大多数情况下都是type
万物皆对象,类也就是对象了,那么对象是有类实例化产生的,那么类也就是
另一个类实例化产生的,所以说默认情况下所有的类元类就是TYPE
#元类验证实例
class A:
    pass
a = A()
print(type(a))  # a 的元类是 <class '__main__.A'>
print(type(A))   # A 的元类是  <class 'type'>

学习元类的目的:
高度自定义一个类,类也是对象,也有自己的类也就是元类
我们可以对类创建对象多一些限制,那么我们就可以在初始化上面做一些手脚
只要我们找到类对象的元类,覆盖其中的__init__方法就可以实现
因为我们不能修改源代码,所以我们应该是用继承元类的方式来编写自己,同时
覆盖__init__来实现
元类的实例

'''
直接调用元类type类来产生对象
cls = type("泰迪",(),{})
print(cls)
一个类的三个基本组成部分
1.类的名字(字符串类型的)
2.父类的名字(列表或者元祖组成)
3.类的名称空间(字典类型)

'''

　　

class MyTypt(type):
    def __init__(self,class_name,bases, dict ):
        super().__init__(class_name,bases, dict) # 元类的__init__方法
        print(class_name,bases, dict)
        if not class_name.istitle(): # 限制类的首字母大写
            raise Exception("类名请单词首字母大写")
class Dig(metaclass=MyTypt):
    pass

class Duck(metaclass=MyTypt):
    pass

class ds(metaclass=MyTypt):
    pass
<   raise Exception("类名请单词首字母大写")
Exception: 类名请单词首字母大写  >

　　

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

覆盖元类中的call之后,这个类就无法产生对象,必须调用super().__call__来完成对象的创建  
并返回其返回值
首先使用场景:
想要控制对象的创造过程时需要使用__call__方法
想要控制类创造过程中时候,就要覆盖__init__方法

实例:
class Da(type):
    def __call__(self, *args, **kwargs):
        new_args = []
        for i in args:
            new_args.append(i.upper())
        print(new_args)
        print(kwargs)
        return super().__call__(*new_args,**kwargs)
class Ap(metaclass=Da):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    # def __call__(self, *args, **kwargs):


a = Ap("jack","n")
print(a.name)
print(a.gender)
实例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)
注意:一旦覆盖了call必须调用父类的call方法来产生对象并返回这个对象

　　

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

class Meta(type):
    def __new__(cls, *args, **kwargs):
        print(cls) # 元类自己
        print(*args) # 创建需要的几个参数,类名,基类,名称空间
        print(**kwargs) # 空的
        print("new_run")
        res = type.__new__(cls,*args,**kwargs)
        return res
    def __init__(self,a,b,c):
        super().__init__(a,b,c)
        print("init_run")
class A(metaclass=Meta):
    pass
print(A)

　　

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

单例涉及模式:
设计模式,用于解决问题的方式的某种套路
单例:指的是一个类产生一个对象
为什要使用单例:
    单例是为了节省资源,当一个类的所有对象属性全部相同时,测没有必要创建多对象

实例:
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()
Person()