有人能修改namedtuple或者提供一个可变对象的替代类吗？
主要是出于可读性的原因，我想要一个类似于namedtuple的东西，它可以处理可变对象。
from Camelot import namedgroup
Point = namedgroup('Point', ['x', 'y'])
p = Point(0, 0)
p.x = 10
>>> p
Point(x=10, y=0)
>>> p.x *= 10
Point(x=100, y=0)
转换出的对象必须是可被pickle序列化的。并且与命名元组的特性相符，当表示为字符串时，其顺序必须与构建对象时参数列表的顺序相匹配。
collections.namedtuple - recordclass。
可以从PyPI安装它：pip3 install recordclass
from recordclass import recordclass
Point = recordclass('Point', 'x y')
>>> p = Point(1, 2)
>>> p
Point(x=1, y=2)
>>> print(p.x, p.y)
1 2
>>> p.x += 2; p.y += 3; print(p)
Point(x=3, y=5)
recordclass（自0.5版本起）支持类型提示：
from recordclass import recordclass, RecordClass
class Point(RecordClass):
x: int
y: int
>>> Point.__annotations__
{'x':int, 'y':int}
>>> p = Point(1, 2)
>>> p
Point(x=1, y=2)
>>> print(p.x, p.y)
1 2
>>> p.x += 2; p.y += 3; print(p)
Point(x=3, y=5)
这里有一个更完整的示例（它还包括性能比较）。
Recordclass库现在提供了另一种变体--recordclass.make_dataclass工厂函数。它支持类似数据类的API（有模块级函数update、make、replace，而不是self._update、self._replace、self._asdict、cls._make方法）。
from recordclass import dataobject, make_dataclass
Point = make_dataclass('Point', [('x', int), ('y',int)])
Point = make_dataclass('Point', {'x':int, 'y':int})
class Point(dataobject):
x: int
y: int
>>> p = Point(1, 2)
>>> p
Point(x=1, y=2)
>>> p.x = 10; p.y += 3; print(p)
Point(x=10, y=5)
namedlist，recordclass速度较慢，占用更多内存，并且需要C扩展。 - GrantJnamedtuple和简单的类创建Point = namedtuple('Point', 'x y')时，Jedi可以自动完成属性，而对于recordclass则不是这种情况。如果我使用更长的创建代码（基于RecordClass），那么Jedi就能理解Point类，但不能理解它的构造函数或属性...有没有办法让recordclass与Jedi良好地配合工作？ - PhilMacKaypip3 install recordclass。当我遇到导入错误时，我最初远离了这个解决方案，并决定首先查看 Python 自带的解决方案。其他人可能会在安装新模块等相对简单的事情上卡住。 - Gabriel Staplestypes.SimpleNamespace 是在 Python 3.3 中引入的，支持所需的要求。
from types import SimpleNamespace
t = SimpleNamespace(foo='bar')
t.ham = 'spam'
print(t)
namespace(foo='bar', ham='spam')
print(t.foo)
'bar'
import pickle
with open('/tmp/pickle', 'wb') as f:
pickle.dump(t, f)
SimpleNamespace未通过测试6-10（通过索引访问、迭代解包、迭代、有序字典、原地替换）和12、13（字段、插槽）。请注意，文档（您在答案中提供的链接）明确指出：“SimpleNamespace可能作为class NS: pass的替代品很有用。但是，对于结构化记录类型，请使用namedtuple()。” - AliSimpleNamespace 创建的是对象而不是类构造函数，并且不能替代 namedtuple。类型比较将无法工作，而内存占用会更高。 - RedGlyphNamedTuple，因为它们使用普通类定义，还支持其他类特性。In [20]: from dataclasses import dataclass
In [21]: @dataclass
...: class InventoryItem:
...: '''Class for keeping track of an item in inventory.'''
...: name: str
...: unit_price: float
...: quantity_on_hand: int = 0
...:
...: def total_cost(self) -> float:
...: return self.unit_price * self.quantity_on_hand
...:
演示：
In [23]: II = InventoryItem('bisc', 2000)
In [24]: II
Out[24]: InventoryItem(name='bisc', unit_price=2000, quantity_on_hand=0)
In [25]: II.name = 'choco'
In [26]: II.name
Out[26]: 'choco'
In [27]:
In [27]: II.unit_price *= 3
In [28]: II.unit_price
Out[28]: 6000
In [29]: II
Out[29]: InventoryItem(name='choco', unit_price=6000, quantity_on_hand=0)
dataclass 在 Python 3.7.1 中未通过测试6-10（通过索引访问、迭代解包、迭代、有序字典、原地替换）和12、13（字段、插槽）。 - Alirecordclass 是一种基于 C 扩展的实现，而这是一个纯 Python 实现。当然，是否需要使用C扩展取决于您的具体要求。您的测试（但请注意下面的说明）：
from __future__ import print_function
import pickle
import sys
from namedlist import namedlist
Point = namedlist('Point', 'x y')
p = Point(x=1, y=2)
print('1. Mutation of field values')
p.x *= 10
p.y += 10
print('p: {}, {}\n'.format(p.x, p.y))
print('2. String')
print('p: {}\n'.format(p))
print('3. Representation')
print(repr(p), '\n')
print('4. Sizeof')
print('size of p:', sys.getsizeof(p), '\n')
print('5. Access by name of field')
print('p: {}, {}\n'.format(p.x, p.y))
print('6. Access by index')
print('p: {}, {}\n'.format(p[0], p[1]))
print('7. Iterative unpacking')
x, y = p
print('p: {}, {}\n'.format(x, y))
print('8. Iteration')
print('p: {}\n'.format([v for v in p]))
print('9. Ordered Dict')
print('p: {}\n'.format(p._asdict()))
print('10. Inplace replacement (update?)')
p._update(x=100, y=200)
print('p: {}\n'.format(p))
print('11. Pickle and Unpickle')
pickled = pickle.dumps(p)
unpickled = pickle.loads(pickled)
assert p == unpickled
print('Pickled successfully\n')
print('12. Fields\n')
print('p: {}\n'.format(p._fields))
print('13. Slots')
print('p: {}\n'.format(p.__slots__))
Python 2.7 的输出：
1. 字段值的变异 p: 10, 12
2. 字符串 p: Point(x=10, y=12)
3. 表示 Point(x=10, y=12)
4. 大小 p 的大小：64
5. 按字段名称访问 p: 10, 12
6. 按索引访问 p: 10, 12
7. 迭代解包 p: 10, 12
8. 迭代 p: [10，12]
9. 有序字典 p: OrderedDict([('x'，10)，('y'，12)])
10. 原地替换（更新？） p: Point(x=100，y=200)
11. Pickle 和 Unpickle 成功进行了 Pickle 12. 字段 p: ('x'，'y')
13. Slots p: ('x'，'y')
与 Python 3.5 的唯一区别是 namedlist 变小了，大小为 56（Python 2.7 报告为 64）。
请注意我已更改您的测试 10，用于原地替换。 namedlist 有一个 _replace() 方法，它执行浅复制，这对我来说很合理，因为标准库中的 namedtuple 表现方式相同。更改 _replace() 方法的语义会令人困惑。在我看来，应该使用 _update() 方法进行原地更新。或者也许我没有理解您的测试 10 的意图？
namedlist 存储在列表实例中的值。问题在于，cpython 的 list 实际上是一个动态数组。按设计，它分配比必要更多的内存，以使列表的变异更加便宜。 - intellimathlist，默认情况下使用__slots__优化。当我测量时，Python 2.7上6个字段的内存使用量比recordclass少：96字节与104字节。 - GrantJtypes.SimpleNamespace相对于打错字提供的安全性。不幸的是，pylint不喜欢它 :-( - xvergesSimpleNamespace在测试6-10（通过索引访问、迭代展开、迭代、有序字典、原地替换）和12、13（字段、插槽）中失败了。请注意，文档（链接在该答案中）明确表示：“SimpleNamespace可能作为class NS: pass的替代品很有用。但是，对于结构化记录类型，请使用namedtuple()。”我接受你的使用情况下SimpleNamespace是一个不错的解决方案，但它不是OP的答案；recordclass和namedlist才是。 - Ali看起来这个问题的答案是否定的。
下面的方法非常接近，但它并不是严格可变的。这将使用更新后的x值创建一个新的namedtuple()实例：
Point = namedtuple('Point', ['x', 'y'])
p = Point(0, 0)
p = p._replace(x=10)
另一方面，您可以使用 __slots__ 创建一个简单的类，适用于频繁更新类实例属性：
class Point:
__slots__ = ['x', 'y']
def __init__(self, x, y):
self.x = x
self.y = y
__slots__是很好的选择，因为它在内存效率方面表现良好。唯一的缺点是不能创建新的类属性。__slots__更节省内存的一个非常简明的解释 - Python slots__slots__和Sequence抽象基类的最小类；不进行花哨的错误检测或类似操作，但它可以工作，并且行为大多类似于可变元组（除了类型检查）。from collections import Sequence
class NamedMutableSequence(Sequence):
__slots__ = ()
def __init__(self, *a, **kw):
slots = self.__slots__
for k in slots:
setattr(self, k, kw.get(k))
if a:
for k, v in zip(slots, a):
setattr(self, k, v)
def __str__(self):
clsname = self.__class__.__name__
values = ', '.join('%s=%r' % (k, getattr(self, k))
for k in self.__slots__)
return '%s(%s)' % (clsname, values)
__repr__ = __str__
def __getitem__(self, item):
return getattr(self, self.__slots__[item])
def __setitem__(self, item, value):
return setattr(self, self.__slots__[item], value)
def __len__(self):
return len(self.__slots__)
class Point(NamedMutableSequence):
__slots__ = ('x', 'y')
例子：
>>> p = Point(0, 0)
>>> p.x = 10
>>> p
Point(x=10, y=0)
>>> p.x *= 10
>>> p
Point(x=100, y=0)
def namedgroup(name, members):
if isinstance(members, str):
members = members.split()
members = tuple(members)
return type(name, (NamedMutableSequence,), {'__slots__': members})
例子：
>>> Point = namedgroup('Point', ['x', 'y'])
>>> Point(6, 42)
Point(x=6, y=42)
在Python 2中，您需要稍微调整一下 - 如果您继承自Sequence，那么该类将具有__dict__，并且__slots__将停止工作。
Python 2中的解决方案是不要继承Sequence，而是继承object。如果希望isinstance(Point, Sequence) == True，则需要将NamedMutableSequence注册为Sequence的基类：
Sequence.register(NamedMutableSequence)
import copy
def namedgroup(typename, fieldnames):
def init(self, **kwargs):
attrs = {k: None for k in self._attrs_}
for k in kwargs:
if k in self._attrs_:
attrs[k] = kwargs[k]
else:
raise AttributeError('Invalid Field')
self.__dict__.update(attrs)
def getattribute(self, attr):
if attr.startswith("_") or attr in self._attrs_:
return object.__getattribute__(self, attr)
else:
raise AttributeError('Invalid Field')
def setattr(self, attr, value):
if attr in self._attrs_:
object.__setattr__(self, attr, value)
else:
raise AttributeError('Invalid Field')
def rep(self):
d = ["{}={}".format(v,self.__dict__[v]) for v in self._attrs_]
return self._typename_ + '(' + ', '.join(d) + ')'
def iterate(self):
for x in self._attrs_:
yield self.__dict__[x]
raise StopIteration()
def setitem(self, *args, **kwargs):
return self.__dict__.__setitem__(*args, **kwargs)
def getitem(self, *args, **kwargs):
return self.__dict__.__getitem__(*args, **kwargs)
attrs = {"__init__": init,
"__setattr__": setattr,
"__getattribute__": getattribute,
"_attrs_": copy.deepcopy(fieldnames),
"_typename_": str(typename),
"__str__": rep,
"__repr__": rep,
"__len__": lambda self: len(fieldnames),
"__iter__": iterate,
"__setitem__": setitem,
"__getitem__": getitem,
}
return type(typename, (object,), attrs)
在继续操作之前，它会检查属性是否有效。
那么这个可以进行pickle吗？是的，但只有在你执行以下操作时才可以：
>>> import pickle
>>> Point = namedgroup("Point", ["x", "y"])
>>> p = Point(x=100, y=200)
>>> p2 = pickle.loads(pickle.dumps(p))
>>> p2.x
100
>>> p2.y
200
>>> id(p) != id(p2)
True
定义必须在你的命名空间中，并且必须存在足够长的时间，以便pickle可以找到它。因此，如果您将其定义为在您的软件包中，则应该可以使用。
Point = namedgroup("Point", ["x", "y"])
如果你执行以下操作，或者让定义成为临时的（例如在函数结束时超出范围）pickle将会失败：
some_point = namedgroup("Point", ["x", "y"])
是的，它确实保留了在类型创建中列出的字段的顺序。
for k in self._attrs_: yield getattr(self, k) 的 __iter__ 方法，那么它将支持像元组一样的解包。 - snapshoe__len__、__getitem__ 和 __setitem__ 方法以支持通过索引获取值（如 p[0]）也非常容易。有了这些最后的部分，这似乎是最完整和正确的答案（至少对我来说是这样）。 - snapshoe__len__和__iter__很好。__getitem__和__setitem__可以映射到self.__dict__.__setitem__和self.__dict__.__getitem__。 - MadMan2064元组是不可变的。
然而，您可以创建一个字典子类，在这个子类中，您可以使用点符号访问属性；
In [1]: %cpaste
Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
:class AttrDict(dict):
:
: def __getattr__(self, name):
: return self[name]
:
: def __setattr__(self, name, value):
: self[name] = value
:--
In [2]: test = AttrDict()
In [3]: test.a = 1
In [4]: test.b = True
In [5]: test
Out[5]: {'a': 1, 'b': True}
如果你想要类似于namedtuple但是可变的行为，试试使用namedlist。
请注意，为了可变，它不能是一个元组。
我简直不敢相信之前没有人说过这个，但在我看来，Python只是想让你编写自己的简单可变类，而不是在需要"namedtuple"可变时使用namedtuple。
直接跳到下面的方法5。它简短明了，远比其他选项好。
__call__()的简单可调用类这里是一个简单的Point对象示例，用于表示(x, y)点：
class Point():
def __init__(self, x, y):
self.x = x
self.y = y
def __call__(self):
"""
Make `Point` objects callable. Print their contents when they
are called.
"""
print("Point(x={}, y={})".format(self.x, self.y))
现在使用它：
p1 = Point(1,2)
p1()
p1.x = 7
p1()
p1.y = 8
p1()
这是输出结果：
Point(x=1, y=2)
Point(x=7, y=2)
Point(x=7, y=8)
这与namedtuple非常相似，但它是完全可变的，不像namedtuple。此外，namedtuple不可调用，因此要查看其内容，只需在对象实例名称后面不带括号（如下面示例中的p2，而不是p2()）。请参见此处的示例和输出：
>>> from collections import namedtuple
>>> Point2 = namedtuple("Point2", ["x", "y"])
>>> p2 = Point2(1, 2)
>>> p2
Point2(x=1, y=2)
>>> p2()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'Point2' object is not callable
>>> p2.x = 7
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
__repr__()代替__call__()我刚学到，可以使用__repr__()代替__call__()，以获得更多类似于namedtuple的行为。定义__repr__()方法允许您定义“对象的官方字符串表示”（请参见官方文档）。现在，只需调用p1就相当于调用__repr__()方法，并且您将获得与namedtuple相同的行为。以下是新类：
class Point():
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
"""
Obtain the string representation of `Point`, so that just typing
the instance name of an object of this type will call this method
and obtain this string, just like `namedtuple` already does!
"""
return "Point(x={}, y={})".format(self.x, self.y)
现在使用它：
p1 = Point(1,2)
p1
p1.x = 7
p1
p1.y = 8
p1
这是输出结果：
Point(x=1, y=2)
Point(x=7, y=2)
Point(x=7, y=8)
(x, y) 元组原帖作者（OP）还希望像这样的方法也能够工作（请参见他在我的回答下方的评论）：
x, y = Point(x=1, y=2)
好吧，为了简单起见，我们只需让它起作用：
x, y = Point(x=1, y=2)()
# OR
p1 = Point(x=1, y=2)
x, y = p1()
顺便说一下，让我们也把这个压缩一下：
self.x = x
self.y = y
...转换成这个（源自我第一次看到这个）：
self.x, self.y = x, y
class Point():
def __init__(self, x, y):
self.x, self.y = x, y
def __repr__(self):
"""
Obtain the string representation of `Point`, so that just typing
the instance name of an object of this type will call this method
and obtain this string, just like `namedtuple` already does!
"""
return "Point(x={}, y={})".format(self.x, self.y)
def __call__(self):
"""
Make the object callable. Return a tuple of the x and y components
of the Point.
"""
return self.x, self.y
以下是一些测试调用：
p1 = Point(1,2)
p1
p1.x = 7
x, y = p1()
x2, y2 = Point(10, 12)()
x
y
x2
y2
这次我不会展示将类定义粘贴到解释器中，但是以下是这些调用及其输出：
>>> p1 = Point(1,2)
>>> p1
Point(x=1, y=2)
>>> p1.x = 7
>>> x, y = p1()
>>> x2, y2 = Point(10, 12)()
>>> x
7
>>> y
2
>>> x2
10
>>> y2
12
通过将其转换为迭代器类，我们可以获得以下行为：
x, y = Point(x=1, y=2)
# OR
x, y = Point(1, 2)
# OR
p1 = Point(1, 2)
x, y = p1
让我们摆脱 __call__() 方法，但为了使这个类成为迭代器，我们将添加 __iter__() 和 __next__() 方法。在这里阅读更多关于这些内容的信息：
以下是解决方案：
class Point():
def __init__(self, x, y):
self.x, self.y = x, y
self._iterator_index = 0
self._num_items = 2 # counting self.x and self.y
def __repr__(self):
"""
Obtain the string representation of `Point`, so that just typing
the instance name of an object of this type will call this method
and obtain this string, just like `namedtuple` already does!
"""
return "Point(x={}, y={})".format(self.x, self.y)
def __iter__(self):
return self
def __next__(self):
self._iterator_index += 1
if self._iterator_index == 1:
return self.x
elif self._iterator_index == 2:
return self.y
else:
raise StopIteration
以下是一些测试调用及其输出：
>>> x, y = Point(x=1, y=2)
>>> x
1
>>> y
2
>>> x, y = Point(3, 4)
>>> x
3
>>> y
4
>>> p1 = Point(5, 6)
>>> x, y = p1
>>> x
5
>>> y
6
>>> p1
Point(x=5, y=6)
yield 生成器关键字请参考以下资料：
这里是解决方案。它依赖于一种高级的“可迭代生成器”（也称为“生成器”）关键字/Python 机制，称为 yield。
基本上，当可迭代对象第一次调用下一个项目时，它会调用__iter__()方法，并停止并返回第一个yield调用的内容（在下面的代码中为self.x）。下一次可迭代对象调用下一个项目时，它将从上次离开的地方继续（在这种情况下是第一个yield之后），并查找下一个yield，停止并返回该yield调用的内容（在下面的代码中为self.y）。每个yield的“返回”实际上返回一个“生成器”对象，它本身就是一个可迭代对象，因此您可以对其进行迭代。每个新的可迭代调用下一个项目都会继续这个过程，在最近调用的yield之后重新启动，直到没有更多的yield调用存在，此时迭代结束并且可迭代已完全迭代。因此，一旦这个可迭代对象调用了两个对象，两个yield调用都已用完，因此迭代器结束。最终结果是，像Approach 4中一样，这样的调用可以完美地工作，但要写的代码要少得多！
x, y = Point(x=1, y=2)
# OR
x, y = Point(1, 2)
# OR
p1 = Point(1, 2)
x, y = p1
这是解决方案（部分解决方案也可以在上面的treyhunner.com引用中找到）。请注意解决方案是多么简短和干净！
只有类定义代码，没有文档字符串，所以您可以真正看到这有多么简短和简单：
class Point():
def __init__(self, x, y):
self.x, self.y = x, y
def __repr__(self):
return "Point(x={}, y={})".format(self.x, self.y)
def __iter__(self):
yield self.x
yield self.y
使用描述性的文档字符串：
class Point():
def __init__(self, x, y):
self.x, self.y = x, y
def __repr__(self):
"""
Obtain the string representation of `Point`, so that just typing
the instance name of an object of this type will call this method
and obtain this string, just like `namedtuple` already does!
"""
return "Point(x={}, y={})".format(self.x, self.y)
def __iter__(self):
"""
Make this `Point` class an iterable. When used as an iterable, it will
now return `self.x` and `self.y` as the two elements of a list-like,
iterable object, "generated" by the usages of the `yield` "generator"
keyword.
"""
yield self.x
yield self.y
复制并粘贴与前面方法（方法4）完全相同的测试代码，您将得到与上面完全相同的输出结果！
x，y = Point（x = 1，y = 2）。另外，使用__repr__而不是__call__是否更简单？ - Alexander__repr__()方法。我以前不熟悉它。我已将其添加到我的答案中。我大大改进和扩展了我的答案，添加了第2到第5种方法，以解决您的元组拆包要求。第5种方法是最好的。根据我的测试，它和第4种方法现在都可以完美地实现，就我所知。 - Gabriel Staplesnamedtuple时，您的首选解决方案是什么？您认为我的答案中第5种方法怎么样？ - Gabriel Staplesrecordclass https://pypi.org/project/recordclass/。本周稍后我会尝试更详细地审查您的回复。 - Alexander
namedtuple不同的是，似乎您无需能够通过索引引用属性，即p[0]和p[1]将是分别引用x和y的替代方式，对吗？ - martineau