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__ ) # Trueprint( 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完整的代码
# 英俊的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
