面向对象高级 1.反射 2.元类 # 24

面向对象高级
1.反射

""""""
"""
该文件作为框架的配置文件

    作为框架使用者 ,
    在配置文件中指定你配合框架的类是哪个
"""
CLASS_PATH = "libs.plugins.LinuxCMD"

# window系统终端
class WinCMD:
    def cd(self):
        print('wincmd   切换目录...')
    def delete(self):
        print('wincmd 要不要删库跑路')
    def dir(self):
        print("wincmd 列出所有文件")
# Linux系统终端
class LinuxCMD:
    def cd(self):
        print("Linuxcmd 切换目录")
    def rm(self):
        print("Linux 要不要删库跑路")
    def ls(self):
        print("Linuxcmd 列出所有文件")

""""""
"""
面向对象高级

1.反射 reflect
    什么是反射,其实就是反省,自省的意思
    
    反射指的是一个对象应该具备,可以检测,修改增加自身属性的能力
    
    本质:反射就是通过字符串操作属性
    
    
"""
"""
2.涉及的四个函数,
    这四个函数就是普通的内置函数,
    没有双下划綫,与print等等没有区别

    hasattr, 判断某个对象是否存在某个属性
    getattr,从对象中取出属性
    setattr,为对象添加新的属性
    delattr,从对象中删除属性
"""

# 案例
class Person:
    def __init__(self,name,age,money):
        self.name = name
        self.age = age
        self.money = money
p = Person('llx','24','11111')
# 1.hasattr, 判断某个对象是否存在某个属性
print(hasattr(p,'name'))  # True
# hasattr(对象,属性)
# 2.getattr,从对象中取出属性 的值
print(getattr(p,'name'))  # llx
# getattr(对象,属性)
# 3.setattr,为对象添加新的属性
setattr(p,'number',20000)
print(p.number)  # 20000
# setattr(对象,属性,默认值)
# 4.delattr,从对象中删除属性
delattr(p,'name')
print(p.name)  #  'Person' object has no attribute 'name'
# delattr(对象,属性)

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

""""""
"""
反射--框架的基石
"""
"""
1.为什么?
    因为框架的设计者,不可能提前知道你的对象到底是怎么设计的
    所以你提供的框架对象必须经过判断验证之后才能正常使用

    判断验证就是反射要做的事情
    当然通过__dict__也是可以实现的,其实这些方法也就是对__dict__的操作进行了封装
"""
"""
在框架设计中,我们不可能提前知道
故:框架的用户要提供类相关的信息
"""
# 代码如下
# Python提供了importlib包作为标准库的一部分。目的就是提供Python中import语句的实现（以及__import__函数）。另外，importlib允许程序员创建他们自定义的对象，可用于引入过程（也称为importer）。

# 1.写活代码框架
# 导入库
import importlib
# 抽象类
import abc

# 1.拿到模块 根据模块的路径
p1 = importlib.import_module("libs.plugins")  # plugins插件  # import_module 导入模块
print(p1)
"""
<module 'libs.plugins' from '
E:\Python课堂内容整理\知识点框架
\函数--装饰器--迭代器--生成器--常用模块--ATM
\day24元类和反省\libs\plugins.py'>
"""
# 2.从模块中取出类
cls = getattr(p1,'WinCMD')
print(cls)  # <class 'libs.plugins.WinCMD'>
# 3.实例化产生对象
obj = cls()
obj.cd()  # wincmd   切换目录...
"""
"""

""""""
"""
2.案例
需求:要实现一个用于处理用户的终端指令的小框架
框架就是已经实现了最基础的构架,就是所有项目都一样的部分
"""
# 插件
from libs import plugins
# 框架已经实现的部分
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!")
# 创建一个插件对象,调用框架来使用它
wincmd = plugins.WinCMD()
# 框架之外的部分就有自定义对象来完成
linux = plugins.LinuxCMD()
run(linux)
"""
请输入指令>>>:12
该指令不受支持
请输入指令>>>:exit
see you la la!
"""

""""""
"""
上述(指:3.应用-插件.py)框架代码中 写死了必须使用某个类,这是不合理的,因为无法提前知道对方的类在什么地方 以及类叫什么

所以我们应该为框架的使用者提供一个配置文件,要求对方将累的信息写入配置文件 

然后框架自己去加载需要的模块
"""
"""
最后的框架代码:
"""
# 导入库
import importlib
# 插件
from libs import plugins
# 配置文件
from conf 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!")
# 1.创建一个插件对象
wincmd = plugins.WinCMD()  # <module 'libs.plugins' from 'E:\Python课堂内容整理\知识点框架\函数--装饰器--迭代器--生成器--常用模块--ATM\day24元类和反省\libs\plugins.py'>
# 框架之外的部分就有自定义对象来完成

# 2.框架 得根据配置文件拿到需要的类
path = settings.CLASS_PATH
# print(path) # <class 'libs.plugins.WinCMD'>
# 3.从配置中单独拿出来 模块路径和类名称
module_path,class_name = path.rsplit(".",1)  # rsplit 拆分
# print(module_path,'11111111')  # libs.plugins 11111111
# print(class_name,'222222222222')  # LinuxCMD 222222222222
# 4.拿到模块
mk = importlib.import_module(module_path)
# print(mk,'33333333333')  # <module 'libs.plugins' from 'E:\Python课堂内容整理\知识点框架\函数--装饰器--迭代器--生成器--常用模块--ATM\day24元类和反省\libs\plugins.py'> 33333333333
# 5.拿到类
cls = getattr(mk,class_name)
# print(cls,'444444')  # <class 'libs.plugins.LinuxCMD'> 444444
# 6.实例化对象
obj = cls()
# print(obj,'5')  # <libs.plugins.LinuxCMD object at 0x0000025531A432B0> 5
# 7.调用框架
run(obj)
"""
wincmd   切换目录...
libs.plugins.LinuxCMD
请输入指令>>>:dir
该指令不受支持...
请输入指令>>>:cd
Linuxcmd 切换目录
请输入指令>>>:delete
该指令不受支持...
请输入指令>>>:dir
该指令不受支持...
请输入指令>>>:rm
Linux 要不要删库跑路
请输入指令>>>:ls
Linuxcmd 列出所有文件
请输入指令>>>:exit
see you la la!
"""
# 如此一来,框架就与实现代码彻底解耦了,只剩下配置文件

2.元类

""""""
"""
1.元类 metaclass
    
    元类是什么?
        用于创建类的类
    
    万物皆对象,类当然也是对象
    
    对象是由类实例化产生的,
    如果类也是对象,
    必然类对象也是由另一个类实例化产生的
    
    默认情况下,所有类的元类都是type
"""
# 2.验证
class Person:
    pass
p = Person()
print(type(p))  # <class '__main__.Person'>
print(type(Person))  # <class 'type'>

# 结论:Person类是由type类实例化产生的
"""
3.元类的三大属性
"""
# 案例
class Student(object):
    pass
print(type(Student),'元类的三大属性')  # <class 'type'> 元类的三大属性
# 结论:直接调用type类来产生对象
"""
一个类的三个基本组成部分:
    1.类的名字(字符类型)
    2.类的父类们(是一个元组或列表(需要看具体情况))
    3.类的名称空间 (字典类型)
"""
cls_obj = type('Dog',(),{})
# 用元类生成一个类
print(cls_obj)  # <class '__main__.Dog'>


"""
4.学习元类的目的

    高度自定义的一个类,
    例如控制类的名字必须一大驼峰的形式来书写
    
    类也是对象,也有自己的类
    
    需求:创建类对象做一些限制
    由此想到初始化方法 我们需要找到类对象的类(元类),覆盖其中,init方法就能实现需求
    
    当然我们不能修改源代码,所以应该继承type来编写自己的元类,同时覆盖init来完成需求
"""
"""
5.自定义元类
"""
# 代码如下
# 只要继承了type 那么这个类就变成了一个元类
class MyType(type):
    # 元类 的三大属性:类名称(字符类型),父类(元组或列表),名称空间(字典)
    def __init__(self,clss_name,base,dict):
        super().__init__(clss_name,base,dict)
        print(clss_name,base,dict)
        if not clss_name.istitle():  # istitle 判断是否为字符串
            raise Exception('类名类型错误,应为字符串类型')  # Exception 例外的错误

# 为下列类指定元类
# 1
class Pig(metaclass=MyType):
    pass
# Pig () {'__module__': '__main__', '__qualname__': 'Pig'}
MyType("Pig",(),{})  # Pig () {}

# 2
class A(metaclass=MyType):
    pass
# A () {'__module__': '__main__', '__qualname__': 'A'}
MyType("A",(),{})  # A () {}

""""""
"""
1.元类中call方法
"""
"""
执行时机:
    当你调动类对象时会自动执行元类中的__call__方法
    并将这个类本身作为第一个参数传入,以及后面一堆参数
    
    覆盖元类中的call之后,这个类就无法产生对象,
    必须调用super().__call__()来完成对象的创建
    并返回其返回值
    
2.使用场景
    当你想要控制对象的创建过程时,就覆盖call方法,
    当你想要控制类的创建过程时,就覆盖init方法
"""
# 3.案例
class MyType(type):
    # 执行时机:
    # 当你调动类对象时会自动执行元类中的__call__方法
    def __call__(self, *args, **kwargs):
        new_args = []
        for a in args:
            new_args.append(a.upper())  # upper 大写
        print(new_args)
        print(kwargs)
        return super().__call__(*new_args,**kwargs)

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

p = Pig('llx',gender='nan')
# print(new_args)  #['LLX']
# print(kwargs)  # {'gender': 'nan'}
print(p.name)  # LLX

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

''''''
"""
元类的new方法
"""
"""
执行时机:   
    创建类对象时,会首先执行元类中的__new__方法,拿到一个空对象,然后自动调用 __init__来对这个类进行初始化操作

ps:
    如果你覆盖了该方法则必须保证,new方法必须有返回值.且必须是对应类对象
"""
# 2.案例
class Mete(type):
    # 创建类对象时,会首先执行元类中的__new__方法,拿到一个空对象,然后自动调用 __init__来对这个类进行初始化操作
    def __new__(cls, *args, **kwargs):
        print(cls)  # <class '__main__.Mete'> # 元类自己
        print(args)  # ('A', (), {'__module__': '__main__', '__qualname__': 'A'})  # # 创建类需要的几个参数  类名,基类,名称空间
        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=Mete):
    pass
print(A)
"""
new run
init run
<class '__main__.A'>
"""
"""
结论:总结new方法和init 都可以实现控制类的创建过程,new和init都存在.__new__优先级更高,init更简单
"""

''''''
"""
1.单例设计模式
    设计模式用于解决某种固定问题的套路
    例如:MVC MTV等
    
    单例:指的是一个类产生一个对象
    
    为什么要使用单例?
        单例是为了节省资源 
        当一个类的所有对象属性全部相同时,则没有必要创建多个对象
"""
# 2.案例
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say_hi(self):
        print("hello %s"%self.name)
    # 用于获取对象的方法
    @staticmethod
    def get_instance():
        # 判断是否有了对象(即:属性是否在类中)
        if hasattr(Person,'obj'):
            return getattr(Person,'obj')
        obj = Person('llx',24)
        Person.obj = obj
        print('new run')
        return obj
p = Person.get_instance()
p.say_hi()
p2 = Person.get_instance()
p2.say_hi()

p3 = Person.get_instance()
p3.say_hi()
"""
new run
hello llx
hello llx
hello llx
"""
# 单例模式 -- 优化
class Single(type):
    def __call__(self, *args, **kwargs):
        # 判断是否有了对象(即:属性是否在类中)
        if hasattr(self,"onj"):
            return getattr(self,"onj")
        # onj = type.__call__(self, *args, **kwargs)  #
        onj = super().__call__(self,*args, **kwargs) # 没有则创建
        print('new onj')
        self.onj = onj  # 并存入类中
        return onj
class Student(metaclass=Single):
    def __init__(self,name):
        self.name = name
class Teacher(metaclass=Single):
    pass
# 单例只会创建一个对象
Student()  # new onj  # super
# Teacher()  # new onj  # type