面向对象之高级篇 反射，元类

今日内容

1.反射

2.元类

3.单列模式

 

一 反射（反省）

什么是反省：
　　通过字符串来反射，映射到对象，类的属性上，英文中叫反省（自省）

面向对象中的反省，指的是一个对象必须具备，发现自身属性，以及修改自身属性的能力：

一个对象在设计初期，可能考虑不够周全，后期需要删除或者修改已经存在的属性，和增加属性

反省就是通过字符串啦操控对象属性

涉及到的有四种方法：

　　　hasattr：判断是否存在某个属性

　　　getattr：获取某个属性的值

　　　setattr：新增或者修改某个属性

　　　delattr：删除某个属性

注意：只要点能访问的属性，以上四个方法都能操作

案例：四个方法

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

    def run(self):
        print('%s is running'%self.name)

pe = People('zy',19)

print(pe.__dict__)#{'name': 'zy', 'age': 19}

print(pe.name) # pe.__dict__['name']

pe.name = 'zhangyu' # pe.__dict__['name] = 'zhangyu'

del pe.name # del pe.__dict__['name']

四个方法
查看是否在里面
print(hasattr(pe,'name')) # 'name' in pe.__dict__

获取值
print(getattr(pe,'name')) # pe.__dict__['name']

通过键获取值要是键不存在的话，会报错，但你也可以加上一个None让他不报错，打印None
print(getattr(pe,'xxx',None)) # pe.__dict__['xxx']

可以修改值
setattr(pe,'name','zhangyu') # pe.__dict__['name']='zhnagyu'
print(pe.name)
print(pe.__dict__)# {'name': 'zhangyu', 'age': 19}

删除
把name这个键值对删除了
delattr(pe,'name')
print(pe.__dict__)

反射的案例：

class Ftp:
    def get(self):
        print('get')

    def put(self):
        print('put')

    def login(self):
        print('login')

    def run(self):
        while True:
            cmd = input('>>>').strip()
            if hasattr(self,cmd):
                method = getattr(self,cmd)
                method()
            else:
                print('输入的方法不存在')

obj = Ftp()

obj.run()

二 元类

元类简介：
　　元类是什么，用于创建类的类，万物皆对象，类也是对象，

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

　　实例化产生的，默认情况下所有类的元类都是type

案例：

　　

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

    def score(self):
        print('%s is scoring'%self.name)

t = OldboyTeacher('zy',19,'male')
print(type(t))
print(type(OldboyTeacher))


对象t 是调用OldboyTeacher类得到的，如果说一切皆对象的话，
那么OldboyTeacher也是一个对象，只要是对象，都是调用一个类
实例化得到的，即OldboyTeacher = 元类，内置的元类是type

为什么要学习元类：

　　高度的自定义一个类，列如控制类的名字必须以大驼峰的方式来书写，

　　类也是对象，也有自己的类，我们的需求是创建类对象做一些限制

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

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

　案例：

"""
只要继承了type 那么这个类就变成了一个元类
"""
# 定义了一个元类
class MyType(type):
    def __init__(self,clss_name,bases,dict):
        super().__init__(clss_name,bases,dict)
        print(clss_name,bases,dict)
        if not clss_name.istitle():
            raise Exception("你丫的 类名不会写...")

# 为pig类指定了元类为MyType
class Pig(metaclass=MyType):
    pass

class Duck(metaclass=MyType):
    pass

元类中的call方法：

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

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

使用场景：　

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

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

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

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

        print(new_args)
        print(kwargs)
        return super().__call__(*new_args,**kwargs)


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

p = Person(name="jack",gender="woman")
print(p.name)
print(p.gender)

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

元类中的new方法：

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

案例：

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
    def __init__(self,a,b,c):
        super().__init__(a,b,c)
        print("init run")
class A(metaclass=Meta):
    pass
print(A)

总结：

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

元类总结：owen版

# 元类：所有自定义的类本身也是对象，是元类的对象，所有自定义的类本质上是由元类实例化出来了
Student = type('Student', (object, ), namespace)

class MyMeta(type):
    # 在class Student时调用：Student类的创建 => 来控制类的创建
    
    # 自定义元类，重写init方法的目的：
    # 1.该方法是从type中继承来的，所以参数同type的init
    # 2.最终的工作(如果开辟空间，如果操作内存)还是要借助type
    # 3.在交给type最终完成工作之前，可以对类的创建加以限制 *****
    def __init__(cls, class_name, bases, namespace):
        # 目的：对class_name | bases | namespace加以限制 **********************
        super().__init__(class_name, bases, namespace)
    
    # 在Student()时调用：Student类的对象的创建 => 来控制对象的创建
    
    # 自定义元类，重写call方法的目的：
    # 1.被该元类控制的类生成对象，会调用元类的call方法
    # 2.在call中的返回值就是创建的对象
    # 3.在call中
    #       -- 通过object开辟空间产生对象
    #       -- 用被控制的类回调到自己的init方法完成名称空间的赋值
    #       -- 将修饰好的对象反馈给外界
    def __call__(cls, *args, **kwargs):
        # 目的：创建对象，就可以对对象加以限制 **********************
        obj = object.__new__(cls)  # 通过object为哪个类开辟空间
        cls.__init__(obj, *args, **kwargs)  # 调回当前被控制的类自身的init方法，完成名称空间的赋值
        return obj

# 问题：
# 1.继承是想获得父级的属性和方法，元类是要将类的创建于对象的创建加以控制
# 2.类的创建由元类的__init__方法控制
#        -- 元类(class_name, bases, namespase) => 元类.__init__来完成实例化
# 3.类的对象的创建由元类的__call__方法控制
#         -- 对象产生是需要开辟空间，在__call__中用object.__new__()来完成的
class Student(object, metaclass=MyMeta):
    pass

# class Student:  <=>  type(class_name, bases, namespace)

元类总结：egon版

'''
元类介绍
什么是元类：
    源自一句话：在Python中，一切皆对象，而对象都是由类实例化得到的

'''

# class OldboyTeacher:
#     def __init__(self,name,age,sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
#     def score(self):
#         print('%s is scoring'%self.name)
#
# t = OldboyTeacher('zy',19,'male')
# print(type(t))
# print(type(OldboyTeacher))
'''
对象t 是调用OldboyTeacher类得到的，如果说一切皆对象的话，
那么OldboyTeacher也是一个对象，只要是对象，都是调用一个类
实例化得到的，即OldboyTeacher = 元类，内置的元类是type

关系
1. 调用元类----->自定义的类
2. 调用自定义的类---->自定义的对象
'''



'''
class关键字创建自定义类的底层的工作原理，分为四步
1.先拿到类名：'OldboyTeacher'
2.再拿到类的基类们:(object)
3.然后拿到类的名称空间（执行类体代码，将产生的名字放到类的名称空间，也就是一个字典里，补充一个exec）
4. 调用元类实例化得到自定义的类: OldboyTeacher=type('OldboyTeacher',(object,),{...})
'''
# class OldboyTeacher:# OldboyTeacher=type(...)
#     school = 'Oldboy'
#     def __init__(self,name,age,sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
#     def score(self):
#         print('%s is scoring'% self.name)
'''
自定义类的三个关键组成部分：
1. 类名
2. 类的基类们
3. 类的名称空间
'''


'''
案例：
    如何不依赖class关键字创建一个自定义类
'''
# # 1. 拿到类名
# class_name='OldboyTeacher'
# #2. 拿到类的基类们:(object,)
# class_bases=(object,)
# #3. 拿到类的名称空间
# class_dic={}
# class_body="""
# school = 'Oldboy'
#
# def __init__(self,name,age,sex):
#     self.name=name
#     self.age=age
#     self.sex=sex
#
# def score(self):
#     print('%s is scoring' %self.name)
# """
# exec(class_body,{},class_dic)
# print(class_dic)
# #4. 调用type得到自定义的类
# OldboyTeacher=type(class_name,class_bases,class_dic)
#
# print(OldboyTeacher)
# # print(OldboyTeacher.school)
# # print(OldboyTeacher.score)
#
# tea1=OldboyTeacher('egon',18,'male')
# print(tea1.__dict__)
#



'''
自定义元类来控制类的产生
模板
'''
# class Mymeta(type):# 单反继承了type的类才能称之为自定义的元类，否则就是一个普通的类
#     def __init__(self,class_name,class_bases,class_dic):
#         print(self)
#         print(class_name)
#         print(class_bases)
#         print(class_dic)
#
# class OldboyTeacher(object,metaclass=Mymeta):#OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
#     school = 'Oldboy'
#
#     def __init__(self,name,age,sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
#     def score(self):
#         print('%s is scoring'%self.name)


'''
控制类的产生

1. 类名必须用驼峰法
2. 类体必须有文档注释，且文档注释不能为空
'''
# class Mymeta(type):  # 单反继承了type的类才能称之为自定义的元类，否则就是一个普通的类
#     def __init__(self, class_name, class_bases, class_dic):
#         if class_name.islower():
#             raise TypeError ('类名必须使用驼峰体')
#
#         doc = class_dic.get('__doc__')
#         if doc is None or len(doc) == 0 or len(doc.strip('
')) == 0:
#             raise TypeError ('类体中必须有文档注释，且文档注释不能为空')
#
# class OldboyTeacher(object, metaclass=Mymeta):  # OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
#     school = 'Oldboy'
#     def __init__(self, name, age, sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
#     def score(self):
#         print('%s is scoring' % self.name)
# print(OldboyTeacher.__dict__)



'''
自定义元类来控制类调用的过程
#总结:对象之所以可以调用,是因为对象的类中有一个函数__call__
#推导:如果一切皆对象,那么OldboyTeacher也是一个对象,该对象之所可以调用,肯定是这个对象的类中也定义了一个函数__call__
'''

# 实例化OldboyTeacher，或者说调用OldboyTeacher类
#1.先产生一个空对象
#2.执行__init__方法，完成对象的初始化属性操作
#3.返回初始化好的那个对象
#推导：调用OldboyTeacher（....）就是在调用OldboyTeacher的类中的__call__,那么在__call__中就腰做以上三件事

# 自定义元类来控制类的调用（即类的实例化过程）

class Mymeta(type):  # 单反继承了type的类才能称之为自定义的元类，否则就是一个普通的类
    def __call__(self,*args,**kwargs):#self=OldboyTeacher这个类,args=('egon',18,'male'),kwargs={}
        # 1.先产生一个空对象
        tea_obj = self.__new__(self)# tea_obj是OldboyTeacher这个类的对象
        # 2. 执行__init__方法,完成对象的初始属性操作
        self.__init__(tea_obj,*args,**kwargs)
        # 变为私有的
        tea_obj.__dict__ = {('_%s__%s' % (self.__name__, k)): v for k, v in tea_obj.__dict__.items()}
        # 3. 返回初始化好的那个对象
        return tea_obj

class OldboyTeacher(object, metaclass=Mymeta):  # OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
    school = 'Oldboy'
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def score(self):
        print('%s is scoring' % self.name)

tea1 = OldboyTeacher('egon',18,'male')# 会触发OldboyTeacher的类，即（元类）中的__call__函数
print(tea1.__dict__)

三 单列模式

什么是单列模式：　

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

元类实现案例：

# 单例n元类
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()