有时将相关数据聚集在一起是有意义的。我倾向于使用字典来实现，例如：
group = dict(a=1, b=2, c=3)
print(group['a'])
我的其中一位同事喜欢创建一个类
class groupClass:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
group = groupClass(1, 2, 3)
print(group.a)
请注意，我们没有定义任何类方法。
我喜欢使用字典，因为我喜欢尽可能减少代码行数。我的同事认为如果使用类，代码更易读，并且将来向类添加方法会更容易。
你更喜欢哪个，并解释原因？
背景
R. Hettinger在2017年SF Python假日聚会上介绍了一些基于属性的替代数据容器。请参阅他的推文和幻灯片。他还在PyCon 2018上做了一个有关dataclasses的演讲。
其他数据容器类型在这个文章中提到，主要在Python 3文档中（见下面的链接）。
这里是关于将recordclass添加到标准库的python-ideas邮件列表上的讨论。
选项
标准库中的替代方案
collections.namedtuple：带属性的元组（请参阅开创性的recipe）typing.NamedTuple：可子类化的元组（请参阅这篇post，并与namedtuple进行比较）types.SimpleNamespace：带有可选类声明的简单类types.MappingProxy：只读字典enum.Enum：相关常量的受限集合（行为类似于类）dataclasses.dataclass：具有默认值/无样板文件的可变命名元组外部选项
SimpleNamedspace；也可以参见munch（py3））__slots__等）。也请参阅关于cattrs的文档。例子
import typing as typ
import collections as ct
import dataclasses as dc
# Problem: You want a simple container to hold personal data.
# Solution: Try a NamedTuple.
>>> class Person(typ.NamedTuple):
... name: str
... age: int
>>> a = Person("bob", 30)
>>> a
Person(name='bob', age=30)
# Problem: You need to change age each year, but namedtuples are immutable.
# Solution: Use assignable attributes of a traditional class.
>>> class Person:
... def __init__(self, name, age):
... self.name = name
... self.age = age
>>> b = Person("bob", 30)
>>> b.age = 31
>>> b
<__main__.Person at 0x4e27128>
# Problem: You lost the pretty repr and want to add comparison features.
# Solution: Use included repr and eq features from the new dataclasses.
>>> @dc.dataclass(eq=True)
... class Person:
... name: str
... age: int
>>> c = Person("bob", 30)
>>> c.age = 31
>>> c
Person(name='bob', age=31)
>>> d = Person("dan", 31)
>>> c != d
True
如果你从来没有定义任何类方法，使用字典或者namedtuple在我看来更加合理。简单+内置很不错! 当然，每个人有他们自己的做法。
class Point(namedtuple('Point', 'x y')): ... - Peter Milleynamedtuple 的示例与 OP 代码结合使用可能会很好。 - tokland顺便说一下，我认为Python 3.7实现的@dataclass是实现类作为数据容器的最简单、最有效的方法。
@dataclass
class Data:
a: list
b: str #default variables go after non default variables
c: bool = False
def func():
return A(a="hello")
print(func())
输出结果将是：hello
这与Scala的case class非常相似，是使用类作为容器的最简单方式。
你的方式更好。不要试图过度预测未来，因为你可能不会成功。
然而，有时候使用类似于C结构体这样的东西可能是有意义的，例如如果你想要识别不同的类型而不是为每个东西都使用字典。
class ObjDict(dict):
def __getattr__(self,attr):
return self[attr]
def __setattr__(self,attr,value):
self[attr]=value
self.group = ObjDict(a=1, b=2, c=3)
print self.group.a
__slots__的类都是不错的选择。但是，如果需要在有限的内存上下文中创建数百万个具有几个简单属性的对象，则可以使用基于recordclass库的解决方案。from recordclass import make_dataclass
C = make_dataclass("C", ('a', 'b', 'c'))
c = C(1, 2, 3)
与类定义相同：
from recordclass import dataobject
class C(dataobject):
a:int
b:int
c:int
c = C(1, 2, 3)
它的内存占用非常小 = sizeof(PyObject_HEAD) + 3*sizeof(PyObject*) 字节。
相比之下，基于__slots__的变体需要sizeof(PyGC_Head) + sizeof(PyObject_HEAD) + 3*sizeof(PyObject*)字节。
自0.15版本以来，有一个名为fast_new的选项，可加快实例创建速度：
C = make_dataclass("C", ('a', 'b', 'c'), fast_new=True)
或者
class C(dataobject, fast_new=True):
a:int
b:int
c:int
这个选项可以使实例创建加速两倍。
我不同意使用没有方法的类来使代码更易读。通常情况下，我们期望从类中获得功能性，而不仅仅是数据。
因此，在需要功能性之前，我会选择使用字典。然后当需要时，构造函数可以接收一个字典参数，转化成类实例对象。
关于 Prodict 如何呢:
group = Prodict(a=1, b=2, c=3)
group.d = 4
如果您希望实现自动类型转换和自动代码补全（智能感知）：
class Person(Prodict):
name: str
email: str
rate: int
john = Person(name='John', email='john@appleseed.com')
john.rate = 7
john.age = 35 # dynamic
print self.group['a']。 - Muhammad Alkarouri