Python là __del__ luôn được gọi

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

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

See for more details

Changed in version 3. 9. Evaluating

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

This type has a single value. There is a single object with this value. This object is accessed through the literal

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

These are created by numeric literals and returned as results by arithmetic operators and arithmetic built-in functions. Numeric objects are immutable; once created their value never changes. Python numbers are of course strongly related to mathematical numbers, but subject to the limitations of numerical representation in computers

The string representations of the numeric classes, computed by and , have the following properties

• They are valid numeric literals which, when passed to their class constructor, produce an object having the value of the original numeric

• The representation is in base 10, when possible

• Leading zeros, possibly excepting a single zero before a decimal point, are not shown

• Trailing zeros, possibly excepting a single zero after a decimal point, are not shown

• A sign is shown only when the number is negative

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

These represent elements from the mathematical set of integers [positive and negative]

There are two types of integers

These represent numbers in an unlimited range, subject to available [virtual] memory only. For the purpose of shift and mask operations, a binary representation is assumed, and negative numbers are represented in a variant of 2’s complement which gives the illusion of an infinite string of sign bits extending to the left

These represent the truth values False and True. The two objects representing the values

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

The rules for integer representation are intended to give the most meaningful interpretation of shift and mask operations involving negative integers

These represent machine-level double precision floating point numbers. You are at the mercy of the underlying machine architecture [and C or Java implementation] for the accepted range and handling of overflow. Python does not support single-precision floating point numbers; the savings in processor and memory usage that are usually the reason for using these are dwarfed by the overhead of using objects in Python, so there is no reason to complicate the language with two kinds of floating point numbers

These represent complex numbers as a pair of machine-level double precision floating point numbers. The same caveats apply as for floating point numbers. The real and imaginary parts of a complex number

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

These represent finite ordered sets indexed by non-negative numbers. The built-in function returns the number of items of a sequence. When the length of a sequence is n, the index set contains the numbers 0, 1, …, n-1. Item i of sequence a is selected by

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

Sequences also support slicing.

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

Some sequences also support “extended slicing” with a third “step” parameter.

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

from inspect import isclass

def subscribe[obj, x]:
    """Return the result of the expression 'obj[x]'"""

    class_of_obj = type[obj]

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__[obj, x]
    if hasattr[class_of_obj, '__getitem__']:
        return class_of_obj.__getitem__[obj, x]

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__[x]
    elif isclass[obj] and hasattr[obj, '__class_getitem__']:
        return obj.__class_getitem__[x]

    # Else, raise an exception
    else:
        raise TypeError[
            f"'{class_of_obj.__name__}' object is not subscriptable"
        ]

Sequences are distinguished according to their mutability

An object of an immutable sequence type cannot change once it is created. [If the object contains references to other objects, these other objects may be mutable and may be changed; however, the collection of objects directly referenced by an immutable object cannot change. ]

The following types are immutable sequences

A string is a sequence of values that represent Unicode code points. All the code points in the range

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

The items of a tuple are arbitrary Python objects. Tuples of two or more items are formed by comma-separated lists of expressions. A tuple of one item [a ‘singleton’] can be formed by affixing a comma to an expression [an expression by itself does not create a tuple, since parentheses must be usable for grouping of expressions]. An empty tuple can be formed by an empty pair of parentheses

A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 >> from enum import Enum >>> class Menu[Enum]: .. """A breakfast menu""" .. SPAM = 'spam' .. BACON = 'bacon' ... >>> # Enum classes have a custom metaclass: >>> type[Menu] >>> # EnumMeta defines __getitem__, >>> # so __class_getitem__ is not called, >>> # and the result is not a GenericAlias object: >>> Menu['SPAM'] >>> type[Menu['SPAM']] 4] and the built-in constructor can be used to create bytes objects. Also, bytes objects can be decoded to strings via the method

Mutable sequences can be changed after they are created. The subscription and slicing notations can be used as the target of assignment and [delete] statements

There are currently two intrinsic mutable sequence types

Các mục của danh sách là các đối tượng Python tùy ý. Danh sách được hình thành bằng cách đặt một danh sách các biểu thức được phân tách bằng dấu phẩy trong dấu ngoặc vuông. [Lưu ý rằng không có trường hợp đặc biệt nào cần thiết để tạo danh sách có độ dài 0 hoặc 1. ]

Một đối tượng bytearray là một mảng có thể thay đổi. Chúng được tạo bởi hàm tạo tích hợp. Ngoài việc có thể thay đổi [và do đó không thể băm được], các mảng byte còn cung cấp giao diện và chức năng giống như các đối tượng bất biến

Mô-đun mở rộng cung cấp một ví dụ bổ sung về loại trình tự có thể thay đổi, cũng như mô-đun

Chúng đại diện cho các tập hợp hữu hạn, không có thứ tự của các đối tượng duy nhất, bất biến. Như vậy, chúng không thể được lập chỉ mục bởi bất kỳ chỉ số nào. Tuy nhiên, chúng có thể được lặp đi lặp lại và hàm tích hợp trả về số lượng mục trong một tập hợp. Các cách sử dụng phổ biến cho các tập hợp là kiểm tra tư cách thành viên nhanh, loại bỏ các bản trùng lặp khỏi một chuỗi và tính toán các phép toán như giao, hợp, hiệu và hiệu đối xứng

Đối với các phần tử tập hợp, các quy tắc bất biến tương tự áp dụng cho các khóa từ điển. Lưu ý rằng các loại số tuân theo các quy tắc thông thường để so sánh số. nếu hai số so sánh bằng nhau [e. g. ,

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

a[1:2] = b

Hiện tại có hai loại tập hợp nội tại

Chúng đại diện cho một tập hợp có thể thay đổi. Chúng được tạo bởi hàm tạo dựng sẵn và có thể được sửa đổi sau đó bằng một số phương thức, chẳng hạn như

a[1:2] = b

Chúng đại diện cho một tập hợp bất biến. Chúng được tạo bởi hàm tạo tích hợp. Vì một bộ đóng băng là bất biến và , nên nó có thể được sử dụng lại như một phần tử của một bộ khác hoặc làm khóa từ điển

Chúng đại diện cho các bộ đối tượng hữu hạn được lập chỉ mục bởi các bộ chỉ mục tùy ý. Ký hiệu chỉ số phụ

a[1:2] = b

a[1:2] = b

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Hiện tại có một loại ánh xạ nội tại duy nhất

Chúng đại diện cho các bộ đối tượng hữu hạn được lập chỉ mục bởi các giá trị gần như tùy ý. Các loại giá trị duy nhất không được chấp nhận làm khóa là các giá trị chứa danh sách hoặc từ điển hoặc các loại có thể thay đổi khác được so sánh theo giá trị thay vì theo danh tính đối tượng, lý do là việc triển khai từ điển hiệu quả yêu cầu giá trị băm của khóa không đổi. Các loại số được sử dụng cho các phím tuân theo các quy tắc thông thường để so sánh số. nếu hai số so sánh bằng nhau [e. g. ,

>>> # list has class "type" as its metaclass, like most classes:
>>> type[list]

>>> type[dict] == type[list] == type[tuple] == type[str] == type[bytes]
True
>>> # "list[int]" calls "list.__class_getitem__[int]"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type[list[int]]

a[1:2] = b

Từ điển duy trì thứ tự chèn, nghĩa là các khóa sẽ được tạo theo cùng thứ tự mà chúng được thêm tuần tự vào từ điển. Thay thế một khóa hiện có không thay đổi thứ tự, tuy nhiên việc xóa một khóa và cắm lại sẽ thêm khóa đó vào cuối thay vì giữ nguyên vị trí cũ

Từ điển có thể thay đổi;

Các mô-đun mở rộng và cung cấp các ví dụ bổ sung về các loại ánh xạ, cũng như mô-đun

Đã thay đổi trong phiên bản 3. 7. Từ điển không giữ nguyên thứ tự chèn trong các phiên bản Python trước 3. 6. Trong CPython 3. 6, thứ tự chèn được giữ nguyên, nhưng nó được coi là chi tiết triển khai tại thời điểm đó hơn là đảm bảo ngôn ngữ.

Đây là những loại có thể áp dụng thao tác gọi hàm [xem phần ]

Một đối tượng hàm do người dùng định nghĩa được tạo bởi một định nghĩa hàm [xem phần ]. Nó nên được gọi với một danh sách đối số chứa cùng số mục như danh sách tham số chính thức của hàm

thuộc tính đặc biệt

Thuộc tí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

Chuỗi tài liệu của chức năng, hoặc

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Có thể ghi

Tên chức năng

Có thể ghi

Chức năng

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

Có thể ghi

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Tên của mô-đun mà chức năng đã được xác định trong hoặc

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Có thể ghi

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Một bộ chứa các giá trị đối số mặc định cho những đối số có giá trị mặc định hoặc

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Có thể ghi

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Đối tượng mã đại diện cho thân hàm đã biên dịch

Có thể ghi

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Tham chiếu đến từ điển chứa các biến toàn cục của hàm — không gian tên toàn cục của mô-đun trong đó hàm được xác định

Chỉ đọc

Không gian tên hỗ trợ các thuộc tính chức năng tùy ý

Có thể ghi

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, '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

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

Một dict chứa chú thích của các tham số. Các khóa của dict là tên tham số 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

Có thể ghi

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Một lệnh chứa các giá trị mặc định cho các tham số chỉ từ khóa

Có thể ghi

Hầu hết các thuộc tính có nhãn “Writable” kiểm tra loại giá trị được gán

Các đối tượng hàm cũng hỗ trợ nhận và đặt các thuộc tính tùy ý, chẳng hạn như có thể được sử dụng để đính kèm siêu dữ liệu vào các hàm. Ký hiệu dấu chấm thuộc tính thông thường được sử dụng để lấy và đặt các thuộc tính đó. Lưu ý rằng việc triển khai hiện tại chỉ hỗ trợ các thuộc tính chức năng trên các chức năng do người dùng xác định. Các thuộc tính chức năng trên các chức năng tích hợp có thể được hỗ trợ trong tương lai

Một đối tượng ô có thuộc tí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

Thông tin bổ sung về định nghĩa của hàm có thể được truy xuất từ ​​đối tượng mã của nó; . Loại có thể được truy cập trong mô-đun

Một đối tượng phương thức thể hiện kết hợp một lớp, một thể hiện của lớp và bất kỳ đối tượng nào có thể gọi được [thông thường là một hàm do người dùng định nghĩa]

Thuộc tính chỉ đọc đặ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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Các phương thức cũng hỗ trợ truy cập [nhưng không cài đặt] các thuộc tính hàm tùy ý trên đối tượng hàm bên dưới

Các đối tượng phương thức do người dùng định nghĩa có thể được tạo khi nhận một thuộc tính của một lớp [có thể thông qua một thể hiện của lớp đó], nếu thuộc tính đó là một đối tượng hàm do người dùng định nghĩa hoặc một đối tượng phương thức của lớp

Khi một đối tượng phương thức thể hiện được tạo bằng cách truy xuất một đối tượng hàm do người dùng định nghĩa từ một lớp thông qua một trong các thể hiện của nó, thì thuộc tí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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Khi một đối tượng phương thức thể hiện được tạo bằng cách truy xuất một đối tượng phương thức lớp từ một lớp hoặc thể hiện, thuộc tí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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Khi một đối tượng phương thức thể hiện được gọi, hàm bên dướ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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Khi một đối tượng phương thức thể hiện được bắt nguồn từ một đối tượng phương thức lớp, thì “thể hiện lớp” được lưu trữ 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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Lưu ý rằng việc chuyển đổi từ đối tượng hàm sang đối tượng phương thức thể hiện xảy ra mỗi khi thuộc tính được truy xuất từ ​​thể hiện. Trong một số trường hợp, cách tối ưu hiệu quả là gán thuộc tính cho một biến cục bộ và gọi biến cục bộ đó. Cũng lưu ý rằng việc chuyển đổi này chỉ xảy ra đối với các chức năng do người dùng xác định; . Cũng cần lưu ý rằng các hàm do người dùng định nghĩa là các thuộc tính của một thể hiện lớp không được chuyển đổi thành các phương thức ràng buộc;

Hàm hoặc phương thức sử dụng câu lệnh [xem phần ] được gọi là hàm tạo. Một hàm như vậy, khi được gọi, luôn trả về một đối tượng có thể được sử dụng để thực thi phần thân của hàm. gọi phương thức của iterator sẽ khiến hàm thực thi cho đến khi nó cung cấp một giá trị bằng cách sử dụng 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

Một hàm hoặc phương thức được định nghĩa bằng cách sử dụng được gọi là hàm coroutine. Một hàm như vậy, khi được gọi, sẽ trả về một đối tượng. Nó có thể chứa các biểu thức, cũng như và các câu lệnh. Xem thêm phần

Một hàm hoặc phương thức được định nghĩa bằng cách sử dụng và sử dụng câu lệnh được gọi là hàm tạo không đồng bộ. Một hàm như vậy, khi được gọi, trả về một đối tượng có thể được sử dụng trong một câu lệnh để thực thi phần thân của hàm

Việc gọi phương thức của trình vòng lặp không đồng bộ sẽ trả về một phương thức mà khi được chờ đợi sẽ thực thi cho đến khi nó cung cấp một giá trị bằng cách sử dụng biểu thức. Khi hàm thực thi một câu lệnh trống hoặc rơi ra khỏi phần cuối, một ngoại lệ sẽ được đưa ra và trình lặp không đồng bộ sẽ đạt đến phần cuối của tập hợp các giá trị sẽ được tạo ra

Một đối tượng chức năng tích hợp là một trình bao bọc xung quanh một hàm C. Ví dụ về các hàm tích hợp sẵn là và [ là mô-đun tích hợp sẵn tiêu chuẩn]. Số lượng và loại đối số được xác định bởi hàm C. Thuộc tính chỉ đọc đặ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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Đây thực sự là một cách ngụy trang khác của một hàm dựng sẵn, lần này chứa một đối tượng được truyền cho hàm C dưới dạng một đối số phụ ngầm định. Một ví dụ về phương thức dựng sẵ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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Các lớp có thể gọi được. Các đối tượng này thường đóng vai trò là nhà máy cho các phiên bản mới của chính chúng, nhưng các biến thể có thể xảy ra đối với các loại lớp ghi đè. Các đối số của cuộc gọi được chuyển đế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

Các thể hiện của các lớp tùy ý có thể được gọi bằng cách định nghĩa một phương thức trong lớp của chúng

Các mô-đun là một đơn vị tổ chức cơ bản của mã Python và được tạo bởi as được gọi bởi câu lệnh hoặc bằng cách gọi các hàm như và tích hợp sẵn. Một đối tượng mô-đun có một không gian tên được triển khai bởi một đối tượng từ điển [đây là từ điển được tham chiếu bởi thuộc tí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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Gán thuộc tính cập nhật từ điển không gian tên của mô-đun, e. g. ,

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Thuộc tính được xác định trước [có thể ghi]

Tên của mô-đun

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

09

Chuỗi tài liệu của mô-đun hoặc

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

8 nếu không có

Tên đường dẫn của tệp mà mô-đun được tải từ đó, nếu nó được tải từ một tệp. Thuộc tính có thể bị thiếu đối với một số loại mô-đun, chẳng hạn như mô-đun C được liên kết tĩnh vào trình thông dịch. Đối với các mô-đun mở rộng được tải động từ thư viện dùng chung, đó là tên đường dẫn của tệp thư viện dùng chung

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

23

Một từ điển chứa được thu thập trong quá trình thực thi thân mô-đun. Để biết các phương pháp hay nhất khi làm việc 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

23, vui lòng xem

Thuộc tính chỉ đọc đặc biệt. là không gian tên của mô-đun như một đối tượng từ điển

Chi tiết triển khai CPython. Do cách CPython xóa từ điển mô-đun, từ điển mô-đun sẽ bị xóa khi mô-đun nằm ngoài phạm vi ngay cả khi từ điển vẫn có tham chiếu trực tiếp. Để tránh điều này, hãy sao chép từ điển hoặc giữ nguyên mô-đun trong khi sử dụng trực tiếp từ điển của nó

Các loại lớp tùy chỉnh thường được tạo bởi các định nghĩa lớp [xem phần ]. Một lớp có một không gian tên được triển khai bởi một đối tượng từ điển. Tham chiếu thuộc tính lớp được dịch sang tra cứu trong từ điển này, 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

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

Khi một tham chiếu thuộc tính lớp [đối với 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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

Các phép gán thuộc tính lớp cập nhật từ điển của lớp, không bao giờ là từ điển của lớp cơ sở

Một đối tượng lớp có thể được gọi [xem ở trên] để tạo ra một thể hiện của lớp [xem bên dưới]

thuộc tính đặc biệt

tên 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

13

Tên của mô-đun trong đó lớp được định nghĩa

Từ điển chứa không gian tên của lớp

Một bộ chứa các lớp cơ sở, theo thứ tự xuất hiện của chúng trong danh sách lớp cơ 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

09

Chuỗi tài liệu của lớp, hoặc

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

8 nếu không xá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

23

Một từ điển chứa được thu thập trong quá trình thực thi nội dung lớp. Để biết các phương pháp hay nhất khi làm việc 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

23, vui lòng xem

Một thể hiện của lớp được tạo bằng cách gọi một đối tượng lớp [xem bên trên]. Một thể hiện của lớp có một không gian tên được triển khai dưới dạng từ điển, đây là nơi đầu tiên mà các tham chiếu thuộc tính được tìm kiếm. Khi một thuộc tính không được tìm thấy ở đó và lớp của đối tượng có một thuộc tính theo tên đó, quá trình tìm kiếm sẽ tiếp tục với các thuộc tính của lớp. Nếu một thuộc tính lớp được tìm thấy là một đối tượng hàm do người dùng định nghĩa, nó sẽ được chuyển đổi thành một đối tượng phương thức thể hiện có thuộc tí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

Việc gán và xóa thuộc tính cập nhật từ điển của cá thể, không bao giờ là từ điển của lớp. Nếu lớp có phương thức hoặc, thì phương thức này được gọi thay vì cập nhật trực tiếp từ điển cá thể

Các thể hiện của lớp có thể giả vờ là số, trình tự hoặc ánh xạ nếu chúng có các phương thức với một số tên đặc biệt. xem phần

thuộc tính đặc biệt. là từ điển thuộc tính;

A đại diện cho một tệp đang mở. Nhiều phím tắt có sẵn để tạo các đối tượng tệp. chức năng tích hợp sẵn, cũng như , và phương thức của các đối tượng ổ cắm [và có lẽ bởi các chức năng hoặc phương thức khác được cung cấp bởi các mô-đun mở rộng]

Các đố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

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

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

Một vài loại được trình thông dịch sử dụng nội bộ được hiển thị cho người dùng. Định nghĩa của chúng có thể thay đổi với các phiên bản tương lai của trình thông dịch, nhưng chúng được đề cập ở đây cho đầy đủ

Các đối tượng mã đại diện cho mã Python thực thi được biên dịch theo byte hoặc. Sự khác biệt giữa đối tượng mã và đối tượng hàm là đối tượng hàm chứa tham chiếu rõ ràng đến toàn cục của hàm [mô-đun trong đó nó được xác định], trong khi đối tượng mã không chứa ngữ cảnh; . Không giống như các đối tượng chức năng, các đối tượng mã là bất biến và không chứa tham chiếu [trực tiếp hoặc gián tiếp] đến các đối tượng có thể thay đổi

Thuộc tính chỉ đọc đặc biệt.

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

Các bit cờ sau đây được xác định 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

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

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

Các khai báo tính năng trong tương lai [

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

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

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

Other bits 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

Nếu một đối tượng mã đại diện cho một chức năng, mục đầu tiên trong

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Trả về một lần lặp qua các vị trí mã nguồn của mỗi lệnh mã byte trong đối tượng mã

Trình vòng lặp trả về các bộ chứ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

Thông tin vị trí này có thể bị thiếu. Danh sách không đầy đủ các trường hợp điều này có thể xảy ra

• Chạy trình thông dịch 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
  

  64

• Đang tải tệp pyc được biên dịch trong khi sử dụ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
  

  64

• Vị trí các bộ dữ liệu tương ứng với các hướng dẫn nhân tạo

• Số dòng và số cột không thể được biểu diễn do giới hạn triển khai cụ thể

Khi điều này xảy ra, một số hoặc tất cả các phần tử của bộ dữ liệu có thể được

Mới trong phiên bản 3. 11

Ghi chú

Tính năng này yêu cầu lưu trữ các vị trí cột trong các đối tượng mã, điều này có thể dẫn đến việc tăng nhẹ mức sử dụng đĩa của các tệp Python đã biên dịch hoặc mức sử dụng bộ nhớ trình thông dịch. Để tránh lưu trữ thông tin bổ sung và/hoặc hủy kích hoạt in thông tin truy nguyên bổ sung, có thể sử dụng cờ dòng 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

Các đối tượng khung đại diện cho các khung thực thi. Chúng có thể xảy ra trong các đối tượng theo dõi [xem bên dưới] và cũng được chuyển đến các chức năng theo dõi đã đăng ký

Thuộc tính chỉ đọc đặc biệt.

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

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

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

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

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

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

Việc truy cập vào

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

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

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

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

Thuộc tính có thể ghi đặc biệt.

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

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

Việc triển khai có thể cho phép yêu cầu các sự kiện trên mỗi mã hành động bằng cách đặt

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

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

Các đối tượng khung hỗ trợ một phương thức

Phương pháp này xóa tất cả các tham chiếu đến các biến cục bộ được giữ bởi khung. Ngoài ra, nếu khung thuộc về trình tạo, trình tạo được hoàn thiện. Điều này giúp phá vỡ các chu kỳ tham chiếu liên quan đến các đối tượng khung [ví dụ: khi bắt một ngoại lệ và lưu trữ dấu vết của nó để sử dụng sau này]

được nâng lên nếu khung hiện đang thực thi

Mới trong phiên bản 3. 4

Các đối tượng truy nguyên đại diện cho một dấu vết ngăn xếp của một ngoại lệ. Một đối tượng truy nguyên được tạo hoàn toàn khi xảy ra ngoại lệ và cũng có thể được tạo rõ ràng bằng cách gọi

For implicitly created tracebacks, when the search for an exception handler unwinds the execution stack, at each unwound level a traceback object is inserted in front of the current traceback. Khi một trình xử lý ngoại lệ được nhập, dấu vết ngăn xếp sẽ được cung cấp cho chương trình. [Xem phần. ] Nó có thể truy cập dưới dạng mục thứ ba của bộ đượ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

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

Khi chương trình không chứa trình xử lý phù hợp, dấu vết ngăn xếp được ghi [được định dạng độc đáo] vào luồng lỗi tiêu chuẩn;

Đối với các dấu vết được tạo rõ ràng, người tạo dấu vết phải xác định cách liên kết các thuộc tí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

Thuộc tính chỉ đọc đặc biệt.

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

Truy cập vào

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

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

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Thuộc tính có thể ghi đặc biệt.

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Changed in version 3. 7. Các đối tượng truy ngược giờ đây có thể được khởi tạo rõ ràng từ mã Python và thuộc tí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

Các đối tượng lát cắt được sử dụng để biểu diễn các lát cắt cho các phương thức. Chúng cũng được tạo bởi chức năng tích hợp

Thuộc tính chỉ đọc đặc biệt.

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Slice objects support one method

This method takes a single integer argument length and computes information about the slice that the slice object would describe if applied to a sequence of length items. It returns a tuple of three integers; respectively these are the start and stop indices and the step or stride length of the slice. Missing or out-of-bounds indices are handled in a manner consistent with regular slices

Static method objects provide a way of defeating the transformation of function objects to method objects described above. A static method object is a wrapper around any other object, usually a user-defined method object. When a static method object is retrieved from a class or a class instance, the object actually returned is the wrapped object, which is not subject to any further transformation. Static method objects are also callable. Static method objects are created by the built-in constructor

A class method object, like a static method object, is a wrapper around another object that alters the way in which that object is retrieved from classes and class instances. The behaviour of class method objects upon such retrieval is described above, under “User-defined methods”. Class method objects are created by the built-in constructor

3. 3. Special method names

A class can implement certain operations that are invoked by special syntax [such as arithmetic operations or subscripting and slicing] by defining methods with special names. This is Python’s approach to operator overloading, allowing classes to define their own behavior with respect to language operators. For instance, if a class defines a method named , 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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

Setting a special method to

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

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. For example, some sequences may work well with retrieval of individual elements, but extracting a slice may not make sense. [One example of this is the

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

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

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

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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

class Meta[type]:
    pass

class MyClass[metaclass=Meta]:
    pass

class MySubclass[MyClass]:
    pass

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, '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

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
    x = C[]  # Automatically calls: x.__set_name__[A, 'x']

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

def __hash__[self]:
    return hash[[self.name, self.nick, self.color]]

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook

class A:
   pass

c = C[]
A.x = c                  # The hook is not called
c.__set_name__[A, 'x']   # Manually invoke the hook