在Python 3.10+中,有一个名为
dataclasses.KW_ONLY
的标记,它的工作原理如下:
@dataclasses.dataclass
class Example:
a: int
b: int
_: dataclasses.KW_ONLY
c: int
d: int
任何在
KW_ONLY
伪字段之后的字段都是仅限关键字参数的。
dataclasses.dataclass
装饰器还有一个
kw_only
参数,它使所有字段都成为仅限关键字参数。
@dataclasses.dataclass(kw_only=True)
class Example:
a: int
b: int
还可以通过将kw_only=True
传递给dataclasses.field
来将单个字段标记为仅限关键字。
如果关键字字段位于非关键字字段之后(可能是通过继承或通过单独标记字段为关键字字段),关键字字段将在其他字段之后重新排序,特别是为了__init__
的目的。其他数据类功能将保持声明的顺序。这种重新排序很令人困惑,可能应该避免使用。
Python 3.10 之前的解决方案:
在这方面,dataclasses
并不能提供太多帮助。无法指定一个字段应该通过关键字参数进行初始化,而且 __post_init__
钩子函数无法知道原始构造函数参数是通过关键字传递的。此外,无法很好地检查 InitVar
,更不用说将 InitVar
标记为只能通过关键字传递。
至少,你需要替换生成的 __init__
方法。可能最简单的方法是手动定义 __init__
。如果你不想这样做,可能最可靠的方法是创建字段对象,并在 metadata
中将它们标记为关键字参数,然后在你自己的装饰器中检查这些元数据。这比听起来还要复杂:
import dataclasses
import functools
import inspect
def kwonly(default=dataclasses.MISSING, **kwargs):
kwargs.setdefault('metadata', {})
kwargs['metadata']['kwonly'] = True
return dataclasses.field(default=default, **kwargs)
def mydataclass(_cls, *, init=True, **kwargs):
if _cls is None:
return functools.partial(mydataclass, **kwargs)
no_generated_init = (not init or '__init__' in _cls.__dict__)
_cls = dataclasses.dataclass(_cls, **kwargs)
if no_generated_init:
return _cls
fields = dataclasses.fields(_cls)
if any(field.metadata.get('kwonly') and not field.init for field in fields):
raise TypeError('Non-init field marked kwonly')
init_fields = [field for field in fields if field.init]
for i, field in enumerate(init_fields):
if field.metadata.get('kwonly'):
first_kwonly = field.name
num_kwonly = len(init_fields) - i
break
else:
return _cls
if not all(field.metadata.get('kwonly') for field in init_fields[-num_kwonly:]):
raise TypeError('non-kwonly init fields following kwonly fields')
required_kwonly = [field.name for field in init_fields[-num_kwonly:]
if field.default is field.default_factory is dataclasses.MISSING]
original_init = _cls.__init__
init_params = tuple(inspect.signature(original_init).parameters)
if init_params[-num_kwonly] != first_kwonly:
raise TypeError('InitVars after kwonly fields.')
max_positional = len(init_params) - num_kwonly - 1
@functools.wraps(original_init)
def __init__(self, *args, **kwargs):
if len(args) > max_positional:
raise TypeError('Too many positional arguments')
check_required_kwargs(kwargs, required_kwonly)
return original_init(self, *args, **kwargs)
_cls.__init__ = __init__
return _cls
def check_required_kwargs(kwargs, required):
missing = [name for name in required if name not in kwargs]
if not missing:
return
raise TypeError(f"__init__ missing required keyword-only argument(s): {missing}")
使用示例:
@mydataclass
class S3Obj:
bucket: str
key: str
storage_class: str = kwonly('Standard')
这个已经有点测试过了,但还不够彻底,不如我希望的那样。
你无法通过
...
来获得你提出的语法,因为
...
对于元类或装饰器来说没有任何作用。你可以通过触发名称查找或赋值的方式来获得非常接近的效果,比如
kwonly_start = True
,这样元类就可以看到它发生了。然而,一个健壮的实现是复杂的,因为有很多需要专门处理的事情。继承、
typing.ClassVar
、
dataclasses.InitVar
、注解中的前向引用等等,如果不小心处理,都会引起问题。继承可能引起最多的问题。
一个不处理所有琐碎细节的概念验证可能看起来像这样:
class POCMetaDict(dict):
def __setitem__(self, key, item):
if key == 'kwonly_start':
self['__non_kwonly'] = len(self['__annotations__'])
super().__setitem__(key, item)
class POCMeta(type):
@classmethod
def __prepare__(cls, name, bases, **kwargs):
return POCMetaDict()
def __new__(cls, name, bases, classdict, **kwargs):
classdict.pop('kwonly_start')
non_kwonly = classdict.pop('__non_kwonly')
newcls = super().__new__(cls, name, bases, classdict, **kwargs)
newcls = dataclass(newcls)
if non_kwonly is None:
return newcls
original_init = newcls.__init__
@functools.wraps(original_init)
def __init__(self, *args, **kwargs):
if len(args) > non_kwonly:
raise TypeError('Too many positional arguments')
return original_init(self, *args, **kwargs)
newcls.__init__ = __init__
return newcls
你会像这样使用它
class S3Obj(metaclass=POCMeta):
bucket: str
key: str
kwonly_start = True
storage_class: str = 'Standard'
这是未经测试的。