枚举-支持枚举

在3.4版中添加。

源代码： 库/枚举.py

重要

此页面包含API参考信息。用于教程有关更高级主题的信息和讨论，请参见

• 基础教程

• 高级教程

• 枚举食谱

---

枚举：

• 是一组绑定到唯一值的符号名（成员）

• 可以迭代以返回其规范（即非别名）成员定义顺序

• 使用呼叫按值返回成员的语法

• 使用指数按名称返回成员的语法

枚举可以通过使用班语法，或按使用function-call语法：

>>>从 枚举 进口 枚举

>>>#类语法
>>>班 颜色(枚举):
...    红色 = 1
...    绿色 = 2
...    蓝色 = 三

>>>#函数语法
>>>颜色 = 枚举('颜色', [“红色”, “绿色”, “蓝色”])

即使我们可以使用班创建枚举、枚举的语法不是普通的Python类。请参阅枚举有何不同？了解更多详细信息。

注释

术语

• 这个班级颜色是一个枚举（或枚举)

• 属性颜色。红色,颜色。绿色等，是枚举成员（或成员)和是功能常数。

• 枚举成员具有姓名和值（的名称颜色。红色是红色，的值颜色。蓝色是三等）

---

模块内容

枚举类型

这个类型用于枚举及其子类。

枚举

用于创建枚举常量的基类。

IntEnum（内部枚举）

用于创建枚举常量的基类的子类整数. (笔记)

StrEnum（结构枚举）

用于创建枚举常量的基类的子类字符串. (笔记)

标志

用于创建可使用组合的枚举常量的基类按位操作不会丢失标志会员资格。

IntFlag（国际标志）

用于创建可使用组合的枚举常量的基类位运算符，而不会丢失IntFlag（国际标志）会员资格。国际标志成员也是的子类整数. (笔记)

再现

使用者IntEnum（内部枚举）,StrEnum（结构枚举）、和IntFlag（国际标志）保持str（）混合型。

枚举检查

具有值的枚举连续,名称_障碍、和独特，用于验证（）确保各种约束由给定的枚举满足。

标志边界

具有值的枚举严格,符合,弹出、和保持它允许更精细地控制无效值的大小在枚举中处理。

汽车

实例被替换为枚举成员的适当值。StrEnum（结构枚举）默认为成员名称的小写版本，而其他枚举默认为1，并从中增加。

属性（）

允许枚举成员具有不与冲突的属性成员名称。这个价值和名称属性是这样实现的方式。

唯一（）

枚举类修饰符，确保只有一个名称绑定到任何一个值。

验证（）

枚举类装饰器，用于检查枚举。

成员（）

制造商对象成员。可以用作装饰器。

非成员（）

不要制造对象成员。可以用作装饰器。

全局数字（）

修改str（）和报告（）枚举的将其成员显示为属于模块而不是属于其类，并将枚举成员导出到全局命名空间。

显示标记值（）

返回标志中包含的所有双幂整数的列表。

在版本3.6中添加：标志,IntFlag（国际标志）,汽车

在版本3.11中添加：StrEnum（结构枚举）,枚举检查,再现,标志边界,财产,成员,非成员,全局_编号,显示标记值

---

数据类型

班 枚举。枚举类型

枚举类型是元类对于枚举枚举。这是可能的子类枚举类型–请参见子类EnumType了解详细信息。

枚举类型负责设置正确的__报告_（）,__str__（）,__格式_（）、和__reduce__（）上的方法最终的枚举，以及创建枚举成员，正确处理重复，提供枚举类的迭代等。

__呼叫__(cls公司,价值,姓名=无,*,模块=无,资格=无,类型=无,开始=1,边界=无)

此方法以两种不同的方式调用：

• 查找现有成员：

  cls公司:

  正在调用的枚举类。

  价值:

  要查找的值。

• 使用cls公司枚举以创建新枚举（仅当现有枚举没有任何成员）：

  cls公司:

  正在调用的枚举类。

  价值:

  要创建的新枚举的名称。

  姓名:

  新枚举的成员的名称/值。

  模块:

  创建新枚举的模块的名称。

  qualname（姓名）:

  模块中可以找到此枚举的实际位置。

  类型:

  新枚举的混合类型。

  开始:

  枚举的第一个整数值（由使用汽车).

  边界:

  如何处理位操作产生的超出范围的值(标志仅限）。

__包含__(cls公司,成员)

退换商品真的如果成员属于cls公司:

>>>一些变量 = 颜色.红色
>>>一些变量 在里面 颜色
真的
>>>颜色.红色.价值 在里面 颜色
真的

在版本3.12中更改：在Python 3.12之前类型错误如果非枚举成员用于包含检查。

__目录__(cls公司)

退换商品['__class__'， '__doc__'， '__members__'， '__module__']和中成员的名称cls公司:

>>>目录(颜色)
[‘蓝色’，‘绿色’，‘红色’，‘__class__'，‘__contains__’，‘___doc__'

__获取项目__(cls公司,名称)

返回中的枚举成员cls公司匹配名称，或引发键错误:

>>>颜色[“蓝色”]
<颜色。蓝色：3>

__iter公司__(cls公司)

返回中的每个成员cls公司按定义顺序：

>>>列表(颜色)
[<红色：1>，<绿色：2>，<蓝色：3>]

__伦__(cls公司)

返回中的成员数cls公司:

>>>伦恩(颜色)
三

__成员__

返回每个枚举名到其成员的映射，包括别名

__反转__(cls公司)

返回中的每个成员cls公司按照相反的定义顺序：

>>>列表(颠倒的(颜色))
[蓝色：3>，绿色：2>，红色：1>]

在版本3.11中添加：3.11之前枚举习惯于EnumMeta（枚举元）类型，保留为别名。

班 枚举。枚举

枚举是所有类的基类枚举枚举。

名称

用于定义枚举成员：

>>>颜色.蓝色.名称
“蓝色”

价值

给定的值枚举成员：

>>>颜色.红色.价值
1

成员的值，可以在中设置__新____（）.

注释

枚举成员值

成员值可以是任何值：整数,字符串等。如果您可以使用的确切值并不重要汽车实例和将为您选择适当的值。请参阅汽车对于细节。

而可变/不可更改的值，例如字典,列表或可变的数据类，可以使用，它们将具有创建期间相对于枚举中可变/不可变值的总数。

_姓名_

成员的名称。

_价值_

成员的值，可以在中设置__新____（）.

_订单_

不再使用，保持向后兼容性。（类属性，在创建类时删除）。

_忽略_

_忽略_仅在创建期间使用，并从创建完成后枚举。

_忽略_是不会成为成员的名称列表名称也将从完成的枚举中删除。请参阅时间段例如。

__目录__(自己)

退换商品['__class__'， '__doc__'， “__module__'， “名称”， “值”]和定义的任何公共方法自我__类__:

>>>从 日期时间 进口 日期
>>>班 工作日(枚举):
...    星期一 = 1
...    星期二 = 2
...    星期三 = 三
...    星期四 = 4
...    星期五 = 5
...    星期六 = 6
...    星期日 = 7
...    @分类方法
...    定义 今天(cls公司):
...        打印('今天是%秒' % cls公司(日期.今天().等工作日()).名称)
...
>>>目录(工作日.星期六)
[“__class__'，”__doc__'“，”__eq__'、“__hash__'”，“__module__”，“name”，“today”，“value”]

_生成下一个值_(名称,开始,计数,last_values（最后_个值）)

名称:

正在定义的成员的名称（例如“RED”）。

开始:

枚举的起始值；默认值为1。

计数:

当前定义的成员数，不包括此成员。

last_values（最后_个值）:

先前值的列表。

A类静态方法用于确定汽车:

>>>从 枚举 进口 汽车
>>>班 三者的力量(枚举):
...    @静态方法
...    定义 _生成下一个值_(名称, 开始, 计数, last_values（最后_个值）):
...        返回 三 ** (计数 + 1)
...    第一 = 汽车()
...    第二 = 汽车()
...
>>>三者的力量.第二.价值
9

__初始化__(自己,*参数,**千瓦时)

默认情况下，不执行任何操作。如果在成员中给定了多个值赋值时，这些值将成为__初始化__; 例如

>>>从 枚举 进口 枚举
>>>班 工作日(枚举):
...    星期一 = 1, “周一”

工作日__初始化_（）将被称为工作日__init__（自身， 1, “周一”）

__init_子类__(cls公司,**千瓦时)

A类分类方法用于进一步配置后续子类。默认情况下，不执行任何操作。

_缺少_(cls公司,价值)

A类分类方法用于查找在中找不到的值cls公司。默认情况下不执行任何操作，但可以重写以实现自定义搜索行为：

>>>从 枚举 进口 StrEnum（结构枚举）
>>>班 生成(StrEnum（结构枚举）):
...    调试 = 汽车()
...    已优化 = 汽车()
...    @分类方法
...    定义 _缺少_(cls公司, 价值):
...        价值 = 价值.降低()
...        对于 成员 在里面 cls公司:
...            如果 成员.价值 == 价值:
...                返回 成员
...        返回 无
...
>>>生成.调试.价值
“调试”
>>>生成(“去BUG”)
<构建。调试：“调试”>

__新的__(cls公司,*参数,**千瓦时)

默认情况下，不存在。如果指定，则在枚举类中定义或在mixin类中（例如整数)，所有给定值将在成员分配中通过；例如

>>>从 枚举 进口 枚举
>>>班 MyIntEnum（我的IntEnum）(整数, 枚举):
...    TWENTYSIX公司 = “1a”, 16

通话结果int（'1a'， 16）和值26对于成员。

注释

编写自定义时__新的__，不使用super（）__新__–打电话给合适的人__新的__而不是。

__代表__(自己)

返回用于报告（）电话。默认情况下，返回枚举名称、成员名称和值，但可以重写：

>>>班 其他样式(枚举):
...    备选方案 = 汽车()
...    其他 = 汽车()
...    SOMETHING_ELSE公司 = 汽车()
...    定义 __代表__(自己):
...        cls名称 = 自己.__类__.__姓名__
...        返回 （f）'{cls名称}.{自己.名称}'
...
>>>其他样式.备选方案, 字符串(其他样式.备选方案), （f）"{其他样式.备选方案}"
（OtherStyle.ALTERNATE，'OtherStley.ALTERNETE'，'OherStyle.ALTERNATE'）

__字符串__(自己)

返回用于str（）电话。默认情况下，返回枚举名称和成员名称，但可以重写：

>>>班 其他样式(枚举):
...    备选方案 = 汽车()
...    其他 = 汽车()
...    SOMETHING_ELSE公司 = 汽车()
...    定义 __字符串__(自己):
...        返回 （f）'{自己.名称}'
...
>>>其他样式.备选方案, 字符串(其他样式.备选方案), （f）"{其他样式.备选方案}"
（<OtherStyle.ALTERNATE:1>，'替代'，'替代]）

__格式__(自己)

返回用于格式（）和f字符串电话。默认情况下，收益__str__（）返回值，但可以重写：

>>>班 其他样式(枚举):
...    备选方案 = 汽车()
...    其他 = 汽车()
...    SOMETHING_ELSE公司 = 汽车()
...    定义 __格式__(自己, 规范):
...        返回 （f）'{自己.名称}'
...
>>>其他样式.备选方案, 字符串(其他样式.备选方案), （f）"{其他样式.备选方案}"
（<OtherStyle.ALTERNATE:1>，'其他样式.ALTERNATO'，'替代'）

注释

使用汽车具有枚举结果为数值递增的整数，从开始1.

在版本3.12中更改：补充数据类支持

班 枚举。IntEnum（内部枚举）

IntEnum（内部枚举）与相同枚举，但其成员也是整数，并且可以是在可以使用整数的任何地方使用。如果执行任何整数运算带有国际枚举成员，则结果值将失去其枚举状态。

>>>从 枚举 进口 IntEnum（内部枚举）
>>>班 编号(IntEnum（内部枚举）):
...    一个 = 1
...    二 = 2
...    三个 = 三
...
>>>编号.三个
<数量。三：3>
>>>编号.一个 + 编号.二
三
>>>编号.三个 + 5
8
>>>编号.三个 == 三
真的

注释

使用汽车具有IntEnum（内部枚举）结果为递增的整数值，从开始1.

版本3.11中的更改：__str__（）现在是int.__str__（）到更好地支持替换现有常量使用案例。__格式_（）已经int.__format__（）出于同样的原因。

班 枚举。StrEnum（结构枚举）

StrEnum（结构枚举）与相同枚举，但其成员也是字符串，可以使用在大多数相同的地方可以使用字符串。任何字符串的结果在或使用StrEnum（结构枚举）成员不是枚举的一部分。

注释

stdlib中有一些位置可以检查字符串而不是字符串子类（即。类型（未知） == 字符串而不是isinstance（未知， 字符串）)，在这些地方将需要使用str（StrEnum.member）.

注释

使用汽车具有StrEnum（结构枚举）结果为小写成员name作为值。

注释

__str__（）是str.__str__（）以更好地支持替换现有常量使用案例。__格式_（）也是如此字符串__format__（）出于同样的原因。

在版本3.11中添加。

班 枚举。标志

标志与相同枚举，但其成员支持按位操作员&(以及),|(或),^(异或)、和~(倒转);这些运算符的结果是枚举的成员。

__包含__(自己,价值)

退换商品真的如果值在self中：

>>>从 枚举 进口 标志, 汽车
>>>班 颜色(标志):
...    红色 = 汽车()
...    绿色 = 汽车()
...    蓝色 = 汽车()
...
>>>紫色 = 颜色.红色 | 颜色.蓝色
>>>白色 = 颜色.红色 | 颜色.绿色 | 颜色.蓝色
>>>颜色.绿色 在里面 紫色
False（错误）
>>>颜色.绿色 在里面 白色
真的
>>>紫色 在里面 白色
真的
>>>白色 在里面 紫色
False（错误）

__iter__（自身）：

返回所有包含的非别名成员：

>>>列表(颜色.红色)
[<红色：1>]
>>>列表(紫色)
[<红色：1>，<蓝色：4>]

在版本3.11中添加。

__len__（自我）：

返回标志中的成员数：

>>>伦恩(颜色.绿色)
1
>>>伦恩(白色)
三

__bool_（自我）：

退换商品真的如果旗下有任何成员，False（错误）否则：

>>>布尔(颜色.绿色)
真的
>>>布尔(白色)
真的
>>>黑色 = 颜色(0)
>>>布尔(黑色)
False（错误）

__或__(自己,其他)

返回当前标志binary或'ed with other:

>>>颜色.红色 | 颜色.绿色
<颜色。红色|绿色：3>

__和__(自己,其他)

返回当前标志binary和'ed with other:

>>>紫色 & 白色
<颜色。红色|蓝色：5>
>>>紫色 & 颜色.绿色
<颜色：0>

__异或__(自己,其他)

返回当前标志binary与other的异或：

>>>紫色 ^ 白色
<颜色。绿色：2>
>>>紫色 ^ 颜色.绿色
<颜色。红色|绿色|蓝色：7>

__反转__（自身）：

返回中的所有标志类型（自身）不存在于自身：

>>>~白色
<颜色：0>
>>>~紫色
<颜色。绿色：2>
>>>~颜色.红色
<颜色。绿色|蓝色：6>

_数字_repr_()

函数，用于格式化任何剩余的未命名数值。默认值为价值代表；常见的选择是六进制（）和oct（）.

注释

使用汽车具有标志结果为整数的幂共两个，从开始1.

版本3.11中的更改：这个报告（）0值标志的已更改。它现在是：

>>>颜色(0) 
<颜色：0>

班 枚举。IntFlag（国际标志）

国际标志与相同标志，但其成员也是整数，可以是在可以使用整数的任何地方使用。

>>>从 枚举 进口 国际标志, 汽车
>>>班 颜色(IntFlag（国际标志）):
...    红色 = 汽车()
...    绿色 = 汽车()
...    蓝色 = 汽车()
...
>>>颜色.红色 & 2
<颜色：0>
>>>颜色.红色 | 2
<颜色。红色|绿色：3>

如果使用IntFlag（国际标志）成员，结果是不是一个IntFlag（国际标志）:

>>>颜色.红色 + 2
三

如果标志使用IntFlag（国际标志）成员和：

• 结果是有效的IntFlag（国际标志）：一个IntFlag（国际标志）已返回

• 结果无效IntFlag（国际标志）：结果取决于标志边界设置

这个报告（）未命名的零值标志已更改。现在是：

>>>颜色(0)
<颜色：0>

注释

使用汽车具有IntFlag（国际标志）结果为整数的幂共两个，从开始1.

版本3.11中的更改：__字符串_（）现在是int.__str__（）以更好地支持替换现有常量使用案例。__格式_（）是已经int.__format__（）出于同样的原因。

反转IntFlag（国际标志）现在返回一个正值，即不在给定标志中的所有标志的并集，而不是负值。这与现有的标志行为。

班 枚举。再现

再现使用报告（）属于枚举,但是str（）混合数据类型：

• int.__str__（）对于IntEnum（内部枚举）和IntFlag（国际标志）

• str.__str__（）对于StrEnum公司

继承自再现保持str（）/格式（）而不是使用枚举-默认str（）.

在版本3.11中添加。

班 枚举。枚举检查

枚举检查包含验证（）装饰师确保各种约束；失败的约束导致值错误.

独特

确保每个值只有一个名称：

>>>从 枚举 进口 枚举, 验证, 独特
>>>@验证(独特)
...班 颜色(枚举):
...    红色 = 1
...    绿色 = 2
...    蓝色 = 三
...    深红色的 = 1
回溯（最近一次调用）：
...
值错误:在<enum“Color”>中找到的别名：CRIMSON->RED

连续

确保最低值成员之间没有缺少值以及价值最高的成员：

>>>从 枚举 进口 枚举, 验证, 连续
>>>@验证(连续)
...班 颜色(枚举):
...    红色 = 1
...    绿色 = 2
...    蓝色 = 5
回溯（最近一次调用）：
...
值错误:枚举“Color”无效：缺少值3、4

名称_障碍

确保所有标志组/掩码仅包含命名标志–在以下情况下很有用值是指定的，而不是由自动（）:

>>>从 枚举 进口 标志, 验证, 名称_障碍
>>>@验证(名称_障碍)
...班 颜色(标志):
...    红色 = 1
...    绿色 = 2
...    蓝色 = 4
...    白色 = 15
...    新能源公司 = 31
回溯（最近一次调用）：
...
值错误:无效的标志“颜色”：别名WHITE和NEON缺少0x18的组合值[有关详细信息，请使用enum.show_Flag_values（value）]

注释

CONTINUOUS和NAMED_FLAGS设计用于处理积分值成员。

在版本3.11中添加。

班 枚举。标志边界

标志边界控制如何在中处理超出范围的值标志及其子类。

严格

超出范围的值会导致值错误有待提高。这是默认为标志:

>>>从 枚举 进口 标志, 严格, 汽车
>>>班 严格标志(标志, 边界=严格):
...    红色 = 汽车()
...    绿色 = 汽车()
...    蓝色 = 汽车()
...
>>>严格标志(2**2 + 2**4)
回溯（最近一次调用）：
...
值错误:＜flag‘StrictFlag’＞无效值20
给定0b0 10100
允许0b0 00111

符合

超出范围的值删除了无效值，留下有效值标志值：

>>>从 枚举 进口 标志, 符合, 汽车
>>>班 符合标志(标志, 边界=符合):
...    红色 = 汽车()
...    绿色 = 汽车()
...    蓝色 = 汽车()
...
>>>符合标志(2**2 + 2**4)
<符合标志。蓝色：4>

弹出

超出范围的值将丢失标志成员身份并恢复为整数.

>>>从 枚举 进口 标志, 弹出, 汽车
>>>班 弹出标志(标志, 边界=弹出):
...    红色 = 汽车()
...    绿色 = 汽车()
...    蓝色 = 汽车()
...
>>>弹出标志(2**2 + 2**4)
20

保持

保持超出范围的值，并且标志保留会员资格。这是默认的IntFlag（国际标志）:

>>>从 枚举 进口 标志, 保持, 汽车
>>>班 保持标志（KeepFlag）(标志, 边界=保持):
...    红色 = 汽车()
...    绿色 = 汽车()
...    蓝色 = 汽车()
...
>>>保持标志（KeepFlag）(2**2 + 2**4)
<保留标志。蓝色|16:20>

在版本3.11中添加。

---

支持__扣篮__姓名

__成员__是的只读有序映射成员名称:成员项目。它只在课堂上提供。

__新____（）如果指定，则必须创建并返回枚举成员；它是设置成员的_价值_适当地。一次所有成员都已创建，不再使用。

支持_分裂_姓名

• _姓名_–成员姓名

• _价值_–成员的价值；可以在中设置__新的__

• _缺少_（）–未找到值时使用的查找函数；可能会被覆盖

• _忽略_–名称列表，可以是列表或a字符串，它将不会转换为成员，并将被删除从最后一节课开始

• _订单_–不再使用，保留向后兼容性（类属性，在创建类时删除）

• _生成下一个值（）–用于获取适当的值枚举成员；可能会被覆盖

  注释

  对于标准枚举类，选择的下一个值是最后看到的值增加了一个。

  对于标志选择的下一个值将是下一个最高的两次断电，无论最后看到的值是多少。

在版本3.6中添加：_失踪_,_订单_,_生成下一个值_

在版本3.7中添加：_忽略_

---

公用设施和装饰

班 枚举。汽车

汽车可以用来代替值。如果使用枚举机械将呼叫枚举的_生成下一个值（）以获得适当的值。对于枚举和IntEnum（内部枚举）该适当的值将是最后一个值加上一个；对于标志和IntFlag（国际标志）这将是两次大停电中的第一次高于最高值；对于StrEnum（结构枚举）它将是小写版本的成员的姓名。混合时必须小心自动（）手动使用指定的值。

汽车只有当处于分配的顶层时，才会解析实例：

• 第一 = 自动（）将工作（auto（）替换为1);

• 第二 = 自动（）， -2将工作（自动替换为2，所以2, -2是用于创建第二枚举成员；

• 三个 = [自动（）， -3]将不工作(<自动 实例>， -3个习惯于创建三个枚举成员）

在版本3.11.1中更改：在以前的版本中，自动（）必须是唯一的在作业线上正常工作。

_生成下一个值_可以重写以自定义汽车.

注释

3.13中的默认值_生成下一个值_将永远返回最高成员值增加1，如果有则失败成员是不兼容的类型。

@枚举。财产

类似于内置的装饰器财产，但专门针对枚举。它允许成员属性与成员具有相同的名称他们自己。

注释

这个财产成员必须在单独的类中定义；例如价值和名称属性在枚举类，以及枚举子类可以用姓名价值和名称.

在版本3.11中添加。

@枚举。独特的

A类班专门用于枚举的修饰符。它搜索枚举__成员__收集找到的别名；如果有建立值错误详细信息如下：

>>>从 枚举 进口 枚举, 独特的
>>>@独一无二的
...班 错误(枚举):
...    一个 = 1
...    二 = 2
...    三个 = 三
...    四 = 三
...
回溯（最近一次调用）：
...
值错误:<枚举“错误”>中发现重复值：四->三

@枚举。验证

A类班专门用于枚举的修饰符。成员来自枚举检查用于指定应检查哪些约束关于修饰枚举。

在版本3.11中添加。

@枚举。成员

枚举中使用的修饰符：其目标将成为成员。

在版本3.11中添加。

@枚举。非成员

枚举中使用的修饰符：其目标不会成为成员。

在版本3.11中添加。

@枚举。全局_编号

用于更改str（）和报告（）枚举的将其成员显示为属于模块而不是属于其类。仅应在导出枚举成员时使用到模块全局命名空间（请参见re.Regex标志例如）。

在版本3.11中添加。

枚举。显示标记值(价值)

返回标志中包含的所有双幂整数的列表价值.

在版本3.11中添加。

---

笔记

IntEnum（内部枚举）,StrEnum（结构枚举）、和IntFlag（国际标志）

这三种枚举类型旨在替代现有的基于整数和字符串的值；因此，它们有额外的限制：

• __字符串__使用枚举成员的值而不是名称

• __格式__，因为它使用__字符串__，也将使用枚举成员而不是其名称

如果您不需要/想要这些限制，您可以创建自己的通过在整数或字符串键入您自己：

>>>从 枚举 进口 枚举
>>>班 MyIntEnum（我的IntEnum）(整数, 枚举):
...    通过

或者您可以重新分配适当的str（）等，在您的枚举中：

>>>从 枚举 进口 枚举, 国际枚举
>>>班 MyIntEnum（我的IntEnum）(IntEnum（内部枚举）):
...    __字符串__ = 枚举.__字符串__