Python - 将 class Z099FB995346F31C749F6E40DB0F395EZ 中的位置 arguments 传递到 metaclass

Question

Passing positional arguments in form *(1, 2, 3) is syntactically alowed after keyword arguments. This code:

class Meta(type):
    def __new__(meta, *args, **kwargs):
        return super().__new__(meta, *args)

class A(metaclass=Meta, sandwich='tasty', *(10,)): pass

gives me an error:

TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

Why is positional argument intermixed with superclass list? I think Python should be able to handle this special case because such implementation forces metaclass user to pass arguments in keyword-only manner and such interface choice is taken away from metaclass programmer.

Answer 1

tl;dr

Starred expressions with a single asterisk * in class definitions get processed before the keyword arguments even if they appear after the keyword arguments. This leads to *(10,) being interpretated as base class and since 10 is not a valid base class the error message occurs.

Explanation

The first point is that the argument list of the __new__ method in the metaclass contains *args . To better understand what's going on, *args could be replaced with name, bases, namespace which are the arguments that are passed to a metaclass when it is referenced in a class definition.

So replace

class Meta(type):
    def __new__(meta, *args, **kwargs):
        return super().__new__(meta, *args)

with

class Meta(type):
    def __new__(self, name, bases, namespace, **kwargs):
       return super().__new__(self, name, bases, namespace)

The second point is that the class definition contains a starred expression.

class A(metaclass=Meta, sandwich='tasty', *(10,)): pass

A class definition however is not a function definition. They may appear similar, but they follow different rules because they serve different purposes.

A function definition allows arbitrary positional arguments, keyword arguments and starred expressions with single asterisk * (variable number of positional arguments) and double asterisk ** (variable number of keyword arguments).

A class definition usually includes a list of all base classes. A special case here is being able to define a metaclass with a keyword argument metaclass=Meta and an arbitrary number of further keyword arguments without any special meaning. The starred expression with double asterisk ** (variable number of keyword arguments) is also supported.

A class definition is an executable statement. The inheritance list usually gives a list of base classes (see Metaclasses for more advanced uses), so each item in the list should evaluate to a class object which allows subclassing.

https://docs.python.org/3/reference/compound_stmts.html#class-definitions

I did not find official documentation that defines the rules when using starred expressions in class definitions, but the rule for using them in calls coincidently fits with the observable behaviour.

(...) although the *expression syntax may appear after explicit keyword arguments, it is processed before the keyword arguments – see below). So:

def f(a, b):
...     print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

https://docs.python.org/dev/reference/expressions.html#calls

Since metaclass is a keyword argument the starred expression is processed before metaclass, so using

class A(metaclass=Meta, sandwich='tasty', *(10,)):
    pass

corresponds to

class A(10, metaclass=Meta, sandwich='tasty'):
    pass

which can be seen in the abstract syntax tree

>>> import ast
>>> source = '''
... class Meta(type):
...     def __new__(meta, *args, **kwargs):
...         return super().__new__(meta, *args)
... 
... class A(metaclass=Meta, sandwich='tasty', *(10,)): pass
... '''
>>> 
>>> ast.dump(ast.parse(source))
"Module(body=[ClassDef(name='Meta', bases=[Name(id='type', ctx=Load())], keywords=[], body=[FunctionDef(name='__new__', args=arguments(posonlyargs=[], args=[arg(arg='meta')], vararg=arg(arg='args'), kwonlyargs=[], kw_defaults=[], kwarg=arg(arg='kwargs'), defaults=[]), body=[Return(value=Call(func=Attribute(value=Call(func=Name(id='super', ctx=Load()), args=[], keywords=[]), attr='__new__', ctx=Load()), args=[Name(id='meta', ctx=Load()), Starred(value=Name(id='args', ctx=Load()), ctx=Load())], keywords=[]))], decorator_list=[])], decorator_list=[]), ClassDef(name='A', bases=[Starred(value=Tuple(elts=[Constant(value=10)], ctx=Load()), ctx=Load())], keywords=[keyword(arg='metaclass', value=Name(id='Meta', ctx=Load())), keyword(arg='sandwich', value=Constant(value='tasty'))], body=[Pass()], decorator_list=[])], type_ignores=[])"

where bases is defined as a starred expression containing the tuple (10,)

bases=[Starred(value=Tuple(elts=[Constant(value=10)], ctx=Load()), ctx=Load())]

So any non-keyword arguments in the class definition are interpreted as base classes and since 10 is not a valid base class this results in the mentioned error message.

TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

Passing arguments to metaclass

I'm not sure if it considered best practice but defining the variable positional arguments as class attribute might be meaningful way to handle things.

class Meta(type):
    def __new__(self, name, bases, classdict, *args, **kwargs):
        for key in kwargs:
            print(key + '=' + kwargs[key])
        print('*args', *classdict['args'])
        return super().__new__(self, name, bases, classdict)

class A(metaclass=Meta, sandwich='tasty'):
    args = (10,)

^{I am well aware of the age of the question, but since the first two points could possibly be of more general interest I chose to reply with an answer.}