The creation and use of metaclass metaclass in Python

In Python, we can use the type function to dynamically create a metaclass. We can also use the __metaclass__ attribute to specify a metaclass. Next, we will give specific examples to explain the creation and use of metaclass metaclasses in Python

Metaclasses allow you to define how certain classes are created. Basically, giving you control over how your classes are created.
Metaclass is also a class, a type class.

Metaclasses are generally used to create classes. When executing a class definition, the interpreter must know the correct metaclass for this class. If this attribute is not defined, it will look up the __metaclass__ attribute in the parent class. If it's not found yet, look for global variables.

For traditional classes, their metaclass is types.ClassType.

Metaclasses also have constructors that pass three parameters: the class name, a tuple of data inherited from the base class, and a dictionary of class attributes.
Let's define a metaclass below, which requires that when writing a class, a __str__() method must be provided for the class. If the __repr__() method is not provided,
will give you a warning.

from warnings import warn
#元类需要继承type类
class ReqStrSugRepr(type):
  def __init__(cls, name, bases, attrd):
  #构造函数需要传递的参数为类名，基类，类属性字典
    super(ReqStrSugRepr, cls).__init__(name, bases, attrd)
    # 判断__str__字符串是否在类的属性字典里
    if '__str__' not in attrd:
      raise TypeError('Class requires overriding of __str__()')

    if '__repr__' not in attrd:
      warn('Class suggests overriding of __repr__()\n', stacklevel=3)

class Foo(object):
  #给类指定元类 
  __metaclass__ = ReqStrSugRepr

  def foo(self):
    pass
#这一段代码不用创建类来测试，直接运行一下就会报错，可见元类的功力。

##type

The type function can check the type of a variable, for example:

# <type &#39;int&#39;>
# <type &#39;str&#39;>
type(1)     
type(&#39;mink&#39;)

The type function can also create a new object

type accepts Three parameters, name, bases, dict. The first one accepts the class name, the second parameter accepts the parent class (tuple form), and the third parameter accepts attributes and methods (dictionary form)

X = type('X', (object,), dict(a=1))
# 等于
class X(object):
  a = 1

Here are the methods that accept functions

def say(self):
  print 'hello'

X = type('X', (object,), dict(say=say))
x = X()

# pirnt hello
x.say()

Metaclass

us We all know that instance objects can be created through classes, and metaclasses are classes that create class objects. Type can create class objects, which means type is a metaclass.

metaclass attribute

If you want to use a metaclass to create a class object, you need to add a __metaclass__ attribute to the object. Of course, you must first have a metaclass

class PrivateMetaclass(type):
  def __new__(cls, name, parents, attrs):
    attrs = dict(('__%s' % k, v) for k, v in attrs.itmes())
    return super(PrivateMetaclass, cls).__new__(cls, name, parents, attrs)

class A(object):
  __metaclass__ = PrivateMetaclass
  a = 1
  b = 2

a = A()
# raise AttributeError
print a.a, a.b 

# print 1, 2
print a.__a, a.__b

so that you can modify some characteristics of the class through the metaclass. The above is to modify the variables to private variables.

For more articles related to the creation and use of metaclasses in Python, please pay attention to the PHP Chinese website!