python随用随学-元类

python中的一切都是对象

按着我的逻辑走:

• 首先接受一个公理,「python中的一切都是对象」.不要问为什么,吉大爷(Guido van Rossum,python之父)人当初就是这么设计的,不服去找他评理!
• 类是python语言的一个元素
• 那么类也是一个对象

是的,类也是一个对象,因为python中万物皆对象. 只不过类这个对象具有创建对象的能力.

那么问题来了,既然类也是一个对象,那本质上它和其他对象没有啥区别,我们可以对它进行一下操作:

• 可以赋值给一个变量
• 可以拷贝
• 可以增加属性
• 可以当做入参传递给函数

而且因为类也是一个对象,所以可以在程序运行的时候进行动态的传递.

def choose_class(name):
    if name == 'foo':
        class Foo:
            pass
    <span class="hljs-keyword" style="color: #c678dd; line-height: 26px;">return</span> Foo
<span class="hljs-keyword" style="color: #c678dd; line-height: 26px;">else</span>:
    <span class="hljs-class" style="line-height: 26px;"><span class="hljs-keyword" style="color: #c678dd; line-height: 26px;">class</span> <span class="hljs-title" style="color: #e6c07b; line-height: 26px;">Bar</span>:</span>
        <span class="hljs-keyword" style="color: #c678dd; line-height: 26px;">pass</span>

    <span class="hljs-keyword" style="color: #c678dd; line-height: 26px;">return</span> Bar

Myclass = choose_class('foo')
print(Myclass)

print(Myclass())

看一个简单的例子.首先choose_class()函数中动态的创建了类,然后将类作为返回值
然后我们通过一个变量Myclass接收了这个返回值.

看下面两个print,第一个打印的是我们创建出的类. 第二个打印的是我们创建的类创建的对象.

<class '__main__.choose_class.<locals>.Foo'>
<__main__.choose_class.<locals>.Foo object at 0x0000017102113208>

使用type创建类

❝

「class type(object)」
「class type(name, bases, dict)」
With one argument, return the type of an object. The return value is a type object and generally the same object as returned by object.__class__.
The isinstance() built-in function is recommended for testing the type of an object, because it takes subclasses into account.

❞

type这个类一看就很特别,因为首字母是小写的...它可以用来创建一个类...

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

print(Foo)

foo = Foo()

print(foo)

print(foo.bar)

这里的代码和下面的类创建代码是类似的

class Foo(object):   
    bar = True

「向类中添加方法」

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

def get_bar(self):

print(self.bar)

FooChild = type('FooChild', (Foo,), {'get_bar': get_bar})

print(hasattr(FooChild,'get_bar'))

myfoo = FooChild()

print(myfoo)

myfoo.get_bar()

元类

简单来说,元类就是用来创建类的类. 比如我们上面使用的type就是一个python内置的元类.

比如我们来干一件神器的事情

__metaclass__属性(python3不再支持)

❝

「NOTE!!!」
python3中不再支持__metaclass__属性,而是在定义类的时候使用metaclass=XXXX参数

❞

在写一个类的时候,如果我们指定了__metaclass__属性,就说明我们指明了这个类的元类.

比如我们定义一个类:

class MyClass():
    pass

类在定义的时候,它在内存中还没有生成,知道它会被调用,python会做以下的事情:

1. 在MyClass中寻找__metaclass__属性,如果有,python会在内存中创建一个名字叫MyClass的类对象(注意,是类!对象)
2. 如果在MyClass中没有找到__metaclass__属性,那么会在它的父类中继续寻找
3. 如果父类里还没有,那么回到模块底层去找
4. 如果模块底层还没有,Python会使用type作为元类来创建这个类.

自定义元类

使用函数定义元类

def upper_attr(future_class_name, future_class_parents, future_class_attr):
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
    uppercase_attr = dict((name.upper(), value) for name, value in attrs)
    return type(future_class_name, future_class_parents, uppercase_attr)

class MyMetacalss(object, metaclass=upper_attr):

bar = 'bip'

print(hasattr(MyMetacalss, 'bar'))

print(hasattr(MyMetacalss, 'BAR'))

c = MyMetacalss()

print(c.BAR)

使用class来定义元类

先看一下文档中__new__方法的定义.

❝

「object.__new__(cls[, ...])」
Called to create a new instance of class cls.__new__()is a static method (special-cased so you need not declare it as such) that takes the class of which an instance was requested as its first argument. The remaining arguments are those passed to the object constructor expression (the call to the class). The return value of__new__()should be the new object instance (usually an instance of cls).
Typical implementations create a new instance of the class by invoking the superclass’s __new__() method using super().__new__(cls[, ...]) with appropriate arguments and then modifying the newly-created instance as necessary before returning it.
If __new__()returns an instance of cls, then the new instance’s __init__()method will be invoked like__init__(self[, ...]),where self is the new instance and the remaining arguments are the same as were passed to__new__().
If __new__() does not return an instance of cls, then the new instance’s __init__()method will not be invoked.
__new__() is intended mainly to allow subclasses of immutable types (like int, str, or tuple) to customize instance creation. It is also commonly overridden in custom metaclasses in order to customize class creation.

❞

明白了__new__方法,那改写起来就简单了

class Upper(type):
    def __new__(cls, name, bases, attrs):
        attr = ((name, value) for name, value in attrs.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attr)
        return type.__new__(cls, name, bases, uppercase_attr)

还有一种写法是通过调用父类的__new__()方法来返回类对象. 如果子类需要重写__new__()方法的话,一般要调用父类的__new__()方法.

class Upper(type):
    def __new__(cls, name, bases, attrs):
        attr = ((name, value) for name, value in attrs.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attr)
        return super(Upper,cls).__new__(cls, name, bases , uppercase_attr)

另外通过上面的文档,我们也能知道一个对象创建的时候会有那些操作.

1. 调用__new__()方法来创建内存空间
2. 之后调用__init__()方法来初始化参数.

---

参考资料:

1. python中的元类-简书
2. 深刻理解Python中的元类(metaclass)以及元类实现单例模式