Question

我想知道enum和namedtuple之间有什么区别，以及何时应该使用另一个。

Answer 1

作为一个类比（虽然不完美），您可以将python中的enum.Enum和namedtuple视为C中的enum和struct。换句话说，{ {1}}是一种别名值的方法，而enum是一种按名称封装数据的方法。这两者实际上不可互换，您可以使用namedtuple s作为enum中的命名值。

我认为这个例子说明了不同之处。

namedtuple

您可以像访问常规对象一样访问此人的命名“属性”。

from collections import namedtuple
from enum import Enum

class HairColor(Enum):
    blonde = 1
    brown = 2
    black = 3
    red = 4

Person = namedtuple('Person', ['name','age','hair_color'])
bert = Person('Bert', 5, HairColor.black)

您经常看不到>>> print(bert.name) Bert >>> print(bert.age) 5 >>> print(bert.hair_color) HairColor.black >>> print(bert.hair_color.value) 3这样，因为使用更广为人知的namedtuple声明可以实现相同的基本概念。下面的class定义与上面的class定义几乎完全相同。

namedtuple

但是，class Person: def __init__(self, name, age, hair_color): self.name = name self.age = age self.hair_color = hair_color和namedtuple对象之间的主要区别在于class的属性在创建后无法更改。

Answer 2

namedtuple 是快速结构，使用 __ slots __ 代替 __ dict __ ，最终确定您提供的内容在初始化时（虽然存在_replace（）方法，但实际上它变为只读）。

当您需要许多（例如数百，数千甚至数百万）相同类型的对象或者您正在阅读和/或写入记录时，通常会使用namedtuple。
例如，一个经常被引用的例子是Point namedtuple，它可能用于处理带有x, y, z组件的多边形顶点。
如果与总是按名称指向正确的组件（.x，.y，.z，...）的优点进行比较，那么由一个常规元组引入的命名元数的开销是最小的。而不是索引（0,1,2，...）读取像A.x这样的代码比A [0]更容易：意思很明显，即使你编写代码几个月后也是如此，对于其他程序员来说也是如此。

因此，一个namedtuple很快，可用于有意义地识别元组的内容，最后但并非最不重要的是，可以与通过索引访问元组内容的旧代码共存。

from collections import namedtuple

Point = namedtuple('Point', 'x y z')  # note the x, y, z fields

origin = Point(0, 0, 0)

A = Point(1, 1, 1)
B = Point(1, 1, 0)
C = Point(1, 0, 0)
D = Point(1, 2, 3)

for p in (origin, A, B, C, D):
    print(p)
    print('x:', p.x, '  y:', p.y, '  z:', p.z)
    print('x:', p[0], '  y:', p[1], '  z:', p[2])
    print()

从上面的示例开始，只要所有内容都按名称而不是索引访问点组件，通过不更改任何索引号，可能更容易引入更多更改：

from collections import namedtuple


Point = namedtuple('Point', 'name x y z')  # addition of the field 'name'

origin = Point('O', 0, 0, 0)

A = Point('A', 1, 1, 1)
B = Point('B', 1, 1, 0)
C = Point('C', 1, 0, 0)
D = Point('D', 1, 0, 1)

for p in (origin, A, B, C, D):
    print(p)
    print(p.name)  # more readable than p[0] that is no more the x coordinate
    print('x:', p.x,  '  y:', p.y,  '  z:', p.z)  # unchanged
    print('x:', p[1], '  y:', p[2], '  z:', p[3])  # changed
    print()

枚举是一种将符号名称耦合到常量值并将其归类为特定集合的方法。我们通过创建一个派生自 Enum 或 IntEnum 的类来定义枚举，具体取决于我们希望常量具有的值：Enum是通用版本，IntEnum强制执行这一事实每个常量值都是int类型。

例如，枚举适用于按名称，特定整数类型，性别定义颜色，或者更常见的是 - 属于特定集合的元素。

from enum import Enum, IntEnum, unique

class Color_1(Enum):
    red = 'red'
    green = 'green'
    blue = 'blue'

class Color_2(Enum):
    red = (255, 0, 0)
    green = (0, 255, 0)
    blue = (0, 0, 255)

class Color_3(IntEnum):
    red = 0xFF0000
    green = 0xFF00
    blue = 0xFF

class Gender_1(Enum):
    unknown = 'U'
    male = 'M'
    female = 'F'

class Gender_2(Enum):
    unknown = 0.3
    male = 0.5
    female = 0.7

class Shape(Enum):  # Note the different constants types, perfectly legal
    TRIANGLE = 't'
    RECTANGLE = 5
    SQUARE = tuple('square')

class DataType(IntEnum):
    int8 = -8
    int16 = -16
    int32 = -32
    int64 = -64
    int = -2
    negative = -1
    positive = 1
    uint = 2
    uint8 = 8
    uint16 = 16
    uint32 = 32
    uint64 = 64

在pythonic开发中 - 枚举元素可能具有指定的特定值 - 可以是唯一的也可以不是，具体取决于您的偏好和规范。唯一装饰器用于强制值唯一性。默认情况下，可以将相同的常量值分配给两个或多个不同的符号名称。

class Color_4(IntEnum):
    red = 1
    green = 2
    blue = 3
    RED = 1
    GREEN = 2
    BLUE = 3

枚举元素可以相互比较，但要使它们成功，不仅值必须匹配，即使它们的类型必须相同。

例如：

Color_4.red == Color_4.RED

将返回True（相同的类，相同的值），但以下内容：

Shape.SQUARE == tuple('square')

将为False - 因为比较的正确元素 - 元组（'square'） - 不是Shape类型，尽管它们都具有相同的值。

总而言之，enums和namedtuples是不同的工具。

最近在Python中添加了枚举（搜索PEP435）。如果记忆力对我有用，那个名字元组可以使用很长时间，但我仍然是社区新手，因此我可能错了。 HTH

enum和namedtuple有什么区别？

2 个答案: