Đọ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"]: pass35, 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"]: pass36 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__ = VerboseModule9 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"]: pass0
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"]: pass1 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"]: pass2 để 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"]: pass4' 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"]: pass5. 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"]: pass7' 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"]: pass8' 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"]: pass9,
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à saiKhông được thực hiệnLoạ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 booleanXem 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ửngLoạ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]
75Chú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 sauChú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]
78Chú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__ = VerboseModule60]
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__ = VerboseModule61 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__ = VerboseModule62 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__ = VerboseModule63 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__ = VerboseModule64 đượ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__ = VerboseModule65 [
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule66]
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__ = VerboseModule67 [
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule68]
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__ = VerboseModule69 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__ = VerboseModule60 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__ = VerboseModule61trì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__ = VerboseModule62 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__ = VerboseModule63
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__ = VerboseModule64 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__ = VerboseModule65 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__ = VerboseModule66 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__ = VerboseModule67 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__ = VerboseModule68, 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__ = VerboseModule69
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule60 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__ = VerboseModule65 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__ = VerboseModule66 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ếnMộ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âyChuỗ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__ = VerboseModule63 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__ = VerboseModule65 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__ = VerboseModule66; .
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass60 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"]: pass61 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"]: pass62 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"]: pass63 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
byteMộ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]. 2When 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__ = VerboseModule82 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__ = VerboseModule82 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__ = VerboseModule82 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 itIf
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule82 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__ = VerboseModule84 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 constructorIf
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule82 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__ = VerboseModule84 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__ = VerboseModule82 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 creationobject. __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__ = VerboseModule82], 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__ = VerboseModule84, 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__ = VerboseModule84 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
640Bở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__ = VerboseModule82 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__ = VerboseModule84 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__ = VerboseModule82 để 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__ = VerboseModule84 để 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__ = VerboseModule84; đố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ệnKhô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átGhi 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"]: pass0 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"]: pass0 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"]: pass2
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"]: pass29. Đặc biệt
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ếud2, = 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 thid2, = values[s] ## values[s] is a string and at this point len[values[s]] is 1
648d2, = 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ànhd2, = 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;d2, = values[s] ## values[s] is a string and at this point len[values[s]] is 1
Đượ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ụngViệ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"]: pass62. đố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
698Mộ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__ = VerboseModule61 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__ = VerboseModule62 đượ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 saiBy 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__ = VerboseModule7, 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]
714Xem đ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__ = VerboseModule13
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]
731Nế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]
743Mộ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]
751Nế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]
754Nế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]
751Ghi 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à đúng3. 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
618Note 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"]: pass18 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"]: pass18 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"]: pass19. ] 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"]: pass18 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"]: pass18, 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]
785Ghi 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"]: pass79 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"]: pass80 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"]: pass19 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]
790For 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"]: pass80,
_,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"]: pass19 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 objectFor 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"]: pass80 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__ = VerboseModule600 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__ = VerboseModule600 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__ = VerboseModule602 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__ = VerboseModule603 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__ = VerboseModule602 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__ = VerboseModule606, 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__ = VerboseModule602 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__ = VerboseModule19 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 returnedThe
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule603 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__ = VerboseModule600 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"]: pass22 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__ = VerboseModule613. 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__ = VerboseModule602 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"]: pass22 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"]: pass22 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__ = VerboseModule602 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__ = VerboseModule603 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__ = VerboseModule602 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__ = VerboseModule603 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__ = VerboseModule19object. __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 ownerThis 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 exceptionPEP 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 notobject. __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__ = VerboseModule626 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__ = VerboseModule627 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__ = VerboseModule628 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__ = VerboseModule629 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__ = VerboseModule626, 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__ = VerboseModule627. 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__ = VerboseModule633 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__ = VerboseModule634, 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__ = VerboseModule635, 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__ = VerboseModule636 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__ = VerboseModule633. How the arguments are assembled depends on
d2, = values[s] ## values[s] is a string and at this point len[values[s]] is 1
60Direct CallThe 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__ = VerboseModule639Instance 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__ = VerboseModule633 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__ = VerboseModule641Class 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__ = VerboseModule642 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__ = VerboseModule643Super 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__ = VerboseModule644 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__ = VerboseModule645 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__ = VerboseModule646 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__ = VerboseModule647 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__ = VerboseModule648. 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"]: pass0 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__ = VerboseModule626 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__ = VerboseModule627. 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__ = VerboseModule626 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__ = VerboseModule627, 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__ = VerboseModule626, 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__ = VerboseModule626 [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__ = VerboseModule627] 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__ = VerboseModule662 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__ = VerboseModule663] 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__ = VerboseModule664 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__ = VerboseModule19 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__ = VerboseModule19 can be significant. Attribute lookup speed can be significantly improved as wellobject. __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__ = VerboseModule19 và __weakref__ cho mỗi trường hợp
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 accessibleWithout 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
618. If dynamic assignment of new variables is desired, then addd2, = values[s] ## values[s] is a string and at this point len[values[s]] is 1
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[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__ declarationWithout 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 addimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[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
79,_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
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 andimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule
677Any 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 byimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[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 ofimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule
680class 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
72._,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
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__ = VerboseModule683 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__ = VerboseModule684 solely applies to future subclasses of the class defining the methodclassmethod 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__ = VerboseModule684. 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__ = VerboseModule684, 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__ = VerboseModule687 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__ = VerboseModule688 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__ = VerboseModule684 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__ = VerboseModule690
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__ = VerboseModule691 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__ = VerboseModule692 hookobject. __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
6If 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__ = VerboseModule692 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__ = VerboseModule692 can be called directly
_,s = min[[len[values[s]], s] for s in squares if len[values[s]] > 1]
7See 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"]: pass1. 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__ = VerboseModule696
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__ = VerboseModule688 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__ = VerboseModule698 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__ = VerboseModule699 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__ = VerboseModule600
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule6
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__ = VerboseModule601, 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__ = VerboseModule602 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__ = VerboseModule690] 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]
723. 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__ = VerboseModule608 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__ = VerboseModule609 [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__ = VerboseModule608 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__ = VerboseModule611. 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__ = VerboseModule608 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__ = VerboseModule613, 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]
725If 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__ = VerboseModule608 attribute, then the class namespace is initialised as an empty ordered mapping
Xem thêm
PEP 3115 - Metaclasses in Python 3000Introduced 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__ = VerboseModule608 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__ = VerboseModule617. 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__ = VerboseModule618 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"]: pass22 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__ = VerboseModule620 [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__ = VerboseModule608]
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__ = VerboseModule622.
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass22 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"]: pass22 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__ = VerboseModule625. 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__ = VerboseModule622 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"]: pass22 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__ = VerboseModule628 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__ = VerboseModule629 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"]: pass89 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__ = VerboseModule601, 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__ = VerboseModule629, the following additional customization steps are invoked after creating the class object
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 aimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[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;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;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__ = VerboseModule629, 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__ = VerboseModule19 attribute of the class object
Xem thêm
PEP 3135 - New superDescribes 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"]: pass22 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__ = VerboseModule640 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__ = VerboseModule641 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__ = VerboseModule642 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 ABCsclass. __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__ = VerboseModule643class. __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__ = VerboseModule644
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 ClassesIncludes 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__ = VerboseModule640 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__ = VerboseModule641 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__ = VerboseModule647 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__ = VerboseModule648, 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__ = VerboseModule649 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__ = VerboseModule650 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__ = VerboseModule651 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 HintsIntroducing Python’s framework for type annotations
Các loại bí danh chungTà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 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__ = VerboseModule653
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__ = VerboseModule654phươ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__ = VerboseModule654 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__ = VerboseModule663 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__ = VerboseModule654 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__ = VerboseModule654 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__ = VerboseModule653, 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__ = VerboseModule654
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__ = VerboseModule654 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__ = VerboseModule654 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__ = VerboseModule654 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__ = VerboseModule654 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__ = VerboseModule666, 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__ = VerboseModule654 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__ = VerboseModule6
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__ = VerboseModule601 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__ = VerboseModule601 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__ = VerboseModule650,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule673 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__ = VerboseModule674 đề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__ = VerboseModule654.
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule6
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__ = VerboseModule677 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"]: pass6
Xem thêm
PEP 560 - Hỗ trợ cốt lõi để nhập mô-đun và các loại chungIntroducing
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule654, 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__ = VerboseModule654 being called instead of
d2, = values[s] ## values[s] is a string and at this point len[values[s]] is 1
6063. 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__ = VerboseModule683 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__ = VerboseModule684] 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__ = VerboseModule685], 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__ = VerboseModule686 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__ = VerboseModule687 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__ = VerboseModule688,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule689,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule690,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule691,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule692,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule693,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule694,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule695,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule696, 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__ = VerboseModule697 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__ = VerboseModule678 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__ = VerboseModule699 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__ = VerboseModule600 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__ = VerboseModule602,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule603, 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__ = VerboseModule688. 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__ = VerboseModule605,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule606,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule607,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule608,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule609,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule694,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule611,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule612 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__ = VerboseModule613, 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__ = VerboseModule651 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__ = VerboseModule615,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule616,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule617,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule618,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule619 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__ = VerboseModule620 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__ = VerboseModule621 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__ = VerboseModule622 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__ = VerboseModule622 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__ = VerboseModule62. 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__ = VerboseModule69 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 contextCPython 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__ = VerboseModule630. 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__ = VerboseModule630 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__ = VerboseModule62] 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__ = VerboseModule633. 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__ = VerboseModule633 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 methodobject. __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__ = VerboseModule636. 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__ = VerboseModule69 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__ = VerboseModule639 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"]: pass6
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__ = VerboseModule0
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
68object. __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__ = VerboseModule641. 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__ = VerboseModule644 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__ = VerboseModule645 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__ = VerboseModule646 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__ = VerboseModule644 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__ = VerboseModule654 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__ = VerboseModule641. 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 methodobject. __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__ = VerboseModule641. 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 methodobject. __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__ = VerboseModule641 for dict subclasses when key is not in the dictionaryobject. __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.
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__ = VerboseModule659 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__ = VerboseModule660 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__ = VerboseModule659 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__ = VerboseModule660 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__ = VerboseModule659
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__ = VerboseModule622 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__ = VerboseModule667] 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 iterableobject. __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__ = VerboseModule621, 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__ = VerboseModule671,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule672,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule673,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule674,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule675,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule676,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule677,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule678,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule679,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule680,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule681,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule682,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule683,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule684,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule685]. 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__ = VerboseModule686, 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__ = VerboseModule615, 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__ = VerboseModule688 đượ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__ = VerboseModule689 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__ = VerboseModule690 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__ = VerboseModule691; 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__ = VerboseModule692. 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__ = VerboseModule693 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__ = VerboseModule679 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__ = VerboseModule671,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule672,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule673,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule674,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule675,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule676,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule677,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule678,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule679,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule680,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule681,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule682,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule683,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule684,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule685] 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"]: pass611, 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"]: pass612 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"]: pass613 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"]: pass614 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__ = VerboseModule679 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"]: pass616 [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"]: pass617,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass618,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass619,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass620,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass621,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass622,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass623,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass624,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass625,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass626,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass627,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass628,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass629]. 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__ = VerboseModule617 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"]: pass631 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"]: pass632 . 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"]: pass633 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"]: pass634 đượ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__ = VerboseModule686. 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__ = VerboseModule672,
import sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule671,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass638 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"]: pass639]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"]: pass640,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass641 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"]: pass642. 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"]: pass643, 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"]: pass644,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass645 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"]: pass646 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"]: pass647,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass648 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"]: pass649 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"]: pass641,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass642 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"]: pass640 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"]: pass653đố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"]: pass654 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__ = VerboseModule72 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"]: pass656,
class Philosopher: def __init_subclass__[cls, /, default_name, **kwargs]: super[].__init_subclass__[**kwargs] cls.default_name = default_name class AustralianPhilosopher[Philosopher, default_name="Bruce"]: pass657 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"]: pass658. 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"]: pass659 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"]: pass660 [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"]: pass641 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"]: pass663 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"]: pass647 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"]: pass653 đề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"]: pass641 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"]: pass663 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"]: pass8. 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"]: pass8 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"]: pass8 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"]: pass671 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
68Nế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"]: pass673 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"]: pass8 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"]: pass675 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__ = VerboseModule698. Để 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"]: pass677
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"]: pass678 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"]: pass679 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"]: pass675 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"]: pass681. 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úcThô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"]: pass683
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__ = VerboseModule1
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ạiimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule2
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__ = VerboseModule3
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ượngimport sys from types import ModuleType class VerboseModule[ModuleType]: def __repr__[self]: return f'Verbose {self.__name__}' def __setattr__[self, attr, value]: print[f'Setting {attr}...'] super[].__setattr__[attr, value] sys.modules[__name__].__class__ = VerboseModule4
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"]: pass688 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__ = VerboseModule59 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"]: pass690 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"]: pass688. 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"]: pass692 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__ = VerboseModule60.
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"]: pass694, 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"]: pass695] 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"]: pass688 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__ = VerboseModule58 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__ = VerboseModule58 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"]: pass89 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"]: pass688. 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"]: pass604 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__ = VerboseModule58, 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"]: pass688 return value, described abovecoroutine. 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"]: pass607 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__ = VerboseModule58, 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"]: pass688 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ọiquy 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"]: pass5 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"]: pass611 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"]: pass612 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__ = VerboseModule62object. __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__ = VerboseModule69 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__ = VerboseModule5
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"]: pass615 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"]: pass615 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 error3. 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"]: pass618 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"]: pass619 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__ = VerboseModule61đố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"]: pass621, đ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"]: pass673, đ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__ = VerboseModule6
New in version 3. 5
chú thích
1Trong 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.
2The
_,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__ = VerboseModule660, 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__ = VerboseModule621 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 callable3“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__ = VerboseModule615 - 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