对象的创建过程

缺乏、安全感 2021-10-26 13:58 323阅读 0赞

**阅读目录(Content)**

*  一、 type()
    
     *  1、创建类的两种方式
        
         *  方式一
         *  方式二
 *  二、元类（metaclass）
    
     *  使用metaclass的两种方式
        
         *   方式一:即用类的形式
         *  方式二：用函数的形式
     *   metaclass 原理
        
         *  1.基础
         *  2.查找顺序
 *  三、 \_\_init\_\_，\_\_new\_\_，\_\_call\_\_三个特殊方法
    
     *  1.对于\_\_new\_\_
     *  2.对于\_\_init\_\_
     *  3.对于\_\_call\_\_
 *  4、实例化对象的完整过程

回到顶部(go to top)

# 一、 type() #

## 1、创建类的两种方式 ##

### 方式一 ###

![复制代码][Image 1]

class MyClass(object):
        def func(self,name):
            print(name)
    
    myc = MyClass()
    
    print(MyClass, type(MyClass))
    print(myc, type(myc))

![复制代码][Image 1]

我们创建了一个名为MyClass的类，并实例化了这个类，得到其对象myc

上面代码打印的结果为：

`type()`函数可以查看一个类型或变量的类型，`MyClass`是一个class，它的类型就是`type`，而`myc`是一个实例，它的类型就是class `MyClass`。

我们说class的定义是运行时动态创建的，而创建class的方法就是使用`type()`函数。

`type()`函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过`type()`函数创建出`MyClass`类，而无需通过`Class MyClass(object)...`的定义：

### 方式二 ###

动态创建类

type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

![复制代码][Image 1]

def fn(self, name='world'): # 先定义函数
        print('Hello, %s.' % name)
    
    MyClass = type('MyClass', (object,), {
         'func':fn}) # 创建MyClass类,得到一个type的类对象
    # MyClass = type('MyClass', (object,), {'func':lambda self,name:name}) # 创建MyClass类
    
    myc=MyClass()
    
    print(MyClass, type(MyClass))
    print(myc, type(myc))

![复制代码][Image 1]

打印结果：

要创建一个class对象，`type()`函数依次传入3个参数：

1.  class的名称；
2.  继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
3.  class的方法名称与函数绑定，这里我们把函数`fn`绑定到方法名`func`上。

通过`type()`函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用`type()`函数创建出class。

**type就是创建类对象的类。**你可以通过检查\_\_class\_\_属性来看到这一点。Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类(元类，默认为type，也可以自定制)创建而来。type也是由type创建。。

回到顶部(go to top)

# 二、元类（metaclass） #

除了使用`type()`动态创建类以外，要控制类的创建行为，还可以使用metaclass。

metaclass，直译为元类，简单的解释就是：

当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。

但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义元类（不自定义时，默认用type），然后创建类。

连接起来就是：先定义metaclass，就可以创建类，最后创建实例。

所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是元类创建出来的“实例”。

默认情况下，类是使用type()构造的。类主体在一个新的名称空间中执行，类名在本地绑定到类型的结果(名称、基、名称空间)。

可以通过在类定义行中传递元类关键字参数来定制类创建过程，或者从包含此类参数的现有类继承。在下面的示例中，MyClass和MySubclass都是Meta的实例:

![复制代码][Image 1]

class Meta(type):
        pass
    
    class MyClass(metaclass=Meta):
        pass
    
    class MySubclass(MyClass):
        pass

![复制代码][Image 1]

## 使用metaclass的两种方式 ##

![复制代码][Image 1]

class MyType(type):　　# 自定义一个type的派生类 def __init__(self,*args,**kwargs):
    　　　　print('xx')
           super(MyType,self).__init__(*args,**kwargs)
    
        def __call__(cls, *args, **kwargs):
            obj = cls.__new__(cls,*args, **kwargs)
            cls.__init__(obj,*args, **kwargs)
            return obj
    
    def with_metaclass(base):
        return MyType("MyType2",(base,),{})
    
    # 方式一
    class Foo(metaclass=MyType):　　# metaclass=MyType,即指定了由MyType创建Foo类，当程序运行，用到class Foo时，即调用MyType的__init__方法，创建Foo类 def __init__(self,name):
            self.name = name
    
    
    #方式二    在Flask的wtform的源码中用到过
    # class Foo(with_metaclass(object)):
    #     def __init__(self,name):
    #         self.name = name
    
    
    a=Foo('name')

![复制代码][Image 1]

###  方式一:即用类的形式 ###

执行代码后，当遇到class Foo时即声明要创建一个Foo类，就会调用type的\_\_init\_\_方法创建类，由于此处（metaclass=MyType），即指定了Foo类的创建方式，所以会执行type的派生类MyType的\_\_init\_\_方法，创建Foo类，打印一次'xx'

**　　 \*一般情况下, 如果你要用类来实现metaclass的话，该类需要继承于type，而且通常会重写type的\_\_new\_\_方法来控制创建过程。**

**　　\* 在metaclass里面定义的方法会成为类的方法，可以直接通过类名来调用**

### 方式二：用函数的形式 ###

构建一个函数，返回一个type的派生类对象，例如叫type的派生类, 需要3个参数：name, bases, attrs

name: 类的名字

bases: 基类，通常是tuple类型

attrs: dict类型，就是类的属性或者函数

##  metaclass 原理 ##

### 1.基础 ###

metaclass的原理其实是这样的：当定义好类之后，创建类的时候其实是调用了type的\_\_new\_\_方法为这个类分配内存空间，创建好了之后再调用type的\_\_init\_\_方法初始化（做一些赋值等）。所以metaclass的所有magic其实就在于这个\_\_new\_\_方法里面了。

说说这个方法：\_\_new\_\_(cls, name, bases, attrs)

cls: 将要创建的类，类似与self，但是self指向的是instance，而这里cls指向的是class

name: 类的名字，也就是我们通常用类名.\_\_name\_\_获取的。

bases: 基类

attrs: 属性的dict。dict的内容可以是变量(类属性），也可以是函数（类方法）。

所以在创建类的过程，我们可以在这个函数里面修改name，bases，attrs的值来自由的达到我们的功能。这里常用的配合方法是

getattr和setattr（just an advice)

### 2.查找顺序 ###

元类是由以下优先规则决定的:

如果“元类”存在，它就被使用了。

否则，如果至少有一个基类，则使用它的元类(这首先查找类属性，如果没有找到，则使用它的类型)。

否则，如果一个名为元类的全局变量存在，就会使用它。

回到顶部(go to top)

# 三、 \_\_init\_\_，\_\_new\_\_，\_\_call\_\_三个特殊方法 #

\_\_new\_\_： 对象的创建，是一个静态方法，第一个参数是cls。(想想也是，不可能是self，对象还没创建，哪来的self)

其必须要有返回值，返回实例化出来的实例，需要注意的是，可以return父类\_\_new\_\_()出来的实例，也可以直接将object的\_\_new\_\_()出来的实例返回。

\_\_init\_\_ ： 对象的初始化， 是一个实例方法，第一个参数是self，该self参数就是\_\_new\_\_()返回的实例，\_\_init\_\_()在\_\_new\_\_()的基础上可以完成一些其它初始化的动作，\_\_init\_\_()不需要返回值。  
\_\_call\_\_ ： 对象可call，注意不是类，是对象。

## 1.对于\_\_new\_\_ ##

![复制代码][Image 1]

class Bar(object):
        pass
    
    class Foo(object):
        def __new__(cls, *args, **kwargs):
            return Bar()
    
    print(Foo())

![复制代码][Image 1]

打印结果为：

<__main__.Bar object at 0x0090F930>

可以看到，输出来是一个Bar对象。

\_\_new\_\_方法在类定义中不是必须写的，如果没定义，默认会调用object.\_\_new\_\_去创建一个对象。如果定义了，就是会覆盖,使用自定义的，这样就可以自定制创建对象的行为。

单例模式也可以通过这种方式来创建。[点击查看【几种单例模式的创建方法】][Link 1]

## 2.对于\_\_init\_\_ ##

![复制代码][Image 1]

class Person(object):
    
      def __init__(self, name, age):
        self.name = name
        self.age = age
        print('执行__init__')
    
      def __new__(cls, *args, **kwargs):
          obj = object.__new__(cls) # 创建对象
          print('执行__new__方法')
          return obj
    
    p1 = Person('hc', 24)
    print(p1)

![复制代码][Image 1]

打印结果：

执行__new__方法
    执行__init__
    <__main__.Person object at 0x028EB830>

\_\_init\_\_ 方法通常用在初始化一个类实例的时候，但\_\_init\_\_其实不是实例化一个类的时候第一个被调用 的方法。当使用 Persion(name, age) 这样的表达式来实例化一个类时，最先被调用的方法 其实是 \_\_new\_\_ 方法。从打印结果就可以看出来

若\_\_new\_\_()没有正确返回当前类cls的实例，那\_\_init\_\_()将不会被调用，即使是父类的实例也不行。

## 3.对于\_\_call\_\_ ##

对象通过提供\_\_call\_\_(slef, \*args ,\*\*kwargs)方法可以模拟函数的行为，如果一个对象x提供了该方法，就可以像函数一样使用它，也就是说x(arg1, arg2...) 等同于调用x.\_\_call\_\_(self, arg1, arg2) 。

![复制代码][Image 1]

class Foo(object): 
      def __call__(self): 
        pass 
     
    f = Foo()    #类()，即执行元类的__call__
    f()    #对象()，即执行Foo的__call__

![复制代码][Image 1]

回到顶部(go to top)

# 4、实例化对象的完整过程 #

class Foo(Bar):
        pass

当我们写如这段代码时，Python做了如下的操作：

**Foo中有metaclass这个属性吗？如果是，Python会在内存中通过metaclass创建一个名字为Foo的类对象（我说的是类对象，请紧跟我的思路）。如果Python没有找到metaclass，它会继续在Bar（父类）中寻找metaclass属性，并尝试做和前面同样的操作。如果Python在任何父类中都找不到metaclass，它就会在模块层次中去寻找metaclass，并尝试做同样的操作。如果还是找不到metaclass,Python就会用内置的type来创建这个类对象。**

把上面这段话反复读几次，现在的问题就是，你可以在metaclass中放置些什么代码呢？

答案就是：可以创建一个类的东西。

那么什么可以用来创建一个类呢？

type，或者任何使用到type或者子类化type的东东都可以。

以上面的代码为例，我们实例化一个对象obj=Foo()时，会先执行Foo类的\_\_new\_\_方法，没写时，用父类的\_\_new\_\_方法，创建一个对象，并返回，然后执行\_\_init\_\_方法（自己有就用自己的，没有就用父类的），对创建的对象进行初始化。

obj()会执行Foo类的\_\_call\_\_方法，没有则用父类的

我们现在已经知道，类也是对象，是元类的对象，即我们实例化一个类时，调用其元类的\_\_call\_\_方法。

**元类处理过程：定义一个类时，使用声明或者默认的元类对该类进行创建，对元类求type运算，得到父元类（该类声明的元类的父元类），调用父元类的\_\_call\_\_函数，在父元类的\_\_call\_\_函数中, 调用该类声明的元类的\_\_new\_\_函数来创建对象（该函数需要返回一个对象（指类）实例），然后再调用该元类的\_\_init\_\_初始化该对象（此处对象是指类，因为是元类创建的对象），最终返回该类**

1.对象是类创建，创建对象时候类的\_\_init\_\_方法自动执行，对象()执行类的 \_\_call\_\_ 方法  
2.类是type创建，创建类时候type的\_\_init\_\_方法自动执行，类() 执行type的 \_\_call\_\_方法(类的\_\_new\_\_方法,类的\_\_init\_\_方法)

![复制代码][Image 1]

原始type的__call__应该是参数结构应该是：
    
    　　metaname, clsname, baseclasses, attrs
    
     
    
    原始type的__new__
    
    　　metaname, clsname, baseclasses, attrs
    
     
    
    原始type的__init__
    
    　　class_obj, clsname, baseclasses, attrs
    
     
    
    元类的__new__和__init__影响的是创建类对象的行为，父元类的__call__控制对子元类的 __new__，__init__的调用，就是说控制类对象的创建和初始化。父元类的__new__和__init__由更上层的控制，
    
    　　　　一般来说，原始type是最初的父元类，其__new__和__init__是具有普遍意义的，即应该是分配内存、初始化相关信息等
    
    元类__call__影响的是创建类的实例对象的行为，此时如果类自定义了__new__和__init__就可以控制类的对象实例的创建和初始化
    
     
    
    __new__和__init__ 影响的是创建对象的行为，当这些函数在元类中时，影响创建的是类；同理，当这俩个函数在普通类中时，影响创建的是普通的对象实例。
    
    __call__ 影响()调用行为, __call__是在创建类的时候调用，即: class Test(object): __metaclass__=type, 定义类时就是创建类，此时会调用元类的__call__，如果元类有继承，子元类定义时执行的是父元类的__call__。
    
                 如果是普通类实例化对象，调用的是普通类的__call__

![复制代码][Image 1]

http://blog.jobbole.com/21351/

转载于:https://www.cnblogs.com/cmd61/p/11273692.html

[Image 1]: 
[Link 1]: http://www.cnblogs.com/huchong/p/8244279.html#_lab2_1_2