面向对象双下方法、元类

面向对象的双下方法

__str__

对象被执行打印（print，前端展示）操作的时候会自动触发

该方法必须返回字符串类型的数据

很多时候用来更加精准的描述对象

__del__

对象被执行（被动（垃圾回收），主动）删除操作之后自动触发

__getattr__

对象查找不存在名字的时候自动触发

__setattr__

对象在执行添加属性操作的时候自动触发

__call__

对象被加括号调用的时候自动触发

__enter__ ；__exit__

被执行with语法自动触发，绑定在一起

__enter__返回什么得到什么

__getattribute__

只要对象查找名字无论名字是否存在都会执行该方法

如果类中有__getattribute__方法，那么就不会执行__getattr__方法

__new__

元类会提及

实战

让字典具备句点符查找值的功能

class MyDict(dict):
      def __getattr__(self, item):
          return self.get(item)

      def __setattr__(self, key, value):
          self[key] = value

obj = MyDict({'name':'zhou','age':18})

具备句点符取v

print(obj.name) # zhou
print(obj.age) # 18

句点符设k:v

obj['gender'] = 'male'
obj.pwd = 123
print(obj) # {'name': 'jason', 'age': 18, 'gender': 'male', 'pwd': 123}

补全下列代码，使其运行不报错

题目：

class Context:
        pass
with Context() as ctx:
    ctx.do_something()

解：

 class Context:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def do_something(self):
        pass
    with Context() as ctx:
    ctx.do_something()

元类

含义

元类：即产生类的类

推导过程

根据前面学过的 type 知识点：

print(type(123)) # <class 'int'>
print(type([12, 33, 44])) # <class 'list'>
print(type({'name':'zhou','pwd':123})) # <class 'dict'>

这是我们注意到：class

type查看的其实是当前对象所属的类名称

class MyClass(object):
    pass
obj = MyClass()
print(type(obj))  # <class '__main__.MyClass'>
print(type(MyClass))  # <class 'type'>

class Student:
    pass
print(type(Student))  # <class 'type'>

class Teacher(MyClass):
    pass
print(type(Teacher))  # <class 'type'>

再结合元类的含义可得知：

type 就是所有类默认的元类

产生类的两种表现形式

class关键字

class C1(object):
    pass
    print(C1)  # <class '__main__.C1'>

type元类

type(类名,父类,类的名称空间)
res = type('C1', (), {})
    print(res)  # <class '__main__.C1'>

学习元类的目的：元类能够控制类的创建，也就意味着我们可以高度定制类的行为

元类的基本使用

元类是不能通过继承的方式直接指定的，需要通过关键字参数的形式修改

class MyTypeClass(type):
    pass
class C1(MyTypeClass):
    pass
print(C1) # <class '__main__.C1'>
print(type(C1)) # <class 'type'>

直接继承打印结果是没有反应的

而这里需要的关键字参数就是：metaclass

class MyTypeClass(type):
    pass
class C1(metaclass=MyTypeClass):
    pass
print(type(C1)) # <class '__main__.MyTypeClass'>

class MyTypeClass(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):
        # print(cls, cls_name, cls_bases, cls_dict)
        if not cls_name.istitle():
            raise Exception("类名的首字母必须大写 你个SD")
        super().__init__(cls_name, cls_bases, cls_dict)

class C1(metaclass=MyTypeClass):
    school = '清华大学'

class a(metaclass=MyTypeClass):
    school = '清华大学'

元类进阶操作

类里面的__init__方法和元类里面的__call__方法执行的先后顺序

对象加括号会自动执行产生该对象的类里面的__call__,并且该方法返回什么对象加括号就会得到什么

推导：类加括号会执行元类的里面的__call__该方法返回什么其实类加括号就会得到什么

class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        print('__call__ run')
        super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
      def __init__(self, name):
          print('__init__ run')
          self.name = name
obj = MyClass('jason')

类里面的__init__方法执行之前会先执行元类里面的__call__方法

强制规定：类在实例化产生对象的时候，对象的独有数据必须采用关键字参数

class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
　　　　 """__call__方法会先创建一个空对象，然后调用类里面的__init__实例化"""
        # print('__call__ run')
        # print(args,kwargs)
        if args:
            raise Exception('必须全部采用关键字参数')
        super().__call__(*args, **kwargs)

class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        # print('__init__ run')
        self.name = name

obj1 = MyClass('jason')
obj2 = MyClass(name='jason')

总结

如果你想高度定制类的产生过程：编写元类里面的__init__方法

如果你想高度定制对象的产生过程：编写元类里面的__call__方法

双下new方法

__new__用于产生空对象(类)     骨架  

__init__用于实例化对象(类)       血肉

 在__init__方法之前还要再进行__new__方法

注意

并不是所有的地方都可以直接调用，__new__ 该方法过于底层

如果是在元类的__new__里面，可以直接调用

class Meta(type):
      def __new__(cls, *args, **kwargs):
          obj = type.__new__(cls,*args,**kwargs)
          return obj

如果是在元类的__call__里面 需要间接调用

class Mate(type):
        def __call__(self, *args, **kwargs):
            obj = object.__new__(self) # 创建一个空对象
            self.__init__(obj,*args,**kwargs) # 让对象去初始化
            return obj    

实战题目

编写元类规定对象的所有数据值转大写

obj.name = 'zhou'，print(obj.name)打印结果为 ZHOU

class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        args = []
        for i in args:
            args.append(i.upper())
        return super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __setattr__(self, key, value):
        self.__dict__[key] = value.upper()

obj = MyClass('jason', 'male')
print(obj.name)
print(obj.gender)
obj.hobby = 'jdb'
print(obj.hobby)