python 面向对象十二元类

一、类也是对象

只要使用关键字class，Python解释器在执行的时候就会创建一个对象。下面的代码段：

 class ObjectCreator(object):

     pass

将在内存中创建一个对象，名字就是ObjectCreator。这个对象（类）自身拥有创建对象（类实例）的能力。

它的本质仍然是一个对象，于是乎你可以对它做如下的操作：

1) 你可以将它赋值给一个变量

2) 你可以拷贝它

3) 你可以为它增加属性

4) 你可以将它作为函数参数进行传递

 >>> class ObjectCreator(object):

 ...     pass

 ...

 >>> print(ObjectCreator)    # 可以打印，因为也是个对象

 <class '__console__.ObjectCreator'>

 >>> print(type(ObjectCreator))

 <class 'type'>

 >>> def echo(o):

 ...     print(o)

 ...

 >>> echo(ObjectCreator)     # 当做参数

 <class '__console__.ObjectCreator'>

 >>> hasattr(ObjectCreator, 'new_attribute')

 False

 >>> ObjectCreator.new_attribute = 'foo'    # 增加属性

 >>> hasattr(ObjectCreator, 'new_attribute')

 True

 >>> ObjectCreator.new_attribute

 'foo'

 >>> ObjectCreatorMirror = ObjectCreator    # 赋值给变量

 >>> ObjectCreatorMirror()

 <__console__.ObjectCreator object at 0x0000000002CB38D0>

二、使用type动态创建类

type可以接受一个类的描述作为参数，然后返回一个类。type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值））

 >>> MyShinyClass = type('MyShinyClass', (), {})

 >>> MyShinyClass

 <class '__console__.MyShinyClass'>

 >>> MyShinyClass()

 <__console__.MyShinyClass object at 0x0000000002CB3978>

 >>> MyShiny = type('MyShinyClass', (), {})

 >>> MyShiny

 <class '__console__.MyShinyClass'>

 >>> MyShinyClass

 <class '__console__.MyShinyClass'>

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

>>> Foo.bar

True

>>> f = Foo()

>>> f.bar

True

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

 >>> FooChild

 <class '__console__.FooChild'>

 >>> FooChild.bar

 True

>>> def echo_bar(self):

…       print(self.bar)

…

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

>>> hasattr(Foo, 'echo_bar')

False

>>> hasattr(FooChild, 'echo_bar')

True

>>> my_foo = FooChild()

>>> my_foo.echo_bar()

True

三、元类

元类就是用来创建类的“东西”。元类创建类对象，类对象创建实例对象。

type可以动态创建类，是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。

四、metaclass

在用 class 语句自定义类时，默认 metaclass 是 type，我们也可以指定 metaclass 来创建类。

五、自定义元类

元类的主要目的就是为了当创建类时能够自动地改变类。通常，你会为API做这样的事情，你希望可以创建符合当前上下文的类。假想一个很傻的例子，你决定在你的模块里所有的类的属性都应该是大写形式。

 class UpperAttrMetaclass(type):

     def __new__(cls, name, bases, dct):

         print(name, bases, dct)

         attrs = ((name, value)

                  for name, value in dct.items() if not name.startswith('__'))

         uppercase_attr = dict((name.upper(), value) for name, value in attrs)

         return super(UpperAttrMetaclass,

                      cls).__new__(cls, name, bases, uppercase_attr)

 class Foo(object, metaclass=UpperAttrMetaclass):

     bar = 'bip'

 print(hasattr(Foo, 'bar'))

 # 输出: False

 print(hasattr(Foo, 'BAR'))

 # 输出:True

 f = Foo()

 print(f.BAR)

 # 输出:'bip'

 sensitive_words_list = ['asshole', 'fuck', 'shit']

 def detect_sensitive_words(st):

     '''检测敏感词汇'''

     words_detected = list(filter(

         lambda word: word in st.lower(), sensitive_words_list))

     if words_detected:

         raise NameError('Sensitive words {0} detected in the string "{1}".'

                         .format(', '.join(map(lambda s: '"%s"' % s,

                                               words_detected)), st)

                         )

 class CleanerMeta(type):

     def __new__(cls, class_name, bases, attrs):

         detect_sensitive_words(class_name)  # 检查类名

         map(detect_sensitive_words, attrs.keys())  # 检查属性名

         print("Well done! You are a polite coder!")  # 如无异常，输出祝贺消息

         return super(CleanerMeta, cls).__new__(cls, class_name, bases, attrs)

         # 重要！这行一定不能漏！！这回调用内建的类构造器来构造类，否则定义好的类将会变成 None

 class APIBase(object, metaclass=CleanerMeta):

     pass

 a = APIBase()

 print(a.__class__)

 print(a.__class__.__class__)

 print(a.__class__.__class__.__class__)

输出：

Well done! You are a polite coder!

<class '__main__.APIBase'>

<class '__main__.CleanerMeta'>

<class 'type'>

创建

python 面向对象十二 元类

python 面向对象十二元类