可选关键字参数的命名元组和默认值

我试图将一个较长的中空“数据”类转换为命名元组。我的类目前看起来是这样的:

class Node(object):
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

转换为namedtuple后，它看起来像:

from collections import namedtuple
Node = namedtuple('Node', 'val left right')

但这里有一个问题。我最初的类允许我只传入一个值，并通过为named/keyword参数使用默认值来处理默认值。喜欢的东西:

class BinaryTree(object):
    def __init__(self, val):
        self.root = Node(val)

但这在重构的命名tuple中不起作用，因为它期望我传递所有字段。我当然可以替换Node(val)到Node(val, None, None)的出现，但这不是我喜欢的。

那么，是否存在一个好技巧，可以让我的重写成功，而不增加大量的代码复杂性(元编程)，或者我应该吞下药丸，继续“搜索和替换”?：）

当前回答

你也可以用这个:

import inspect

def namedtuple_with_defaults(type, default_value=None, **kwargs):
    args_list = inspect.getargspec(type.__new__).args[1:]
    params = dict([(x, default_value) for x in args_list])
    params.update(kwargs)

    return type(**params)

这基本上让你有可能构造任何带有默认值的命名元组，并只覆盖你需要的参数，例如:

import collections

Point = collections.namedtuple("Point", ["x", "y"])
namedtuple_with_defaults(Point)
>>> Point(x=None, y=None)

namedtuple_with_defaults(Point, x=1)
>>> Point(x=1, y=None)

2012-10-17 17:34:08

其他回答

我不确定是否有一个简单的方法，只有内置的namedtuple。有一个很好的模块叫做recordtype，它有这个功能:

>>> from recordtype import recordtype
>>> Node = recordtype('Node', [('val', None), ('left', None), ('right', None)])
>>> Node(3)
Node(val=3, left=None, right=None)
>>> Node(3, 'L')
Node(val=3, left=L, right=None)

2012-07-05 19:25:29

另一个解决方案:

import collections


def defaultargs(func, defaults):
    def wrapper(*args, **kwargs):
        for key, value in (x for x in defaults[len(args):] if len(x) == 2):
            kwargs.setdefault(key, value)
        return func(*args, **kwargs)
    return wrapper


def namedtuple(name, fields):
    NamedTuple = collections.namedtuple(name, [x[0] for x in fields])
    NamedTuple.__new__ = defaultargs(NamedTuple.__new__, [(NamedTuple,)] + fields)
    return NamedTuple

用法:

>>> Node = namedtuple('Node', [
...     ('val',),
...     ('left', None),
...     ('right', None),
... ])
__main__.Node

>>> Node(1)
Node(val=1, left=None, right=None)

>>> Node(1, 2, right=3)
Node(val=1, left=2, right=3)

2017-03-27 11:06:20

如果你想保留使用类型注释的可能性，不幸的是，@mark-lodato非常好的解决方案是不可用的(它失败于我设置__defaults__)。另一种方法是使用attrs:

import attr

 
@attr.s
class Node(object):
    val: str = attr.ib()
    left: 'Node' = attr.ib(None)
    right: 'Node' = attr.ib(None)

这有:

类型注解漂亮的__str__和__repr__ 可定制的，因为它是一个真正的类所有Python版本的实现都相同

2021-04-05 06:55:51

Python 3.7:在namedtuple定义中引入默认参数。

示例如文档所示:

>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
>>> Account._fields_defaults
{'balance': 0}
>>> Account('premium')
Account(type='premium', balance=0)

点击这里阅读更多。

2018-07-26 11:17:21

1. 使用NamedTuple >= Python 3.6

从Python 3.7+开始，您可以从支持默认值的typing模块中使用NamedTuple。

https://docs.python.org/3/library/typing.html#typing.NamedTuple

from typing import NamedTuple

class Employee(NamedTuple):
    name: str
    id: int = 3

employee = Employee('Guido')
assert employee.id == 3

注意:虽然NamedTuple在类语句中作为超类出现，但它实际上不是。打字。NamedTuple使用元类的高级功能来自定义用户类的创建。

issubclass(Employee, typing.NamedTuple)
# return False
issubclass(Employee, tuple)
# return True

2. 使用数据类>= Python 3.7

from dataclasses import dataclass

@dataclass(frozen=True)
class Employee:
    name: str
    id: int = 3

employee = Employee('Guido')
assert employee.id == 3

frozen=True使数据类不可变。

2022-08-23 14:05:30

可选关键字参数的命名元组和默认值

推荐文章

最新文章

标签