一、Type创建类
class A(object):
def __init__(self, name):
self.name = name
def __new__(cls, *args, **kwargs):
data = object.__new__(cls)
return data
根据类创建对象
obj=A(‘kobe’)
1、执行类的new方法，创建对象（空对象）,【构造方法】 {}
2、执行类的init方法，初始化对象 ,【初始化方法】 {‘name’:‘kobe’}
对象是基于类创建出来的；问题：类是由谁创建的？
类默认是由type创建的
1、传统方式创建类
class A(object):
v1 = 123
def func(self):
return 666
print(A) #<class '__main__.A'>
2、非传统方式
类名
继承类
成员
A1 = type('A', (object,), {"v1": 123, "func": lambda self: 666})
print(A1) #<class '__main__.A'>
# 根据类创建对象
obj1 = A1() #<__main__.A object at 0x0000017049D035E0>
print(obj1)
# 调用对象中的func方法
print(obj1.func()) #666
类默认由type创建，怎么让一个类的创建改为其他的东西呢？ 元类。
二、元类
元类：指定类由谁来创建
1、Foo类由MyType创建，代码如下
class MyType(type):
pass
# Foo类由MyType创建
class Foo(object, metaclass=MyType):
pass
2、假设Foo是一个对象，它是由MyType类创建。
class MyType(type):
def __init__(self, *args, **kwargs):
print('init')
super().__init__(*args, **kwargs)
def __new__(cls, *args, **kwargs):
# 创建类
print('new')
new_cls = super().__new__(cls, *args, **kwargs)
print(new_cls)
return new_cls
# 假设Foo是一个对象，由MyType类创建。
class Foo(object, metaclass=MyType):
pass
执行结果
new
<class '__main__.Foo'>
init
3、类加括号得到的是对象，执行的是__init__()和__new__()方法，对象加括号执行__call__()方法
class F1(object):
def __init__(self):
print('init')
# def __new__(cls, *args, **kwargs):
# print('new')
def __call__(self, *args, **kwargs):
print(111)
# 类加括号得到的是对象，执行的是__init__和__new__方法
obj = F1()
# 对象加括号执行call方法
obj()
执行结果
init
111
4、假设Foo是一个对象，由MyType创建。
Foo类其实是MyType的一个对象。
Foo() 加括号执行的是——》MyType类中的__call__()方法
__call__()方法实现的功能是：
1、调用自己那个类的__new__方法创建对象
empty_object=self.__new__(self)
2、调用你自己那个类__init__方法去初始化对象
self.__init__(empty_object,*args,**kwargs)
3、将创建的对象返回：return empty_object
class MyType(type):
def __init__(self, *args, **kwargs):
print('init')
super().__init__(*args, **kwargs)
def __new__(cls, *args, **kwargs):
# 创建类
print('new')
new_cls = super().__new__(cls, *args, **kwargs)
print(new_cls)
return new_cls
def __call__(self, *args, **kwargs):
# 1、调用自己哪个类的__new__方法创建对象
empty_object=self.__new__(self)
#2、调用你自己那个类 __init__方法去初始化
self.__init__(empty_object,*args,**kwargs)
return empty_object
# 假设Foo是一个对象，由MyType创建。
# Foo类其实是MyType的一个对象。
# Foo() ——》MyType对象()
class Foo(object, metaclass=MyType):
def __init__(self,name):
self.name=name
v1=Foo('666')
print(v1)
print(v1.name)
三、总结
1、当我们不写MyType类时，Type中已经帮我们定义好了__init____new____call__ 方法了
当我定义了MyType类时，__init____new____call__ 方法是我们自己定义的
2、这就是为什么实例化对象的时候，先去创建对象再去初始化对象，Type类中已经实现了先 __new__()再__init__()
3、代码从上到下执行，当执行到class Foo(object, metaclass=MyType)时
先创建这个类，去MyType中的__new__()创建方法__init__()实例化方法,类在内存中创建好了，
但是MyType中的__call__()方法是不执行的,因为类后面没有加括号
如果类后面加了括号Foo()，会执行MyType的__call__()方法
4、如果自己定义的类中实现了__call__方法，此时是不会执行的，因为Foo是MyType创建出来的
5、如果要执行Foo类的__call__方法，需要实例化Foo类的对象v1，
然后v1加括号
