Python类的定义再简单不过了。不过你有想过动态定义一个Python类吗?What?动态定义,是动态解析Python代码吗?不,这仍然是静态定义。我是说,干预类的创建过程,在类的创建过程中,对类中的一切东西动态干预,这个听起来很酷,那么到底是怎么做到的呢?继续看文章吧!在理解元类之前,首先需要掌握Python的类。Python从Smalltalk语言中借用了一个非常特殊的类概念。在大多数语言中,类只是描述如何产生对象的代码段。在Python中也是如此: class ObjectCreator(object): pass my_object = ObjectCreator() print(my_object) 输出:<__main__.ObjectCreator object at 0x1055b03c8>当你使用class关键字时,Python就会执行class代码块中的代码,并创建一个对象。class ObjectCreator(object): pass 这段代码在内存中创建了一个名为ObjectCreator的对象。这个对象(类)本身具有创建对象(实例)的能力,这就是为什么它是一个类。但不管怎样,ObjectCreator仍然是一个对象,因此我们可以做如下事情:(4)将ObjectCreator作为值参传入函数;下面演示了ObjectCreator作为对象和类的使用过程:class ObjectCreator(object): pass
# 由于ObjectCreator是一个对象,所以可以打印ObjectCreator print(ObjectCreator)
def echo(obj): print(obj) # 可以将ObjectCreator作为值参传入函数 echo(ObjectCreator)
# 判断ObjectCreator是否存在new_attribute属性 print(hasattr(ObjectCreator, 'new_attribute')) # 为ObjectCreator动态添加属性 ObjectCreator.new_attribute = 'value' # 判断ObjectCreator是否存在new_attribute属性 print(hasattr(ObjectCreator, 'new_attribute'))
# 将ObjectCreator赋给另一个变量 ObjectCreatorMirror = ObjectCreator print(ObjectCreatorMirror.new_attribute)
print(ObjectCreatorMirror())
<class '__main__.ObjectCreator'> <class '__main__.ObjectCreator'> False True value <__main__.ObjectCreator object at 0x105053780> 由于类是对象,因此可以像创建任何对象一样动态创建类。# 将ObjectCreator赋给另一个变量 ObjectCreatorMirror = ObjectCreator print(ObjectCreatorMirror.new_attribute) print(ObjectCreatorMirror()) def choose_class(name): if name == 'foo': class Foo(object): pass return Foo # return the class, not an instance else: class Bar(object): pass return Bar
MyClass = choose_class('foo') print(MyClass) # 函数返回一个类,而不是一个类的实例 print(MyClass()) # 创建一个类实例
<class '__main__.choose_class.<locals>.Foo'> <__main__.choose_class.<locals>.Foo object at 0x10e905438> 尽管这段代码可以根据choose_class函数的参数值返回不同的Python类,但这并不是动态的,因为仍然必须自己编写整个类。由于类是对象,因此它们必须由某种东西生成。当使用class关键字时,Python会自动创建此对象。但与Python中大多数场景一样,为我们提供了一种手动进行操作的方法。使用class关键字时,Python会自动创建此对象。但是,与Python中的大多数事情一样,它为您提供了一种手动进行操作的方法。还记得type函数吗?该函数可以让你知道对象的类型。# 获取函数的类型 print(type(1)) # <type 'int'> print(type('1')) # <type 'str'> print(type(ObjectCreator)) # <type 'type'> print(type(ObjectCreator())) # <class '__main__.ObjectCreator'> type函数的功能很多,giant函数可以动态创建类。type函数可以将类的描述作为参数,并返回一个类。好吧,类型具有完全不同的能力,它也可以动态创建类。type可以将类的描述作为参数,并返回一个类。name: 类名; bases: 父类的元组(用于继承,可以为空); attrs: 包含属性名称和值的字典;
class MyShinyClass(object): pass
MyShinyClass = type('MyShinyClass', (), {}) # 返回类对象 print(MyShinyClass) # 输出结果:<class '__main__.MyShinyClass'> print(MyShinyClass()) # 创建类的实例,输出结果:<__main__.MyShinyClass object at 0x8997cec> 你会注意到,我们使用“ MyShinyClass”作为类的名称和变量来保存类引用。它们可以不同,但是没有理由使事情复杂化。class Foo(object): bar = True 可以使用下面的代码动态创建Foo类,并动态为该类添加名为bar的属性。Foo = type('Foo', (), {'bar':True})
# 使用Foo类 print(Foo) # 输出:<class '__main__.Foo'> print(Foo.bar) # 输出:True f = Foo() print(f) # 输出:<__main__.Foo object at 0x8a9b84c> print(f.bar) # 输出:True
class FooChild(Foo): pass 使用下面的代码可以动态创建继承至Foo类的FooChild类。# 动态继承Foo FooChild = type('FooChild', (Foo,), {}) print(FooChild) # 输出:<class '__main__.FooChild'> # bar属性来至于Foo类 print(FooChild.bar) # 输出:True 最后,你需要向类中添加方法。只需定义具有适当签名的函数并将其分配为属性即可。# 向FooChild类动态添加echo_bar函数 FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) print(hasattr(Foo, 'echo_bar')) # 输出:False print(hasattr(FooChild, 'echo_bar')) # 输出:True my_foo = FooChild() my_foo.echo_bar() # 输出:True 在动态创建类之后,可以向该类中添加更多方法,就像将方法添加到正常创建的类对象中一样。def echo_bar_more(self): print('yet another method') FooChild.echo_bar_more = echo_bar_more print(hasattr(FooChild, 'echo_bar_more')) # 输出:True 看到这里,你应该了解了Python类的本质。类就是对象,可以像动态创建对象一样创建Python类。Python在使用class关键字时通过使用元类来完成创建类的过程。元类是创建类的“原料”。我们定义类是为了创建对象,而我们知道,Python类是对象,所以定义元类,就是为了创建类,也就是说,元类是类的类,可以通过下面的伪代码来描绘元类和类:# 通过元类创建类 MyClass = MetaClass() # 通过类创建类实例 my_object = MyClass() 第1行代码其实相当于使用type函数动态创建MyClass类(或其他的类)MyClass = type('MyClass', (), {}) 之所以可以这么用,是因为type函数是Python用于在幕后创建所有类的元类。所以type是一个类,而不是一个普通的函数。现在还有一个疑问,Python类的命名规则都是首字母大写,那么为什么type类是首字母小写呢?我想这与str类创建字符串对象和int类创建整数对象一致性有关。type只是创建类对象的类。在Python中一切都是对象,其中包括整数,字符串,函数和类。它们都是对象。通过检查__class__属性可以看到这一点。age = 35 print(age.__class__) # 输出:<type 'int'> name = 'bob' print(name.__class__) # 输出:<type 'str'> def foo(): pass print(foo.__class__) # 输出:<type 'function'> class Bar(object): pass b = Bar() print(b.__class__) # 输出:<class '__main__.Bar'> 那么__class__的__class__是什么呢?print(age.__class__.__class__) # 输出:<type 'type'> print(name.__class__.__class__) # 输出:<type 'type'> print(foo.__class__.__class__) # 输出:<type 'type'> print(b.__class__.__class__) # 输出:<type 'type'> 我们可以看到,__class__的__class__都是同一个东西,那就是type,所以Python中的所有类都是用type创建的。如果愿意,可以将type称为“类工厂”type只是Python中的内建元类,当然,我们可以创建自己的元类。我们还可以自定义元类,一个元类可以是一个函数,函数的参数与type函数相同。现在给出一个使用元类的例子。假设已经有一个Foo类,该类中有若干个属性,都是小写,如bar等。现在要求将Foo类中所有的属性名都改成大写。要实现这个需求,当然可以一个一个地修改Foo类中属性的名,不过这简直太愚蠢了。万一以后领导又说,还是都是小写好,那岂不是又要改回来了。所以要实现这个需求,最好的方式就是使用元类。在Python2中,需要设置__metaclass__变量,不过在Python3中,使用元类的方式有所改变,需要在MyClass(metaclass=...)中使用metaclass指定元类函数,代码如下:# 元类(metaclass)将自动为该函数传递与type函数相同的参数值 def upper_attr(class_name, class_parents, class_attrs): ''' 返回一个类对象,将该对象的所有属性的名称都变成大写 ''' # 除了以'__'开头的属性外,其他的属性都变成大写 uppercase_attrs = { attr if attr.startswith('__') else attr.upper(): v for attr, v in class_attrs.items() }
# 使用type动态创建类对象 return type(class_name, class_parents, uppercase_attrs)
# 使用metaclass指定元类函数,系统会自动调用元类函数(upper_attr) # 为该函数传递的参数值与调用type函数动态创建Foo类时传入的参数值相同 class Foo(metaclass=upper_attr): bar = 'bip'
print(hasattr(Foo, 'bar')) # 输出:False print(hasattr(Foo, 'BAR')) # 输出:True # bar已经被元类函数自动改成了BAR print(Foo.BAR) # 输出:bip 我们可以看到,通过metaclass指定upper_attr函数后,在创建Foo类时将不再调用type函数,而是调用upper_attr函数,为该函数传入的参数值与type函数相同。关注「极客起源」公众号,加星标,不错过精彩技术干货
|