search

Lấy giá trị enum trong python

1 năms trước
Trả lời: 0
Lượt xem: 94

Bạn có thể thêm một phương thức 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
99 vào enum của mình, nếu tất cả những gì bạn muốn là cung cấp một biểu diễn chuỗi tùy chỉnh. Nó cũng sẽ cho phép bạn in nó theo cách đó trong danh sách

Show

from enum import Enum


class D(Enum):
    def __str__(self):
        return str(self.value)

    x = 1
    y = 2


print(D.x)

Output. 1

Do comment if you have any doubts and suggestions on this Python enum topic

Note. IDE.  PyCharm 2021. 3. 3 (Community Edition)

Windows 10

Python 3. 10. 1

All Python Examples are in Python 3, so Maybe its different from python 2 or upgraded versions

Lấy giá trị enum trong python

Rohit

Degree in Computer Science and Engineer. App Developer and has multiple Programming languages experience. Enthusiasm for technology & like learning technical

Chúc các bạn một ngày tốt lành. In this post, we'll look at how to solve the Python Enum Key String Get programming puzzle

from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)

We have shown how to address the Python Enum Key String Get problemby looking at a number of different cases

How do I get the enum key in Python?

Use the name attribute on the enum member to get the name, e. g. Sizes. SMALL. name . If you only have the corresponding value, pass the value to the enumeration class and access the name attribute. Copied. You can use the name and value properties on an enum member to get the enum's name and value. 17-Jun-2022

How do I find my enum key?

To get an enum key by value

  • Use the Object. values() method to get an array of the enum's values
  • Use the indexOf() method to get the index of the value in the array
  • Use the Object. keys() method to get an array of the enum's keys
  • Access the array of keys at the specific index

How do you return enum value in Python?

To get a value in an enum in Python

  • Use dot notation to access the specific enum member, e. g. Color. GREEN
  • Access the value attribute on the enum member, e. g. Color. GREEN. value

How do I print an enum in Python?

We can access the enum members by using the dot operator(. ) with the enum class name. repr() . The repr() method used to print enum member. type(). This is used to print the type of enum member

What is enum value in Python?

An Enum is a set of symbolic names bound to unique values. They are similar to global variables, but they offer a more useful repr() , grouping, type-safety, and a few other features. As you can see, creating an Enum is as simple as writing a class that inherits from Enum itself

What is key enumeration?

The next set of Keys values refers to the horizontal row of number keys located above the letter keys regardless of shift state. Keys Enumeration (number keys) Member. Value. 14-May-2022

What is enum TS?

In TypeScript, enums, or enumerated types, are data structures of constant length that hold a set of constant values. Each of these constant values is known as a member of the enum. Enums are useful when setting properties or values that can only be a certain number of possible values. 14-Jun-2021

How do you use enums?

You should always use enums when a variable (especially a method parameter) can only take one out of a small set of possible values. Examples would be things like type constants (contract status. “permanent”, “temp”, “apprentice”), or flags (“execute now”, “defer execution”). 30-Tháng 9-2020

Can enum values be strings Python?

Enumerations are created using classes. Enums have names and values associated with them. Properties of enum. Enums can be displayed as string or repr. 16-Aug-2022

Can Python enum have methods?

Python enumerations are classes. It means that you can add methods to them, or implement the dunder methods to customize their behaviors

Some programming languages, like Java and C++, include syntax that supports a data type known as enumerations, or just enums. This data type allows you to create sets of semantically related constants that you can access through the enumeration itself. Python doesn’t have a dedicated syntax for enums. However, the Python standard library has an 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 module that supports enumerations through the 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 class

If you come from a language with enumerations, and you’re used to working with them, or if you just want to learn how to use enumerations in Python, then this tutorial is for you

In this tutorial, you’ll learn how to

  • Create enumerations of constants using Python’s 
    >>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
    2 class
  • Làm việc với các kiểu liệt kê và các thành viên của chúng trong Python
  • Tùy chỉnh các lớp liệt kê với các chức năng mới
  • Viết mã các ví dụ thực tế để hiểu lý do tại sao bạn sẽ sử dụng kiểu liệt kê

Ngoài ra, bạn sẽ khám phá các kiểu liệt kê cụ thể khác tồn tại trong 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1, bao gồm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
7. Họ sẽ giúp bạn tạo các enum chuyên dụng

Để làm theo hướng dẫn này, bạn nên làm quen với lập trình hướng đối tượng và kế thừa trong Python

Mã nguồn. Nhấp vào đây để tải xuống mã nguồn miễn phí mà bạn sẽ sử dụng để xây dựng bảng liệt kê trong Python

Làm quen với phép liệt kê trong Python

Một số ngôn ngữ lập trình, bao gồm Java và C++, có kiểu dữ liệu liệt kê hoặc kiểu dữ liệu enum riêng như một phần cú pháp của chúng. Kiểu dữ liệu này cho phép bạn tạo các tập hợp các hằng số được đặt tên, được coi là thành viên của enum chứa. Bạn có thể truy cập các thành viên thông qua bảng liệt kê

Phép liệt kê có ích khi bạn cần xác định một tập hợp bất biến và rời rạc của các giá trị hằng số tương tự hoặc có liên quan có thể có hoặc không có ý nghĩa ngữ nghĩa trong mã của bạn

Ngày trong tuần, tháng và mùa trong năm, hướng chính của Trái đất, mã trạng thái của chương trình, mã trạng thái HTTP, màu sắc của đèn giao thông và kế hoạch định giá của dịch vụ web đều là những ví dụ tuyệt vời về phép liệt kê trong lập trình. Nói chung, bạn có thể sử dụng enum bất cứ khi nào bạn có một biến có thể nhận một trong số các giá trị có thể có giới hạn

Python không có kiểu dữ liệu enum như một phần cú pháp của nó. May mắn thay, Python 3. 4 đã thêm mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 vào thư viện chuẩn. Mô-đun này cung cấp lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 để hỗ trợ các kiểu liệt kê có mục đích chung trong Python

Phép liệt kê được giới thiệu bởi PEP 435, định nghĩa chúng như sau

Một phép liệt kê là một tập hợp các tên tượng trưng được liên kết với các giá trị không đổi, duy nhất. Trong một phép liệt kê, các giá trị có thể được so sánh theo danh tính và bản thân phép liệt kê có thể được lặp lại. (Nguồn)

Trước phần bổ sung này vào thư viện chuẩn, bạn có thể tạo thứ gì đó tương tự như phép liệt kê bằng cách xác định một chuỗi các hằng số tương tự hoặc có liên quan. Để làm được điều này, các nhà phát triển Python thường sử dụng thành ngữ sau

>>> 

from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)
1

Mặc dù thành ngữ này hoạt động, nhưng nó không mở rộng tốt khi bạn đang cố gắng nhóm một số lượng lớn các hằng số liên quan. Một điều bất tiện khác là hằng số đầu tiên sẽ có giá trị là 

from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)
20, giá trị này là sai trong Python. Đây có thể là một vấn đề trong một số trường hợp nhất định, đặc biệt là những trường hợp liên quan đến kiểm tra Boolean

Ghi chú. Nếu bạn đang sử dụng phiên bản Python trước 3. 4, thì bạn có thể tạo bảng liệt kê bằng cách cài đặt thư viện enum34, đây là cổng sau của thư viện chuẩn 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1. Thư viện của bên thứ ba aenum cũng có thể là một lựa chọn cho bạn

Trong hầu hết các trường hợp, phép liệt kê có thể giúp bạn tránh được nhược điểm của thành ngữ trên. Chúng cũng sẽ giúp bạn tạo mã có tổ chức hơn, dễ đọc và mạnh mẽ hơn. Việc liệt kê có một số lợi ích, một số lợi ích liên quan đến việc mã hóa dễ dàng

  • Cho phép nhóm các hằng số liên quan một cách thuận tiện trong một loại không gian tên
  • Cho phép hành vi bổ sung với các phương thức tùy chỉnh hoạt động trên thành viên enum hoặc chính enum
  • Cung cấp quyền truy cập nhanh chóng và linh hoạt cho các thành viên enum
  • Cho phép lặp lại trực tiếp trên các thành viên, bao gồm tên và giá trị của họ
  • Tạo điều kiện hoàn thành mã trong IDE và trình chỉnh sửa
  • Cho phép kiểm tra loại và lỗi bằng trình kiểm tra tĩnh
  • Cung cấp một trung tâm tên có thể tìm kiếm
  • Giảm thiểu lỗi chính tả khi sử dụng các phần tử của một kiểu liệt kê

Họ cũng làm cho mã của bạn mạnh mẽ bằng cách cung cấp các lợi ích sau

  • Đảm bảo các giá trị không đổi không thể thay đổi trong quá trình thực thi mã
  • Đảm bảo an toàn cho loại bằng cách phân biệt cùng một giá trị được chia sẻ trên một số enum
  • Cải thiện khả năng đọc và khả năng bảo trì bằng cách sử dụng tên mô tả thay vì giá trị bí ẩn hoặc số ma thuật
  • Tạo điều kiện gỡ lỗi bằng cách tận dụng các tên có thể đọc được thay vì các giá trị không có ý nghĩa rõ ràng
  • Cung cấp một nguồn duy nhất của sự thật và tính nhất quán trong toàn bộ mã

Bây giờ bạn đã biết kiến ​​thức cơ bản về kiểu liệt kê trong lập trình và trong Python, bạn có thể bắt đầu tạo kiểu kiểu liệt kê của riêng mình bằng cách sử dụng lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 của Python

Loại bỏ các quảng cáo

Tạo bảng liệt kê với >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 2 của Python

Mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 của Python cung cấp lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2, cho phép bạn tạo các kiểu liệt kê. Để tạo bảng liệt kê của riêng bạn, bạn có thể phân lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 hoặc sử dụng API chức năng của nó. Cả hai tùy chọn sẽ cho phép bạn xác định một tập hợp các hằng số liên quan dưới dạng thành viên enum

Trong các phần sau, bạn sẽ tìm hiểu cách tạo kiểu liệt kê trong mã của mình bằng cách sử dụng lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2. Bạn cũng sẽ tìm hiểu cách đặt giá trị được tạo tự động cho enum của mình và cách tạo liệt kê chứa bí danh và giá trị duy nhất. Để bắt đầu, bạn sẽ bắt đầu bằng cách học cách tạo một phép liệt kê bằng cách phân lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

Tạo bảng liệt kê bằng cách phân lớp >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 2

Mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 xác định kiểu liệt kê có mục đích chung với khả năng lặp lại và so sánh. Bạn có thể sử dụng loại này để tạo các tập hợp các hằng số được đặt tên mà bạn có thể sử dụng để thay thế các chữ cái của các loại dữ liệu phổ biến, chẳng hạn như số và chuỗi

Một ví dụ kinh điển về thời điểm bạn nên sử dụng kiểu liệt kê là khi bạn cần tạo một tập hợp các hằng số liệt kê biểu thị các ngày trong tuần. Mỗi ngày sẽ có một tên tượng trưng và một giá trị số giữa 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
31 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
32, bao gồm cả

Đây là cách bạn có thể tạo bảng liệt kê này bằng cách sử dụng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 làm lớp cha hoặc lớp cha của bạn

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6

Lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34 của bạn là một lớp con của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2. Vì vậy, bạn có thể gọi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34 là một kiểu liệt kê, hoặc chỉ là một kiểu liệt kê. 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
37, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
38, và những thứ tương tự là thành viên điều tra, còn được gọi là thành viên enum, hoặc chỉ thành viên. Mỗi thành viên phải có một giá trị, cần phải không đổi

Bởi vì các thành viên liệt kê phải là hằng số, Python không cho phép bạn gán giá trị mới cho các thành viên enum trong thời gian chạy

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

Nếu bạn cố gắng thay đổi giá trị của một thành viên enum, thì bạn sẽ nhận được một 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
39. Không giống như tên thành viên, bản thân tên chứa kiểu liệt kê không phải là hằng mà là một biến. Vì vậy, có thể rebind tên này bất cứ lúc nào trong quá trình thực thi chương trình của bạn, nhưng bạn nên tránh làm điều đó

Trong ví dụ trên, bạn đã chỉ định lại 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34, hiện giữ một chuỗi thay vì kiểu liệt kê ban đầu. Bằng cách này, bạn đã mất tham chiếu đến chính enum

Thông thường, các giá trị được ánh xạ tới các thành viên là các số nguyên liên tiếp. Tuy nhiên, chúng có thể thuộc bất kỳ loại nào, kể cả các loại do người dùng định nghĩa. Trong ví dụ này, giá trị của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
37 là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
31, giá trị của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
38 là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
84, v.v.

Ghi chú. Bạn có thể nhận thấy rằng các thành viên của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34 được viết hoa. Đây là lý do tại sao

Bởi vì Enums được sử dụng để đại diện cho các hằng số, chúng tôi khuyên bạn nên sử dụng tên UPPER_CASE cho các thành viên enum… (Nguồn)

Bạn có thể coi kiểu liệt kê là tập hợp các hằng số. Giống như danh sách, bộ dữ liệu hoặc từ điển, liệt kê Python cũng có thể lặp lại. Đó là lý do tại sao bạn có thể sử dụng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
86 để biến một điều tra thành một 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
87 thành viên điều tra

Các thành viên của một bảng liệt kê Python là các thể hiện của chính bảng liệt kê vùng chứa

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

Bạn không nên nhầm lẫn một lớp enum tùy chỉnh như 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34 với các thành viên của nó. 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
37, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
38, v.v. Trong ví dụ này, loại enum 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34 là một trung tâm dành cho các thành viên liệt kê, thuộc loại 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
34

Bạn cũng có thể sử dụng thành ngữ dựa trên 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
83 để xây dựng bảng liệt kê

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
9

Trong ví dụ này, bạn sử dụng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
83 với phần bù 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
85 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
86. Giá trị bù 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
85 cho phép bạn cung cấp số bắt đầu phạm vi, trong khi giá trị bù 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
86 xác định số mà tại đó phạm vi sẽ ngừng tạo số

Mặc dù bạn sử dụng cú pháp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
89 để tạo kiểu liệt kê, nhưng chúng là các lớp đặc biệt khác với các lớp Python thông thường. Không giống như các lớp thông thường, enums

  • Không thể khởi tạo
  • Không thể được phân lớp trừ khi enum cơ sở không có thành viên
  • Cung cấp một đại diện chuỗi có thể đọc được cho con người cho các thành viên của họ
  • Có thể lặp lại không, trả về các thành viên của chúng theo trình tự
  • Cung cấp các thành viên có thể băm có thể được sử dụng làm khóa từ điển
  • Hỗ trợ cú pháp dấu ngoặc vuông, cú pháp gọi và ký hiệu dấu chấm để truy cập các thành viên
  • Không cho phép chỉ định lại thành viên

Bạn nên ghi nhớ tất cả những khác biệt tinh tế này khi bắt đầu tạo và làm việc với các kiểu liệt kê của riêng mình trong Python

Thông thường, các phần tử của một phép liệt kê nhận các giá trị nguyên liên tiếp. Tuy nhiên, trong Python, giá trị của các thành viên có thể thuộc bất kỳ kiểu nào, kể cả kiểu do người dùng định nghĩa. Ví dụ: đây là bảng liệt kê các điểm của trường sử dụng các giá trị số không liên tiếp theo thứ tự giảm dần

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]

Ví dụ này cho thấy Python enums khá linh hoạt và cho phép bạn sử dụng bất kỳ giá trị có ý nghĩa nào cho các thành viên của chúng. Bạn có thể đặt các giá trị thành viên theo mục đích của mã của mình

Bạn cũng có thể sử dụng các giá trị chuỗi cho các thành viên liệt kê của mình. Dưới đây là ví dụ về bảng liệt kê 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 mà bạn có thể sử dụng trong cửa hàng trực tuyến

>>> 

from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)
2

Trong ví dụ này, giá trị được liên kết với mỗi kích thước chứa một mô tả có thể giúp bạn và các nhà phát triển khác hiểu ý nghĩa mã của bạn

Bạn cũng có thể tạo bảng liệt kê các giá trị Boolean. Trong trường hợp này, các thành viên của bảng liệt kê của bạn sẽ chỉ có hai giá trị

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
3

Hai ví dụ này cho thấy cách bạn có thể sử dụng kiểu liệt kê để thêm ngữ cảnh bổ sung vào mã của mình. Trong ví dụ đầu tiên, bất kỳ ai đọc mã của bạn sẽ biết rằng mã này mô phỏng một đối tượng chuyển đổi với hai trạng thái có thể xảy ra. Thông tin bổ sung này cải thiện đáng kể khả năng đọc mã của bạn

Bạn cũng có thể xác định một phép liệt kê với các giá trị không đồng nhất

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
8

Tuy nhiên, thực tế này làm cho mã của bạn không nhất quán từ góc độ an toàn loại. Do đó, nó không được khuyến khích thực hành. Lý tưởng nhất là sẽ hữu ích nếu bạn có các giá trị thuộc cùng một kiểu dữ liệu, điều này phù hợp với ý tưởng nhóm các hằng số tương tự, có liên quan với nhau trong kiểu liệt kê

Cuối cùng, bạn cũng có thể tạo các kiểu liệt kê trống

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
8

Trong ví dụ này, 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
601 đại diện cho một kiểu liệt kê trống vì nó không xác định bất kỳ hằng số thành viên nào. Lưu ý rằng bạn có thể sử dụng câu lệnh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
602, ký tự 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
603 (
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
604) hoặc chuỗi tài liệu cấp lớp để tạo các bảng liệt kê trống. Cách tiếp cận cuối cùng này có thể giúp bạn cải thiện khả năng đọc mã của mình bằng cách cung cấp thêm ngữ cảnh trong chuỗi tài liệu

Bây giờ, tại sao bạn vẫn cần xác định một kiểu liệt kê trống?

Xem xét ví dụ sau

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
60

Trong ví dụ này, bạn tạo 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
605 dưới dạng liệt kê không có phần tử nào. Bạn chỉ có thể phân lớp một bảng liệt kê tùy chỉnh nếu nó không có thành viên, vì vậy 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
605 đủ điều kiện. Lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
607 kế thừa từ kiểu liệt kê trống của bạn, nghĩa là bạn có thể truy cập phương thức 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
608. Phương thức này chuyển đổi giá trị của một phần tử đã cho thành một danh sách

Loại bỏ các quảng cáo

Tạo bảng liệt kê với API chức năng

Lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 cung cấp một API chức năng mà bạn có thể sử dụng để tạo các bảng liệt kê mà không cần sử dụng cú pháp lớp thông thường. Bạn sẽ chỉ cần gọi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 với các đối số phù hợp giống như bạn làm với một hàm hoặc bất kỳ hàm nào khác có thể gọi được

API chức năng này giống với cách hoạt động của chức năng nhà máy 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
611. Trong trường hợp của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2, chữ ký chức năng có dạng sau

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
61

Từ chữ ký này, bạn có thể kết luận rằng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 cần hai đối số vị trí, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
614 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
615. Nó cũng có thể có tối đa bốn đối số tùy chọn và chỉ từ khóa. Các đối số này là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
616, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
617, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
618 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
85

Đây là bảng tóm tắt nội dung và ý nghĩa của từng đối số trong chữ ký của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

Đối sốMô tảBắt buộc

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
614Giữ một chuỗi có tên của lớp liệt kê mớiCó
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
615Cung cấp tên cho các thành viên liệt kêCó
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
616Lấy tên của mô-đun xác định lớp liệt kêNo
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
617Giữ vị trí của mô-đun xác định lớp liệt kêNo
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
618Giữ một lớp sẽ được sử dụng làm lớp trộn đầu tiênNo____485Lấy giá trị bắt đầu từ

Để cung cấp đối số 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
615, bạn có thể sử dụng các đối tượng sau

  • Một chuỗi chứa tên thành viên được phân tách bằng dấu cách hoặc dấu phẩy
  • Một iterable tên thành viên
  • Có thể lặp lại các cặp tên-giá trị

Các đối số 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
616 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
617 đóng một vai trò quan trọng khi bạn cần chọn lọc và giải nén các liệt kê của mình. Nếu 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
616 không được đặt, thì Python sẽ cố gắng tìm mô-đun. Nếu nó không thành công, thì lớp sẽ không thể chọn được. Tương tự, nếu 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
617 không được đặt, thì Python sẽ đặt nó ở phạm vi toàn cầu, điều này có thể khiến các liệt kê của bạn không thể giải nén trong một số trường hợp

Đối số 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
618 là bắt buộc khi bạn muốn cung cấp lớp mixin cho phép liệt kê của mình. Sử dụng lớp mixin có thể cung cấp cho enum tùy chỉnh của bạn chức năng mới, chẳng hạn như khả năng so sánh mở rộng, như bạn sẽ tìm hiểu trong phần về cách trộn kiểu liệt kê với các kiểu dữ liệu khác

Cuối cùng, đối số 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
85 cung cấp một cách để tùy chỉnh giá trị ban đầu của bảng liệt kê của bạn. Đối số này mặc định là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
31 thay vì 
from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)
20. Lý do cho giá trị mặc định này là vì 
from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)
20 sai theo nghĩa Boolean, nhưng các thành viên enum đánh giá là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
637. Do đó, bắt đầu từ 
from enum import Enum
class Status(Enum):
    STATUS_OK = 0
    STATUS_ERR_NULL_POINTER = 1 
    STATUS_ERR_INVALID_PARAMETER = 2
    #giving you access to the name and value:
name = Status(1).name  # gives 'STATUS_ERR_NULL_POINTER'
value = Status.STATUS_ERR_NULL_POINTER.value  # gives 1
or
#You'd have to loop through the class attributes to find the matching name:
name = next(name for name, value in vars(Status).items() if value == 1)
20 sẽ có vẻ ngạc nhiên và khó hiểu

Hầu hết thời gian, bạn sẽ chỉ sử dụng hai đối số đầu tiên cho 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 khi tạo bảng liệt kê của mình. Đây là một ví dụ về việc tạo một bảng liệt kê các phương thức HTTP phổ biến

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
62

Cuộc gọi tới 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 này trả về một bảng liệt kê mới có tên là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
641. Để cung cấp tên thành viên, bạn sử dụng danh sách các chuỗi. Mỗi chuỗi đại diện cho một phương thức HTTP. Lưu ý rằng các giá trị thành viên được tự động đặt thành các số nguyên liên tiếp bắt đầu từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
31. Bạn có thể thay đổi giá trị ban đầu này bằng đối số 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
85

Lưu ý rằng việc xác định các kiểu liệt kê ở trên bằng cú pháp lớp sẽ tạo ra kết quả tương tự

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
63

Ở đây, bạn sử dụng cú pháp lớp để định nghĩa 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
641 enum. Ví dụ này hoàn toàn tương đương với ví dụ trước, vì bạn có thể kết luận từ đầu ra của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
86

Sử dụng cú pháp lớp hoặc API chức năng để tạo bảng liệt kê là quyết định của bạn và chủ yếu sẽ phụ thuộc vào sở thích và điều kiện cụ thể của bạn. Tuy nhiên, nếu bạn muốn tạo bảng liệt kê động, thì API chức năng có thể là lựa chọn duy nhất của bạn

Xem xét ví dụ sau, nơi bạn tạo một enum với các thành viên do người dùng cung cấp

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
64

Ví dụ này hơi cực đoan vì tạo bất kỳ đối tượng nào từ đầu vào của người dùng của bạn là một thực tế khá rủi ro, vì bạn không thể dự đoán những gì người dùng sẽ nhập. Tuy nhiên, ví dụ này nhằm cho thấy rằng API chức năng là cách phù hợp khi bạn cần tạo các bảng liệt kê động

Cuối cùng, nếu bạn cần đặt các giá trị tùy chỉnh cho các thành viên enum của mình, thì bạn có thể sử dụng một cặp giá trị tên có thể lặp lại làm đối số 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
615 của mình. Trong ví dụ bên dưới, bạn sử dụng danh sách các bộ giá trị tên để khởi tạo tất cả các thành viên liệt kê

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
65

Cung cấp một danh sách các bộ giá trị tên như bạn đã làm ở trên để có thể tạo bảng liệt kê 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
647 với các giá trị tùy chỉnh cho các thành viên. Trong ví dụ này, nếu bạn không muốn sử dụng danh sách các bộ giá trị tên, thì bạn cũng có thể sử dụng từ điển ánh xạ tên thành giá trị

Loại bỏ các quảng cáo

Xây dựng bảng liệt kê từ các giá trị tự động

Mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 của Python cung cấp một chức năng tiện lợi có tên là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
649 cho phép bạn đặt các giá trị tự động cho các thành viên enum của mình. Hành vi mặc định của hàm này là gán các giá trị số nguyên liên tiếp cho các thành viên

Đây là cách hoạt động của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
649

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
66

Bạn cần gọi 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
649 một lần cho mỗi giá trị tự động mà bạn cần. Bạn cũng có thể kết hợp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
649 với các giá trị cụ thể, giống như bạn đã làm với 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
653 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
654 trong ví dụ này

Theo mặc định, 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
649 gán các số nguyên liên tiếp cho từng thành viên mục tiêu bắt đầu từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
31. Bạn có thể điều chỉnh hành vi mặc định này bằng cách ghi đè phương thức 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
657 mà 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
649 sử dụng để tạo các giá trị tự động

Đây là một ví dụ về cách làm điều này

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
67

Trong ví dụ này, bạn tạo một bảng liệt kê các hướng chính của Trái đất, trong đó các giá trị được tự động đặt thành chuỗi chứa ký tự đầu tiên trong tên của mỗi thành viên. Lưu ý rằng bạn phải cung cấp phiên bản 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
657 bị ghi đè trước khi xác định bất kỳ thành viên nào. Đó là bởi vì các thành viên sẽ được xây dựng bằng cách gọi phương thức

Tạo bảng liệt kê với bí danh và giá trị duy nhất

Bạn có thể tạo các kiểu liệt kê trong đó hai hoặc nhiều phần tử có cùng giá trị không đổi. Các thành viên dư thừa được gọi là bí danh và có thể hữu ích trong một số trường hợp. Ví dụ: giả sử bạn có một enum chứa một bộ hệ điều hành (HĐH), như trong đoạn mã sau

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
68

Các bản phân phối Linux được coi là hệ điều hành độc lập. Vì vậy, Ubuntu và Debian đều là các hệ thống độc lập với các mục tiêu và đối tượng mục tiêu khác nhau. Tuy nhiên, họ chia sẻ một hạt nhân chung gọi là Linux

Bảng liệt kê trên ánh xạ các hệ điều hành tới các nhân tương ứng của chúng. Mối quan hệ này biến 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
660 thành bí danh của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
661, điều này có thể hữu ích khi bạn có mã liên quan đến nhân cùng với mã dành riêng cho một bản phân phối Linux nhất định

Một phần hành vi quan trọng cần lưu ý trong ví dụ trên là khi bạn lặp lại trực tiếp phép liệt kê, các bí danh không được xem xét. Nếu bạn cần lặp lại tất cả các thành viên, bao gồm cả bí danh, thì bạn cần sử dụng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
662. Bạn sẽ tìm hiểu thêm về phép lặp và thuộc tính 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
662 trong phần về phép lặp qua phép liệt kê

Bạn cũng có tùy chọn cấm hoàn toàn bí danh trong bảng liệt kê của mình. Để làm điều này, bạn có thể sử dụng trình trang trí 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
664 từ mô-đun 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
69

Trong ví dụ này, bạn trang trí 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
666 với 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
664. Nếu bất kỳ giá trị thành viên nào bị trùng lặp, thì bạn sẽ nhận được một 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
668. Ở đây, thông báo ngoại lệ chỉ ra rằng 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
660 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
661 chia sẻ cùng một giá trị, điều này không được phép

Làm việc với bảng liệt kê trong Python

Cho đến thời điểm này, bạn đã biết kiểu liệt kê là gì, khi nào nên sử dụng chúng và bạn nhận được những lợi ích gì khi sử dụng chúng trong mã của mình. Bạn cũng đã tìm hiểu cách tạo kiểu liệt kê trong Python bằng cách sử dụng lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 làm lớp cha hoặc lớp có thể gọi được

Bây giờ là lúc để bạn bắt đầu tìm hiểu cách thức hoạt động của các phép liệt kê trong Python và cách bạn có thể sử dụng chúng trong mã của mình

Loại bỏ các quảng cáo

Truy cập thành viên liệt kê

Khi nói đến việc sử dụng kiểu liệt kê trong mã của bạn, việc truy cập các thành viên của chúng là thao tác cơ bản để thực hiện. Bạn sẽ có ba cách khác nhau để truy cập các thành viên liệt kê trong Python

Ví dụ: giả sử bạn cần truy cập thành viên 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
672 của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
673 enum bên dưới. Trong tình huống này, bạn có thể làm một cái gì đó như thế này

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
20

Dòng được đánh dấu đầu tiên trong ví dụ này cho thấy cách bạn có thể truy cập một thành viên enum bằng cách sử dụng ký hiệu dấu chấm, khá trực quan và dễ đọc. Dòng được đánh dấu thứ hai truy cập thành viên đích bằng cách gọi phép liệt kê với giá trị của thành viên làm đối số

Ghi chú. Điều quan trọng cần lưu ý là việc gọi một phép liệt kê với giá trị của thành viên làm đối số có thể khiến bạn cảm thấy như mình đang khởi tạo phép liệt kê. Tuy nhiên, không thể khởi tạo kiểu liệt kê, như bạn đã biết

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
21

Cố gắng tạo một phiên bản của một bảng liệt kê hiện có không được phép, vì vậy bạn sẽ nhận được một 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
674 nếu bạn cố gắng làm điều đó. Do đó, bạn không được nhầm lẫn giữa việc khởi tạo với việc truy cập các thành viên thông qua lệnh gọi liệt kê

Cuối cùng, dòng được đánh dấu thứ ba cho biết cách bạn có thể sử dụng ký hiệu giống như từ điển hoặc ký hiệu chỉ số dưới để truy cập thành viên bằng cách sử dụng tên của thành viên làm khóa đích

Bảng liệt kê của Python cung cấp sự linh hoạt tuyệt vời để bạn truy cập các thành viên. Ký hiệu dấu chấm được cho là cách tiếp cận được sử dụng phổ biến nhất trong mã Python. Tuy nhiên, hai cách tiếp cận khác cũng có thể hữu ích. Vì vậy, hãy sử dụng ký hiệu đáp ứng nhu cầu, quy ước và phong cách cụ thể của bạn

Sử dụng thuộc tính >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 675 và >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 676

Các thành viên của một bảng liệt kê Python là các thể hiện của lớp chứa chúng. Trong quá trình phân tích cú pháp lớp enum, mỗi thành viên sẽ tự động được cung cấp một thuộc tính 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
675 chứa tên của thành viên dưới dạng một chuỗi. Các thành viên cũng nhận được một thuộc tính 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
676 lưu trữ giá trị được gán cho chính thành viên đó trong định nghĩa lớp

Bạn có thể truy cập 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
675 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
676 như bạn làm với một thuộc tính thông thường, sử dụng ký hiệu dấu chấm. Xem xét ví dụ sau, mô phỏng một semaphore, thường được gọi là đèn giao thông

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
22

Thuộc tính 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
675 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
676 của thành viên enum cho phép bạn truy cập trực tiếp vào tên của thành viên dưới dạng chuỗi và giá trị của thành viên, tương ứng. Các thuộc tính này rất hữu ích khi bạn lặp qua các phép liệt kê của mình, bạn sẽ khám phá các thuộc tính này trong phần tiếp theo

Lặp lại thông qua liệt kê

Một tính năng đáng chú ý của kiểu liệt kê Python so với các lớp thông thường là kiểu liệt kê có thể lặp lại theo mặc định. Vì chúng có thể lặp lại nên bạn có thể sử dụng chúng trong vòng lặp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
683 và với các công cụ khác chấp nhận và xử lý các lần lặp

Phép liệt kê của Python hỗ trợ phép lặp trực tiếp qua các thành viên theo thứ tự định nghĩa

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
23

Trong ví dụ này, bạn sử dụng vòng lặp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
683 để lặp qua các phần tử của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
685. Lưu ý rằng các thành viên được tạo theo cùng thứ tự như chúng được định nghĩa trong định nghĩa lớp

Khi bạn đang lặp lại một phép liệt kê, bạn có thể truy cập các thuộc tính 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
675 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
676 khi bạn thực hiện

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
24

Loại kỹ thuật lặp này trông khá giống với lặp qua từ điển. Vì vậy, nếu bạn đã quen thuộc với phép lặp từ điển, thì việc lặp qua các phép liệt kê bằng kỹ thuật này sẽ là một nhiệm vụ đơn giản với nhiều trường hợp sử dụng tiềm năng

Ngoài ra, các kiểu liệt kê có một thuộc tính đặc biệt được gọi là 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
662 mà bạn cũng có thể sử dụng để lặp lại các phần tử của chúng. Thuộc tính này chứa một từ điển ánh xạ tên cho các thành viên. Sự khác biệt giữa việc lặp qua từ điển này và trực tiếp qua phép liệt kê là từ điển cho phép bạn truy cập vào tất cả các thành viên của phép liệt kê, bao gồm tất cả các bí danh mà bạn có thể có

Dưới đây là một số ví dụ về việc sử dụng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
662 để lặp qua điều tra 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
685 của bạn

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
25

Bạn có thể sử dụng thuộc tính đặc biệt 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
662 để truy cập theo chương trình chi tiết tới các thành viên của bảng liệt kê Python. Vì 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
662 chứa một từ điển thông thường nên bạn có thể sử dụng tất cả các kỹ thuật lặp áp dụng cho loại dữ liệu tích hợp này. Một số kỹ thuật này bao gồm sử dụng các phương pháp từ điển như 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
693, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
694 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
695

Loại bỏ các quảng cáo

Sử dụng phép liệt kê trong câu lệnh >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 696 và >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 697

Các câu lệnh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 bị xiềng xích và câu lệnh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
697 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 tương đối mới là những vị trí phổ biến và được cho là tự nhiên mà bạn có thể sử dụng kiểu liệt kê. Cả hai cấu trúc đều cho phép bạn thực hiện các hành động khác nhau tùy thuộc vào các điều kiện nhất định

Ví dụ: giả sử bạn có một đoạn mã xử lý semaphore hoặc đèn giao thông trong ứng dụng điều khiển giao thông. Bạn phải thực hiện các hành động khác nhau tùy thuộc vào ánh sáng hiện tại của semaphore. Trong tình huống này, bạn có thể sử dụng phép liệt kê để thể hiện đèn hiệu và đèn của nó. Sau đó, bạn có thể sử dụng một chuỗi câu lệnh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 để quyết định hành động sẽ chạy

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
26

Chuỗi câu lệnh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 trong hàm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
206 của bạn kiểm tra giá trị của đèn hiện tại để quyết định hành động cần thực hiện. Lưu ý rằng các cuộc gọi đến 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
207 trong 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
206 chỉ là trình giữ chỗ. Trong mã thực, bạn sẽ thay thế chúng bằng các thao tác phức tạp hơn

Nếu bạn đang sử dụng Python 3. 10 trở lên, thì bạn có thể nhanh chóng biến chuỗi câu lệnh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 ở trên thành một câu lệnh tương đương 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
697 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
27

Việc triển khai mới này của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
206 tương đương với việc triển khai trước đó sử dụng các câu lệnh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699. Sử dụng một trong hai kỹ thuật là một vấn đề của hương vị và phong cách. Cả hai kỹ thuật đều hoạt động tốt và có thể so sánh về khả năng đọc. Tuy nhiên, lưu ý rằng nếu bạn cần đảm bảo khả năng tương thích ngược với các phiên bản Python thấp hơn 3. 10, thì bạn phải sử dụng các câu lệnh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 bị xiềng xích

Cuối cùng, hãy lưu ý rằng mặc dù kiểu liệt kê có vẻ phù hợp với các câu lệnh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
697 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201, nhưng bạn phải nhớ rằng các câu lệnh này không mở rộng tốt. Nếu bạn thêm các thành viên mới vào bảng liệt kê mục tiêu của mình, thì bạn sẽ cần cập nhật chức năng xử lý để xem xét các thành viên mới này

So sánh liệt kê

Có thể sử dụng phép liệt kê trong câu lệnh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
696 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
699 và câu lệnh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
697 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 gợi ý rằng các thành viên bảng liệt kê có thể được so sánh. Theo mặc định, enums hỗ trợ hai loại toán tử so sánh

  1. Danh tính, sử dụng toán tử 
    >>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
    226 và 
    >>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
    227
  2. Đẳng thức, sử dụng toán tử 
    >>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
    228 và 
    >>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
    229

Việc so sánh danh tính dựa trên thực tế là mỗi thành viên enum là một thể hiện đơn lẻ của lớp liệt kê của nó. Đặc điểm này cho phép so sánh danh tính nhanh chóng và rẻ tiền của các thành viên bằng cách sử dụng toán tử 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
226 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
227

Xem xét các ví dụ sau, so sánh các kết hợp khác nhau của các thành viên enum

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
28

Mỗi thành viên enum có danh tính riêng, khác với danh tính của các thành viên anh chị em của nó. Quy tắc này không áp dụng cho các bí danh của thành viên vì chúng chỉ là tham chiếu đến các thành viên hiện có và chia sẻ cùng một danh tính. Đây là lý do tại sao so sánh 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
232 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
233 trả về 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
637 trong ví dụ cuối cùng của bạn

Ghi chú. Để có được danh tính của một đối tượng nhất định trong Python, bạn có thể sử dụng hàm 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
235 tích hợp với đối tượng làm đối số

Kiểm tra danh tính giữa các thành viên của các bảng liệt kê khác nhau luôn trả về 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
236

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
29

Lý do cho kết quả giả này là các thành viên của các enum khác nhau là các thể hiện độc lập với danh tính riêng của chúng, vì vậy bất kỳ kiểm tra danh tính nào đối với chúng đều trả về 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
236

Các toán tử đẳng thức 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
228 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
229 cũng hoạt động giữa các thành viên liệt kê

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
20

Phép liệt kê của Python hỗ trợ cả hai toán tử, 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
228 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
229, bằng cách ủy quyền cho các toán tử 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
226 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
227, tương ứng

Như bạn đã biết, các thành viên enum luôn có một giá trị cụ thể có thể là một số, một chuỗi hoặc bất kỳ đối tượng nào khác. Do đó, việc so sánh bình đẳng giữa các thành viên enum và các đối tượng chung có thể rất hấp dẫn.

Tuy nhiên, kiểu so sánh này không hoạt động như mong đợi vì so sánh thực tế dựa trên nhận dạng đối tượng

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
21

Mặc dù các giá trị thành viên bằng với các số nguyên trong mỗi ví dụ, những so sánh này trả về 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
236. Điều này là do các thành viên enum thông thường so sánh theo danh tính đối tượng thay vì theo giá trị. Trong ví dụ trên, bạn đang so sánh các thành viên enum với số nguyên, giống như so sánh táo và cam. Họ sẽ không bao giờ so sánh ngang nhau, bởi vì họ có bản sắc khác nhau

Ghi chú. Sau đó, bạn sẽ tìm hiểu về 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5, đây là những kiểu liệt kê đặc biệt có thể được so sánh với số nguyên

Cuối cùng, một tính năng liên quan đến so sánh khác của phép liệt kê là bạn có thể thực hiện kiểm tra tư cách thành viên trên chúng bằng cách sử dụng toán tử 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
246 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
247

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
22

Các phép liệt kê của Python hỗ trợ các toán tử 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
246 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
247 theo mặc định. Sử dụng các toán tử này, bạn có thể kiểm tra xem một thành viên nhất định có mặt trong một liệt kê nhất định hay không

Loại bỏ các quảng cáo

Sắp xếp liệt kê

Theo mặc định, enum của Python không hỗ trợ các toán tử so sánh như 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
250, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
251, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
252 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
253. Đó là lý do tại sao bạn không thể sắp xếp trực tiếp các phần tử của một bảng liệt kê bằng cách sử dụng hàm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
254 tích hợp sẵn, như trong ví dụ bên dưới

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
23

Khi bạn sử dụng một kiểu liệt kê làm đối số cho 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
254, bạn sẽ nhận được một ____2674 bởi vì các kiểu liệt kê không hỗ trợ toán tử 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
251. Tuy nhiên, có một cách để sắp xếp thành công các liệt kê theo tên và giá trị của các thành viên của chúng bằng cách sử dụng đối số 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
258 trong lệnh gọi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
254

Đây là cách thực hiện

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
24

Trong ví dụ đầu tiên, bạn sử dụng hàm 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
260 lấy một phần tử liệt kê làm đối số và trả về thuộc tính 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
676 của nó. Với kỹ thuật này, bạn có thể sắp xếp kiểu liệt kê đầu vào theo các giá trị của nó. Trong ví dụ thứ hai, hàm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
260 lấy một phần tử enum và trả về thuộc tính 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
675 của nó. Bằng cách này, bạn có thể sắp xếp liệt kê theo tên của các thành viên của nó

Mở rộng bảng liệt kê với hành vi mới

Trong các phần trước, bạn đã học cách tạo và sử dụng kiểu liệt kê trong mã Python của mình. Cho đến thời điểm này, bạn đã làm việc với kiểu liệt kê mặc định. Điều này có nghĩa là bạn chỉ sử dụng các kiểu liệt kê của Python với các tính năng và hành vi tiêu chuẩn của chúng.

Đôi khi, bạn có thể cần cung cấp bảng liệt kê của mình với hành vi tùy chỉnh. Để làm điều này, bạn có thể thêm các phương thức vào enum của mình và triển khai chức năng cần thiết. Bạn cũng có thể sử dụng các lớp mixin. Trong các phần sau, bạn sẽ tìm hiểu cách tận dụng cả hai kỹ thuật để tùy chỉnh bảng liệt kê của mình

Thêm và tinh chỉnh các phương thức thành viên

Bạn có thể cung cấp cho các phép liệt kê của mình chức năng mới bằng cách thêm các phương thức mới vào các lớp liệt kê của bạn giống như bạn làm với bất kỳ lớp Python thông thường nào. Kiểu liệt kê là các lớp có các tính năng đặc biệt. Giống như các lớp thông thường, kiểu liệt kê có thể có các phương thức và phương thức đặc biệt

Xem xét ví dụ sau, được điều chỉnh từ tài liệu Python

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
25

Trong ví dụ này, bạn có một bảng liệt kê 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
264 với ba phần tử. Các phương thức thông thường như 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
265 bị ràng buộc với các trường hợp chứa enum của chúng, đó là các thành viên enum. Vì vậy, bạn phải gọi các phương thức thông thường trên các thành viên enum hơn là trên chính lớp enum

Ghi chú. Hãy nhớ rằng không thể khởi tạo kiểu liệt kê của Python. Các thành viên của một bảng liệt kê là các trường hợp được phép của bảng liệt kê. Vì vậy, tham số 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
266 đại diện cho thành viên hiện tại

Tương tự, phương pháp đặc biệt 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
267 hoạt động trên các phần tử, cung cấp một biểu diễn có thể in được của mỗi phần tử

Cuối cùng, phương thức 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
268 là một phương thức lớp, hoạt động trên chính lớp hoặc kiểu liệt kê. Các phương thức lớp như thế này cung cấp quyền truy cập vào tất cả các thành viên enum từ bên trong lớp

Bạn cũng có thể tận dụng khả năng này để chứa hành vi bổ sung khi cần triển khai mẫu chiến lược. Ví dụ: giả sử bạn cần một lớp cho phép bạn sử dụng hai chiến lược để sắp xếp danh sách các số theo thứ tự tăng dần và giảm dần. Trong trường hợp này, bạn có thể sử dụng một kiểu liệt kê như sau

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
26

Mỗi thành viên của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
269 đại diện cho một chiến lược sắp xếp. Phương thức 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
270 làm cho các thành viên của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
269 có thể gọi được. Bên trong 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
270, bạn sử dụng hàm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
254 tích hợp sẵn để sắp xếp các giá trị đầu vào theo thứ tự tăng dần hoặc giảm dần, tùy thuộc vào thành viên được gọi

Ghi chú. Ví dụ trên nhằm mục đích là một ví dụ minh họa về việc sử dụng enum để triển khai mẫu thiết kế chiến lược. Trong thực tế, không cần thiết phải tạo 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
269 enum này với mục đích duy nhất là bọc hàm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
254. Thay vào đó, bạn có thể sử dụng trực tiếp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
254 và đối số 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
277 của nó và tránh kỹ thuật quá mức cho giải pháp của bạn

Khi bạn gọi 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
278, các số đầu vào được sắp xếp theo thứ tự tăng dần. Ngược lại, khi bạn gọi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
279, các số sẽ được sắp xếp theo thứ tự giảm dần. Đó là nó. Bạn đã sử dụng một bảng liệt kê để nhanh chóng triển khai mẫu thiết kế chiến lược

Loại bỏ các quảng cáo

Trộn bảng liệt kê với các loại khác

Python hỗ trợ đa kế thừa như một phần của các tính năng hướng đối tượng của nó. Điều này có nghĩa là trong Python, bạn có thể kế thừa nhiều lớp khi tạo phân cấp lớp. Đa kế thừa hữu ích khi bạn muốn sử dụng lại chức năng từ nhiều lớp cùng một lúc

Một thực tế phổ biến trong lập trình hướng đối tượng là sử dụng cái được gọi là lớp mixin. Các lớp này cung cấp chức năng mà các lớp khác có thể sử dụng. Trong Python, bạn có thể thêm các lớp mixin vào danh sách cha của một lớp nhất định để tự động nhận chức năng mixin

Ví dụ: giả sử bạn muốn có một phép liệt kê hỗ trợ so sánh số nguyên. Trong trường hợp này, bạn có thể sử dụng loại 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 tích hợp làm mixin khi xác định enum của mình

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
27

Trong ví dụ này, lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 của bạn kế thừa từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2. Kế thừa từ loại 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 cho phép so sánh trực tiếp giữa các thành viên thông qua các toán tử so sánh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
250, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
251, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
252 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
253. Nó cũng cho phép so sánh giữa các thành viên 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 và số nguyên

Cuối cùng, lưu ý rằng khi bạn sử dụng loại dữ liệu làm mixin, thuộc tính 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
676 của thành viên không giống với chính thành viên đó, mặc dù nó tương đương và sẽ so sánh như vậy. Đó là lý do tại sao bạn có thể so sánh trực tiếp các thành viên của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 với các số nguyên

Ghi chú. Sử dụng các giá trị thành viên enum nguyên là một thực tế khá phổ biến. Đó là lý do tại sao mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 cung cấp một 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5 để tạo trực tiếp các bảng liệt kê có giá trị số nguyên. Bạn sẽ tìm hiểu thêm về lớp này trong phần Khám phá các lớp liệt kê khác

Ví dụ trên cho thấy rằng việc tạo các bảng liệt kê với các lớp mixin thường giúp ích rất nhiều khi bạn cần sử dụng lại một phần chức năng nhất định. Nếu bạn quyết định sử dụng kỹ thuật này trong một số enum của mình, thì bạn sẽ phải tuân theo chữ ký sau

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
28

Chữ ký này ngụ ý rằng bạn có thể có một hoặc nhiều lớp mixin, nhiều nhất là một lớp kiểu dữ liệu và lớp enum cha, theo thứ tự đó

Xem xét các ví dụ sau

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
29

Lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
294 cho thấy rằng trong chuỗi cơ sở, bạn phải đặt bao nhiêu lớp mixin tùy ý—nhưng chỉ một loại dữ liệu—trước 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
296 cho thấy rằng nếu bạn đặt 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 ở bất kỳ vị trí nào khác với vị trí cuối cùng, thì bạn sẽ nhận được một 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
674 với thông tin về chữ ký chính xác để sử dụng. Trong khi đó, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
299 xác nhận rằng danh sách các lớp mixin của bạn phải có nhiều nhất một loại dữ liệu cụ thể, chẳng hạn như 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 hoặc 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201

Hãy nhớ rằng nếu bạn sử dụng một loại dữ liệu cụ thể trong danh sách các lớp mixin của mình, thì các giá trị thành viên phải khớp với loại của loại dữ liệu cụ thể này

Khám phá các lớp liệt kê khác

Ngoài 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2, mô-đun 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 cung cấp một số lớp bổ sung cho phép bạn tạo các bảng liệt kê với các hành vi cụ thể. Bạn sẽ có lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5 để tạo các hằng số liệt kê cũng là các lớp con của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280, ngụ ý rằng tất cả các thành viên sẽ có tất cả các tính năng của một số nguyên

Bạn cũng sẽ tìm thấy các lớp học chuyên biệt hơn, như 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
7. Cả hai lớp sẽ cho phép bạn tạo các tập hợp liệt kê các hằng số mà bạn có thể kết hợp bằng cách sử dụng các toán tử bitwise. Trong phần sau, bạn sẽ khám phá các lớp này và cách chúng hoạt động trong Python

Xây dựng bảng liệt kê số nguyên. >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 5

Việc liệt kê số nguyên phổ biến đến mức mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 xuất một lớp chuyên dụng có tên là 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5 được tạo riêng để bao gồm trường hợp sử dụng này. Nếu bạn cần các thành viên trong bảng liệt kê của mình hoạt động giống như số nguyên, thì bạn nên kế thừa từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5 thay vì từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

Phân lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5 tương đương với việc sử dụng đa kế thừa với 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 làm lớp mixin

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
90

Bây giờ 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 kế thừa trực tiếp từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5 thay vì từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2. Giống như phiên bản trước của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600, phiên bản mới này có đầy đủ khả năng so sánh và hỗ trợ tất cả các toán tử so sánh. Bạn cũng có thể sử dụng trực tiếp các thành viên của lớp trong các phép toán số nguyên

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 sẽ tự động tìm cách chuyển đổi bất kỳ giá trị nào thuộc loại dữ liệu khác thành số nguyên. Nếu chuyển đổi này không thể thực hiện được thì bạn sẽ nhận được một 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
668

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
91

Trong ví dụ đầu tiên, 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
600 tự động chuyển đổi chuỗi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
223 thành một giá trị số nguyên. Trong ví dụ thứ hai, vì chuỗi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
224 không chứa giá trị số hợp lệ, bạn nhận được một 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
668 và quá trình chuyển đổi không thành công

Trong phiên bản Python ổn định hiện tại, 3. 10, mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 không bao gồm lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
227. Tuy nhiên, lớp này là một ví dụ khác về trường hợp sử dụng phổ biến của kiểu liệt kê. Vì lý do này, Python 3. 11 sẽ bao gồm một loại 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
227 với sự hỗ trợ trực tiếp cho các hoạt động chuỗi phổ biến. Trong thời gian chờ đợi, bạn có thể mô phỏng hành vi của lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
227 bằng cách tạo một lớp mixin với 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2 làm lớp cha

Loại bỏ các quảng cáo

Tạo cờ số nguyên. >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 6 và >>> from enum import Enum >>> class Grade(Enum): .. A = 90 .. B = 80 .. C = 70 .. D = 60 .. F = 0 ... >>> list(Grade) [ <Grade.A: 90>, <Grade.B: 80>, <Grade.C: 70>, <Grade.D: 60>, <Grade.F: 0> ] 7

Bạn có thể sử dụng 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 làm lớp cơ sở cho các phép liệt kê sẽ hỗ trợ các toán tử theo bit. Thực hiện các thao tác bitwise trên các thành viên của phân lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 sẽ trả về một đối tượng cũng là thành viên của enum bên dưới

Dưới đây là ví dụ về phép liệt kê 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
236 cho phép bạn quản lý các vai trò người dùng khác nhau trong một đối tượng kết hợp duy nhất

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
92

Trong đoạn mã này, bạn tạo một bảng liệt kê chứa một tập hợp vai trò người dùng trong một ứng dụng nhất định. Các thành viên của bảng liệt kê này chứa các giá trị số nguyên mà bạn có thể kết hợp bằng cách sử dụng toán tử OR theo bit (

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
237). Ví dụ: người dùng có tên John có cả vai trò 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
238 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
239. Lưu ý rằng đối tượng được lưu trữ trong 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
240 là thành viên của bảng liệt kê 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
236 của bạn

Ghi chú. Bạn nên nhớ rằng các thành viên riêng lẻ của enums dựa trên 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6, còn được gọi là cờ, nên nhận các giá trị là lũy thừa của hai (1, 2, 4, 8, …). Tuy nhiên, đây không phải là yêu cầu đối với các tổ hợp cờ, chẳng hạn như 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
243

Trong ví dụ trên, bạn đã xác định 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
243 là sự kết hợp của các vai trò. Giá trị của nó là kết quả của việc áp dụng toán tử OR theo bit cho danh sách đầy đủ các vai trò trước đó trong phép liệt kê

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 cũng hỗ trợ các phép toán số nguyên, chẳng hạn như các phép toán số học và so sánh. Tuy nhiên, các loại hoạt động này trả về số nguyên chứ không phải đối tượng thành viên

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
93

Các thành viên của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 cũng là các lớp con của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280. Đó là lý do tại sao bạn có thể sử dụng chúng trong các biểu thức liên quan đến số nguyên. Trong những tình huống này, giá trị kết quả sẽ là một số nguyên chứ không phải là thành viên enum

Cuối cùng, bạn cũng sẽ tìm thấy lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
7 có sẵn trong 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1. Lớp này hoạt động tương tự như 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 và có một số hạn chế bổ sung

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
94

Sự khác biệt chính giữa 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
7 là cái sau không kế thừa từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280. Do đó, hoạt động số nguyên không được hỗ trợ. Khi bạn cố gắng sử dụng một phần tử của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
236 trong một phép tính số nguyên, bạn sẽ nhận được một số 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
674

Cũng giống như các thành viên của 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 enums, các thành viên của 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
7 enums phải có các giá trị là lũy thừa của hai. Một lần nữa, điều này không áp dụng cho các tổ hợp cờ, như 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
243 trong ví dụ trên

Sử dụng bảng liệt kê. Hai ví dụ thực tế

Phép liệt kê của Python có thể giúp bạn cải thiện khả năng đọc và tổ chức mã của mình. Bạn có thể sử dụng chúng để nhóm các hằng số tương tự mà sau đó bạn có thể sử dụng trong mã của mình để thay thế các chuỗi, số và các giá trị khác bằng các tên có ý nghĩa và dễ đọc

Trong các phần sau, bạn sẽ viết mã một vài ví dụ thực tế xử lý các trường hợp sử dụng enum phổ biến. Những ví dụ này sẽ giúp bạn quyết định khi nào mã của bạn có thể hưởng lợi từ việc sử dụng kiểu liệt kê

Thay thế số ma thuật

Phép liệt kê rất hữu ích khi bạn cần thay thế các bộ số ma thuật có liên quan, chẳng hạn như mã trạng thái HTTP, cổng máy tính và mã thoát. Với kiểu liệt kê, bạn có thể nhóm các hằng số này và gán cho chúng các tên dễ đọc và mô tả mà bạn có thể sử dụng và tái sử dụng trong mã của mình sau này

Giả sử bạn có chức năng sau như một phần của ứng dụng truy xuất và xử lý nội dung HTTP trực tiếp từ web

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
95

Hàm 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
259 của bạn lấy một đối tượng HTTP 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
260 làm đối số. Sau đó, nó lấy mã trạng thái từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
260 bằng phương pháp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
262. Câu lệnh 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
697 … 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 tuần tự so sánh mã trạng thái hiện tại với một số mã trạng thái tiêu chuẩn được cung cấp dưới dạng số ma thuật trong ví dụ của bạn

Nếu khớp xảy ra, thì khối mã trong 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 khớp sẽ chạy. Nếu không có sự trùng khớp nào xảy ra, thì mặc định 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 sẽ chạy. Lưu ý rằng giá trị mặc định 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
201 là giá trị sử dụng dấu gạch dưới (
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
268) làm tiêu chí đối sánh

Phần còn lại của mã kết nối với một trang web mẫu, thực hiện yêu cầu 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
269, truy xuất đối tượng phản hồi và xử lý nó bằng hàm 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
259 của bạn. Mệnh đề 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
271 đóng kết nối đang hoạt động để tránh rò rỉ tài nguyên

Mặc dù mã này hoạt động, nhưng có thể khó đọc và hiểu đối với những người không quen với mã trạng thái HTTP và ý nghĩa tương ứng của chúng. Để khắc phục những vấn đề này và làm cho mã của bạn dễ đọc và dễ bảo trì hơn, bạn có thể sử dụng một phép liệt kê để nhóm các mã trạng thái HTTP và đặt tên mô tả cho chúng

>>> 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
96

Mã này thêm một bảng liệt kê mới có tên là 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
647 vào ứng dụng của bạn. Nhóm enum này mã trạng thái HTTP mục tiêu và đặt cho chúng những cái tên dễ đọc. Nó cũng làm cho chúng không đổi một cách nghiêm ngặt, giúp ứng dụng của bạn đáng tin cậy hơn

Bên trong 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
259, bạn sử dụng các tên mô tả và dễ đọc để cung cấp thông tin về ngữ cảnh và nội dung. Giờ đây, bất kỳ ai đọc mã của bạn sẽ biết ngay rằng tiêu chí đối sánh là mã trạng thái HTTP. Họ cũng sẽ nhanh chóng phát hiện ra ý nghĩa của từng mã mục tiêu

Loại bỏ các quảng cáo

Tạo một máy trạng thái

Một trường hợp sử dụng thú vị khác của phép liệt kê là khi bạn sử dụng chúng để tạo lại các trạng thái khác nhau có thể có của một hệ thống nhất định. Nếu hệ thống của bạn có thể ở chính xác một trong số các trạng thái hữu hạn tại bất kỳ thời điểm nào, thì hệ thống của bạn hoạt động như một cỗ máy trạng thái. Bảng liệt kê rất hữu ích khi bạn cần triển khai mẫu thiết kế phổ biến này

Như một ví dụ về cách sử dụng enum để triển khai mẫu máy trạng thái, bạn tạo trình giả lập trình phát đĩa tối thiểu. Để bắt đầu, hãy tiếp tục và tạo một tệp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
274 với nội dung sau

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
97

Tại đây, bạn định nghĩa lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
275. Lớp này nhóm tất cả các trạng thái có thể có của đầu đĩa của bạn. 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
276, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
277, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
278 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
279. Bây giờ bạn có thể mã hóa lớp người chơi 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280, trông giống như thế này

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
98

Lớp 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 thực hiện tất cả các hành động có thể mà trình phát của bạn có thể thực hiện, bao gồm đưa và đẩy đĩa ra, phát, tạm dừng và dừng trình phát. Lưu ý cách mỗi phương thức trong 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 kiểm tra và cập nhật trạng thái hiện tại của trình phát bằng cách tận dụng phép liệt kê 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
275 của bạn

Để hoàn thành ví dụ của mình, bạn sẽ sử dụng thành ngữ 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
284 truyền thống để kết thúc một vài dòng mã cho phép bạn dùng thử lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
99

Trong đoạn mã này, trước tiên bạn định nghĩa một biến 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
286, biến này chứa chuỗi các phương thức mà bạn sẽ gọi từ 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
280 để dùng thử lớp. Sau đó, bạn tạo một thể hiện của lớp trình phát đĩa của mình. Cuối cùng, bạn bắt đầu một vòng lặp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
683 để lặp lại danh sách các hành động và chạy mọi hành động thông qua phiên bản 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
289

Đó là nó. Trình giả lập trình phát đĩa của bạn đã sẵn sàng để thử nghiệm. Để chạy nó, hãy tiếp tục và thực hiện lệnh sau tại dòng lệnh của bạn

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
0

Đầu ra của lệnh này cho thấy rằng ứng dụng của bạn đã trải qua tất cả các trạng thái có thể. Tất nhiên, ví dụ này là tối thiểu và không xem xét tất cả các tình huống có thể xảy ra. Đó là một ví dụ minh họa về cách bạn có thể sử dụng phép liệt kê để triển khai mẫu máy trạng thái trong mã của mình

Sự kết luận

Bây giờ bạn đã biết cách tạo và sử dụng kiểu liệt kê trong Python. Enumerations, hay chỉ enums, là kiểu dữ liệu thông dụng và phổ biến trong nhiều ngôn ngữ lập trình. Với phép liệt kê, bạn có thể nhóm các tập hợp các hằng số liên quan và truy cập chúng thông qua chính phép liệt kê

Python không cung cấp cú pháp enum chuyên dụng. Tuy nhiên, mô-đun 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 hỗ trợ kiểu dữ liệu chung này thông qua lớp 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
2

Trong hướng dẫn này, bạn đã học cách

  • Tạo bảng liệt kê của riêng bạn bằng cách sử dụng lớp 
    >>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
    2 của Python
  • Làm việc với các bảng liệt kê và các thành viên của chúng
  • Cung cấp các lớp liệt kê của bạn với các chức năng mới
  • Sử dụng phép liệt kê với một số ví dụ thực tế

Bạn cũng đã học về các kiểu liệt kê hữu ích khác, chẳng hạn như 

>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
5, 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
6 và 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
7. Chúng có sẵn trong 
>>> from enum import Enum

>>> class Grade(Enum):
..     A = 90
..     B = 80
..     C = 70
..     D = 60
..     F = 0
...

>>> list(Grade)
[
    <Grade.A: 90>,
    <Grade.B: 80>,
    <Grade.C: 70>,
    <Grade.D: 60>,
    <Grade.F: 0>
]
1 và sẽ giúp bạn tạo các enum chuyên dụng

Với tất cả kiến ​​thức này, giờ bạn đã sẵn sàng bắt đầu sử dụng enum của Python để nhóm, đặt tên và xử lý các tập hợp các hằng số liên quan đến ngữ nghĩa. Phép liệt kê cho phép bạn tổ chức mã của mình tốt hơn, làm cho mã dễ đọc, rõ ràng và dễ bảo trì hơn

Mã nguồn. Nhấp vào đây để tải xuống mã nguồn miễn phí mà bạn sẽ sử dụng để xây dựng bảng liệt kê trong Python

Đánh dấu là đã hoàn thành

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Lấy giá trị enum trong python

Gửi cho tôi thủ thuật Python »

Giới thiệu về Leodanis Pozo Ramos

Lấy giá trị enum trong python
Lấy giá trị enum trong python

Leodanis là một kỹ sư công nghiệp yêu thích Python và phát triển phần mềm. Anh ấy là một nhà phát triển Python tự học với hơn 6 năm kinh nghiệm. Anh ấy là một nhà văn đam mê kỹ thuật với số lượng bài báo được xuất bản ngày càng tăng trên Real Python và các trang web khác

» Tìm hiểu thêm về Leodanis

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Lấy giá trị enum trong python

Aldren

Lấy giá trị enum trong python

Bartosz

Lấy giá trị enum trong python

Geir Arne

Lấy giá trị enum trong python

kate

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Lấy giá trị enum trong python

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng các chuyên gia Pythonistas

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Chúng ta có thể lấy một enum theo giá trị không?

Lấy giá trị của Enum . Trong ví dụ đầu tiên, kiểu mặc định là int nên chúng ta phải gõ kiểu int. Ngoài ra, chúng ta có thể lấy giá trị chuỗi của enum đó bằng cách sử dụng phương thức ToString() như bên dưới. To get the value of enum we can simply typecast it to its type. In the first example, the default type is int so we have to typecast it to int. Also, we can get the string value of that enum by using the ToString() method as below.

Giá trị enum có thể là danh sách Python không?

Chúng tôi có thể in enum dưới dạng danh sách có thể lặp lại .

What is enum value?

Kiểu liệt kê (hoặc kiểu enum) là một loại giá trị được xác định bởi một tập hợp các hằng số được đặt tên thuộc loại số tích phân cơ sở . Để xác định kiểu liệt kê, hãy sử dụng từ khóa enum và chỉ định tên của các thành viên enum. Sao chép C#.

programming python

Bài Viết Liên Quan

Chương trình php tuân theo quy trình nào để thực thi để hiển thị đầu ra trên trình duyệt?
Chương trình php tuân theo quy trình nào để thực thi để hiển thị đầu ra trên trình duyệt?

Ngày thi đấu ERAS 2023
Ngày thi đấu ERAS 2023

Sao chép tổng từ thanh trạng thái excel
Sao chép tổng từ thanh trạng thái excel

Tôi nên sử dụng trình định dạng Python nào?
Tôi nên sử dụng trình định dạng Python nào?

Làm thế nào để bạn tìm thấy sự khác biệt giữa số nhỏ nhất và số lớn nhất trong python?
Làm thế nào để bạn tìm thấy sự khác biệt giữa số nhỏ nhất và số lớn nhất trong python?

Làm thế nào để bạn làm máy tính nâng cao trong python?
Làm thế nào để bạn làm máy tính nâng cao trong python?

New Moon Aries 2023
New Moon Aries 2023

Bạn có thể chỉnh sửa ngày đăng WordPress không?
Bạn có thể chỉnh sửa ngày đăng WordPress không?

Power Automate HTML thành văn bản không hoạt động
Power Automate HTML thành văn bản không hoạt động

Bản đồ python lambda giải pháp hackerrank
Bản đồ python lambda giải pháp hackerrank

MỚI CẬP NHẬP

Giải bài 52 sgk toán 8 tập 1 trang 96 năm 2024
14 phúts trước . bởi AboriginalRepublic
Nội dung về câu truyện một gia đình văn hóa năm 2024
40 phúts trước . bởi ExpressedLine-up
First name và last name khác nhau như thế nào năm 2024
54 phúts trước . bởi UsableDegeneration
Holding the flag on the top of the mountain năm 2024
1 giờs trước . bởi GorgeousMotto
Muốn sinh con trai thì phải làm thế nào năm 2024
1 giờs trước . bởi CeaselessHello
Caác bai toán lơp 5 bai 20 25nhân000 1 năm 2024
2 giờs trước . bởi AccursedAuspices
Hóa trị cao nhất với oxi và hiđro năm 2024
2 giờs trước . bởi ImpudentDeliverance
Đồ văn phòng thanh lý tại hà nội năm 2024
2 giờs trước . bởi CavernousOunce
Bồi dưỡng thường xuyên môn hóa học thcs năm 2024
4 giờs trước . bởi MirroredNucleus
235 võ văn kiệt phường khánh xuân tp bmt năm 2024
4 giờs trước . bởi ConcernedGenesis

Xem Nhiều

Hóa ra anh vẫn ở đây truyện tóm tắt năm 2024
6 ngàys trước . bởi Long-lostFeedback
Bài thu hoạch về học tập chuyên đề năm 2023 năm 2024
3 ngàys trước . bởi ElectricalRobber
Bài thuyết trình về tập đoàn xăng dầu việt nam năm 2024
3 ngàys trước . bởi RowdyViolation
Lỗi cập phép đã bị thủ hồi pubg mobile năm 2024
2 ngàys trước . bởi UnderlyingCheesecake
Lỗi không xem được video trên windows media player năm 2024
1 ngàys trước . bởi ObliqueEpilepsy
Top trung tâm anh ngữ giá rẻ tphcm năm 2024
5 ngàys trước . bởi SexyPotassium
Trung bình mỗi lần quan hệ tốn bao nhiêu calo năm 2024
5 ngàys trước . bởi ProdigiousTights
Đạo đức kinh doanh và văn hóa công ty năm 2024
1 ngàys trước . bởi LinkedPhrasing
Treo gương bát quái lồi như thế nào năm 2024
1 tuầns trước . bởi AnguishedTuesday
Bài tập số ít số nhiều của động từ năm 2024
1 ngàys trước . bởi ProletarianTwenties

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Bản quyền © 2024 Inc.