Hướng dẫn convert data class to dict python - chuyển đổi lớp dữ liệu thành dict python

Nội dung mô -đun

Hàm này là một nhà trang trí được sử dụng để thêm các phương pháp đặc biệt được tạo vào các lớp, như được mô tả dưới đây.decorator that is used to add generated special methods to classes, as described below.

Người trang trí

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Thứ tự của các trường trong tất cả các phương thức được tạo là thứ tự chúng xuất hiện trong định nghĩa lớp.

Nhà trang trí

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Nếu

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

@dataclass
class C:
    ...

@dataclass[]
class C:
    ...

@dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
class C:
   ...

Các tham số đến

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

• def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand
  

  5: Nếu đúng [mặc định], phương thức

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 sẽ được tạo.

  Nếu lớp đã xác định

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3, tham số này sẽ bị bỏ qua.

• def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand
  

  8: Nếu đúng [mặc định], phương thức

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  4 sẽ được tạo. Chuỗi repr được tạo sẽ có tên lớp và tên và repr của mỗi trường, theo thứ tự chúng được xác định trong lớp. Các trường được đánh dấu là bị loại trừ khỏi repr không được bao gồm. Ví dụ:

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  0.

  Nếu lớp đã xác định

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  4, tham số này sẽ bị bỏ qua.

• @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2: Nếu đúng [mặc định], phương thức

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  3 sẽ được tạo. Phương pháp này so sánh lớp như thể nó là một bộ của các trường của nó, theo thứ tự. Cả hai trường hợp trong so sánh phải thuộc loại giống hệt nhau.

  Nếu lớp đã xác định

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  3, tham số này sẽ bị bỏ qua.

• @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  5: Nếu đúng [mặc định là

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  6],

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  7,

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  8,

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  9 và

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  0 sẽ được tạo ra. Chúng so sánh lớp như thể nó là một bộ phận của các trường của nó, theo thứ tự. Cả hai trường hợp trong so sánh phải thuộc loại giống hệt nhau. Nếu

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  5 là đúng và

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2 là sai, thì

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  3 sẽ được nâng lên.

  Nếu lớp đã xác định bất kỳ

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  7,

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  8,

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  9 hoặc

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  0, thì

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  8 sẽ được nâng lên.

• @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  9: Nếu

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  6 [mặc định], phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 được tạo theo cách

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2 và

  def __init__[self, a: int, b: int = 0]:
  

  3 được đặt.

  def __init__[self, a: int, b: int = 0]:
  

  1 được sử dụng bởi

  def __init__[self, a: int, b: int = 0]:
  

  5 tích hợp và khi các đối tượng được thêm vào các bộ sưu tập băm như từ điển và bộ. Có một

  def __init__[self, a: int, b: int = 0]:
  

  1 ngụ ý rằng các trường hợp của lớp là bất biến. Khả năng đột biến là một tài sản phức tạp phụ thuộc vào ý định của lập trình viên, sự tồn tại và hành vi của

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  3 và các giá trị của các cờ

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2 và

  def __init__[self, a: int, b: int = 0]:
  

  3 trong bộ trang trí

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  7.

  Theo mặc định,

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  7 sẽ không ngầm thêm phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 trừ khi an toàn để làm như vậy. Nó sẽ không thêm hoặc thay đổi một phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 được xác định rõ ràng hiện có. Đặt thuộc tính lớp

  @dataclass
  class C:
      mylist: list[int] = field[default_factory=list]
  
  c = C[]
  c.mylist += [1, 2, 3]
  

  4 có một ý nghĩa cụ thể đối với Python, như được mô tả trong tài liệu

  def __init__[self, a: int, b: int = 0]:
  

  1.

  Nếu

  def __init__[self, a: int, b: int = 0]:
  

  1 không được xác định rõ ràng hoặc nếu nó được đặt thành

  @dataclass
  class C:
      mylist: list[int] = field[default_factory=list]
  
  c = C[]
  c.mylist += [1, 2, 3]
  

  7, thì

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  7 có thể thêm một phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 ngầm. Mặc dù không được khuyến nghị, bạn có thể buộc

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  7 để tạo phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 với

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  02. Đây có thể là trường hợp nếu lớp của bạn là bất biến về mặt logic nhưng dù sao cũng có thể bị đột biến. Đây là một trường hợp sử dụng chuyên ngành và nên được xem xét cẩn thận.

  Dưới đây là các quy tắc quản lý việc tạo ra một phương pháp

  def __init__[self, a: int, b: int = 0]:
  

  1. Lưu ý rằng cả hai bạn không thể có một phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 rõ ràng trong DataClass của bạn và đặt

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  02; Điều này sẽ dẫn đến

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  8.

  Nếu

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2 và

  def __init__[self, a: int, b: int = 0]:
  

  3 đều đúng, theo mặc định,

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  7 sẽ tạo phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 cho bạn. Nếu

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2 là đúng và

  def __init__[self, a: int, b: int = 0]:
  

  3 là sai,

  def __init__[self, a: int, b: int = 0]:
  

  1 sẽ được đặt thành

  @dataclass
  class C:
      mylist: list[int] = field[default_factory=list]
  
  c = C[]
  c.mylist += [1, 2, 3]
  

  7, đánh dấu nó không thể vượt qua [đó là, vì nó là có thể thay đổi]. Nếu

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  2 là sai,

  def __init__[self, a: int, b: int = 0]:
  

  1 sẽ không bị ảnh hưởng có nghĩa là phương pháp

  def __init__[self, a: int, b: int = 0]:
  

  1 của siêu lớp sẽ được sử dụng [nếu siêu lớp là

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  18, điều này có nghĩa là nó sẽ quay trở lại băm dựa trên ID].

• def __init__[self, a: int, b: int = 0]:
  

  3: Nếu đúng [mặc định là

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  6], việc gán cho các trường sẽ tạo ra một ngoại lệ. Điều này mô phỏng các trường hợp đông lạnh chỉ đọc. Nếu

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  21 hoặc

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  22 được xác định trong lớp, thì

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  8 sẽ được nâng lên. Xem các cuộc thảo luận dưới đây.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  24: Nếu đúng [mặc định là

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  25], tple

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  26 sẽ được tạo từ danh sách các tham số đến phương thức

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 được tạo [ngay cả khi

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 không được tạo, xem ở trên]. Nếu sai, hoặc nếu

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  26 đã được xác định trong lớp, thì

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  26 sẽ không được tạo.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  31: Nếu đúng [giá trị mặc định là

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  6], thì tất cả các trường sẽ được đánh dấu là chỉ từ khóa. Nếu một trường được đánh dấu là chỉ từ khóa, thì hiệu ứng duy nhất là tham số

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 được tạo từ trường chỉ từ khóa phải được chỉ định với từ khóa khi

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 được gọi. Không có ảnh hưởng đến bất kỳ khía cạnh nào khác của DataClasses. Xem mục nhập bảng chú số để biết chi tiết. Cũng xem phần

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  35.parameter glossary entry for details. Also see the

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  35 section.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  36: Nếu đúng [mặc định là

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  6], thuộc tính

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  38 sẽ được tạo và lớp mới sẽ được trả về thay vì bản gốc. Nếu

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  38 đã được xác định trong lớp, thì

  @dataclass
  class C:
      a: int       # 'a' has no default value
      b: int = 0   # assign a default value for 'b'
  

  8 sẽ được nâng lên.

Mới trong phiên bản 3.10.

Đã thay đổi trong phiên bản 3.11: Nếu một tên trường đã được bao gồm trong

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 của một lớp cơ sở, thì nó sẽ không được đưa vào

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 được tạo để ngăn chặn chúng. Do đó, không sử dụng

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 để truy xuất tên trường của DataClass. Sử dụng

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

44 thay thế. Để có thể xác định các vị trí di truyền, lớp cơ sở

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 có thể là bất kỳ điều gì có thể lặp lại, nhưng không phải là một trình lặp.If a field name is already included in the

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 of a base class, it will not be included in the generated

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 to prevent overriding them. Therefore, do not use

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 to retrieve the field names of a dataclass. Use

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

44 instead. To be able to determine inherited slots, base class

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

38 may be any iterable, but not an iterator.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  46: Nếu đúng [mặc định là

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  6], hãy thêm một khe có tên là __weakref__, được yêu cầu để tạo một trường hợp yếu. Đó là một lỗi để chỉ định

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  48 mà không chỉ định

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  49.

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

Trong ví dụ này, cả

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

def __init__[self, a: int, b: int = 0]:

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

Đối với các trường hợp sử dụng thông thường và đơn giản, không có chức năng nào khác là bắt buộc. Tuy nhiên, có một số tính năng DataClass yêu cầu thêm thông tin trên mỗi trường. Để đáp ứng nhu cầu này để biết thêm thông tin, bạn có thể thay thế giá trị trường mặc định bằng một cuộc gọi đến hàm

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

@dataclass
class C:
    mylist: list[int] = field[default_factory=list]

c = C[]
c.mylist += [1, 2, 3]

Như được hiển thị ở trên, giá trị

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

@dataclass
class C:
    mylist: list[int] = field[default_factory=list]

c = C[]
c.mylist += [1, 2, 3]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Các tham số đến

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  60: Nếu được cung cấp, đây sẽ là giá trị mặc định cho trường này. Điều này là cần thiết vì

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  55 tự gọi thay thế vị trí bình thường của giá trị mặc định.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  62: Nếu được cung cấp, nó phải là một cuộc gọi không có thể gọi được sẽ được gọi khi cần giá trị mặc định cho trường này. Trong số các mục đích khác, điều này có thể được sử dụng để chỉ định các trường có các giá trị mặc định có thể thay đổi, như được thảo luận dưới đây. Đó là một lỗi để chỉ định cả

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  60 và

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  62.

• def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand
  

  5: Nếu đúng [mặc định], trường này được bao gồm dưới dạng tham số cho phương thức

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 được tạo.

• def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand
  

  8: Nếu đúng [mặc định], trường này được bao gồm trong chuỗi được trả về bởi phương thức

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  4 được tạo.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  69: Đây có thể là bool hoặc

  @dataclass
  class C:
      mylist: list[int] = field[default_factory=list]
  
  c = C[]
  c.mylist += [1, 2, 3]
  

  7. Nếu đúng, trường này được bao gồm trong phương thức

  def __init__[self, a: int, b: int = 0]:
  

  1 được tạo. Nếu

  @dataclass
  class C:
      mylist: list[int] = field[default_factory=list]
  
  c = C[]
  c.mylist += [1, 2, 3]
  

  7 [mặc định], hãy sử dụng giá trị của

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  73: Đây thường là hành vi mong đợi. Một lĩnh vực nên được xem xét trong băm nếu nó được sử dụng để so sánh. Đặt giá trị này thành bất cứ điều gì khác ngoài

  @dataclass
  class C:
      mylist: list[int] = field[default_factory=list]
  
  c = C[]
  c.mylist += [1, 2, 3]
  

  7 không được khuyến khích.

  Một lý do có thể để đặt

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  75 Nhưng

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  76 sẽ là nếu một trường tốn kém để tính giá trị băm cho, trường đó là cần thiết để kiểm tra bình đẳng và có các trường khác đóng góp vào giá trị băm kiểu loại. Ngay cả khi một trường được loại trừ khỏi băm, nó vẫn sẽ được sử dụng để so sánh.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  73: Nếu đúng [mặc định], trường này được bao gồm trong các phương thức công bằng và so sánh được tạo [

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  3,

  @dataclass
  class C:
      ...
  
  @dataclass[]
  class C:
      ...
  
  @dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
  class C:
     ...
  

  9, et al.].

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  80: Đây có thể là một ánh xạ hoặc không có. Không ai được coi là một dict trống rỗng. Giá trị này được bọc trong

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  81 để làm cho nó chỉ đọc và tiếp xúc trên đối tượng

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  82. Nó hoàn toàn không được sử dụng bởi các lớp dữ liệu và được cung cấp như một cơ chế mở rộng của bên thứ ba. Nhiều bên thứ ba có thể có chìa khóa riêng, để sử dụng làm không gian tên trong siêu dữ liệu.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  31: Nếu đúng, trường này sẽ được đánh dấu là chỉ từ khóa. Điều này được sử dụng khi các tham số phương thức

  from dataclasses import dataclass
  
  @dataclass
  class InventoryItem:
      """Class for keeping track of an item in inventory."""
      name: str
      unit_price: float
      quantity_on_hand: int = 0
  
      def total_cost[self] -> float:
          return self.unit_price * self.quantity_on_hand
  

  3 được tạo được tính toán.

Nếu giá trị mặc định của trường được chỉ định bởi một cuộc gọi đến

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Thuộc tính lớp

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  98: Tên của trường.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  99: Loại trường.

• def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  60,

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  62,

  def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand
  

  5,

  def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
      self.name = name
      self.unit_price = unit_price
      self.quantity_on_hand = quantity_on_hand
  

  8,

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  69,

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  73,

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  80 và

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  31 có ý nghĩa và giá trị giống hệt như chúng trong hàm

  def dict[self]:
      body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                         else f'self.{f}'] for f in self.__slots__]
      # Compute the text of the entire function.
      txt = f'def dict[self]:\n return {{{body_lines}}}'
      ns = {}
      exec[txt, locals[], ns]
      _dict_fn = self.__class__.dict = ns['dict']
      return _dict_fn[self]
  

  55.

Các thuộc tính khác có thể tồn tại, nhưng chúng là riêng tư và không được kiểm tra hoặc dựa vào.

Trả về một tuple của các đối tượng

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Chuyển đổi DataClass

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Ví dụ về việc sử dụng

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Để tạo một bản sao nông, cách giải quyết sau đây có thể được sử dụng:

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Chuyển đổi DataClass

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Tiếp tục từ ví dụ trước:

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Để tạo một bản sao nông, cách giải quyết sau đây có thể được sử dụng:

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Chuyển đổi DataClass

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Tiếp tục từ ví dụ trước:

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Tạo một dữ liệu mới với tên

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
    self.name = name
    self.unit_price = unit_price
    self.quantity_on_hand = quantity_on_hand

def __init__[self, name: str, unit_price: float, quantity_on_hand: int = 0]:
    self.name = name
    self.unit_price = unit_price
    self.quantity_on_hand = quantity_on_hand

@dataclass
class C:
    ...

@dataclass[]
class C:
    ...

@dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
class C:
   ...

@dataclass
class C:
    ...

@dataclass[]
class C:
    ...

@dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
class C:
   ...

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

def __init__[self, a: int, b: int = 0]:

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Chức năng này không được yêu cầu nghiêm ngặt, bởi vì bất kỳ cơ chế Python nào để tạo một lớp mới với

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Tương đương với:

DataClasses.Replace [obj, /, ** thay đổi] ¶

Tạo một đối tượng mới cùng loại với

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Các biến chỉ dành cho ban đầu không có giá trị mặc định, nếu có, phải được chỉ định trong cuộc gọi đến

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Đó là một lỗi cho

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

dataclasses.is_dataclass [obj] ¶

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

@dataclass
class C:
    ...

@dataclass[]
class C:
    ...

@dataclass[init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False]
class C:
   ...

Nếu bạn cần biết liệu một lớp có phải là một thể hiện của một dữ liệu [và không phải là chính dữ liệu], thì hãy thêm kiểm tra thêm cho

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Trong ví dụ này, các trường

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Trong một DataClass duy nhất, đó là một lỗi để chỉ định nhiều hơn một trường có loại là

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Mới trong phiên bản 3.10.

Lớn lên khi một

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Xử lý sau khi khởi động

Mã

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Trong số các mục đích sử dụng khác, điều này cho phép khởi tạo các giá trị trường phụ thuộc vào một hoặc nhiều trường khác. Ví dụ:

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Phương pháp

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Tuy nhiên, lưu ý rằng nói chung, các phương thức

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Xem phần bên dưới trên các biến chỉ dành cho init để biết các cách để chuyển các tham số sang

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Biến lớp

Một trong hai nơi

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

Biến chỉ khởi động

Nơi khác mà

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Ví dụ: giả sử một trường sẽ được khởi tạo từ cơ sở dữ liệu, nếu một giá trị không được cung cấp khi tạo lớp:

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Trong trường hợp này,

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Các trường hợp đóng băng

Không thể tạo ra các đối tượng Python thực sự bất biến. Tuy nhiên, bằng cách chuyển

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Có một hình phạt hiệu suất nhỏ khi sử dụng

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Di sản¶

Khi DataClass được tạo bởi trình trang trí

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Danh sách cuối cùng của các trường là, theo thứ tự,

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Phương thức

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Đặt hàng lại các tham số chỉ từ khóa trong ________ 43¶

Sau khi các tham số cần thiết cho

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Trong ví dụ này,

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Phương thức

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Lưu ý rằng các tham số đã được đặt hàng lại từ cách chúng xuất hiện trong danh sách các trường: các tham số có nguồn gốc từ các trường thông thường được theo sau bởi các tham số có nguồn gốc từ các trường chỉ từ khóa.

Thứ tự tương đối của các tham số chỉ từ khóa được duy trì trong danh sách tham số

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Các chức năng nhà máy mặc định

Nếu

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Nếu một trường được loại trừ khỏi

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

def dict[self]:
    body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                       else f'self.{f}'] for f in self.__slots__]
    # Compute the text of the entire function.
    txt = f'def dict[self]:\n return {{{body_lines}}}'
    ns = {}
    exec[txt, locals[], ns]
    _dict_fn = self.__class__.dict = ns['dict']
    return _dict_fn[self]

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

Giá trị mặc định có thể thay đổi

Python lưu trữ các giá trị biến thành viên mặc định trong các thuộc tính lớp. Hãy xem xét ví dụ này, không sử dụng DataClasses:

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Lưu ý rằng hai trường hợp của lớp

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Sử dụng DataClasses, nếu mã này hợp lệ:

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Nó sẽ tạo mã tương tự như:

from dataclasses import dataclass, asdict, field
from uuid import UUID, uuid4


class DictMixin:
    """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""

    def dict[self]:
        body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                           else f'self.{f}'] for f in self.__slots__]
        # Compute the text of the entire function.
        txt = f'def dict[self]:\n return {{{body_lines}}}'
        ns = {}
        exec[txt, locals[], ns]
        _dict_fn = self.__class__.dict = ns['dict']
        return _dict_fn[self]


@dataclass
class MessageHeader:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict1[self]:
        _dict = self.__dict__.copy[]
        _dict['message_id'] = str[_dict['message_id']]
        return _dict

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in self.__dict__.items[]}

    def dict3[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


@dataclass[slots=True]
class MessageHeaderWithSlots[DictMixin]:
    message_id: UUID = field[default_factory=uuid4]
    string: str = 'a string'
    integer: int = 1000
    floating: float = 1.0

    def dict2[self]:
        return {k: str[v] if k == 'message_id' else v
                for k, v in asdict[self].items[]}


if __name__ == '__main__':
    from timeit import timeit

    header = MessageHeader[]
    header_with_slots = MessageHeaderWithSlots[]

    n = 10000
    print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
    print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
    print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]

    print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
    print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]

    print[]

    dict__ = header.dict1[]
    print[dict__]

    asdict__ = header.dict3[]
    print[asdict__]

    assert isinstance[dict__['message_id'], str]
    assert isinstance[dict__['integer'], int]

    assert header.dict1[] == header.dict2[] == header.dict3[]
    assert header_with_slots.dict[] == header_with_slots.dict2[]

Điều này có vấn đề tương tự như ví dụ ban đầu sử dụng lớp

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost[self] -> float:
        return self.unit_price * self.quantity_on_hand

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

Sử dụng các hàm nhà máy mặc định là một cách để tạo các phiên bản mới của các loại có thể thay đổi làm giá trị mặc định cho các trường:

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Đã thay đổi trong phiên bản 3.11: Thay vì tìm kiếm và loại bỏ các đối tượng thuộc loại

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Các lĩnh vực mô tả kiểu

Các trường được gán các đối tượng mô tả vì giá trị mặc định của chúng có các hành vi đặc biệt sau:descriptor objects as their default value have the following special behaviors:

• Giá trị cho trường được chuyển đến phương thức DataClass từ

  dict1[]:   0.005992999998852611
  dict2[]:   0.00800508284009993
  dict3[]:   0.07069579092785716
  slots -> dict[]:   0.00583599996753037
  slots -> dict2[]:  0.07395245810039341
  
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  

  63 được chuyển cho phương thức mô tả ____ ____364 thay vì ghi đè lên đối tượng mô tả.

• Tương tự, khi nhận hoặc đặt trường, phương thức mô tả

  dict1[]:   0.005992999998852611
  dict2[]:   0.00800508284009993
  dict3[]:   0.07069579092785716
  slots -> dict[]:   0.00583599996753037
  slots -> dict2[]:  0.07395245810039341
  
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  

  65 hoặc

  dict1[]:   0.005992999998852611
  dict2[]:   0.00800508284009993
  dict3[]:   0.07069579092785716
  slots -> dict[]:   0.00583599996753037
  slots -> dict2[]:  0.07395245810039341
  
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  

  64 được gọi là thay vì trả về hoặc ghi đè đối tượng mô tả.

• Để xác định xem một trường có chứa giá trị mặc định hay không,

  dict1[]:   0.005992999998852611
  dict2[]:   0.00800508284009993
  dict3[]:   0.07069579092785716
  slots -> dict[]:   0.00583599996753037
  slots -> dict2[]:  0.07395245810039341
  
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  

  67 sẽ gọi phương thức

  dict1[]:   0.005992999998852611
  dict2[]:   0.00800508284009993
  dict3[]:   0.07069579092785716
  slots -> dict[]:   0.00583599996753037
  slots -> dict2[]:  0.07395245810039341
  
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  

  65 của bộ mô tả bằng mẫu truy cập lớp của nó [nghĩa là

  dict1[]:   0.005992999998852611
  dict2[]:   0.00800508284009993
  dict3[]:   0.07069579092785716
  slots -> dict[]:   0.00583599996753037
  slots -> dict2[]:  0.07395245810039341
  
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  {'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
  

  69. Nếu mô tả trả về giá trị trong trường hợp này, nó sẽ được sử dụng làm mặc định của trường. Nếu mô tả tăng

  from dataclasses import dataclass, asdict, field
  from uuid import UUID, uuid4
  
  
  class DictMixin:
      """Mixin class to add a `dict[]` method on classes that define a __slots__ attribute"""
  
      def dict[self]:
          body_lines = ','.join[f"'{f}':" + [f'str[self.{f}]' if f == 'message_id'
                                             else f'self.{f}'] for f in self.__slots__]
          # Compute the text of the entire function.
          txt = f'def dict[self]:\n return {{{body_lines}}}'
          ns = {}
          exec[txt, locals[], ns]
          _dict_fn = self.__class__.dict = ns['dict']
          return _dict_fn[self]
  
  
  @dataclass
  class MessageHeader:
      message_id: UUID = field[default_factory=uuid4]
      string: str = 'a string'
      integer: int = 1000
      floating: float = 1.0
  
      def dict1[self]:
          _dict = self.__dict__.copy[]
          _dict['message_id'] = str[_dict['message_id']]
          return _dict
  
      def dict2[self]:
          return {k: str[v] if k == 'message_id' else v
                  for k, v in self.__dict__.items[]}
  
      def dict3[self]:
          return {k: str[v] if k == 'message_id' else v
                  for k, v in asdict[self].items[]}
  
  
  @dataclass[slots=True]
  class MessageHeaderWithSlots[DictMixin]:
      message_id: UUID = field[default_factory=uuid4]
      string: str = 'a string'
      integer: int = 1000
      floating: float = 1.0
  
      def dict2[self]:
          return {k: str[v] if k == 'message_id' else v
                  for k, v in asdict[self].items[]}
  
  
  if __name__ == '__main__':
      from timeit import timeit
  
      header = MessageHeader[]
      header_with_slots = MessageHeaderWithSlots[]
  
      n = 10000
      print['dict1[]:  ', timeit['header.dict1[]', number=n, globals=globals[]]]
      print['dict2[]:  ', timeit['header.dict2[]', number=n, globals=globals[]]]
      print['dict3[]:  ', timeit['header.dict3[]', number=n, globals=globals[]]]
  
      print['slots -> dict[]:  ', timeit['header_with_slots.dict[]', number=n, globals=globals[]]]
      print['slots -> dict2[]: ', timeit['header_with_slots.dict2[]', number=n, globals=globals[]]]
  
      print[]
  
      dict__ = header.dict1[]
      print[dict__]
  
      asdict__ = header.dict3[]
      print[asdict__]
  
      assert isinstance[dict__['message_id'], str]
      assert isinstance[dict__['integer'], int]
  
      assert header.dict1[] == header.dict2[] == header.dict3[]
      assert header_with_slots.dict[] == header_with_slots.dict2[]
  

  84 trong tình huống này, sẽ không có giá trị mặc định nào được cung cấp cho trường.

dict1[]:   0.005992999998852611
dict2[]:   0.00800508284009993
dict3[]:   0.07069579092785716
slots -> dict[]:   0.00583599996753037
slots -> dict2[]:  0.07395245810039341

{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}
{'message_id': 'b4e17ef9-1a58-4007-9cef-39158b094da2', 'string': 'a string', 'integer': 1000, 'floating': 1.0}

Lưu ý rằng nếu một trường được chú thích bằng loại mô tả, nhưng không được gán một đối tượng mô tả là giá trị mặc định của nó, trường sẽ hoạt động như một trường bình thường.