Python基础之面向对象：8、面向对象之元类

目录

• 面向对象之元类
  
  
  
  • 一、什么是元类
    
  • 二、元类推导流程
    
  • 三、创建类的方式
    
    
    
    • 方式一：
      
    • 方式二：
      
    
    
  • 四、元类定制类的产生行为
    
  • 五、元类定制对象的产生行为
    
  • 六、元类之双下new
    
  
  

面向对象之元类

一、什么是元类

• Python中一切皆为对象，对象是有类实例化生成；
  
• 类也是对象（类对象），生成类对象的类可称之为元类；
  
• 所以，元类就是来创建类对象的，可称之为类工厂；
  
• type是python内建元类，type是最上层的元类，也可称为一切类对象的元类
  

二、元类推导流程

1. """推导步骤1:如何查看数据的数据类型"""
2. # s1 = 'hello world'  # str()
3. # l1 = [11, 22, 33, 44]  # list()
4. # d1 = {'name': 'jason', 'pwd': 123}  # dict()
5. # t1 = (11, 22, 33, 44)  # tuple()
6. # print(type(s1))  # <class 'str'>
7. # print(type(l1))  # <class 'list'>
8. # print(type(d1))  # <class 'dict'>
9. # print(type(t1))  # <class 'tuple'>
11. """推导步骤2:其实type方法是用来查看产生对象的类名"""
12. # class Student:
13. #     pass
14. # obj = Student()
15. # print(type(obj))  # <class '__main__.Student'>
17. """推导步骤3:python中一切皆对象 我们好奇type查看类名显示的是什么"""
18. class Student:
19.     pass
20. obj = Student()
21. print(type(obj))  # <class '__main__.Student'>
22. print(type(Student))  # <class 'type'>
23. class A:pass
24. class B:pass
25. print(type(A), type(B))
27. """
28. 结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)
29. """

复制代码

三、创建类的方式

方式一：

创建方法：
​        直接使用class关键字创建

1. class Foo:
3.     school_name = 'kangkang
5.     def func1(self):
6.         pass
8.     print(Teacher)
9.     print(Teacher.__dict__)

复制代码

方式二：

创建方法：
​        使用元类type
​        type(类名， 类的父类， 类的名称空间)

1. cls = type('Student', (object,), {'name':'jason'})
2. print(cls)
3. print(cls.__dict__)
5. """
6. 1.手动写键值对
7.     针对绑定方法不好定义
8. 2.内置方法exec
9.     能够运行字符串类型的代码并产生名称空间
10. """

复制代码

四、元类定制类的产生行为

​        通过上述推导，我们得出了我们所创建的类，其实就是type帮我们所生成的，那么我们是否可以通过继承type（元类）的方式，来研究type底层代码原理，来改修，新增条件，来定制类的生成
例如：
​        生成类时，类名的首字母必须大写，否则报错
推导流程：

1. """
2. 推导
3.         1、对象是由类名加括号产生的          __init__
4.         2、类是由元类加括号产生的                __init__
5.         3、查看type底层源码，找到__init__
6.         __init__(cls, what, bases=None, dict=None)
7.         cls:元类本身
8.         what：需要产生的类名
9.         bases：产生类的父类
10.         dict：类体名称空间
11.         4、通过上述我们就可以发现what可以控制类名的产生
12.        
13. """
15. # 1、首先生成一个类，继承元类（type）
16.     class MyMetaClass(type):
17.         pass
18.    
19. # 2、在类中，创建def __init__(self, what, bases=None, dict=None):
20. # 3、对限制what产生类名的条件
21.         class MyMetaClass(type):
22.         
23.     def __init__(self, what, bases=None, dict=None):
24.         
25.         # 设置条件，未满足时，主动抛出异常并提示
26.         if not what.istitle():
27.             raise TypeError('类的首字母要大写')
28.             
29.         # 条件满足后调用父类进行产生
30.         super().__init__(what, bases, dict)
32. # 4、指定类的元类:利用关键字metaclass指定类的元类
33. class myclass(metaclass=MyMetaClass):
34.     desc = '元类其实很有趣 就是有点绕'
36. class Student(metaclass=MyMetaClass):
37.     info = '我是学生 我很听话'
38. print(Student)
39. print(Student.__dict__)
41. # 5、这个时候我们在生成MyMetaClass的子类时，就必须要遵循它的条件，否则将会报错

复制代码

五、元类定制对象的产生行为

要求：
​        生成的对象必须使用关键字进行传参，否则将无法生成对象
推导流程：

1. '''
2. 推导：
3.         1、我们在上述学习了类的魔法方法，发现：
4.         2、对象加括号会执行产生该对象类里的__call__
5.         3、类加括号会执行产生该类的类里的__call__
6.         4、观察__call__(self, *args, **kwargs):
7.                 self: 调用者本身
8.                 *args:接收位置实参
9.                 **kwargs：接收关键字实参
10.         5、得出结论，我们需要对args进行约束就可达到条件
11. '''
13. class MyMetaClass(type):
14.     def __call__(self, *args, **kwargs):
15.         
16.         # 1.产生一个空对象(骨架)
17.         # 2.调用__init__给对象添加独有的数据(血肉)
18.         # 3.返回创建好的对象
19.         # print(args)  # ('jason', 18, 'male')
20.         # print(kwargs)  # {}
21.         
22.                   # 设置条件
23.         if args:
24.         # 当条件未满足时，主动抛出异常，并提升
25.             raise TypeError("需要进行关键字传参")
26.             
27.         # 条件满足后执行，使用super，重新调用父类
28.         return super().__call__(*args, **kwargs)
29.            
31. class Student(metaclass=MyMetaClass):
32.     def __init__(self, name, age, gender):
33.         # print('__init__')
34.         self.name = name
35.         self.age = age
36.         self.gender = gender
38. # obj = Student('jason', 18, 'male')
39. obj = Student(name='jason',age= 18,gender= 'male')
40. print(obj.__dict__)

复制代码

六、元类之双下new

​        当我们在使用类产生对象时，类体代码种名字产生的顺序是:
​        __ call __ >>>： __ new __ >>>：__ init __
​        双下call将类名传给双下new，然后new将对象的名字传给双下init而后产生类名
​        得出结论：对象是由new进行产生的

1. class MyMetaClass(type):
2.     def __call__(self, *args, **kwargs):
3.         
4.         # 1.产生一个空对象(骨架)
5.         obj = self.__new__(self)
6.         
7.         # 2.调用__init__给对象添加独有的数据(血肉)
8.         self.__init__(obj,*args, **kwargs)
9.         
10.         # 3.返回创建好的对象
11.         return obj
13. class Student(metaclass=MyMetaClass):
14.     def __init__(self, name):
15.         self.name = name
17. obj = Student('jason')
18. print(obj.name)
19. """
20. __new__可以产生空对象
21. """

复制代码