def choose_class(name):

  if name == 'foo':

  class Foo(object):

  pass

  return Foo # 返回的是类， 不是类的实例

  else:

  class Bar(object):

  pass

  return Bar

>>> print type(1) #数值的类型

<type 'int'>

>>> print type("1") #字符串的类型

<type 'str'>

>>> print type(ObjectCreator()) #实例对象的类型

<class '__main__.ObjectCreator'>

>>> print type(ObjectCreator) #类的类型

<type 'type'>

创建格式：type(类名, 由⽗类名称组成的元组（ 针对继承的情况， 可以为空） ，包含属性的字典（ 名称和值） )

可以⼿动像这样创建：

Test2 = type("Test2",(),{}) #定了⼀个Test2类

In [5]: Test2() #创建了⼀个Test2类的实例对象

Out[5]: <__main__.Test2 at 0x10d406b38>

class Test2:

    pass

Foo = type('Foo', (), {'bar':True})

>>> class Foo(object):

… bar = True

>>> FooChild = type('FooChild', (Foo,),{})

>>> print FooChild

<class '__main__.FooChild'>

>>> print FooChild.bar # bar属性是由Foo继承⽽来

True

>>> class FooChild(Foo):

… pass

In [46]: def echo_bar(self): #定义了⼀个普通的函数

...: print(self.bar)

...:

In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})

In [48]: hasattr(Foo, 'echo_bar') #判断Foo类中， 是否有echo_bar这个属性

Out[48]: False

In [49]:

In [49]: hasattr(FooChild, 'echo_bar') #判断FooChild类中， 是否有echo_bar这个

Out[49]: True

In [50]: my_foo = FooChild()

In [51]: my_foo.echo_bar()

True

添加类方法

In [42]: @classmethod

...: def testClass(cls):

...: print(cls.bar)

...:

In [43]:

In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,"testClass":testClass})

In [44]:

In [44]: fooclid = Foochild()

In [45]: fooclid.testClass()

True

添加静态方法

In [36]: @staticmethod

...: def testStatic():

...: print("static method ....")

...:

In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,“testStatic”:testStatic})

In [38]: fooclid = Foochild()

In [39]: fooclid.testStatic

Out[39]: <function __main__.testStatic>

In [40]: fooclid.testStatic()

static method ....

In [41]: fooclid.echo_bar()

True

看到这么多实现动态类的方法，你该明白python是怎么做到的，在这里就涉及到元类，元类就是用来创建类的东西，而创建类就是为了创建类的实例对象，所以可以这样理解，元类就是为了创建类对象的，而type实际上就是一个元类，传统类的元类就是types.classType,在python中元类的介绍中也介绍了元类，有兴趣的读者可以去看看。

你也可以定义自己的元类，用到的就是上面的属性，首先，你可以在定义⼀个类的时候为其添加__metaclass__属性。

class Foo(object):

    __metaclass__ = something…

    #...省略...

那么当python解释器看到下面代码时

class Foo(Bar):

    pass

python做了如下的操作：

1. Foo中有__metaclass__这个属性吗？ 如果是， Python会通过__metaclass__创建⼀个名字为Foo的类(对象)

2. 如果Python没有找到__metaclass__， 它会继续在Bar（ ⽗类） 中寻找__metaclass__属性， 并尝试做和前⾯同样的操作。

3. 如果Python在任何⽗类中都找不到__metaclass__， 它就会在模块层次中去寻找__metaclass__， 并尝试做同样的操作。

4. 如果还是找不到__metaclass__,Python就会⽤内置的type来创建这个类对象。

在这个__metaclass__中可以放一些什么代码呢？------可以做任何涉及到类操作的事情，用type或者其子类来完成。

下面是用自定义类来当做元类

#coding=utf-8

class UpperAttrMetaClass(type):

    # __new__ 是在__init__之前被调⽤的特殊⽅法

    # __new__是⽤来创建对象并返回之的⽅法

    # ⽽__init__只是⽤来将传⼊的参数初始化给对象

    # 你很少⽤到__new__， 除⾮你希望能够控制对象的创建

    # 这⾥， 创建的对象是类， 我们希望能够⾃定义它， 所以我们这⾥改写__new__

    # 如果你希望的话， 你也可以在__init__中做些事情

    # 还有⼀些⾼级的⽤法会涉及到改写__call__特殊⽅法， 但是我们这⾥不⽤

    def __new__(cls, future_class_name, future_class_parents, future_clas

        #遍历属性字典， 把不是__开头的属性名字变为⼤写

        newAttr = {}

        for name,value in future_class_attr.items():

            if not name.startswith("__"):

                newAttr[name.upper()] = value

        # ⽅法1： 通过'type'来做类对象的创建

        # return type(future_class_name, future_class_

        parents, newAttr)

        # ⽅法2： 复⽤type.__new__⽅法

        # 这就是基本的OOP编程， 没什么魔法

        # return type.__new__(cls, future_class_name,         future_class_parent

        # ⽅法3： 使⽤super⽅法

        return super(UpperAttrMetaClass, cls).__new__(cls, future_class_n

#python2的⽤法

class Foo(object):

    __metaclass__ = UpperAttrMetaClass

    bar = 'bip'

# python3的⽤法

# class Foo(object, metaclass = UpperAttrMetaClass):

    # bar = 'bip'

print(hasattr(Foo, 'bar'))

# 输出: False

print(hasattr(Foo, 'BAR'))

# 输出:True

f = Foo()

print(f.BAR)

# 输出:'bip'

1. 拦截类的创建

2. 修改类

3. 返回修改之后的类

哈哈，我想说的是对于元类咱们99%的人不会用到。