Dấu phẩy python bằng

Đọc qua bài luận Giải mọi câu đố Sudoku của Peter Norvig, tôi đã gặp một vài thành ngữ Python mà tôi chưa từng thấy trước đây

Tôi biết rằng một hàm có thể trả về một bộ/danh sách các giá trị, trong trường hợp đó, bạn có thể gán nhiều biến cho kết quả, chẳng hạn như

def f[]:
    return 1,2

a, b = f[]

Nhưng ý nghĩa của mỗi điều sau đây là gì?

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1

Nếu

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
35, thì câu lệnh này khác với
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
36 như thế nào?

Một câu hỏi khác về việc sử dụng dấu gạch dưới trong bài tập tại đây

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]

Dấu gạch dưới có tác dụng loại bỏ về cơ bản giá trị đầu tiên được trả về trong danh sách không?

Các đối tượng là sự trừu tượng hóa dữ liệu của Python. Tất cả dữ liệu trong chương trình Python được biểu diễn bằng đối tượng hoặc bằng quan hệ giữa các đối tượng. [Theo một nghĩa nào đó, và phù hợp với mô hình “máy tính chương trình được lưu trữ” của Von Neumann, mã cũng được biểu diễn bằng các đối tượng. ]

Mỗi đối tượng có một danh tính, một loại và một giá trị. Danh tính của một đối tượng không bao giờ thay đổi khi nó đã được tạo; . Toán tử '______37' so sánh danh tính của hai đối tượng;

Chi tiết triển khai CPython. Đối với CPython,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
9 là địa chỉ bộ nhớ lưu trữ
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
0

Loại đối tượng xác định các hoạt động mà đối tượng hỗ trợ [e. g. , "nó có độ dài không?"] và cũng xác định các giá trị có thể có cho các đối tượng thuộc loại đó. Hàm

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
1 trả về kiểu của một đối tượng [chính nó là một đối tượng]. Giống như danh tính của nó, loại đối tượng cũng không thể thay đổi. 1

Giá trị của một số đối tượng có thể thay đổi. Các đối tượng có giá trị có thể thay đổi được gọi là có thể thay đổi; . [Giá trị của một đối tượng vùng chứa bất biến có chứa tham chiếu đến một đối tượng có thể thay đổi có thể thay đổi khi giá trị của đối tượng sau này bị thay đổi; tuy nhiên, vùng chứa vẫn được coi là không thay đổi, bởi vì tập hợp các đối tượng mà nó chứa không thể thay đổi được. Vì vậy, tính bất biến không hoàn toàn giống với việc có một giá trị không thể thay đổi, nó tinh tế hơn. ] Khả năng thay đổi của một đối tượng được xác định bởi loại của nó;

Các đối tượng không bao giờ bị phá hủy một cách rõ ràng; . Việc triển khai được phép hoãn việc thu gom rác hoặc bỏ qua hoàn toàn — đó là vấn đề về chất lượng triển khai, cách thức triển khai việc thu gom rác, miễn là không có đối tượng nào được thu thập mà vẫn có thể truy cập được

Chi tiết triển khai CPython. CPython hiện đang sử dụng sơ đồ đếm tham chiếu với [tùy chọn] phát hiện chậm rác được liên kết theo chu kỳ, thu thập hầu hết các đối tượng ngay khi chúng không thể truy cập được, nhưng không được đảm bảo để thu thập rác chứa tham chiếu vòng tròn. Xem tài liệu của mô-đun

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
2 để biết thông tin về cách kiểm soát việc thu gom rác tuần hoàn. Các triển khai khác hoạt động khác và CPython có thể thay đổi. Không phụ thuộc vào việc hoàn thiện ngay lập tức các đối tượng khi chúng không thể truy cập được [vì vậy bạn phải luôn đóng tệp một cách rõ ràng]

Lưu ý rằng việc sử dụng các phương tiện theo dõi hoặc gỡ lỗi của triển khai có thể giữ cho các đối tượng tồn tại mà thông thường có thể thu thập được. Cũng lưu ý rằng việc bắt một ngoại lệ bằng câu lệnh '_______63...

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
4' có thể giữ cho các đối tượng tồn tại

Một số đối tượng chứa các tham chiếu đến tài nguyên “bên ngoài” chẳng hạn như tệp hoặc cửa sổ đang mở. Điều này được hiểu rằng các tài nguyên này được giải phóng khi đối tượng được thu gom rác, nhưng vì việc thu gom rác không được đảm bảo xảy ra, nên các đối tượng đó cũng cung cấp một cách rõ ràng để giải phóng tài nguyên bên ngoài, thường là phương thức

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
5. Các chương trình được khuyến khích mạnh mẽ để đóng các đối tượng như vậy một cách rõ ràng. Câu lệnh '_______63...
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
7' và câu lệnh '
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
8' cung cấp các cách thuận tiện để thực hiện việc này

Một số đối tượng chứa tham chiếu đến các đối tượng khác; . Ví dụ về vùng chứa là bộ dữ liệu, danh sách và từ điển. Các tham chiếu là một phần giá trị của vùng chứa. Trong hầu hết các trường hợp, khi chúng ta nói về giá trị của một vùng chứa, chúng ta ngụ ý các giá trị, không phải danh tính của các đối tượng được chứa; . So, if an immutable container [like a tuple] contains a reference to a mutable object, its value changes if that mutable object is changed

Types affect almost all aspects of object behavior. Ngay cả tầm quan trọng của danh tính đối tượng cũng bị ảnh hưởng theo một nghĩa nào đó. đối với các loại bất biến, các hoạt động tính toán các giá trị mới thực sự có thể trả về một tham chiếu đến bất kỳ đối tượng hiện có nào có cùng loại và giá trị, trong khi đối với các đối tượng có thể thay đổi thì điều này không được phép. e. g. , sau

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
9,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
60 và
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
61 có thể hoặc không tham chiếu đến cùng một đối tượng với giá trị một, tùy thuộc vào cách triển khai, nhưng sau
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
62,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
63 và
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
64 được đảm bảo tham chiếu đến hai danh sách trống khác nhau, duy nhất, mới được tạo. [Lưu ý rằng
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
65 gán cùng một đối tượng cho cả
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
63 và
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
64. ]

3. 2. Hệ thống phân cấp loại tiêu chuẩn¶

Dưới đây là danh sách các loại được tích hợp sẵn trong Python. Các mô-đun mở rộng [được viết bằng C, Java hoặc các ngôn ngữ khác, tùy thuộc vào việc triển khai] có thể xác định các loại bổ sung. Các phiên bản tương lai của Python có thể thêm các loại vào hệ thống phân cấp loại [e. g. , số hữu tỷ, mảng số nguyên được lưu trữ hiệu quả, v.v. ], mặc dù những phần bổ sung như vậy thường sẽ được cung cấp thông qua thư viện chuẩn để thay thế

Một số mô tả loại bên dưới chứa đoạn liệt kê 'thuộc tính đặc biệt. ' Đây là những thuộc tính cung cấp quyền truy cập vào việc triển khai và không dành cho mục đích sử dụng chung. Định nghĩa của họ có thể thay đổi trong tương lai

Không có

Loại này có một giá trị duy nhất. Có một đối tượng duy nhất với giá trị này. Đối tượng này được truy cập thông qua tên dựng sẵn

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68. Nó được sử dụng để biểu thị sự vắng mặt của một giá trị trong nhiều tình huống, e. g. , nó được trả về từ các hàm không trả về bất cứ thứ gì một cách rõ ràng. Giá trị thật của nó là sai

Không được thực hiện

Loại này có một giá trị duy nhất. Có một đối tượng duy nhất với giá trị này. Đối tượng này được truy cập thông qua tên dựng sẵn

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69. Các phương thức số và các phương thức so sánh phong phú sẽ trả về giá trị này nếu chúng không thực hiện thao tác cho các toán hạng được cung cấp. [Trình thông dịch sau đó sẽ thử thao tác được phản ánh hoặc một số hoạt động dự phòng khác, tùy thuộc vào người vận hành. ] Nó không nên được đánh giá trong ngữ cảnh boolean

Xem Thực hiện các phép toán số học để biết thêm chi tiết.

Đã thay đổi trong phiên bản 3. 9. Đánh giá

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69 trong ngữ cảnh boolean không được dùng nữa. Mặc dù nó hiện được đánh giá là đúng, nhưng nó sẽ phát ra một
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
71. Nó sẽ tăng
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 trong phiên bản tương lai của Python.

dấu chấm lửng

Loại này có một giá trị duy nhất. Có một đối tượng duy nhất với giá trị này. Đối tượng này được truy cập thông qua

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
73 theo nghĩa đen hoặc tên tích hợp sẵn
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
74. Giá trị thật của nó là true

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
75

Chúng được tạo bởi các chữ số và được trả về dưới dạng kết quả bởi các toán tử số học và các hàm tích hợp số học. Các đối tượng số là bất biến; . Tất nhiên, các số trong Python có liên quan chặt chẽ với các số toán học, nhưng chịu các hạn chế của biểu diễn số trong máy tính

Biểu diễn chuỗi của các lớp số, được tính bởi

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
76 và
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
77, có các thuộc tính sau

  • Chúng là các chữ số hợp lệ, khi được chuyển đến hàm tạo của lớp chúng, sẽ tạo ra một đối tượng có giá trị của số ban đầu

  • Biểu diễn ở cơ sở 10, khi có thể

  • Các số 0 ở đầu, có thể ngoại trừ một số 0 trước dấu thập phân, không được hiển thị

  • Các số 0 ở cuối, có thể ngoại trừ một số 0 sau dấu thập phân, không được hiển thị

  • Một dấu hiệu chỉ được hiển thị khi số âm

Python distinguishes between integers, floating point numbers, and complex numbers

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
78

Chúng đại diện cho các phần tử từ tập hợp các số nguyên [dương và âm]

Có hai loại số nguyên

Số nguyên [
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
79]

Chúng đại diện cho các số trong một phạm vi không giới hạn, chỉ tùy thuộc vào bộ nhớ [ảo] có sẵn. Với mục đích của các phép toán dịch chuyển và mặt nạ, một biểu diễn nhị phân được giả định và các số âm được biểu diễn dưới dạng một biến thể của phần bù 2, điều này tạo ảo giác về một chuỗi vô hạn các bit dấu kéo dài sang trái

Booleans [
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
60]

Chúng đại diện cho các giá trị thật Sai và Đúng. Hai đối tượng đại diện cho các giá trị

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
61 và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
62 là các đối tượng Boolean duy nhất. Kiểu Boolean là một kiểu con của kiểu số nguyên và các giá trị Boolean hoạt động giống như các giá trị 0 và 1 tương ứng trong hầu hết các ngữ cảnh, ngoại trừ khi được chuyển đổi thành một chuỗi, các chuỗi
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
63 hoặc
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
64 được trả về tương ứng

Các quy tắc biểu diễn số nguyên nhằm mục đích đưa ra cách giải thích có ý nghĩa nhất về phép dịch chuyển và mặt nạ liên quan đến số nguyên âm

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
65 [
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
66]

Chúng đại diện cho các số dấu phẩy động chính xác kép ở cấp độ máy. Bạn phụ thuộc vào kiến ​​trúc máy bên dưới [và triển khai C hoặc Java] cho phạm vi được chấp nhận và xử lý tràn. Python không hỗ trợ các số dấu phẩy động có độ chính xác đơn;

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
67 [
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
68]

Chúng biểu thị các số phức dưới dạng một cặp số dấu phẩy động chính xác kép ở cấp độ máy. Các cảnh báo tương tự áp dụng cho các số dấu phẩy động. Phần thực và phần ảo của một số phức

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
69 có thể được truy xuất thông qua các thuộc tính chỉ đọc
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
60 và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
61

trình tự

These represent finite ordered sets indexed by non-negative numbers. Hàm tích hợp

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
62 trả về số lượng phần tử của một chuỗi. Khi độ dài của một dãy là n, bộ chỉ số chứa các số 0, 1, …, n-1. Mục i của dãy a được chọn bởi
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
63

Trình tự cũng hỗ trợ cắt.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
64 selects all items with index k such that i
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
65 k
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
66 j. Khi được sử dụng như một biểu thức, một lát cắt là một chuỗi cùng loại. Điều này ngụ ý rằng bộ chỉ mục được đánh số lại để nó bắt đầu từ 0

Một số trình tự cũng hỗ trợ “cắt lát mở rộng” với tham số “bước” thứ ba.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
67 chọn tất cả các mục của a có chỉ số x trong đó
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
68, n
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
69
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
60 và i
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
65 x
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
66 j

Các trình tự được phân biệt theo khả năng biến đổi của chúng

Trình tự bất biến

Một đối tượng thuộc loại chuỗi bất biến không thể thay đổi sau khi được tạo. [Nếu đối tượng chứa các tham chiếu đến các đối tượng khác, các đối tượng khác này có thể thay đổi và có thể thay đổi; tuy nhiên, tập hợp các đối tượng được tham chiếu trực tiếp bởi một đối tượng không thể thay đổi không thể thay đổi. ]

Các loại sau đây là trình tự bất biến

Dây

Chuỗi là một chuỗi các giá trị đại diện cho các điểm mã Unicode. All the code points in the range

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
63 can be represented in a string. Python không có loại char ; . Hàm tích hợp sẵn
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
65 chuyển đổi một điểm mã từ dạng chuỗi của nó thành một số nguyên trong phạm vi
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
66; .
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
60 can be used to convert a
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
61 to
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
62 using the given text encoding, and
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
63 can be used to achieve the opposite.

bộ dữ liệu

Các mục của một tuple là các đối tượng Python tùy ý. Các bộ gồm hai mục trở lên được tạo bởi các danh sách biểu thức được phân tách bằng dấu phẩy. Một bộ của một mục [một 'singleton'] có thể được tạo bằng cách thêm dấu phẩy vào một biểu thức [bản thân một biểu thức không tạo ra một bộ, vì dấu ngoặc đơn phải được sử dụng để nhóm các biểu thức]. Một bộ trống có thể được tạo bởi một cặp dấu ngoặc đơn rỗng

byte

Một đối tượng bytes là một mảng bất biến. Các mục là các byte 8 bit, được biểu thị bằng các số nguyên trong phạm vi 0 1] 72]

Setting a special method to

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68 indicates that the corresponding operation is not available. Ví dụ: nếu một lớp đặt
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
621 thành
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68, thì lớp đó không thể lặp lại, do đó, việc gọi
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
623 trên các phiên bản của nó sẽ tăng
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 [không quay lại
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606]. 2

When implementing a class that emulates any built-in type, it is important that the emulation only be implemented to the degree that it makes sense for the object being modelled. Ví dụ: một số trình tự có thể hoạt động tốt với việc truy xuất các phần tử riêng lẻ, nhưng việc trích xuất một lát cắt có thể không có ý nghĩa. [Một ví dụ về điều này là giao diện

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
626 trong Mô hình Đối tượng Tài liệu của W3C. ]

3. 3. 1. Basic customization¶

object. __new__[cls[ , . ]]

Được gọi để tạo một thể hiện mới của lớp cls.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 là một phương thức tĩnh [có trường hợp đặc biệt nên bạn không cần khai báo nó như vậy] lấy lớp mà một thể hiện được yêu cầu làm đối số đầu tiên của nó. Các đối số còn lại là những đối số được truyền cho biểu thức hàm tạo đối tượng [lệnh gọi đến lớp]. Giá trị trả về của
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 phải là phiên bản đối tượng mới [thường là phiên bản của cls]

Typical implementations create a new instance of the class by invoking the superclass’s

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 method using
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
630 with appropriate arguments and then modifying the newly created instance as necessary before returning it

If

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 is invoked during object construction and it returns an instance of cls, then the new instance’s
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84 method will be invoked like
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
633, where self is the new instance and the remaining arguments are the same as were passed to the object constructor

If

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 does not return an instance of cls, then the new instance’s
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84 method will not be invoked

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 is intended mainly to allow subclasses of immutable types [like int, str, or tuple] to customize instance creation. It is also commonly overridden in custom metaclasses in order to customize class creation

object. __init__[self[ , . ]]

Được gọi sau khi phiên bản đã được tạo [bởi

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82], nhưng trước khi nó được trả lại cho người gọi. The arguments are those passed to the class constructor expression. Nếu một lớp cơ sở có một phương thức
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84, thì phương thức
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84 của lớp dẫn xuất, nếu có, phải gọi nó một cách rõ ràng để đảm bảo khởi tạo đúng phần lớp cơ sở của thể hiện; .
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
640

Bởi vì

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84 làm việc cùng nhau trong việc xây dựng các đối tượng [
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
82 để tạo nó và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84 để tùy chỉnh nó], không có giá trị nào không phải
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68 có thể được trả về bởi
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
84;

đối tượng. __del__[bản thân]

Được gọi khi instance sắp bị hủy. Đây còn được gọi là bộ hoàn thiện hoặc [không chính xác] là bộ hủy. Nếu một lớp cơ sở có một phương thức

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
648, thì phương thức
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
648 của lớp dẫn xuất, nếu có, phải gọi nó một cách rõ ràng để đảm bảo việc xóa đúng phần lớp cơ sở của thể hiện

It is possible [though not recommended. ] cho phương pháp

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
648 để trì hoãn việc hủy đối tượng bằng cách tạo một tham chiếu mới cho nó. Đây được gọi là hồi sinh đối tượng. Nó phụ thuộc vào việc triển khai liệu
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
648 có được gọi lần thứ hai khi một đối tượng được hồi sinh sắp bị hủy hay không; .
CPython implementation only calls it once.

Không đảm bảo rằng các phương thức

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
648 được gọi cho các đối tượng vẫn tồn tại khi trình thông dịch thoát

Ghi chú

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
653 không gọi trực tiếp
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
654 - cái trước giảm số tham chiếu cho
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
0 xuống một và cái sau chỉ được gọi khi số tham chiếu của
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
0 bằng 0

Chi tiết triển khai CPython. Có thể cho một chu kỳ tham chiếu để ngăn số lượng tham chiếu của một đối tượng về 0. Trong trường hợp này, chu kỳ sẽ được phát hiện và xóa sau đó bởi bộ thu gom rác theo chu kỳ . Một nguyên nhân phổ biến của các chu kỳ tham chiếu là khi một ngoại lệ bị bắt trong một biến cục bộ. Sau đó, các cục bộ của khung tham chiếu ngoại lệ, ngoại lệ này tham chiếu truy nguyên của chính nó, ngoại lệ này tham chiếu các cục bộ của tất cả các khung được bắt trong truy nguyên.

Xem thêm

Tài liệu cho mô-đun

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
2

Cảnh báo

Do các trường hợp bấp bênh trong đó các phương thức

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
648 được gọi, các ngoại lệ xảy ra trong quá trình thực thi chúng sẽ bị bỏ qua và thay vào đó, một cảnh báo sẽ được in tới
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
29. Đặc biệt

  • d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
    
    648 có thể được gọi khi mã tùy ý đang được thực thi, kể cả từ bất kỳ luồng tùy ý nào. Nếu
    d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
    
    648 cần khóa hoặc gọi bất kỳ tài nguyên chặn nào khác, nó có thể bị bế tắc vì tài nguyên có thể đã bị mã lấy bị gián đoạn để thực thi
    d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
    
    648

  • d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
    
    648 có thể được thực thi trong khi tắt trình thông dịch. Do đó, các biến toàn cục mà nó cần truy cập [bao gồm cả các mô-đun khác] có thể đã bị xóa hoặc được đặt thành
    d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
    
    68. Python đảm bảo rằng các hình cầu có tên bắt đầu bằng một dấu gạch dưới sẽ bị xóa khỏi mô-đun của chúng trước khi các hình cầu khác bị xóa;

đối tượng. __repr__[bản thân]

Được gọi bởi hàm tích hợp

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
666 để tính toán biểu diễn chuỗi "chính thức" của một đối tượng. Nếu có thể, đây sẽ giống như một biểu thức Python hợp lệ có thể được sử dụng để tạo lại một đối tượng có cùng giá trị [với môi trường thích hợp]. Nếu điều này là không thể, một chuỗi có dạng
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
667 sẽ được trả về. Giá trị trả về phải là một đối tượng chuỗi. Nếu một lớp định nghĩa
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
76 nhưng không phải là
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
77, thì
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
76 cũng được sử dụng khi biểu diễn chuỗi "không chính thức" của các thể hiện của lớp đó được yêu cầu

Điều này thường được sử dụng để gỡ lỗi, vì vậy điều quan trọng là biểu diễn phải giàu thông tin và rõ ràng

đối tượng. __str__[bản thân]

Được gọi bởi

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
671 và các hàm tích hợp sẵn
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
672 và
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
673 để tính toán biểu diễn chuỗi "không chính thức" hoặc có thể in được của một đối tượng. Giá trị trả về phải là một đối tượng chuỗi .

Phương thức này khác với

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
674 ở chỗ không có kỳ vọng rằng
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
77 sẽ trả về một biểu thức Python hợp lệ. một đại diện thuận tiện hơn hoặc ngắn gọn có thể được sử dụng

Việc triển khai mặc định được xác định bởi loại tích hợp

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
676 gọi
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
674

đối tượng. __bytes__[bản thân]

Được gọi bởi byte để tính toán biểu diễn chuỗi byte của một đối tượng. Điều này sẽ trả về một đối tượng

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
62.

đối tượng. __format__[bản thân , format_spec]

Được gọi bởi hàm tích hợp sẵn

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
672 và bằng cách mở rộng, đánh giá các chuỗi ký tự được định dạng và phương thức
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
680, để tạo ra “ . The format_spec argument is a string that contains a description of the formatting options desired. Việc giải thích đối số format_spec tùy thuộc vào loại triển khai
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
681, tuy nhiên, hầu hết các lớp sẽ ủy quyền định dạng cho một trong các loại tích hợp sẵn hoặc sử dụng cú pháp tùy chọn định dạng tương tự.

Xem Ngôn ngữ nhỏ đặc tả định dạng để biết mô tả về cú pháp định dạng chuẩn.

Giá trị trả về phải là một đối tượng chuỗi

Đã thay đổi trong phiên bản 3. 4. Phương thức __format__ của

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
676 tự tạo ra một
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 nếu truyền bất kỳ chuỗi không trống nào.

Đã thay đổi trong phiên bản 3. 7. ______1684 hiện tương đương với

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
685 thay vì
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
686.

đối tượng. __lt__[bản thân , khác . ]object.__le__[bản thân , khác . ]object.__eq__[bản thân , khác . ]object.__ne__[bản thân , khác . ]object.__gt__[bản thân , khác . ]object.__ge__[bản thân , khác]

These are the so-called “rich comparison” methods. Sự tương ứng giữa các ký hiệu toán tử và tên phương thức như sau.

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
687 calls
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
688,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
689 calls
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
690,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
691 calls
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
692,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
693 calls
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
694,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
695 calls
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
696, and
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
697 calls
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
698

Một phương thức so sánh phong phú có thể trả về đơn lẻ

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69 nếu nó không thực hiện thao tác cho một cặp đối số đã cho. Theo quy ước,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
61 và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
62 được trả về để so sánh thành công. Tuy nhiên, các phương thức này có thể trả về bất kỳ giá trị nào, vì vậy nếu toán tử so sánh được sử dụng trong ngữ cảnh Boolean [e. g. , trong điều kiện của câu lệnh
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
702], Python sẽ gọi
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
703 trên giá trị để xác định xem kết quả là đúng hay sai

By default,

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
676 implements
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 by using
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
7, returning
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69 in the case of a false comparison.
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
708. Đối với
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
709, theo mặc định, nó ủy quyền cho
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 và đảo ngược kết quả trừ khi nó là
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69. Không có mối quan hệ ngụ ý nào khác giữa các toán tử so sánh hoặc triển khai mặc định; . Để tự động tạo các hoạt động đặt hàng từ một hoạt động gốc, hãy xem
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
714

Xem đoạn trên

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 để biết một số lưu ý quan trọng về cách tạo các đối tượng có thể băm hỗ trợ các thao tác so sánh tùy chỉnh và có thể sử dụng làm khóa từ điển.

Không có phiên bản đối số hoán đổi của các phương thức này [được sử dụng khi đối số bên trái không hỗ trợ thao tác nhưng đối số bên phải thì hỗ trợ]; . Nếu các toán hạng có kiểu khác nhau và kiểu của toán hạng bên phải là lớp con trực tiếp hoặc gián tiếp của kiểu toán hạng bên trái, thì phương thức được phản ánh của toán hạng bên phải sẽ được ưu tiên, nếu không thì phương thức của toán hạng bên trái sẽ được ưu tiên. Phân lớp ảo không được xem xét

đối tượng. __hash__[bản thân]

Được gọi bởi hàm tích hợp

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
722 và cho các hoạt động trên các thành viên của bộ sưu tập được băm bao gồm
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
723,
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
724 và
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
725. Phương thức
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 sẽ trả về một số nguyên. Thuộc tính bắt buộc duy nhất là các đối tượng so sánh bằng nhau có cùng giá trị băm; . Thí dụ

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
13

Ghi chú

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
722 truncates the value returned from an object’s custom
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 method to the size of a
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
729. Đây thường là 8 byte trên bản dựng 64 bit và 4 byte trên bản dựng 32 bit. Nếu
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 của một đối tượng phải tương tác trên các bản dựng có kích thước bit khác nhau, hãy đảm bảo kiểm tra chiều rộng trên tất cả các bản dựng được hỗ trợ. Một cách dễ dàng để làm điều này là với
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
731

Nếu một lớp không định nghĩa một phương thức

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 thì nó cũng không nên định nghĩa một hoạt động
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715; . Nếu một lớp định nghĩa các đối tượng có thể thay đổi và triển khai phương thức
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705, thì lớp đó không nên triển khai
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715, vì việc triển khai các bộ sưu tập có thể băm yêu cầu giá trị băm của khóa là bất biến [nếu giá trị băm của đối tượng thay đổi, nó sẽ nằm trong nhóm băm sai]

User-defined classes have

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 and
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 methods by default; with them, all objects compare unequal [except with themselves] and
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
740 returns an appropriate value such that
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
741 implies both that
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
742 and
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
743

Một lớp ghi đè

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 và không định nghĩa
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 sẽ có
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 được đặt hoàn toàn thành
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68. Khi phương thức
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 của một lớp là
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68, các thể hiện của lớp sẽ tăng một giá trị thích hợp
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 khi một chương trình cố gắng truy xuất giá trị băm của chúng và cũng sẽ được xác định chính xác là không thể băm được khi kiểm tra
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
751

Nếu một lớp ghi đè

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 cần giữ lại việc triển khai
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 từ lớp cha, trình thông dịch phải được thông báo điều này một cách rõ ràng bằng cách đặt
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
754

Nếu một lớp không ghi đè

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
705 muốn chặn hỗ trợ băm, thì lớp đó nên bao gồm
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
756 trong định nghĩa lớp. Một lớp xác định
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 của riêng nó mà tăng một cách rõ ràng một
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 sẽ được xác định không chính xác là có thể băm bởi một cuộc gọi
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
751

Ghi chú

Theo mặc định, các giá trị

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 của các đối tượng str và bytes được "muối" với một giá trị ngẫu nhiên không thể đoán trước. Mặc dù chúng không đổi trong một quy trình Python riêng lẻ, nhưng chúng không thể dự đoán được giữa các lần gọi Python lặp đi lặp lại

Điều này nhằm cung cấp khả năng bảo vệ chống lại tấn công từ chối dịch vụ gây ra bởi các đầu vào được lựa chọn cẩn thận nhằm khai thác hiệu suất trong trường hợp xấu nhất của thao tác chèn chính tả, độ phức tạp O[n2]. xem http. //www. chứng chỉ. org/advisories/ocert-2011-003. html để biết chi tiết

Thay đổi giá trị băm ảnh hưởng đến thứ tự lặp lại của các tập hợp. Python chưa bao giờ đảm bảo về thứ tự này [và nó thường khác nhau giữa các bản dựng 32 bit và 64 bit]

See also

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
761

Đã thay đổi trong phiên bản 3. 3. Băm ngẫu nhiên được bật theo mặc định.

object. __bool__[bản thân]

Được gọi để thực hiện kiểm tra giá trị thực và hoạt động tích hợp sẵn

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
703; . Khi phương thức này không được xác định, thì
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
765 được gọi, nếu nó được xác định và đối tượng được coi là đúng nếu kết quả của nó khác không. Nếu một lớp không định nghĩa
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
765 hay
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
767, thì tất cả các thể hiện của nó được coi là đúng

3. 3. 2. Tùy chỉnh quyền truy cập thuộc tính¶

Các phương thức sau đây có thể được định nghĩa để tùy chỉnh ý nghĩa của quyền truy cập thuộc tính [sử dụng, gán hoặc xóa

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
768] cho các thể hiện của lớp

đối tượng. __getattr__[bản thân , tên]

Called when the default attribute access fails with an

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618 [either
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
770 raises an
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618 because name is not an instance attribute or an attribute in the class tree for
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
772; or
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773 of a name property raises
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618]. Phương thức này sẽ trả về giá trị thuộc tính [đã tính] hoặc tăng ngoại lệ
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618

Note that if the attribute is found through the normal mechanism,

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
18 is not called. [This is an intentional asymmetry between
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
18 and
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
19. ] This is done both for efficiency reasons and because otherwise
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
18 would have no way to access other attributes of the instance. Note that at least for instance variables, you can fake total control by not inserting any values in the instance attribute dictionary [but instead inserting them in another object]. See the
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
770 method below for a way to actually get total control over attribute access

đối tượng. __getattribute__[self , name]

Called unconditionally to implement attribute accesses for instances of the class. If the class also defines

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
18, the latter will not be called unless
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
770 either calls it explicitly or raises an
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618. This method should return the [computed] attribute value or raise an
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618 exception. In order to avoid infinite recursion in this method, its implementation should always call the base class method with the same name to access any attributes it needs, for example,
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
785

Ghi chú

This method may still be bypassed when looking up special methods as the result of implicit invocation via language syntax or built-in functions. See Special method lookup .

For certain sensitive attribute accesses, raises an auditing event

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
79 with arguments
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
80 and
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
788.

object. __setattr__[self , name , value]

Called when an attribute assignment is attempted. This is called instead of the normal mechanism [i. e. store the value in the instance dictionary]. name is the attribute name, value is the value to be assigned to it

If

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
19 wants to assign to an instance attribute, it should call the base class method with the same name, for example,
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
790

For certain sensitive attribute assignments, raises an auditing event

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
791 with arguments
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
80,
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
788,
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
794.

object. __delattr__[self , name]

Like

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
19 but for attribute deletion instead of assignment. This should only be implemented if
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
796 is meaningful for the object

For certain sensitive attribute deletions, raises an auditing event

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
797 with arguments
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
80 and
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
788.

object. __dir__[self]

Called when

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
600 is called on the object. A sequence must be returned.
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
600 converts the returned sequence to a list and sorts it

3. 3. 2. 1. Customizing module attribute access¶

Special names

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
603 can be also used to customize access to module attributes. The
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 function at the module level should accept one argument which is the name of an attribute and return the computed value or raise an
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618. If an attribute is not found on a module object through the normal lookup, i. e.
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
606, then
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 is searched in the module
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
19 before raising an
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618. If found, it is called with the attribute name and the result is returned

The

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
603 function should accept no arguments, and return a sequence of strings that represents the names accessible on module. If present, this function overrides the standard
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
600 search on a module

For a more fine grained customization of the module behavior [setting attributes, properties, etc. ], one can set the

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 attribute of a module object to a subclass of
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
613. For example

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

Ghi chú

Defining module

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 and setting module
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 only affect lookups made using the attribute access syntax – directly accessing the module globals [whether by code within the module, or via a reference to the module’s globals dictionary] is unaffected

Changed in version 3. 5.

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 module attribute is now writable.

New in version 3. 7.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
603 module attributes.

Xem thêm

PEP 562 - Module __getattr__ and __dir__

Describes the

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
603 functions on modules

3. 3. 2. 2. Implementing Descriptors¶

The following methods only apply when an instance of the class containing the method [a so-called descriptor class] appears in an owner class [the descriptor must be in either the owner’s class dictionary or in the class dictionary for one of its parents]. In the examples below, “the attribute” refers to the attribute whose name is the key of the property in the owner class’

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
19

object. __get__[self , instance , owner=None]

Called to get the attribute of the owner class [class attribute access] or of an instance of that class [instance attribute access]. The optional owner argument is the owner class, while instance is the instance that the attribute was accessed through, or

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68 when the attribute is accessed through the owner

This method should return the computed attribute value or raise an

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
618 exception

PEP 252 specifies that

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773 is callable with one or two arguments. Python’s own built-in descriptors support this specification; however, it is likely that some third-party tools have descriptors that require both arguments. Python’s own
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
770 implementation always passes in both arguments whether they are required or not

object. __set__[self , instance , value]

Called to set the attribute on an instance instance of the owner class to a new value, value

Note, adding

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
626 or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
627 changes the kind of descriptor to a “data descriptor”. See Invoking Descriptors for more details.

object. __delete__[bản thân , thể hiện]

Called to delete the attribute on an instance instance of the owner class

The attribute

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
628 is interpreted by the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
629 module as specifying the class where this object was defined [setting this appropriately can assist in runtime introspection of dynamic class attributes]. For callables, it may indicate that an instance of the given type [or a subclass] is expected or required as the first positional argument [for example, CPython sets this attribute for unbound methods that are implemented in C]

3. 3. 2. 3. Invoking Descriptors¶

In general, a descriptor is an object attribute with “binding behavior”, one whose attribute access has been overridden by methods in the descriptor protocol.

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
626, and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
627. If any of those methods are defined for an object, it is said to be a descriptor

The default behavior for attribute access is to get, set, or delete the attribute from an object’s dictionary. For instance,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
633 has a lookup chain starting with
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
634, then
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
635, and continuing through the base classes of
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
636 excluding metaclasses

However, if the looked-up value is an object defining one of the descriptor methods, then Python may override the default behavior and invoke the descriptor method instead. Where this occurs in the precedence chain depends on which descriptor methods were defined and how they were called

The starting point for descriptor invocation is a binding,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
633. How the arguments are assembled depends on
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
60

Direct Call

The simplest and least common call is when user code directly invokes a descriptor method.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
639

Instance Binding

If binding to an object instance,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
633 is transformed into the call.
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641

Class Binding

If binding to a class,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
642 is transformed into the call.
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
643

Super Binding

A dotted lookup such as

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
644 searches
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
645 for a base class
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
646 following
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
647 and then returns
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
648. If not a descriptor,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
0 is returned unchanged

For instance bindings, the precedence of descriptor invocation depends on which descriptor methods are defined. A descriptor can define any combination of

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
626 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
627. If it does not define
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773, then accessing the attribute will return the descriptor object itself unless there is a value in the object’s instance dictionary. If the descriptor defines
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
626 and/or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
627, it is a data descriptor; if it defines neither, it is a non-data descriptor. Normally, data descriptors define both
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
626, while non-data descriptors have just the
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773 method. Data descriptors with
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
773 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
626 [and/or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
627] defined always override a redefinition in an instance dictionary. In contrast, non-data descriptors can be overridden by instances

Python methods [including those decorated with

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
662 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
663] are implemented as non-data descriptors. Accordingly, instances can redefine and override methods. This allows individual instances to acquire behaviors that differ from other instances of the same class

The

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
664 function is implemented as a data descriptor. Accordingly, instances cannot override the behavior of a property

3. 3. 2. 4. __slots__¶

__slots__ allow us to explicitly declare data members [like properties] and deny the creation of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
19 and __weakref__ [unless explicitly declared in __slots__ or available in a parent. ]

The space saved over using

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
19 can be significant. Attribute lookup speed can be significantly improved as well

object. __slots__

This class variable can be assigned a string, iterable, or sequence of strings with variable names used by instances. __slots__ dành chỗ cho các biến đã khai báo và ngăn việc tạo tự động

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
19 và __weakref__ cho mỗi trường hợp

3. 3. 2. 4. 1. Notes on using __slots__¶
  • When inheriting from a class without __slots__, the

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    19 and __weakref__ attribute of the instances will always be accessible

  • Without a

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    19 variable, instances cannot be assigned new variables not listed in the __slots__ definition. Attempts to assign to an unlisted variable name raises
    d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
    
    618. If dynamic assignment of new variables is desired, then add
    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    671 to the sequence of strings in the __slots__ declaration

  • Without a __weakref__ variable for each instance, classes defining __slots__ do not support

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    672 to its instances. If weak reference support is needed, then add
    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    673 to the sequence of strings in the __slots__ declaration

  • __slots__ are implemented at the class level by creating descriptors for each variable name. As a result, class attributes cannot be used to set default values for instance variables defined by __slots__; otherwise, the class attribute would overwrite the descriptor assignment.

  • The action of a __slots__ declaration is not limited to the class where it is defined. __slots__ declared in parents are available in child classes. However, child subclasses will get a

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    19 and __weakref__ unless they also define __slots__ [which should only contain names of any additional slots]

  • If a class defines a slot also defined in a base class, the instance variable defined by the base class slot is inaccessible [except by retrieving its descriptor directly from the base class]. This renders the meaning of the program undefined. In the future, a check may be added to prevent this

  • Nonempty __slots__ does not work for classes derived from “variable-length” built-in types such as

    _,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
    
    79,
    class Philosopher:
        def __init_subclass__[cls, /, default_name, **kwargs]:
            super[].__init_subclass__[**kwargs]
            cls.default_name = default_name
    
    class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
        pass
    
    62 and
    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    677

  • Any non-string iterable may be assigned to __slots__.

  • If a

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    678 is used to assign __slots__, the dictionary keys will be used as the slot names. The values of the dictionary can be used to provide per-attribute docstrings that will be recognised by
    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    679 and displayed in the output of
    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    680

  • class Philosopher:
        def __init_subclass__[cls, /, default_name, **kwargs]:
            super[].__init_subclass__[**kwargs]
            cls.default_name = default_name
    
    class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
        pass
    
    22 assignment works only if both classes have the same __slots__

  • Multiple inheritance with multiple slotted parent classes can be used, but only one parent is allowed to have attributes created by slots [the other bases must have empty slot layouts] - violations raise

    _,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
    
    72.

  • If an iterator is used for __slots__ then a descriptor is created for each of the iterator’s values. However, the __slots__ attribute will be an empty iterator.

3. 3. 3. Customizing class creation¶

Whenever a class inherits from another class,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
683 is called on the parent class. This way, it is possible to write classes which change the behavior of subclasses. This is closely related to class decorators, but where class decorators only affect the specific class they’re applied to,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684 solely applies to future subclasses of the class defining the method

classmethod object. __init_subclass__[cls]

This method is called whenever the containing class is subclassed. cls is then the new subclass. If defined as a normal instance method, this method is implicitly converted to a class method

Keyword arguments which are given to a new class are passed to the parent’s class

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684. For compatibility with other classes using
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684, one should take out the needed keyword arguments and pass the others over to the base class, as in

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

The default implementation

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
687 does nothing, but raises an error if it is called with any arguments

Ghi chú

The metaclass hint

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
688 is consumed by the rest of the type machinery, and is never passed to
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684 implementations. The actual metaclass [rather than the explicit hint] can be accessed as
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
690

New in version 3. 6

When a class is created,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
691 scans the class variables and makes callbacks to those with a
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
692 hook

object. __set_name__[self , owner , name]

Automatically called at the time the owning class owner is created. The object has been assigned to name in that class

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
6

If the class variable is assigned after the class is created,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
692 will not be called automatically. If needed,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
692 can be called directly

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
7

See Creating the class object for more details.

New in version 3. 6

3. 3. 3. 1. Metaclasses¶

By default, classes are constructed using

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
1. The class body is executed in a new namespace and the class name is bound locally to the result of
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
696

The class creation process can be customized by passing the

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
688 keyword argument in the class definition line, or by inheriting from an existing class that included such an argument. In the following example, both
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
698 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
699 are instances of
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
600

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
6

Any other keyword arguments that are specified in the class definition are passed through to all metaclass operations described below

When a class definition is executed, the following steps occur

  • MRO entries are resolved;

  • the appropriate metaclass is determined;

  • the class namespace is prepared;

  • the class body is executed;

  • the class object is created

3. 3. 3. 2. Giải quyết các mục MRO¶

If a base that appears in class definition is not an instance of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
601, then an
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602 method is searched on it. If found, it is called with the original bases tuple. This method must return a tuple of classes that will be used instead of this base. The tuple may be empty, in such case the original base is ignored

Xem thêm

PEP 560 - Core support for typing module and generic types

3. 3. 3. 3. Determining the appropriate metaclass¶

The appropriate metaclass for a class definition is determined as follows

  • if no bases and no explicit metaclass are given, then

    class Philosopher:
        def __init_subclass__[cls, /, default_name, **kwargs]:
            super[].__init_subclass__[**kwargs]
            cls.default_name = default_name
    
    class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
        pass
    
    1 is used;

  • if an explicit metaclass is given and it is not an instance of

    class Philosopher:
        def __init_subclass__[cls, /, default_name, **kwargs]:
            super[].__init_subclass__[**kwargs]
            cls.default_name = default_name
    
    class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
        pass
    
    1, then it is used directly as the metaclass;

  • if an instance of

    class Philosopher:
        def __init_subclass__[cls, /, default_name, **kwargs]:
            super[].__init_subclass__[**kwargs]
            cls.default_name = default_name
    
    class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
        pass
    
    1 is given as the explicit metaclass, or bases are defined, then the most derived metaclass is used

The most derived metaclass is selected from the explicitly specified metaclass [if any] and the metaclasses [i. e.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
690] of all specified base classes. The most derived metaclass is one which is a subtype of all of these candidate metaclasses. If none of the candidate metaclasses meets that criterion, then the class definition will fail with
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72

3. 3. 3. 4. Preparing the class namespace¶

Once the appropriate metaclass has been identified, then the class namespace is prepared. If the metaclass has a

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608 attribute, it is called as
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
609 [where the additional keyword arguments, if any, come from the class definition]. The
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608 method should be implemented as a
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
611. The namespace returned by
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608 is passed in to
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
613, but when the final class object is created the namespace is copied into a new
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
725

If the metaclass has no

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608 attribute, then the class namespace is initialised as an empty ordered mapping

Xem thêm

PEP 3115 - Metaclasses in Python 3000

Introduced the

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608 namespace hook

3. 3. 3. 5. Executing the class body¶

The class body is executed [approximately] as

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
617. The key difference from a normal call to
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
618 is that lexical scoping allows the class body [including any methods] to reference names from the current and outer scopes when the class definition occurs inside a function

However, even when the class definition occurs inside the function, methods defined inside the class still cannot see names defined at the class scope. Class variables must be accessed through the first parameter of instance or class methods, or through the implicit lexically scoped

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 reference described in the next section

3. 3. 3. 6. Creating the class object¶

Once the class namespace has been populated by executing the class body, the class object is created by calling

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
620 [the additional keywords passed here are the same as those passed to
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608]

This class object is the one that will be referenced by the zero-argument form of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
622.
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 is an implicit closure reference created by the compiler if any methods in a class body refer to either
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
625. This allows the zero argument form of
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
622 to correctly identify the class being defined based on lexical scoping, while the class or instance that was used to make the current call is identified based on the first argument passed to the method

CPython implementation detail. In CPython 3. 6 and later, the

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 cell is passed to the metaclass as a
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
628 entry in the class namespace. If present, this must be propagated up to the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
629 call in order for the class to be initialised correctly. Failing to do so will result in a
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
89 in Python 3. 8

When using the default metaclass

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
601, or any metaclass that ultimately calls
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
629, the following additional customization steps are invoked after creating the class object

  1. The

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    629 method collects all of the attributes in the class namespace that define a
    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    692 method;

  2. Those

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    635 methods are called with the class being defined and the assigned name of that particular attribute;

  3. The

    import sys
    from types import ModuleType
    
    class VerboseModule[ModuleType]:
        def __repr__[self]:
            return f'Verbose {self.__name__}'
    
        def __setattr__[self, attr, value]:
            print[f'Setting {attr}...']
            super[].__setattr__[attr, value]
    
    sys.modules[__name__].__class__ = VerboseModule
    
    683 hook is called on the immediate parent of the new class in its method resolution order

After the class object is created, it is passed to the class decorators included in the class definition [if any] and the resulting object is bound in the local namespace as the defined class

When a new class is created by

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
629, the object provided as the namespace parameter is copied to a new ordered mapping and the original object is discarded. The new copy is wrapped in a read-only proxy, which becomes the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
19 attribute of the class object

Xem thêm

PEP 3135 - New super

Describes the implicit

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
22 closure reference

3. 3. 3. 7. Uses for metaclasses¶

The potential uses for metaclasses are boundless. Some ideas that have been explored include enum, logging, interface checking, automatic delegation, automatic property creation, proxies, frameworks, and automatic resource locking/synchronization

3. 3. 4. Customizing instance and subclass checks¶

The following methods are used to override the default behavior of the

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
640 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641 built-in functions

In particular, the metaclass

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
642 implements these methods in order to allow the addition of Abstract Base Classes [ABCs] as “virtual base classes” to any class or type [including built-in types], including other ABCs

class. __instancecheck__[self , instance]

Return true if instance should be considered a [direct or indirect] instance of class. If defined, called to implement

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
643

class. __subclasscheck__[self , subclass]

Trả về true nếu lớp con nên được coi là lớp con [trực tiếp hoặc gián tiếp] của lớp. If defined, called to implement

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
644

Note that these methods are looked up on the type [metaclass] of a class. Chúng không thể được định nghĩa là phương thức lớp trong lớp thực tế. Điều này phù hợp với việc tra cứu các phương thức đặc biệt được gọi trên các cá thể, chỉ trong trường hợp này, cá thể đó chính là một lớp

Xem thêm

PEP 3119 - Introducing Abstract Base Classes

Includes the specification for customizing

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
640 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641 behavior through
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
647 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
648, with motivation for this functionality in the context of adding Abstract Base Classes [see the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
649 module] to the language

3. 3. 5. Emulating generic types¶

Khi sử dụng chú thích loại , việc tham số hóa loại chung using Python’s square-brackets notation. For example, the annotation

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
650 might be used to signify a
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
651 in which all the elements are of type
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
79.

Xem thêm

PEP 484 - Type Hints

Introducing Python’s framework for type annotations

Các loại bí danh chung

Tài liệu cho các đối tượng đại diện cho các lớp chung được tham số hóa

Thuốc chung , Thuốc chung do người dùng định nghĩa
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
653

Tài liệu về cách triển khai các lớp chung có thể được tham số hóa trong thời gian chạy và được hiểu bởi trình kiểm tra kiểu tĩnh

Một lớp nói chung chỉ có thể được tham số hóa nếu nó định nghĩa phương thức lớp đặc biệt

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654

phương thức lớp đối tượng. __class_getitem__[cls , key]

Return an object representing the specialization of a generic class by type arguments found in key

When defined on a class,

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 is automatically a class method. Như vậy, nó không cần phải được trang trí bằng
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
663 khi nó được định nghĩa

3. 3. 5. 1. Mục đích của __class_getitem__¶

The purpose of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 is to allow runtime parameterization of standard-library generic classes in order to more easily apply type hints to these classes.

Để triển khai các lớp chung tùy chỉnh có thể được tham số hóa trong thời gian chạy và được hiểu bởi trình kiểm tra kiểu tĩnh, người dùng nên kế thừa từ một lớp thư viện tiêu chuẩn đã triển khai

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 hoặc kế thừa từ
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
653, lớp có triển khai riêng của nó là
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654

Custom implementations of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 on classes defined outside of the standard library may not be understood by third-party type-checkers such as mypy. Using
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 on any class for purposes other than type hinting is discouraged

3. 3. 5. 2. __class_getitem__ versus __getitem__¶

Thông thường, đăng ký của một đối tượng sử dụng dấu ngoặc vuông sẽ gọi phương thức thể hiện

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606 được định nghĩa trên lớp của đối tượng. Tuy nhiên, nếu đối tượng được đăng ký chính là một lớp, phương thức lớp
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 có thể được gọi thay thế.
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 sẽ trả về một đối tượng GenericAlias nếu nó được xác định đúng.

Presented with the expression

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
666, the Python interpreter follows something like the following process to decide whether
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606 or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 should be called.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
6

Trong Python, tất cả các lớp đều là thể hiện của các lớp khác. Lớp của một lớp được gọi là siêu lớp của lớp đó và hầu hết các lớp đều có lớp

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
601 làm siêu lớp của chúng.
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
601 không định nghĩa
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606, nghĩa là các biểu thức như
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
650,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
673 và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
674 đều dẫn đến việc gọi là
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
6

However, if a class has a custom metaclass that defines

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606, subscribing the class may result in different behaviour. An example of this can be found in the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
677 module

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
6

Xem thêm

PEP 560 - Hỗ trợ cốt lõi để nhập mô-đun và các loại chung

Introducing

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654, and outlining when a subscription results in
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 being called instead of
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606

3. 3. 6. Mô phỏng các đối tượng có thể gọi được¶

đối tượng. __call__[bản thân[ , . args...]]

Được gọi khi thể hiện được “gọi” là một hàm;

3. 3. 7. Mô phỏng các loại vùng chứa¶

The following methods can be defined to implement container objects. Containers usually are sequences [such as

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
683 or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684] or mappings [like
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
685], but can represent other containers as well. The first set of methods is used either to emulate a sequence or to emulate a mapping; the difference is that for a sequence, the allowable keys should be the integers k for which
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
686 where N is the length of the sequence, or
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
687 objects, which define a range of items. It is also recommended that mappings provide the methods
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
688,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
689,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
690,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
691,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
692,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
693,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
694,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
695,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
696, and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
697 behaving similar to those for Python’s standard
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
678 objects. The
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
699 module provides a
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
600 abstract base class to help create those methods from a base set of
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
602,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
603, and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
688. Mutable sequences should provide methods
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
605,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
606,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
607,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
608,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
609,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
694,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
611,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
612 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
613, like Python standard
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
651 objects. Finally, sequence types should implement addition [meaning concatenation] and multiplication [meaning repetition] by defining the methods
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
615,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
616,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
617,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
618,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
619 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
620 described below; they should not define other numerical operators. It is recommended that both mappings and sequences implement the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
621 method to allow efficient use of the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
622 operator; for mappings,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
622 should search the mapping’s keys; for sequences, it should search through the values. It is further recommended that both mappings and sequences implement the
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
621 method to allow efficient iteration through the container; for mappings,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
621 should iterate through the object’s keys; for sequences, it should iterate through the values.

object. __len__[self]

Called to implement the built-in function

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
62. Should return the length of the object, an integer
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
69 0. Also, an object that doesn’t define a
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
767 method and whose
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
765 method returns zero is considered to be false in a Boolean context

CPython implementation detail. In CPython, the length is required to be at most

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
630. If the length is larger than
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
630 some features [such as
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
62] may raise
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
633. To prevent raising
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
633 by truth value testing, an object must define a
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
767 method

object. __length_hint__[self]

Called to implement

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
636. Should return an estimated length for the object [which may be greater or less than the actual length]. The length must be an integer
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
69 0. The return value may also be
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69, which is treated the same as if the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
639 method didn’t exist at all. This method is purely an optimization and is never required for correctness

Mới trong phiên bản 3. 4

Ghi chú

Cắt lát được thực hiện độc quyền với ba phương pháp sau. A call like

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
6

is translated to

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
0

and so forth. Missing slice items are always filled in with

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68

object. __getitem__[self , key]

Called to implement evaluation of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641. For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes [if the class wishes to emulate a sequence type] is up to the
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606 method. If key is of an inappropriate type,
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 may be raised; if of a value outside the set of indexes for the sequence [after any special interpretation of negative values],
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
644 should be raised. For mapping types, if key is missing [not in the container],
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
645 should be raised.

Ghi chú

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
646 loops expect that an
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
644 will be raised for illegal indexes to allow proper detection of the end of the sequence

Ghi chú

When subscripting a class, the special class method

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
654 may be called instead of
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606. See __class_getitem__ versus __getitem__ for more details.

object. __setitem__[self , key , value]

Called to implement assignment to

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641. Same note as for
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606. This should only be implemented for mappings if the objects support changes to the values for keys, or if new keys can be added, or for sequences if elements can be replaced. The same exceptions should be raised for improper key values as for the
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606 method

object. __delitem__[self , key]

Called to implement deletion of

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641. Same note as for
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606. This should only be implemented for mappings if the objects support removal of keys, or for sequences if elements can be removed from the sequence. The same exceptions should be raised for improper key values as for the
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606 method

object. __missing__[self , key]

Called by

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
725.
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606 to implement
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
641 for dict subclasses when key is not in the dictionary

object. __iter__[self]

This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container. For mappings, it should iterate over the keys of the container.

object. __reversed__[self]

Called [if present] by the

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
659 built-in to implement reverse iteration. It should return a new iterator object that iterates over all the objects in the container in reverse order

If the

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
660 method is not provided, the
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
659 built-in will fall back to using the sequence protocol [
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
765 and
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606]. Objects that support the sequence protocol should only provide
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
660 if they can provide an implementation that is more efficient than the one provided by
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
659

The membership test operators [

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
622 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
667] are normally implemented as an iteration through a container. However, container objects can supply the following special method with a more efficient implementation, which also does not require the object be iterable

object. __contains__[self , item]

Called to implement membership test operators. Should return true if item is in self, false otherwise. For mapping objects, this should consider the keys of the mapping rather than the values or the key-item pairs

For objects that don’t define

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
621, the membership test first tries iteration via
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
621, then the old sequence iteration protocol via
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
606, see this section in the language reference .

3. 3. 8. Emulating numeric types¶

The following methods can be defined to emulate numeric objects. Methods corresponding to operations that are not supported by the particular kind of number implemented [e. g. , hoạt động theo bit cho các số không tách rời] sẽ không được xác định

object. __add__[bản thân , khác . ]object.__sub__[self , other]object. __mul__[self , other]object. __matmul__[self , other]object. __truediv__[self , other]object. __floordiv__[self , other]object. __mod__[self , other]object. __divmod__[bản thân , khác . ]object.__pow__[bản thân , khác . [, modulo]]object.__lshift__[bản thân , khác . ]object.__rshift__[bản thân , khác . ]object.__and__[self , other]object. __xor__[bản thân , khác . ]object.__or__[self , other]

Các phương thức này được gọi để thực hiện các phép tính số học nhị phân [

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
671,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
672,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
673,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
674,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
675,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
676,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
677,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
678,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
679,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
680,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
681,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
682,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
683,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
685]. Chẳng hạn, để đánh giá biểu thức
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
686, trong đó x là một thể hiện của lớp có phương thức
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
615, thì
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
688 được gọi. The
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
689 method should be the equivalent to using
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
690 and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
691; it should not be related to
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
692. Lưu ý rằng
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
693 phải được xác định để chấp nhận đối số thứ ba tùy chọn nếu phiên bản ternary của hàm
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
679 tích hợp sẽ được hỗ trợ

Nếu một trong các phương thức đó không hỗ trợ thao tác với các đối số được cung cấp, thì nó sẽ trả về

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69

đối tượng. __radd__[self , other]object. __rsub__[self , other]object. __rmul__[bản thân , khác . ]object.__rmatmul__[self , other]object. __rtruediv__[self , other]object. __rfloordiv__[self , other]object. __rmod__[bản thân , khác . ]object.__rdivmod__[bản thân , khác . ]object.__rpow__[bản thân , khác . [, modulo]]object.__rlshift__[bản thân , khác . ]object.__rrshift__[bản thân , khác . ]object.__rand__[bản thân , khác . ]object.__rxor__[bản thân , khác . ]object.__ror__[self , other]

Các phương thức này được gọi để thực hiện các phép toán số học nhị phân [

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
671,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
672,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
673,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
674,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
675,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
676,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
677,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
678,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
679,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
680,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
681,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
682,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
683,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
684,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
685] với các toán hạng được phản ánh [hoán đổi]. These functions are only called if the left operand does not support the corresponding operation 3 and the operands are of different types. 4 For instance, to evaluate the expression
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
611, where y is an instance of a class that has an
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
612 method,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
613 is called if
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
614 returns NotImplemented

Lưu ý rằng ternary

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
679 sẽ không thử gọi
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
616 [các quy tắc cưỡng chế sẽ trở nên quá phức tạp]

Ghi chú

Nếu kiểu của toán hạng bên phải là lớp con của kiểu toán hạng bên trái và lớp con đó cung cấp cách triển khai khác của phương thức được phản ánh cho thao tác, thì phương thức này sẽ được gọi trước phương thức không được phản ánh của toán hạng bên trái. This behavior allows subclasses to override their ancestors’ operations

object. __iadd__[bản thân , khác . ]object.__isub__[bản thân , khác . ]object.__imul__[bản thân , khác . ]object.__imatmul__[bản thân , khác . ]object.__itruediv__[self , other]object. __ifloordiv__[self , other]object. __imod__[bản thân , khác . ]object.__ipow__[bản thân , khác . [, modulo]]object.__ilshift__[self , other]object. __irshift__[self , other]object. __iand__[self , other]object. __ixor__[bản thân , khác . ]object.__ior__[bản thân , khác]

Các phương thức này được gọi để thực hiện các bài tập số học tăng cường [

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
617,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
618,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
619,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
620,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
621,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
622,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
623,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
624,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
625,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
626,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
627,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
628,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
629]. Các phương thức này sẽ cố gắng thực hiện thao tác tại chỗ [bản thân sửa đổi] và trả về kết quả [có thể, nhưng không nhất thiết phải là bản thân]. Nếu một phương thức cụ thể không được xác định, phép gán tăng cường sẽ quay trở lại các phương thức thông thường. For instance, if x is an instance of a class with an
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
617 method,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
631 is equivalent to
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
632 . Mặt khác,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
633 và
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
634 được xem xét, giống như đánh giá của
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
686. In certain situations, augmented assignment can result in unexpected errors [see Why does a_tuple[i] += [‘item’] raise an exception when the addition works? ], but this behavior is in fact part of the data model.

đối tượng. __neg__[bản thân] ¶ . object.__pos__[bản thân] ¶ . object.__abs__[self]object. __invert__[bản thân]

Called to implement the unary arithmetic operations [

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
672,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
671,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
638 and
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
639]

object. __complex__[bản thân] ¶ . object.__int__[self]object. __float__[self]

Được gọi để triển khai các chức năng tích hợp sẵn

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
640,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
641 và
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
642. Nên trả về một giá trị của loại thích hợp

đối tượng. __index__[self]

Called to implement

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
643, and whenever Python needs to losslessly convert the numeric object to an integer object [such as in slicing, or in the built-in
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
644,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
645 and
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
646 functions]. Sự hiện diện của phương thức này chỉ ra rằng đối tượng số là một kiểu số nguyên. Phải trả về một số nguyên

If

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
647,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
648 and
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
649 are not defined then corresponding built-in functions
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
641,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
642 and
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
640 fall back to
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
653

đối tượng. __round__[bản thân[ , . ndigits]]object.__trunc__[self]object. __floor__[bản thân] ¶ . object.__ceil__[bản thân]

Được gọi để thực hiện chức năng tích hợp sẵn

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
654 và
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
72 chức năng
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
656,
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
657 và
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
658. Unless ndigits is passed to
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
659 all these methods should return the value of the object truncated to an
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
660 [typically an
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
79]

Hàm tích hợp sẵn

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
641 quay trở lại
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
663 nếu cả
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
647 và
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
653 đều không được xác định

Đã thay đổi trong phiên bản 3. 11. The delegation of

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
641 to
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
663 is deprecated.

3. 3. 9. Với Trình quản lý ngữ cảnh câu lệnh¶

Trình quản lý bối cảnh là một đối tượng xác định bối cảnh thời gian chạy sẽ được thiết lập khi thực thi câu lệnh

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
8. Trình quản lý ngữ cảnh xử lý việc nhập và thoát khỏi ngữ cảnh thời gian chạy mong muốn để thực thi khối mã. Context managers are normally invoked using the
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
8 statement [described in section The with statement ], but can also be used by directly invoking their methods.

Typical uses of context managers include saving and restoring various kinds of global state, locking and unlocking resources, closing opened files, etc

Để biết thêm thông tin về trình quản lý ngữ cảnh, hãy xem Các loại trình quản lý ngữ cảnh .

đối tượng. __enter__[bản thân]

Nhập bối cảnh thời gian chạy liên quan đến đối tượng này. Câu lệnh

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
8 sẽ ràng buộc giá trị trả về của phương thức này với [các] mục tiêu được chỉ định trong mệnh đề
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
671 của câu lệnh, nếu có

đối tượng. __exit__[self , exc_type, exc_value, traceback]

Thoát bối cảnh thời gian chạy liên quan đến đối tượng này. Các tham số mô tả ngoại lệ khiến ngữ cảnh bị thoát. Nếu ngữ cảnh đã thoát mà không có ngoại lệ, thì cả ba đối số sẽ là

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68

Nếu một ngoại lệ được cung cấp và phương thức muốn loại bỏ ngoại lệ đó [i. e. , ngăn nó lan truyền], nó sẽ trả về một giá trị thực. Otherwise, the exception will be processed normally upon exit from this method

Lưu ý rằng các phương thức

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
673 không được tăng lại ngoại lệ đã truyền vào;

Xem thêm

PEP 343 - Câu lệnh “với”

The specification, background, and examples for the Python

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
8 statement

3. 3. 10. Tùy chỉnh đối số vị trí trong khớp mẫu lớp¶

When using a class name in a pattern, positional arguments in the pattern are not allowed by default, i. e.

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
675 thường không hợp lệ nếu không có hỗ trợ đặc biệt trong
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
698. Để có thể sử dụng loại mẫu đó, lớp cần xác định thuộc tính __match_args__

đối tượng. __match_args__

Biến lớp này có thể được gán một bộ chuỗi. Khi lớp này được sử dụng trong mẫu lớp có đối số vị trí, mỗi đối số vị trí sẽ được chuyển đổi thành đối số từ khóa, sử dụng giá trị tương ứng trong __match_args__ làm từ khóa. Việc không có thuộc tính này tương đương với việc đặt nó thành

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
677

Ví dụ: nếu

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
678 là
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
679 có nghĩa là
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
675 tương đương với
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
681. Lưu ý rằng số đối số trong mẫu phải nhỏ hơn hoặc bằng số phần tử trong __match_args__;

Mới trong phiên bản 3. 10

Xem thêm

PEP 634 - Kết hợp mô hình cấu trúc

Thông số kỹ thuật cho câu lệnh Python

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
683

3. 3. 11. Tra cứu phương thức đặc biệt¶

Đối với các lớp tùy chỉnh, các lời gọi ẩn của các phương thức đặc biệt chỉ được đảm bảo hoạt động chính xác nếu được định nghĩa trên một loại đối tượng, không phải trong từ điển thể hiện của đối tượng. Hành vi đó là lý do tại sao đoạn mã sau đưa ra một ngoại lệ

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
1

Lý do đằng sau hành vi này nằm ở một số phương thức đặc biệt như

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715 và
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
76 được thực hiện bởi tất cả các đối tượng, bao gồm cả đối tượng kiểu. Nếu tra cứu ẩn của các phương thức này sử dụng quy trình tra cứu thông thường, chúng sẽ thất bại khi được gọi trên chính đối tượng loại

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
2

Incorrectly attempting to invoke an unbound method of a class in this way is sometimes referred to as ‘metaclass confusion’, and is avoided by bypassing the instance when looking up special methods

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
3

Ngoài việc bỏ qua bất kỳ thuộc tính thể hiện nào vì lợi ích của tính chính xác, tra cứu phương thức đặc biệt ngầm thường cũng bỏ qua phương thức

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
770 ngay cả trong siêu dữ liệu của đối tượng

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
4

Bỏ qua máy móc

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
770 theo cách này cung cấp phạm vi đáng kể cho việc tối ưu hóa tốc độ trong trình thông dịch, với chi phí linh hoạt trong việc xử lý các phương thức đặc biệt [phương thức đặc biệt phải được đặt trên chính đối tượng lớp để được trình thông dịch gọi một cách nhất quán

3. 4. Coroutines¶

3. 4. 1. Đối tượng có thể chờ đợi¶

An awaitable object generally implements an

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
688 method. Các đối tượng Coroutine được trả về từ các hàm
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
59 có thể chờ được.

Ghi chú

Các đối tượng trình lặp trình tạo được trả về từ trình tạo được trang trí bằng

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
690 cũng có thể chờ đợi, nhưng chúng không triển khai
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
688.

object. __await__[self]

Must return an iterator . Nên được sử dụng để triển khai các đối tượng awaitable . Chẳng hạn,

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
692 triển khai phương thức này để tương thích với biểu thức
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
60.

Ghi chú

Ngôn ngữ không đặt ra bất kỳ hạn chế nào đối với loại hoặc giá trị của các đối tượng do trình vòng lặp trả về bởi

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
694, vì điều này dành riêng cho việc triển khai khung thực thi không đồng bộ [e. g.
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
695] that will be managing the awaitable object.

New in version 3. 5

Xem thêm

PEP 492 để biết thêm thông tin về các đối tượng có thể chờ đợi

3. 4. 2. Coroutine Objects¶

Các đối tượng Coroutine là các đối tượng có thể chờ đợi . A coroutine’s execution can be controlled by calling

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
688 and iterating over the result. Khi coroutine đã thực thi xong và trả về, trình vòng lặp tăng
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
58 và thuộc tính
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
794 của ngoại lệ giữ giá trị trả về. Nếu coroutine đưa ra một ngoại lệ, nó sẽ được nhân rộng bởi iterator. Coroutines should not directly raise unhandled
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
58 exceptions.

Các coroutine cũng có các phương thức được liệt kê bên dưới, tương tự như các phương thức của bộ tạo [xem Các phương pháp bộ tạo-lặp ]. However, unlike generators, coroutines do not directly support iteration.

Đã thay đổi trong phiên bản 3. 5. 2. It is a

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
89 to await on a coroutine more than once.

quy trình. gửi[giá trị]

Bắt đầu hoặc tiếp tục thực thi coroutine. Nếu giá trị là

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68, điều này tương đương với việc nâng cấp trình vòng lặp được trả về bởi
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
688. Nếu giá trị không phải là
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68, thì phương thức này ủy quyền cho phương thức
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
604 của trình vòng lặp khiến quy trình đăng ký tạm dừng. The result [return value,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
58, or other exception] is the same as when iterating over the
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
688 return value, described above

coroutine. ném[giá trị] ¶ . coroutine.throw[type[ , value[ , traceback]]]

Tăng ngoại lệ được chỉ định trong coroutine. This method delegates to the

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
607 method of the iterator that caused the coroutine to suspend, if it has such a method. Otherwise, the exception is raised at the suspension point. The result [return value,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
58, or other exception] is the same as when iterating over the
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
688 return value, described above. Nếu ngoại lệ không bị bắt trong coroutine, nó sẽ truyền lại cho người gọi

quy trình. close[]

Causes the coroutine to clean itself up and exit. Nếu coroutine bị đình chỉ, phương thức này trước tiên sẽ ủy quyền cho phương thức

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
5 của iterator khiến coroutine bị đình chỉ, nếu nó có một phương thức như vậy. Sau đó, nó tăng
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
611 tại điểm treo, khiến quy trình đăng ký ngay lập tức tự dọn dẹp. Finally, the coroutine is marked as having finished executing, even if it was never started

Coroutine objects are automatically closed using the above process when they are about to be destroyed

3. 4. 3. Asynchronous Iterators¶

Trình lặp không đồng bộ có thể gọi mã không đồng bộ trong phương thức

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
612 của nó

Trình vòng lặp không đồng bộ có thể được sử dụng trong câu lệnh

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
62

object. __aiter__[self]

Phải trả về một đối tượng lặp không đồng bộ

đối tượng. __anext__[bản thân]

Phải trả về một kết quả có thể chờ đợi trong giá trị tiếp theo của trình vòng lặp. Sẽ phát sinh lỗi

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
69 khi quá trình lặp lại kết thúc

An example of an asynchronous iterable object

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
5

New in version 3. 5

Đã thay đổi trong phiên bản 3. 7. Trước Python 3. 7,

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
615 có thể trả về một sự chờ đợi sẽ phân giải thành trình lặp không đồng bộ .

Bắt đầu với Python 3. 7,

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
615 must return an asynchronous iterator object. Returning anything else will result in a
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72 error

3. 4. 4. Trình quản lý ngữ cảnh không đồng bộ¶

Trình quản lý ngữ cảnh không đồng bộ là trình quản lý ngữ cảnh có thể tạm dừng thực thi trong các phương thức

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
618 và
class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
619 của nó

Trình quản lý bối cảnh không đồng bộ có thể được sử dụng trong câu lệnh

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
61

đối tượng. __aenter__[bản thân]

Tương tự về mặt ngữ nghĩa với

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
621, điểm khác biệt duy nhất là nó phải trả về một giá trị chờ

object. __aexit__[bản thân , exc_type, exc_value, traceback]

Tương tự về mặt ngữ nghĩa với

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass
673, điểm khác biệt duy nhất là nó phải trả về giá trị chờ đợi

An example of an asynchronous context manager class

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
6

New in version 3. 5

chú thích

1

Trong một số trường hợp, có thể thay đổi loại đối tượng, trong các điều kiện được kiểm soát nhất định. Mặc dù vậy, nhìn chung đó không phải là một ý kiến ​​hay vì nó có thể dẫn đến một số hành vi rất kỳ lạ nếu xử lý không đúng cách.

2

The

_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
715,
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
621,
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
660, and
import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
621 methods have special handling for this; others will still raise a
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
72, but may do so by relying on the behavior that
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68 is not callable

3

“Không hỗ trợ” ở đây có nghĩa là lớp không có phương thức như vậy hoặc phương thức trả về

d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
69. Không đặt phương thức thành
d2, = values[s]  ## values[s] is a string and at this point len[values[s]] is 1
68 nếu bạn muốn buộc dự phòng về phương thức phản ánh của toán hạng bên phải—thay vào đó, điều đó sẽ có tác dụng ngược lại là chặn rõ ràng dự phòng đó

4

Đối với các toán hạng cùng loại, người ta cho rằng nếu phương thức không được phản ánh - chẳng hạn như

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule
615 - không thành công thì hoạt động tổng thể không được hỗ trợ, đó là lý do tại sao phương thức được phản ánh không được gọi

Chủ Đề