理解Python的元类

Singcing

已于 2024-06-16 20:56:01 修改

阅读量636

点赞数 4

分类专栏： Python学习文章标签： python 服务器 linux

于 2024-06-14 19:41:48 首次发布

本文链接：https://blog.csdn.net/m0_46306264/article/details/139679569

版权

Python学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1.type()函数

type 函数是一个内置函数，用来获取一个对象的类型。它可以接受一个参数，返回这个参数的数据类型。type也可以用来创建类，type就是元类

x=333
list=["ab"]
tuple = (1, "a", True, 3.14)
dict = {
    'name': 'Alice',
    'age': 25,
    'is_student': False
}
print(type(x)) # <class 'int'>
print(type(list)) # <class 'list'>
print(type(tuple)) # <class 'tuple'>
print(type(dict))  # <class 'dict'>

2. type(对象)和type(类)

class Student:
    def __init__(self,name,age) :
        self.name=name
        self.age=age
        
lu=Student("LuMingfei",15)

print( type(lu) )       # <class '__main__.Student'>
print( type(Student) )  # <class 'type'>
print( lu.__class__ )   # <class '__main__.Student'>
print( Student.__class__ ) # <class 'type'>

print( type(lu)==lu.__class__ ) # True
print( type(Student)==Student.__class__ ) # True

print( type(type) )
"""
<class 'type'>
"""

for x in int, float, dict, list, tuple:
   print(type(x))

"""
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
"""

3.`type()` —— `type(<name>, <bases>, <dct>)`：

3.1 example1: type()定义类,创建类

name:指定类名

base:指定一个tuple，指定父类

dct：类体的定义

Student = type('Student', (), {})
Lu = Student()

print( type(Student) ) # <class 'type'>
print( type(Lu) )       # <class '__main__.Student'>

3.2 example2：子类继承父类，定义子类的常规写法

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


class Student(Person):
    def __init__(self, name, score):
        
        super().__init__(name)
        self.score=score


Lu = Student('LuMingfei', 120)


print(Lu.name," ",Lu.score)      # LuMingfei   120
print(type(Lu))     # <class '__main__.Student'>
print(Lu.__class__) # <class '__main__.Student'>
print(Lu.__class__.__base__)    # <class '__main__.Person'>

3.3 example3：type()写法：定义子类，创建子类，子类继承父类

# 父类
class Person:
    def __init__(self, name):
        self.name = name


# 定义student的初始化函数，Student继承了Person类
def student_init(self, name, score):
    super(Student, self).__init__(name)
    self.score = score

#用字典的形式，定义student的方法和变量
StudentDict = {
    '__init__': student_init,
    'score': None
}
      #子类 type(类名，父类，方法和变量)
Student = type('Student', (Person,), StudentDict)

Lu = Student('LuMingfei', 85)

print(Lu.name," ",Lu.score)      # LuMingfei   85
print(type(Lu))     # <class '__main__.Student'>
print(Lu.__class__) # <class '__main__.Student'>
print(Lu.__class__.__base__)    # <class '__main__.Person'>

4.自定义元类

4.1 类创建对象的相关方法

new()和init()

类的new()方法生出了对象，new()创建当前类对应的对象

Student的 new() 方法生出了 lu对象，具体来说，object按照Student的模板生出了lu对象

Student的 init() 填充 lu对象的属性

class Student:

    def __new__(cls,*args) :
        print(cls," ",args) # <class '__main__.Student'>   ('LuMinfei', 120)
        """
        因为Student的父类是object,class Student: 其实是 class Student(object):
        所以obj=object.__new__(cls)
        可以替换成obj=super().__new__(cls)
        """
        # obj=super().__new__(cls)
        obj=object.__new__(cls)  # 根据类(cls)创建了一个 对象(obj)

        print(obj)          # <__main__.Student object at 0x000001C2DF270FA0>
        return obj
    
    def __init__(self,name,score):
        print(self)         # <__main__.Student object at 0x000001C2DF270FA0>
        self.name=name
        self.score=score
    
    """
    __new__()中的obj和__init__()的self的地址相同,
    __new__()先执行,然后到__init__()执行
    __new__():根据 类(cls)创建出对象(obj,也是init()中的self)
    __init__():给对象(self)初始化属性
    """
lu=Student("LuMinfei",120)

也可以这样写，*args改为**kwargs，元组形式的参数改为字典形式的参数

class Student:
    
    def __new__(cls,**kwargs) :
        # <class '__main__.Person'>   {'name': 'LuMingfei'}
        print(cls," ",kwargs) 

        obj=object.__new__(cls)

        return obj
    
    def __init__(self,name,score):
        self.name=name
        self.score=score
    

data_dict = {"name": "LuMingfei","score":120}
lu = Student(**data_dict)
print(lu.name,lu.score)

"""
我靠，**kwargs接受参数，这样写传参数也行
"""
lu=Student(name="LuMingfei",score=135)
print(lu.name,lu.score)

call()

__call__():的调用跟new()和 init()没什么关系

对象() 调用类的__call__()

class Student:

    def __new__(cls,*args) :
        # cls是 <class '__main__.Student'>
        obj=object.__new__(cls)
        # obj是 <__main__.Student object at 0x000001092EB60FA0> lu对象出生了
        return obj
    
    """当new() return obj 时就调用init"""
    def __init__(self,name,score):       
        self.name=name
        self.score=score
    
    """对象(),调用 类的 call()"""
    def __call__(self, *args):
        # 这里的self就是对象lu,self和lu地址相同
        print(self)     # <__main__.Student object at 0x000001092EB60FA0>
        print(args)     # (1, 2, 3, 4, 5, 7, 9, 91)

lu=Student("LuMinfei",120)
# 对象(),调用 类的 call()
lu(1,2,3,4,5,7,9,91)
print(lu)               # <__main__.Student object at 0x000001092EB60FA0>

type创建了类，type是元类

"""
简略写法
"""
class Person:
    pass
print(type(Person)) # <class 'type'>


"""
实际上:
1.Person继承了object
2.type创建了Person
3. type就是传说中的元类，能创建各种 类
"""
class Person(object,metaclass=type):
    pass
print(type(Person)) # <class 'type'>

4.2 自定义元类

用 元类(type) 生成 另一个元类，用 另一个元类 生成常规的类(比如:Person, Student)

也可以说，改造一下type，用 改造过的type 创建常规类。用改造过的type的call方法来创建常规类

定义HandsomeType，改造过的type

new()创建当前类对应的对象，HandsomeType对应的对象是 Student类，

特别的

没有这种：handsometype=HandsomeType(),

只有 Student=HandsomeType(),

然后 lu=Student("name","score")

class HandsomeType(type):
    """
    cls是HandsomeType类
    *args:是Student类的结构

    cls:<class '__main__.HandsomeType'>
    args:('Student', (), 
        {'__module__': '__main__', 
        '__qualname__': 'Student', 
        '__new__': <function Student.__new__ at 0x000002785A349E50>, 
        '__init__': <function Student.__init__ at 0x000002785A349EE0>})
    """
    def __new__(cls,*args) :
       pass

代码什么时候会执行HansomeType中的__new__()方法？

在Python中，当程序使用元类定义一个类，比如 Student(metaclass=HandsomeType)，Python会在类创建过程中自动调用元类的某些方法。eg.__new__(), __init__()

class HandsomeType(type):
    """
    cls是HandsomeType类
    *args:是Student类的结构
    new方法生成Student这个类
    """
    def __new__(cls,*args) :
        # super().__new__(cls,*args)
        StudentClxx=type.__new__(cls,*args)
        print(StudentClxx)  # <class '__main__.Student'>
        return StudentClxx
    def __init__(self,*args):
        print(self)        # <class '__main__.Student'>

class Student(metaclass=HandsomeType):
    
    """生成Student类的对象"""
    def __new__(cls,*args) :
        obj=object.__new__(cls)
        return obj
    
    def __init__(self,name,score) :
        self.name=name
        self.score=score

"""
代码什么时候会执行HansomeType中的__new__()方法？
在Python中，程序使用元类定义一个类，
比如 Student(metaclass=HandsomeType)，、
Python会在类创建过程中自动调用元类的某些方法。eg.__new__(), __init__()
"""

完整的代码。使用HandsomeType创建Student类

HandsomeType在自己的new方法创建了Student类。

Student()时，Student类的创建者(HansomeType)的call方法被调用，在call中，Student调用Student自己的new方法创建lu对象

# 英俊的Type也是继承于object，被type创建的
class HandsomeType(type):
    """
    cls是HandsomeType类
    *args:是Student类的结构
    """
    def __new__(cls,*args):

        """可以替换成 obj=super().__new__(cls,*args)"""
        StudentClaxx=type.__new__(cls,*args)

        return StudentClaxx # return触发init()方法
    
    def __init__(self,*args):
        # 这里的self已经是Student类了
        print(self) # <class '__main__.Student'>
        pass
    
    """当 lu = Student(lumingfei,120)时，call调用"""
    def __call__(self,*args):
        # self是Student类
        # Student类调用_new_()创建lu对象
        lu=self.__new__(self,*args)
        # 根据参数初始化lu对象
        self.__init__(lu,*args)

        return lu

class Student(metaclass=HandsomeType):

    def __new__(cls,*args) :

        obj=object.__new__(cls)

        return obj
    
    def __init__(self,name,score) :
        self.name=name
        self.score=score

"""
此时，到这一样，Student类已经倍创建了
下一行的Student()会调用 HandsomeType的call方法()
"""
lu=Student("LuMingfei",135)
print(lu.name,lu.score)  # LuMingfei 135