我尝试着自己写了一个例子，发现好像清晰多了，没有看懂的大家可以看一下
class Mymeta(type):
    def __init__(self, name, bases, dic):
        super().__init__(name, bases, dic)
        print('===>Mymeta.__init__')
        print(self.__name__)
        print(dic)
        print(self.yaml_tag)

    def __new__(cls, *args, **kwargs):
        print('===>Mymeta.__new__')
        print(cls.__name__)
        return type.__new__(cls, *args, **kwargs)

    def __call__(cls, *args, **kwargs):
        print('===>Mymeta.__call__')
        obj = cls.__new__(cls)
        cls.__init__(cls, *args, **kwargs)
        return obj
    
class Foo(metaclass=Mymeta):
    yaml_tag = '!Foo'

    def __init__(self, name):
        print('Foo.__init__')
        self.name = name

    def __new__(cls, *args, **kwargs):
        print('Foo.__new__')
        return object.__new__(cls)

foo = Foo('foo')
把上面的例子运行完之后就会明白很多了，正常情况下我们在父类中是不能对子类的属性进行操作，但是元类可以。换种方式理解：元类、装饰器、类装饰器都可以归为元编程(引用自 python-cook-book 中的一句话)。

‘用户自定义类，只不过是 type 类的__call__运算符’
景老师，这里这段是不是有点问题，我做了以下实验：

class MyMeta(type):
    def __init__(cls, name, bases, dict):
        print('MyMeta __init__')

    def __new__(cls, name, bases, dict):
        print('MyMeta __new__')
        return type.__new__(cls, name, bases, dict)

    def __call__(cls):
        print('MyMeta __call__')
        return type.__call__(cls)

class Test(metaclass=MyMeta):
    a = 10

    def __init__(self):
        pass

    def __new__(cls):
        return super(Test, cls).__new__(cls)

test = Test()
我发现在使用class Test()定义类时，会依次调用MyMeta的__new__和__init__方法构建Test类，然后在使用test = Test()创建类对象时，才会调用MyMeta的__call__方法来调用Test类的__new__和__init__方法。好像和您说的不一样？
我看您说的意思是，在使用class定义类的时候，先调用metaclass的__call__,然后再调用metaclass的__new__和__init__？

之前没有接触过 metaclass，感觉用metaclass的作用就是超动态生成类。这节课感觉确实比较魔术，跟上一节装饰器还要再细想一下。

pyyaml 5.1以上，这段代码会报错，要把 yaml.load() 改成 yaml.load_all()
yaml.load("""
--- !Monster
name: Cave spider
hp: [2,6] # 2d6
ac: 16
attacks: [BITE, HURT]
""")

class TestMetaClass(type):

    def __new__(mcs, *args, **kwargs):
        print('TestMetaClass.__new__', mcs)
        return type.__new__(mcs, *args, **kwargs)

    def __init__(cls, name, bases, kwds):
        print('TestMetaClass.__init__', cls)
        super(TestMetaClass, cls).__init__(name, bases, kwds)

    def __call__(cls, *args, **kwargs):
        print('TestMetaClass.__call__')
        return super(TestMetaClass, cls).__call__(*args, **kwargs)


class A(metaclass=TestMetaClass):

    def __new__(cls, *args, **kwargs):
        print('A.__new__')
        return super(A, cls).__new__(cls)

    def __init__(self, name=None):
        self.name = name
        print('A.__init__')


A('hello')

老师你好，为什么我执行示例代码会一个constructor错误，查了好久资料都解决不了。
import yaml
class Monster(yaml.YAMLObject):
  yaml_tag = u'!Monster'
  def __init__(self, name, hp, ac, attacks):
    self.name = name
    self.hp = hp
    self.ac = ac
    self.attacks = attacks
  def __repr__(self):
    return "%s(name=%r, hp=%r, ac=%r, attacks=%r)" % (
       self.__class__.__name__, self.name, self.hp, self.ac,
       self.attacks)

yaml.load("""
--- !Monster
name: Cave spider
hp: [2,6] # 2d6
ac: 16
attacks: [BITE, HURT]
""")

错误信息：
ConstructorError: could not determine a constructor for the tag '!Monster'
  in "<unicode string>", line 2, column 5:
    --- !Monster
        ^

yaml.load("""
--- !Monster
name: Cave spider
hp: [2,6] # 2d6
ac: 16
attacks: [BITE, HURT]
""")
运行时报错，pyyaml版本PyYAML-5.1，将语句改成
yaml.load("""
--- !Monster
name: Cave spider
hp: [2,6] # 2d6
ac: 16
attacks: [BITE, HURT]
"""，Loader=yaml.Loader)即可，参见"https://github.com/yaml/pyyaml/issues/266"

每次学完后，都会看一遍大家的留言，很多留言都很精彩，本章内容特别有意思，也领略到了Python的神奇之处，我也留言一次吧，哈哈哈哈。
个人对于metaclass认知，首先它包含了“超越类”和“变形类”含义。
超越类：是因为继承了自定义metaclass的类，都会受到影响。
变形类：类的运行机制跟普通类的机制不同，会增加某种功能。
出现两种特性的根本原因就是因为Python本身的运行机制，每一个定义的类都涉及到继承、重载，中途修改了父类的特性，子类自然受影响，之前说Python里面，处处皆对象，看来可以修改为“Python中处处皆对象，处处皆对象的继承、重载”。举个例子，使用metaclass有点类似于基因编辑，对某一位孕妇采用了基因编辑的技术，如果编辑后可以提高母亲的智商，自然她的子子辈辈的智商都能提高（阿拉丁神灯的效果）；如果编辑后会导致母亲的免疫力下降，自然她的子子辈辈的免疫力都会下降（潘多拉魔盒带来的灾难），所以，基因编辑也要慎重，当然，目前来说是明令禁止。