search

Hướng dẫn chaining ternary operators python - chuỗi các toán tử bậc ba python

Ngày đăng: 11/11/2022
Trả lời: 0
Lượt xem: 157

Can we chain the ternary operator in Python? We can do it for multiple 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
5 conditions in Java. Can that be done in Python too?

Show

Hướng dẫn chaining ternary operators python - chuỗi các toán tử bậc ba python

Anakhand

2,58717 silver badges42 bronze badges17 silver badges42 bronze badges

asked Jun 21, 2020 at 15:39Jun 21, 2020 at 15:39

O_KO_KO_K

6727 silver badges12 bronze badges7 silver badges12 bronze badges

4

1 Answer

Yes.

x = 'x' if 1<0 else 'y' if 0<1 else 'z'

answered Jun 21, 2020 at 15:49Jun 21, 2020 at 15:49

Hướng dẫn chaining ternary operators python - chuỗi các toán tử bậc ba python

khelwoodkhelwoodkhelwood

53.4k13 gold badges80 silver badges101 bronze badges13 gold badges80 silver badges101 bronze badges

0

Chương này giải thích ý nghĩa của các yếu tố của biểu thức trong Python.

Ghi chú cú pháp: Trong các chương này và các chương sau, ký hiệu BNF mở rộng sẽ được sử dụng để mô tả cú pháp, không phải phân tích từ vựng. Khi (một thay thế) một quy tắc cú pháp có biểu mẫu In this and the following chapters, extended BNF notation will be used to describe syntax, not lexical analysis. When (one alternative of) a syntax rule has the form

name ::=  othername

Và không có ngữ nghĩa nào được đưa ra, ngữ nghĩa của hình thức 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
6 này giống như đối với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
7.

6.1. Chuyển đổi số họcArithmetic conversions¶

Khi một mô tả về toán tử số học bên dưới sử dụng cụm từ, các đối số số được chuyển đổi thành một loại chung, điều này có nghĩa là việc triển khai toán tử cho các loại tích hợp hoạt động như sau:

  • Nếu một trong hai đối số là một số phức, thì cái còn lại được chuyển đổi thành phức tạp;

  • Mặt khác, nếu một trong hai đối số là một số điểm nổi, thì một đối số khác được chuyển đổi thành điểm nổi;

  • Nếu không, cả hai phải là số nguyên và không cần chuyển đổi.

Một số quy tắc bổ sung áp dụng cho các toán tử nhất định (ví dụ: một chuỗi là đối số bên trái cho toán tử ‘%,). Phần mở rộng phải xác định hành vi chuyển đổi của riêng họ.

6.2. Nguyên tửAtoms¶

Các nguyên tử là các yếu tố cơ bản nhất của biểu thức. Các nguyên tử đơn giản nhất là định danh hoặc nghĩa đen. Các hình thức được bao bọc trong ngoặc đơn, ngoặc hoặc niềng răng cũng được phân loại theo cách cú pháp như các nguyên tử. Cú pháp cho các nguyên tử là:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom

6.2.1. Định danh (tên)Identifiers (Names)¶

Một định danh xảy ra dưới dạng nguyên tử là một tên. Xem phần Định danh và các từ khóa để định nghĩa từ vựng và đặt tên phần và ràng buộc để tài liệu đặt tên và ràng buộc.Identifiers and keywords for lexical definition and section Naming and binding for documentation of naming and binding.

Khi tên bị ràng buộc với một đối tượng, việc đánh giá nguyên tử mang lại đối tượng đó. Khi một tên không bị ràng buộc, một nỗ lực để đánh giá nó sẽ tăng ngoại lệ 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
8.

Tên riêng biệt mang tính: Khi một định danh xảy ra theo văn bản trong một định nghĩa lớp bắt đầu với hai hoặc nhiều ký tự dấu gạch dưới và không kết thúc trong hai hoặc nhiều dấu gạch dưới, nó được coi là một tên riêng của lớp đó. Tên riêng được chuyển đổi thành một dạng dài hơn trước khi mã được tạo cho chúng. Biến đổi chèn tên lớp, với các dấu gạch dưới hàng đầu được xóa và một dấu gạch dưới được chèn, trước tên. Ví dụ, định danh 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
9 xảy ra trong một lớp có tên 
parenth_form ::=  "(" [starred_expression] ")"
0 sẽ được chuyển đổi thành 
parenth_form ::=  "(" [starred_expression] ")"
1. Sự biến đổi này độc lập với bối cảnh cú pháp trong đó định danh được sử dụng. Nếu tên được chuyển đổi cực kỳ dài (dài hơn 255 ký tự), việc thực hiện cắt ngắn được xác định có thể xảy ra. Nếu tên lớp chỉ bao gồm dấu gạch dưới, không có sự chuyển đổi nào được thực hiện. When an identifier that textually occurs in a class definition begins with two or more underscore characters and does not end in two or more underscores, it is considered a private name of that class. Private names are transformed to a longer form before code is generated for them. The transformation inserts the class name, with leading underscores removed and a single underscore inserted, in front of the name. For example, the identifier 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
9 occurring in a class named 
parenth_form ::=  "(" [starred_expression] ")"
0 will be transformed to 
parenth_form ::=  "(" [starred_expression] ")"
1. This transformation is independent of the syntactical context in which the identifier is used. If the transformed name is extremely long (longer than 255 characters), implementation defined truncation may happen. If the class name consists only of underscores, no transformation is done.

6.2.2. Theo nghĩa chữLiterals¶

Python hỗ trợ chuỗi và byte chữ và các chữ số khác nhau:

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber

Đánh giá một nghĩa đen mang lại một đối tượng của loại đã cho (chuỗi, byte, số nguyên, số điểm nổi, số phức) với giá trị đã cho. Giá trị có thể được xấp xỉ trong trường hợp dấu phẩy động và nghĩa đen (phức tạp). Xem phần Bình luận để biết chi tiết.Literals for details.

Tất cả các chữ tương ứng với các loại dữ liệu bất biến và do đó, nhận dạng đối tượng ít quan trọng hơn giá trị của nó. Nhiều đánh giá của các nghĩa đen có cùng một giá trị (cùng một sự xuất hiện trong văn bản chương trình hoặc một sự xuất hiện khác nhau) có thể có được cùng một đối tượng hoặc một đối tượng khác với cùng một giá trị.

6.2.3. Hình thức ngoặc đơnParenthesized forms¶

Một hình thức ngoặc đơn là một danh sách biểu thức tùy chọn được đặt trong ngoặc đơn:

parenth_form ::=  "(" [starred_expression] ")"

Một danh sách biểu thức được đặt dấu ngoặc đơn mang lại bất cứ điều gì mà danh sách biểu thức đó mang lại: Nếu danh sách chứa ít nhất một dấu phẩy, nó sẽ mang lại một tuple; Mặt khác, nó mang lại biểu thức duy nhất tạo nên danh sách biểu thức.

Một cặp dấu ngoặc đơn trống mang lại một đối tượng Tuple trống. Vì các bộ dữ liệu là bất biến, các quy tắc tương tự như đối với các nghĩa đen được áp dụng (nghĩa là, hai lần xuất hiện của tuple trống có thể hoặc không thể mang lại cùng một đối tượng).

Lưu ý rằng các bộ dữ liệu không được hình thành bởi dấu ngoặc đơn, mà là bằng cách sử dụng dấu phẩy. Ngoại lệ là bộ tuple trống, trong đó các dấu ngoặc đơn được yêu cầu - cho phép không có gì không được khám phá, không có gì trong các biểu thức sẽ gây ra sự mơ hồ và cho phép các lỗi chính tả phổ biến vượt qua.

6.2.4. Hiển thị danh sách, bộ và từ điểnDisplays for lists, sets and dictionaries¶

Để xây dựng một danh sách, một tập hợp hoặc một python từ điển cung cấp cú pháp đặc biệt có tên là Display Display, mỗi bộ trong số chúng trong hai hương vị:

  • Nội dung container được liệt kê rõ ràng hoặc

  • Chúng được tính toán thông qua một tập hợp các hướng dẫn lặp và lọc, được gọi là sự hiểu biết.

Các yếu tố cú pháp chung cho sự hiểu biết là:

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]

Độ hiểu hiểu bao gồm một biểu thức duy nhất theo sau là ít nhất một mệnh đề 

parenth_form ::=  "(" [starred_expression] ")"
2 và 0 hoặc nhiều hơn 
parenth_form ::=  "(" [starred_expression] ")"
2 hoặc 
parenth_form ::=  "(" [starred_expression] ")"
4. Trong trường hợp này, các phần tử của container mới là các phần tử sẽ được sản xuất bằng cách xem xét từng điều khoản 
parenth_form ::=  "(" [starred_expression] ")"
2 hoặc 
parenth_form ::=  "(" [starred_expression] ")"
4, làm tổ từ trái sang phải và đánh giá biểu thức để tạo ra một phần tử mỗi lần đạt được khối trong cùng.

Tuy nhiên, ngoài biểu thức có thể lặp lại trong mệnh đề 

parenth_form ::=  "(" [starred_expression] ")"
2 ngoài cùng bên trái, sự hiểu biết được thực hiện trong một phạm vi được lồng nhau riêng biệt. Điều này đảm bảo rằng các tên được gán cho trong danh sách mục tiêu don lồng rò rỉ vào phạm vi kèm theo.

Biểu thức có thể lặp lại trong mệnh đề 

parenth_form ::=  "(" [starred_expression] ")"
2 ngoài cùng bên trái được đánh giá trực tiếp trong phạm vi kèm theo và sau đó được chuyển làm đối số cho phạm vi lồng nhau ngầm. Các mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 sau đó và bất kỳ điều kiện lọc nào trong mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 ngoài cùng bên trái không thể được đánh giá trong phạm vi kèm theo vì chúng có thể phụ thuộc vào các giá trị thu được từ điều đáng thể bên trái. Ví dụ: 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
1.

Để đảm bảo sự hiểu biết luôn dẫn đến một thùng chứa thuộc loại thích hợp, các biểu thức 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 và 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3 bị cấm trong phạm vi lồng nhau ngầm.

Vì Python 3.6, trong hàm 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4, một mệnh đề 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 có thể được sử dụng để lặp qua một trình lặp không đồng bộ. Sự hiểu biết trong hàm 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 có thể bao gồm một mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 hoặc 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 theo biểu thức hàng đầu, có thể chứa các mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 hoặc 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 bổ sung và cũng có thể sử dụng các biểu thức 
list_display ::=  "[" [starred_list | comprehension] "]"
1. Nếu một sự hiểu biết chứa các điều khoản 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 hoặc các biểu thức 
list_display ::=  "[" [starred_list | comprehension] "]"
1 hoặc các hình thức không đồng bộ khác, nó được gọi là một sự hiểu biết không đồng bộ. Một sự hiểu biết không đồng bộ có thể đình chỉ việc thực hiện chức năng coroutine trong đó nó xuất hiện. Xem thêm Pep 530.asynchronous iterator. A comprehension in an 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 function may consist of either a 
parenth_form ::=  "(" [starred_expression] ")"
2 or 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 clause following the leading expression, may contain additional 
parenth_form ::=  "(" [starred_expression] ")"
2 or 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 clauses, and may also use 
list_display ::=  "[" [starred_list | comprehension] "]"
1 expressions. If a comprehension contains either 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 clauses or 
list_display ::=  "[" [starred_list | comprehension] "]"
1 expressions or other asynchronous comprehensions it is called an asynchronous comprehension. An asynchronous comprehension may suspend the execution of the coroutine function in which it appears. See also PEP 530.

Mới trong Phiên bản 3.6: Sự toàn diện không đồng bộ đã được giới thiệu.Asynchronous comprehensions were introduced.

Đã thay đổi trong phiên bản 3.8: 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 và 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3 bị cấm trong phạm vi lồng nhau ngầm.
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 and 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3 prohibited in the implicitly nested scope.

Đã thay đổi trong phiên bản 3.11: Các toàn diện không đồng bộ hiện được cho phép bên trong sự hiểu biết trong các hàm không đồng bộ. Sự hiểu biết bên ngoài ngầm trở nên không đồng bộ.Asynchronous comprehensions are now allowed inside comprehensions in asynchronous functions. Outer comprehensions implicitly become asynchronous.

6.2.5. Danh sách hiển thịList displays¶

Màn hình danh sách là một loạt các biểu thức có thể trống được đặt trong ngoặc vuông:

list_display ::=  "[" [starred_list | comprehension] "]"

Hiển thị danh sách mang lại một đối tượng danh sách mới, nội dung được chỉ định bởi một danh sách các biểu thức hoặc sự hiểu biết. Khi một danh sách các biểu thức được phân tách bằng dấu phẩy được cung cấp, các yếu tố của nó được đánh giá từ trái sang phải và được đặt vào đối tượng danh sách theo thứ tự đó. Khi một sự hiểu biết được cung cấp, danh sách được xây dựng từ các yếu tố do sự hiểu biết.

6.2.6. Đặt màn hình hiển thịSet displays¶

Một màn hình tập hợp được biểu thị bằng niềng răng xoăn và có thể phân biệt với màn hình từ điển bằng cách thiếu các dấu chấm phân tách các khóa và giá trị:

set_display ::=  "{" (starred_list | comprehension) "}"

Hiển thị tập hợp mang lại một đối tượng SET có thể thay đổi mới, các nội dung được chỉ định bởi một chuỗi các biểu thức hoặc sự hiểu biết. Khi một danh sách các biểu thức được phân tách bằng dấu phẩy được cung cấp, các yếu tố của nó được đánh giá từ trái sang phải và được thêm vào đối tượng đã đặt. Khi một sự hiểu biết được cung cấp, tập hợp được xây dựng từ các yếu tố do sự hiểu biết.

Một tập hợp trống không thể được xây dựng với 

list_display ::=  "[" [starred_list | comprehension] "]"
6; Điều này xây dựng một từ điển trống.

6.2.7. Dictionary Hiển thịDictionary displays¶

Màn hình từ điển là một loạt các cặp khóa/dữ liệu có thể được đặt trong niềng răng xoăn:

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for

Một màn hình từ điển mang lại một đối tượng từ điển mới.

Nếu một chuỗi được phân tách bằng dấu phẩy được đưa ra, chúng được đánh giá từ trái sang phải để xác định các mục của từ điển: mỗi đối tượng khóa được sử dụng làm khóa vào từ điển để lưu trữ mốc dữ liệu tương ứng. Điều này có nghĩa là bạn có thể chỉ định cùng một khóa nhiều lần trong danh sách khóa/mốc và giá trị từ điển cuối cùng cho khóa đó sẽ là cái cuối cùng được đưa ra.

Một dấu hoa thị kép 

list_display ::=  "[" [starred_list | comprehension] "]"
7 biểu thị từ điển giải nén. Toán tử của nó phải là một bản đồ. Mỗi mục ánh xạ được thêm vào từ điển mới. Các giá trị sau này thay thế các giá trị đã được đặt bởi các cặp khóa/dữ liệu trước đó và giải nén từ điển trước đó.mapping. Each mapping item is added to the new dictionary. Later values replace values already set by earlier key/datum pairs and earlier dictionary unpackings.

Mới trong phiên bản 3.5: Giải nén vào màn hình từ điển, ban đầu được đề xuất bởi PEP 448.Unpacking into dictionary displays, originally proposed by PEP 448.

Một sự hiểu biết chính thống, trái ngược với danh sách và thiết lập sự hiểu biết, cần hai biểu thức được phân tách bằng một dấu hai chấm, theo sau là thông thường cho đối với các điều khoản và các điều khoản. Khi sự hiểu biết được chạy, các phần tử giá trị và khóa kết quả được chèn trong từ điển mới theo thứ tự chúng được sản xuất.

Hạn chế đối với các loại giá trị chính được liệt kê trước đó trong phần phân cấp loại tiêu chuẩn. . Datum cuối cùng (về mặt văn bản bên phải trong màn hình) được lưu trữ cho một giá trị khóa nhất đã chiếm ưu thế.The standard type hierarchy. (To summarize, the key type should be hashable, which excludes all mutable objects.) Clashes between duplicate keys are not detected; the last datum (textually rightmost in the display) stored for a given key value prevails.

Đã thay đổi trong phiên bản 3.8: Trước Python 3.8, theo trình độ của Dict, thứ tự đánh giá của khóa và giá trị không được xác định rõ. Trong CPython, giá trị được đánh giá trước khóa. Bắt đầu với 3,8, khóa được đánh giá trước giá trị, theo đề xuất của PEP 572.Prior to Python 3.8, in dict comprehensions, the evaluation order of key and value was not well-defined. In CPython, the value was evaluated before the key. Starting with 3.8, the key is evaluated before the value, as proposed by PEP 572.

6.2.8. Biểu thức máy phátGenerator expressions¶

Biểu thức máy phát là ký hiệu máy phát điện compact trong ngoặc đơn:

generator_expression ::=  "(" expression comp_for ")"

Một biểu thức máy phát mang lại một đối tượng máy phát mới. Cú pháp của nó giống như đối với các toàn bộ, ngoại trừ việc nó được đặt trong ngoặc đơn thay vì dấu ngoặc hoặc niềng răng xoăn.

Các biến được sử dụng trong biểu thức máy phát được đánh giá một cách lười biếng khi phương thức 

list_display ::=  "[" [starred_list | comprehension] "]"
8 được gọi cho đối tượng Trình tạo (theo kiểu tương tự như các trình tạo bình thường). Tuy nhiên, biểu thức có thể lặp lại trong mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 ngoài cùng bên trái được đánh giá ngay lập tức, do đó một lỗi được tạo ra sẽ được phát ra tại điểm xác định biểu thức máy phát, thay vì tại điểm lấy lại giá trị đầu tiên. Các mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 sau đó và bất kỳ điều kiện lọc nào trong mệnh đề 
parenth_form ::=  "(" [starred_expression] ")"
2 ngoài cùng bên trái không thể được đánh giá trong phạm vi kèm theo vì chúng có thể phụ thuộc vào các giá trị thu được từ điều đáng thể bên trái. Ví dụ: 
set_display ::=  "{" (starred_list | comprehension) "}"
2.

Các dấu ngoặc đơn có thể được bỏ qua trong các cuộc gọi chỉ với một đối số. Xem phần gọi để biết chi tiết.Calls for details.

Để tránh can thiệp vào hoạt động dự kiến ​​của biểu thức máy phát, các biểu thức 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 và 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3 bị cấm trong trình tạo được xác định ngầm.

Nếu một biểu thức máy phát chứa các biểu thức 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 hoặc 
list_display ::=  "[" [starred_list | comprehension] "]"
1, nó được gọi là biểu thức máy phát không đồng bộ. Một biểu thức máy phát không đồng bộ trả về một đối tượng máy phát không đồng bộ mới, đây là một trình lặp không đồng bộ (xem iterator không đồng bộ).Asynchronous Iterators).

Mới trong phiên bản 3.6: Biểu thức tạo không đồng bộ đã được giới thiệu.Asynchronous generator expressions were introduced.

Đã thay đổi trong phiên bản 3.7: Trước Python 3.7, các biểu thức tạo không đồng bộ chỉ có thể xuất hiện trong 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 Coroutines. Bắt đầu với 3.7, bất kỳ chức năng nào cũng có thể sử dụng các biểu thức máy phát không đồng bộ.Prior to Python 3.7, asynchronous generator expressions could only appear in 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 coroutines. Starting with 3.7, any function can use asynchronous generator expressions.

Đã thay đổi trong phiên bản 3.8: 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 và 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3 bị cấm trong phạm vi lồng nhau ngầm.
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 and 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3 prohibited in the implicitly nested scope.

6.2.9. Năng lượng biểu thức năng suấtYield expressions¶

name ::=  othername
0

Biểu thức năng suất được sử dụng khi xác định hàm tạo hoặc hàm tạo không đồng bộ và do đó chỉ có thể được sử dụng trong phần thân của định nghĩa hàm. Sử dụng biểu thức năng suất trong cơ thể chức năng, làm cho chức năng đó là chức năng của trình tạo và sử dụng nó trong cơ thể 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 Body khiến chức năng coroutine đó là một hàm tạo không đồng bộ. Ví dụ:generator function or an asynchronous generator function and thus can only be used in the body of a function definition. Using a yield expression in a function’s body causes that function to be a generator function, and using it in an 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 function’s body causes that coroutine function to be an asynchronous generator function. For example:

name ::=  othername
1

Do tác dụng phụ của chúng đối với phạm vi chứa, các biểu thức 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 không được phép là một phần của phạm vi được xác định ngầm được sử dụng để thực hiện các biểu thức toàn diện và trình tạo.

Đã thay đổi trong phiên bản 3.8: Các biểu thức năng suất bị cấm trong các phạm vi lồng nhau ngầm được sử dụng để thực hiện các biểu thức toàn diện và trình tạo.Yield expressions prohibited in the implicitly nested scopes used to implement comprehensions and generator expressions.

Các chức năng của máy phát được mô tả dưới đây, trong khi các hàm máy phát không đồng bộ được mô tả riêng biệt trong phần Các hàm máy phát không đồng bộ.Asynchronous generator functions.

Khi một hàm máy phát được gọi, nó sẽ trả về một trình lặp được gọi là trình tạo. Trình tạo đó sau đó kiểm soát việc thực thi hàm máy phát. Việc thực hiện bắt đầu khi một trong các phương thức của máy phát điện được gọi. Vào thời điểm đó, việc thực hiện tiến hành biểu thức năng suất đầu tiên, trong đó nó bị đình chỉ một lần nữa, trả lại giá trị của 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
2 cho người gọi máy phát điện. Bằng cách đình chỉ, chúng tôi có nghĩa là tất cả các trạng thái địa phương được giữ lại, bao gồm các ràng buộc hiện tại của các biến cục bộ, con trỏ hướng dẫn, ngăn xếp đánh giá nội bộ và trạng thái của bất kỳ xử lý ngoại lệ nào. Khi thực thi được nối lại bằng cách gọi một trong các phương thức của Trình tạo, hàm có thể tiến hành chính xác như thể biểu thức năng suất chỉ là một cuộc gọi bên ngoài khác. Giá trị của biểu thức năng suất sau khi tiếp tục phụ thuộc vào phương thức tiếp tục thực thi. Nếu 
list_display ::=  "[" [starred_list | comprehension] "]"
8 được sử dụng (thường thông qua 
parenth_form ::=  "(" [starred_expression] ")"
2 hoặc 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
5 tích hợp) thì kết quả là 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6. Mặt khác, nếu 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
7 được sử dụng, thì kết quả sẽ là giá trị được truyền vào phương pháp đó.

Tất cả điều này làm cho các chức năng của máy phát khá giống với coroutines; Họ mang lại nhiều lần, họ có nhiều hơn một điểm vào và việc thực hiện của họ có thể bị đình chỉ. Sự khác biệt duy nhất là hàm máy phát không thể kiểm soát khi thực hiện nên tiếp tục sau khi nó mang lại; Điều khiển luôn được chuyển đến người gọi máy phát điện.

Biểu thức năng suất được cho phép ở bất cứ đâu trong cấu trúc 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
8. Nếu trình tạo không được nối lại trước khi nó được hoàn thiện (bằng cách đạt được số lượng tham chiếu bằng không hoặc bằng cách được thu thập rác), phương thức máy phát điện-ra ____ ____89 sẽ được gọi, cho phép bất kỳ điều khoản 
generator_expression ::=  "(" expression comp_for ")"
0 đang chờ xử lý nào.

Khi 

generator_expression ::=  "(" expression comp_for ")"
1 được sử dụng, biểu thức được cung cấp phải là một điều không thể điều chỉnh được. Các giá trị được tạo ra bởi việc lặp lại rằng IT có thể được chuyển trực tiếp cho người gọi của các phương thức máy phát điện hiện tại. Bất kỳ giá trị nào được truyền vào với 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
7 và bất kỳ trường hợp ngoại lệ nào được truyền vào với 
generator_expression ::=  "(" expression comp_for ")"
3 đều được truyền cho trình lặp cơ bản nếu nó có các phương thức thích hợp. Nếu đây không phải là trường hợp, thì 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
7 sẽ tăng 
generator_expression ::=  "(" expression comp_for ")"
5 hoặc 
generator_expression ::=  "(" expression comp_for ")"
6, trong khi 
generator_expression ::=  "(" expression comp_for ")"
3 sẽ chỉ tăng ngoại lệ ngay lập tức.

Khi bộ lặp cơ bản hoàn tất, thuộc tính 

generator_expression ::=  "(" expression comp_for ")"
8 của ví dụ 
generator_expression ::=  "(" expression comp_for ")"
9 được nâng lên trở thành giá trị của biểu thức năng suất. Nó có thể được đặt một cách rõ ràng khi tăng 
generator_expression ::=  "(" expression comp_for ")"
9 hoặc tự động khi trình điều khiển là một trình tạo (bằng cách trả về giá trị từ trình phân chia).

Đã thay đổi trong phiên bản 3.3: Đã thêm 

generator_expression ::=  "(" expression comp_for ")"
1 để ủy quyền luồng điều khiển cho một tiểu thư.Added 
generator_expression ::=  "(" expression comp_for ")"
1 to delegate control flow to a subiterator.

Các dấu ngoặc đơn có thể được bỏ qua khi biểu thức năng suất là biểu thức duy nhất ở phía bên phải của một câu lệnh gán.

Xem thêm

PEP 255 - Máy phát điện đơn giản - Simple Generators

Đề xuất thêm các trình tạo và tuyên bố 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
2 vào Python.

PEP 342 - Coroutines thông qua các máy phát điện nâng cao - Coroutines via Enhanced Generators

Đề xuất tăng cường API và cú pháp của các máy phát điện, làm cho chúng có thể sử dụng như các coroutines đơn giản.

PEP 380 - Cú pháp để ủy thác cho bộ chia - Syntax for Delegating to a Subgenerator

Đề xuất giới thiệu cú pháp 

name ::=  othername
03, giúp phái đoàn trở nên dễ dàng.

PEP 525 - Máy phát điện không đồng bộ - Asynchronous Generators

Đề xuất mở rộng trên PEP 492 bằng cách thêm các khả năng của máy phát vào các chức năng coroutine.PEP 492 by adding generator capabilities to coroutine functions.

6.2.9.1. Phương pháp máy phát điệnGenerator-iterator methods¶

Tiểu mục này mô tả các phương thức của một trình lặp máy phát. Chúng có thể được sử dụng để kiểm soát việc thực hiện hàm máy phát.

Lưu ý rằng việc gọi bất kỳ phương thức trình tạo nào bên dưới khi trình tạo đã thực thi tăng ngoại lệ 

name ::=  othername
04.

Máy phát điện .__ Tiếp theo __ ()__next__()

Bắt đầu thực thi hàm trình tạo hoặc tiếp tục nó ở biểu thức năng suất được thực hiện cuối cùng. Khi một hàm máy phát được nối lại với phương thức 

list_display ::=  "[" [starred_list | comprehension] "]"
8, biểu thức năng suất hiện tại luôn đánh giá thành 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6. Việc thực hiện sau đó tiếp tục đến biểu thức năng suất tiếp theo, trong đó trình tạo bị treo trở lại và giá trị của 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
2 được trả lại cho người gọi ____ ____ 68. Nếu máy phát thoát ra mà không mang lại giá trị khác, ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
9 sẽ được nâng lên.

Phương pháp này thường được gọi là ngầm, ví dụ: bởi một vòng lặp 

parenth_form ::=  "(" [starred_expression] ")"
2, hoặc bằng hàm 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
5 tích hợp.

Generator.Send (Giá trị) ¶send(value)

Tiếp tục thực thi và người hâm mộ gửi một giá trị vào hàm trình tạo. Đối số giá trị trở thành kết quả của biểu thức năng suất hiện tại. Phương thức 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
7 trả về giá trị tiếp theo được tạo bởi trình tạo hoặc tăng 
generator_expression ::=  "(" expression comp_for ")"
9 nếu trình tạo thoát ra mà không mang lại giá trị khác. Khi 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
7 được gọi để khởi động trình tạo, nó phải được gọi bằng 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6 làm đối số, bởi vì không có biểu thức năng suất nào có thể nhận được giá trị.

Generator.throw (Giá trị) ¶erator.throw (loại [, value [, tracback]]))throw(value)generator.throw(type[, value[, traceback]])

Tăng một ngoại lệ tại điểm mà máy phát được tạm dừng và trả về giá trị tiếp theo được mang lại bởi hàm máy phát. Nếu máy phát thoát ra mà không mang lại giá trị khác, ngoại lệ 

generator_expression ::=  "(" expression comp_for ")"
9 sẽ được nâng lên. Nếu chức năng trình tạo không bắt được ngoại lệ được truyền, hoặc tăng một ngoại lệ khác, thì ngoại lệ đó sẽ truyền cho người gọi.

Trong sử dụng điển hình, điều này được gọi với một trường hợp ngoại lệ duy nhất tương tự như cách sử dụng từ khóa 

name ::=  othername
17.

Tuy nhiên, đối với khả năng tương thích ngược, chữ ký thứ hai được hỗ trợ, theo một quy ước từ các phiên bản cũ của Python. Đối số loại phải là một lớp ngoại lệ và giá trị phải là một thể hiện ngoại lệ. Nếu giá trị không được cung cấp, hàm tạo loại được gọi để có được một thể hiện. Nếu TraceBack được cung cấp, nó được đặt trên ngoại lệ, nếu không, bất kỳ thuộc tính 

name ::=  othername
18 hiện có nào được lưu trữ trong giá trị có thể được xóa.

máy phát điện.close () ¶close()

Tăng 

name ::=  othername
19 tại điểm mà hàm máy phát được tạm dừng. Nếu hàm máy phát thì thoát ra một cách duyên dáng, đã bị đóng hoặc tăng 
name ::=  othername
19 (bằng cách không bắt được ngoại lệ), hãy đóng trả về cho người gọi của nó. Nếu trình tạo mang lại một giá trị, một 
name ::=  othername
21 sẽ được nâng lên. Nếu trình tạo tăng bất kỳ ngoại lệ nào khác, nó sẽ được truyền đến người gọi. 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
9 không làm gì nếu trình tạo đã thoát do ngoại lệ hoặc lối thoát bình thường.

6.2.9.2. Ví dụ;Examples¶

Dưới đây là một ví dụ đơn giản thể hiện hành vi của các trình tạo và hàm máy phát:

name ::=  othername
2

Để biết các ví dụ sử dụng 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
3, hãy xem PEP 380: Cú pháp để ủy thác cho một trình phân chia trong trò chơi What What New In Python.PEP 380: Syntax for Delegating to a Subgenerator in “What’s New in Python.”

6.2.9.3. Chức năng máy phát không đồng bộAsynchronous generator functions¶

Sự hiện diện của biểu thức năng suất trong hàm hoặc phương thức được xác định bằng cách sử dụng 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
4 xác định thêm hàm là hàm tạo không đồng bộ.asynchronous generator function.

Khi một hàm máy phát không đồng bộ được gọi, nó sẽ trả về một trình lặp không đồng bộ được gọi là một đối tượng máy phát không đồng bộ. Đối tượng đó sau đó kiểm soát việc thực thi hàm trình tạo. Một đối tượng máy phát không đồng bộ thường được sử dụng trong câu lệnh 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5 trong hàm coroutine tương tự như cách sử dụng đối tượng trình tạo trong câu lệnh 
parenth_form ::=  "(" [starred_expression] ")"
2.

Gọi một trong những phương thức máy phát không đồng bộ trở lại một đối tượng có thể chờ đợi và việc thực thi bắt đầu khi đối tượng này được chờ đợi. Vào thời điểm đó, việc thực hiện tiến hành biểu thức năng suất đầu tiên, trong đó nó bị đình chỉ một lần nữa, trả lại giá trị của 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
2 cho coroutine đang chờ đợi. Như với một máy phát điện, hệ thống treo có nghĩa là tất cả các trạng thái cục bộ được giữ lại, bao gồm các ràng buộc hiện tại của các biến cục bộ, con trỏ hướng dẫn, ngăn xếp đánh giá nội bộ và trạng thái của bất kỳ xử lý ngoại lệ nào. Khi việc thực thi được nối lại bằng cách chờ đối tượng tiếp theo được trả về bởi các phương thức tạo không đồng bộ, chức năng có thể tiến hành chính xác như thể biểu thức năng suất chỉ là một cuộc gọi bên ngoài khác. Giá trị của biểu thức năng suất sau khi tiếp tục phụ thuộc vào phương thức tiếp tục thực thi. Nếu 
name ::=  othername
28 được sử dụng thì kết quả là 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6. Mặt khác, nếu 
name ::=  othername
30 được sử dụng, thì kết quả sẽ là giá trị được truyền vào phương pháp đó.awaitable object, and the execution starts when this object is awaited on. At that time, the execution proceeds to the first yield expression, where it is suspended again, returning the value of 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
2 to the awaiting coroutine. As with a generator, suspension means that all local state is retained, including the current bindings of local variables, the instruction pointer, the internal evaluation stack, and the state of any exception handling. When the execution is resumed by awaiting on the next object returned by the asynchronous generator’s methods, the function can proceed exactly as if the yield expression were just another external call. The value of the yield expression after resuming depends on the method which resumed the execution. If 
name ::=  othername
28 is used then the result is 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6. Otherwise, if 
name ::=  othername
30 is used, then the result will be the value passed in to that method.

Nếu một trình tạo không đồng bộ xảy ra thoát ra sớm bằng 

name ::=  othername
31, tác vụ người gọi bị hủy hoặc các ngoại lệ khác, mã làm sạch Async của Trình tạo sẽ chạy và có thể nêu ra các ngoại lệ hoặc truy cập các biến ngữ cảnh trong bối cảnh bất ngờ có lẽ sau thời gian tồn tại của các nhiệm vụ, nó hoặc trong quá trình tắt vòng lặp sự kiện khi móc thu gom rác máy phát điện không đồng bộ được gọi. Để ngăn chặn điều này, người gọi phải đóng một cách rõ ràng trình tạo async bằng cách gọi phương thức 
name ::=  othername
32 để hoàn thiện trình tạo và cuối cùng tách nó ra khỏi vòng lặp sự kiện.

Trong hàm tạo không đồng bộ, các biểu thức năng suất được cho phép ở bất cứ đâu trong cấu trúc 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
8. Tuy nhiên, nếu một máy phát không đồng bộ không được nối lại trước khi nó được hoàn thiện (bằng cách đạt được số lượng tham chiếu bằng không hoặc bằng cách thu thập rác), thì một biểu thức năng suất trong cấu trúc 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
8 có thể dẫn đến việc không thực thi các điều khoản đang chờ xử lý. Trong trường hợp này, trách nhiệm của vòng lặp sự kiện hoặc bộ lập lịch chạy trình tạo không đồng bộ để gọi phương thức máy phát máy phát điện không đồng bộ 
name ::=  othername
32 và chạy đối tượng Coroutine kết quả, do đó cho phép bất kỳ điều khoản đang chờ xử lý nào.

Để chăm sóc việc hoàn thiện khi chấm dứt vòng lặp sự kiện, một vòng lặp sự kiện nên xác định chức năng Finalizer có trình tạo máy phát không đồng bộ và có lẽ gọi 

name ::=  othername
32 và thực hiện coroutine. Bộ kết thúc này có thể được đăng ký bằng cách gọi 
name ::=  othername
39. Khi lần đầu tiên lặp lại, một máy phát điện không đồng bộ sẽ lưu trữ bộ hoàn thiện đã đăng ký để được gọi khi hoàn thiện. Để biết ví dụ tham chiếu của phương thức Finalizer, hãy xem việc triển khai 
name ::=  othername
40 trong lib/asyncio/base_events.py.

Biểu thức 

generator_expression ::=  "(" expression comp_for ")"
1 là lỗi cú pháp khi được sử dụng trong hàm tạo không đồng bộ.

6.2.9.4. Phương pháp máy phát điện không đồng bộAsynchronous generator-iterator methods¶

Tiểu mục này mô tả các phương thức của một trình lặp máy phát không đồng bộ, được sử dụng để kiểm soát việc thực hiện hàm máy phát.

Coroutineagen .__ anext __ () ¶agen.__anext__()

Trả về một sự chờ đợi mà khi chạy bắt đầu thực thi trình tạo không đồng bộ hoặc tiếp tục nó ở biểu thức năng suất được thực hiện cuối cùng. Khi một hàm máy phát không đồng bộ được nối lại với phương thức 

name ::=  othername
28, biểu thức năng suất hiện tại luôn đánh giá thành 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6 trong phần được trả lại có thể chờ đợi, khi chạy sẽ tiếp tục đến biểu thức năng suất tiếp theo. Giá trị của 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
2 của biểu thức năng suất là giá trị của ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
9 được tăng lên bởi coroutine hoàn thành. Nếu máy phát không đồng bộ thoát ra mà không mang lại một giá trị khác, thay vào đó có thể chờ đợi là ngoại lệ 
name ::=  othername
46, báo hiệu rằng việc lặp không đồng bộ đã hoàn thành.

Phương pháp này thường được gọi là ngầm bằng một vòng 

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
5.

coroutineagen.asend (giá trị) ¶ agen.asend(value)

Trả về một sự chờ đợi, khi chạy tiếp tục thực hiện trình tạo không đồng bộ. Như với phương thức 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
7 cho một trình tạo, điều này sẽ gửi một giá trị vào hàm trình tạo không đồng bộ và đối số giá trị trở thành kết quả của biểu thức năng suất hiện tại. Việc chờ được trả về bằng phương thức 
name ::=  othername
30 sẽ trả về giá trị tiếp theo được tạo bởi trình tạo dưới dạng giá trị của 
generator_expression ::=  "(" expression comp_for ")"
9 được nâng lên hoặc tăng 
name ::=  othername
46 nếu trình tạo không đồng bộ thoát ra mà không mang lại giá trị khác. Khi 
name ::=  othername
30 được gọi để khởi động trình tạo không đồng bộ, nó phải được gọi bằng 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6 làm đối số, bởi vì không có biểu thức năng suất nào có thể nhận được giá trị.

coroutineagen.athrow (loại [, value [, traceback]]) ¶ agen.athrow(type[, value[, traceback]])

Trả về một sự chờ đợi có thể làm tăng ngoại lệ của loại 

name ::=  othername
54 tại điểm mà bộ tạo không đồng bộ được tạm dừng và trả về giá trị tiếp theo được mang lại bởi hàm máy phát là giá trị của ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
9 tăng. Nếu máy phát không đồng bộ thoát ra mà không mang lại giá trị khác, ngoại lệ 
name ::=  othername
46 được nâng lên bởi sự chờ đợi. Nếu hàm máy phát không bắt được ngoại lệ được truyền, hoặc tăng một ngoại lệ khác, thì khi có thể chờ đợi được chạy, ngoại lệ sẽ truyền cho người gọi của sự chờ đợi.

coroutineagen.aclose () ¶agen.aclose()

Trả về một sự chờ đợi rằng khi chạy sẽ ném 

name ::=  othername
19 vào hàm máy phát không đồng bộ tại điểm mà nó bị tạm dừng. Nếu chức năng máy phát không đồng bộ thì thoát ra một cách duyên dáng, đã bị đóng hoặc tăng 
name ::=  othername
19 (bằng cách không bắt được ngoại lệ), thì khả năng chờ được trả lại sẽ tăng ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
9. Bất kỳ sự chờ đợi nào khác được trả lại bởi các cuộc gọi tiếp theo đến trình tạo không đồng bộ sẽ tăng ngoại lệ 
name ::=  othername
46. Nếu máy phát không đồng bộ mang lại một giá trị, một 
name ::=  othername
21 được nâng lên bởi sự chờ đợi. Nếu máy phát không đồng bộ tăng bất kỳ ngoại lệ nào khác, nó sẽ được truyền đến người gọi của người đang chờ đợi. Nếu trình tạo không đồng bộ đã thoát ra do ngoại lệ hoặc lối thoát thông thường, thì các cuộc gọi tiếp theo đến 
name ::=  othername
32 sẽ trả về một sự chờ đợi không có gì.

6.3. Nguyên thủyPrimaries¶

Các nguyên tắc đại diện cho các hoạt động ràng buộc chặt chẽ nhất của ngôn ngữ. Cú pháp của họ là:

name ::=  othername
3

6.3.1. Tài liệu tham khảo thuộc tínhAttribute references¶

Tài liệu tham khảo thuộc tính là một chính theo sau là một khoảng thời gian và một tên:

name ::=  othername
4

Chính phải đánh giá thành một đối tượng của một loại hỗ trợ các tham chiếu thuộc tính, mà hầu hết các đối tượng đều làm. Đối tượng này sau đó được yêu cầu tạo thuộc tính có tên là định danh. Sản xuất này có thể được tùy chỉnh bằng cách ghi đè phương thức 

name ::=  othername
63. Nếu thuộc tính này không có sẵn, ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
5 sẽ được nâng lên. Mặt khác, loại và giá trị của đối tượng được tạo ra được xác định bởi đối tượng. Nhiều đánh giá của cùng một tham chiếu thuộc tính có thể mang lại các đối tượng khác nhau.

6.3.2. Đăng kýSubscriptions¶

Đăng ký một thể hiện của một lớp container thường sẽ chọn một phần tử từ container. Việc đăng ký một lớp chung thường sẽ trả về một đối tượng chung.container class will generally select an element from the container. The subscription of a generic class will generally return a GenericAlias object.

name ::=  othername
5

Khi một đối tượng được đăng ký, trình thông dịch sẽ đánh giá danh sách chính và biểu thức.

Chính phải đánh giá đến một đối tượng hỗ trợ đăng ký. Một đối tượng có thể hỗ trợ đăng ký thông qua việc xác định một hoặc cả 

name ::=  othername
65 và 
name ::=  othername
66. Khi chính được đăng ký, kết quả được đánh giá của danh sách biểu thức sẽ được chuyển cho một trong những phương pháp này. Để biết thêm chi tiết về khi 
name ::=  othername
67 được gọi thay vì 
name ::=  othername
68, xem __class_getitem__ so với __getItem__.__class_getitem__ versus __getitem__.

Nếu danh sách biểu thức chứa ít nhất một dấu phẩy, nó sẽ đánh giá thành 

name ::=  othername
69 chứa các mục của danh sách biểu thức. Mặt khác, danh sách biểu thức sẽ đánh giá đến giá trị của danh sách thành viên duy nhất.

Đối với các đối tượng tích hợp, có hai loại đối tượng hỗ trợ đăng ký qua 

name ::=  othername
65:

  1. Ánh xạ. Nếu chính là ánh xạ, danh sách biểu thức phải đánh giá đến một đối tượng có giá trị là một trong các khóa của ánh xạ và đăng ký chọn giá trị trong ánh xạ tương ứng với khóa đó. Một ví dụ về lớp ánh xạ tích hợp là lớp 

    name ::=  othername
    71.mapping, the expression list must evaluate to an object whose value is one of the keys of the mapping, and the subscription selects the value in the mapping that corresponds to that key. An example of a builtin mapping class is the 
    name ::=  othername
    71 class.

  2. Trình tự. Nếu chính là một chuỗi, danh sách biểu thức phải đánh giá thành một 

    name ::=  othername
    72 hoặc 
    name ::=  othername
    73 (như được thảo luận trong phần sau). Ví dụ về các lớp trình tự xây dựng bao gồm các lớp 
    name ::=  othername
    74, 
    name ::=  othername
    75 và 
    name ::=  othername
    69.sequence, the expression list must evaluate to an 
    name ::=  othername
    72 or a 
    name ::=  othername
    73 (as discussed in the following section). Examples of builtin sequence classes include the 
    name ::=  othername
    74, 
    name ::=  othername
    75 and 
    name ::=  othername
    69 classes.

Cú pháp chính thức không cung cấp đặc biệt cho các chỉ số tiêu cực trong các chuỗi. Tuy nhiên, tất cả các chuỗi tích hợp đều cung cấp một phương thức 

name ::=  othername
65 diễn giải các chỉ số âm bằng cách thêm độ dài của chuỗi vào chỉ mục để, ví dụ, 
name ::=  othername
78 chọn mục cuối cùng của 
name ::=  othername
79. Giá trị kết quả phải là một số nguyên không âm ít hơn số lượng mục trong chuỗi và đăng ký chọn mục có chỉ số là giá trị đó (tính từ 0). Do sự hỗ trợ cho các chỉ số âm và cắt xảy ra trong phương thức đối tượng 
name ::=  othername
65, các lớp con ghi đè phương pháp này sẽ cần thêm hỗ trợ đó một cách rõ ràng.sequences. However, built-in sequences all provide a 
name ::=  othername
65 method that interprets negative indices by adding the length of the sequence to the index so that, for example, 
name ::=  othername
78 selects the last item of 
name ::=  othername
79. The resulting value must be a nonnegative integer less than the number of items in the sequence, and the subscription selects the item whose index is that value (counting from zero). Since the support for negative indices and slicing occurs in the object’s 
name ::=  othername
65 method, subclasses overriding this method will need to explicitly add that support.

Một 

name ::=  othername
81 là một loại trình tự đặc biệt có các mục là các ký tự. Một ký tự không phải là một loại dữ liệu riêng biệt mà là một chuỗi chính xác một ký tự.

6.3.3. Ngả gòSlicings¶

Việc cắt lát chọn một loạt các mục trong một đối tượng chuỗi (ví dụ: một chuỗi, tuple hoặc danh sách). Slicings có thể được sử dụng làm biểu thức hoặc làm mục tiêu trong các câu lệnh gán hoặc 

name ::=  othername
82. Cú pháp để cắt lát:

name ::=  othername
6

Có sự mơ hồ trong cú pháp chính thức ở đây: bất cứ điều gì trông giống như một danh sách biểu thức cũng trông giống như một danh sách lát cắt, vì vậy bất kỳ đăng ký nào cũng có thể được hiểu là một sự cắt lát. Thay vì làm phức tạp thêm cú pháp, điều này được định hướng bằng cách xác định rằng trong trường hợp này, việc giải thích là một thuê bao được ưu tiên so với việc giải thích như một sự cắt lát (đây là trường hợp nếu danh sách lát cắt không chứa lát cắt thích hợp).

Các ngữ nghĩa cho một sự cắt lát như sau. Chính được lập chỉ mục (sử dụng cùng một phương thức 

name ::=  othername
65 làm đăng ký bình thường) với một khóa được xây dựng từ danh sách lát cắt, như sau. Nếu danh sách lát cắt chứa ít nhất một dấu phẩy, chìa khóa là một tuple chứa việc chuyển đổi các mục lát; Mặt khác, việc chuyển đổi mục lát đơn đơn là chìa khóa. Việc chuyển đổi một mục lát cắt là một biểu thức là biểu thức đó. Việc chuyển đổi một lát cắt thích hợp là một đối tượng lát cắt (xem phần phân cấp loại tiêu chuẩn) có các thuộc tính 
name ::=  othername
84, 
name ::=  othername
85 và 
name ::=  othername
86 là các giá trị của các biểu thức được đưa ra như giới hạn dưới, giới hạn trên và sải chân, tương ứng, thay thế 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6 cho các biểu thức bị thiếu.The standard type hierarchy) whose 
name ::=  othername
84, 
name ::=  othername
85 and 
name ::=  othername
86 attributes are the values of the expressions given as lower bound, upper bound and stride, respectively, substituting 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6 for missing expressions.

6.3.4. Cuộc gọi vàCalls¶

Một cuộc gọi gọi là đối tượng có thể gọi (ví dụ: một hàm) với một loạt các đối số có thể trống:function) with a possibly empty series of arguments:

name ::=  othername
7

Một dấu phẩy theo dõi tùy chọn có thể có mặt sau các đối số vị trí và từ khóa nhưng không ảnh hưởng đến ngữ nghĩa.

Chính phải đánh giá thành một đối tượng có thể gọi được (các hàm do người dùng xác định, các hàm tích hợp, phương thức của các đối tượng tích hợp, đối tượng lớp, phương thức của các phiên bản lớp và tất cả các đối tượng có phương thức 

name ::=  othername
88 có thể gọi được). Tất cả các biểu thức đối số được đánh giá trước khi cuộc gọi được thực hiện. Vui lòng tham khảo các định nghĩa chức năng phần cho cú pháp của danh sách tham số chính thức.Function definitions for the syntax of formal parameter lists.

Nếu các đối số từ khóa có mặt, trước tiên chúng được chuyển đổi thành các đối số vị trí, như sau. Đầu tiên, một danh sách các vị trí không được lấp đầy được tạo cho các tham số chính thức. Nếu có n đối số vị trí, chúng được đặt trong n khe đầu tiên. Tiếp theo, đối với mỗi đối số từ khóa, mã định danh được sử dụng để xác định vị trí tương ứng (nếu định danh giống như tên tham số chính thức đầu tiên, khe đầu tiên được sử dụng, v.v.). Nếu khe đã được lấp đầy, ngoại lệ 

generator_expression ::=  "(" expression comp_for ")"
6 sẽ được nâng lên. Mặt khác, đối số được đặt trong khe, điền nó (ngay cả khi biểu thức là 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6, nó sẽ lấp đầy khe). Khi tất cả các đối số đã được xử lý, các vị trí vẫn chưa được lấp đầy với giá trị mặc định tương ứng từ định nghĩa hàm. (Các giá trị mặc định được tính toán, một lần, khi hàm được xác định; do đó, một đối tượng có thể thay đổi như danh sách hoặc từ điển được sử dụng làm giá trị mặc định thường được tránh.) Nếu có bất kỳ vị trí chưa được thực hiện nào mà không có giá trị mặc định được chỉ định, ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
6 được nâng lên. Mặt khác, danh sách các khe đầy được sử dụng làm danh sách đối số cho cuộc gọi.

Chi tiết triển khai CPYThon: Việc triển khai có thể cung cấp các chức năng tích hợp mà các tham số vị trí không có tên, ngay cả khi chúng được đặt tên cho mục đích của tài liệu và do đó không thể được cung cấp bởi từ khóa. Trong CPython, đây là trường hợp cho các chức năng được thực hiện trong C sử dụng 

name ::=  othername
92 để phân tích các đối số của họ. An implementation may provide built-in functions whose positional parameters do not have names, even if they are ‘named’ for the purpose of documentation, and which therefore cannot be supplied by keyword. In CPython, this is the case for functions implemented in C that use 
name ::=  othername
92 to parse their arguments.

Nếu có nhiều đối số vị trí hơn có các khe tham số chính thức, ngoại lệ 

generator_expression ::=  "(" expression comp_for ")"
6 được nâng lên, trừ khi có tham số chính thức sử dụng cú pháp 
name ::=  othername
94; Trong trường hợp này, tham số chính thức đó nhận được một tuple chứa các đối số vị trí dư thừa (hoặc một bộ rỗng nếu không có đối số vị trí dư thừa).

Nếu bất kỳ đối số từ khóa nào không tương ứng với tên tham số chính thức, ngoại lệ 

generator_expression ::=  "(" expression comp_for ")"
6 được nâng lên, trừ khi có tham số chính thức sử dụng cú pháp 
name ::=  othername
96; Trong trường hợp này, tham số chính thức đó nhận được một từ điển chứa các đối số từ khóa dư thừa (sử dụng các từ khóa làm khóa và giá trị đối số làm giá trị tương ứng) hoặc từ điển trống (mới) nếu không có đối số từ khóa dư thừa.

Nếu cú ​​pháp 

name ::=  othername
97 xuất hiện trong lệnh gọi hàm, 
name ::=  othername
98 phải đánh giá thành một điều khác. Các yếu tố từ các vòng lặp này được đối xử như thể chúng là các đối số vị trí bổ sung. Đối với cuộc gọi 
name ::=  othername
99, nếu y đánh giá theo trình tự y1, thì, ym, điều này tương đương với một cuộc gọi với các đối số vị trí m+4 x1, x2, y1, ốp, ym, x3, x4.iterable. Elements from these iterables are treated as if they were additional positional arguments. For the call 
name ::=  othername
99, if y evaluates to a sequence y1, …, yM, this is equivalent to a call with M+4 positional arguments x1, x2, y1, …, yM, x3, x4.

Hậu quả của điều này là mặc dù cú pháp 

name ::=  othername
97 có thể xuất hiện sau các đối số từ khóa rõ ràng, nhưng nó được xử lý trước các đối số từ khóa (và bất kỳ đối số 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
01 nào - xem bên dưới). Vì thế:

name ::=  othername
8

Điều không bình thường đối với cả đối số từ khóa và cú pháp 

name ::=  othername
97 sẽ được sử dụng trong cùng một cuộc gọi, vì vậy trong thực tế, sự nhầm lẫn này thường không phát sinh.

Nếu cú ​​pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
01 xuất hiện trong lệnh gọi hàm, 
name ::=  othername
98 phải đánh giá theo ánh xạ, nội dung được coi là đối số từ khóa bổ sung. Nếu một tham số khớp, một khóa đã được cung cấp một giá trị (bằng một đối số từ khóa rõ ràng hoặc từ một lần giải nén khác), ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
6 sẽ được nâng lên.mapping, the contents of which are treated as additional keyword arguments. If a parameter matching a key has already been given a value (by an explicit keyword argument, or from another unpacking), a 
generator_expression ::=  "(" expression comp_for ")"
6 exception is raised.

Khi 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
01 được sử dụng, mỗi khóa trong ánh xạ này phải là một chuỗi. Mỗi giá trị từ ánh xạ được gán cho tham số chính thức đầu tiên đủ điều kiện cho gán từ khóa có tên bằng khóa. Một khóa không cần phải là một định danh Python (ví dụ: 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
07 là chấp nhận được, mặc dù nó sẽ không khớp với bất kỳ tham số chính thức nào có thể được khai báo). Nếu không có khớp với tham số chính thức, cặp giá trị khóa được thu thập bằng tham số 
list_display ::=  "[" [starred_list | comprehension] "]"
7, nếu có, hoặc nếu không có, ngoại lệ 
generator_expression ::=  "(" expression comp_for ")"
6 được nâng lên.

Các tham số chính thức bằng cách sử dụng cú pháp 

name ::=  othername
94 hoặc 
name ::=  othername
96 không thể được sử dụng làm khe đối số vị trí hoặc làm tên đối số từ khóa.

Đã thay đổi trong phiên bản 3.5: Các cuộc gọi chức năng Chấp nhận bất kỳ số lượng nào của 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12 và 
list_display ::=  "[" [starred_list | comprehension] "]"
7 Giải nén, các đối số vị trí có thể tuân theo các khoản giải nén không thể sử dụng được (
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12) và các đối số từ khóa có thể tuân theo việc giải nén từ điển (
list_display ::=  "[" [starred_list | comprehension] "]"
7). Ban đầu được đề xuất bởi PEP 448.Function calls accept any number of 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12 and 
list_display ::=  "[" [starred_list | comprehension] "]"
7 unpackings, positional arguments may follow iterable unpackings (
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12), and keyword arguments may follow dictionary unpackings (
list_display ::=  "[" [starred_list | comprehension] "]"
7). Originally proposed by PEP 448.

Một cuộc gọi luôn trả về một số giá trị, có thể là 

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6, trừ khi nó làm tăng một ngoại lệ. Làm thế nào giá trị này được tính toán phụ thuộc vào loại đối tượng có thể gọi được.

Nếu nó là-

một chức năng do người dùng xác định:

Khối mã cho hàm được thực thi, chuyển nó theo danh sách đối số. Điều đầu tiên mà khối mã sẽ làm là liên kết các tham số chính thức với các đối số; Điều này được mô tả trong các định nghĩa chức năng phần. Khi khối mã thực thi câu lệnh 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
17, điều này chỉ định giá trị trả về của lệnh gọi hàm.Function definitions. When the code block executes a 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
17 statement, this specifies the return value of the function call.

một chức năng hoặc phương pháp tích hợp:

Kết quả là tùy thuộc vào thông dịch viên; Xem các chức năng tích hợp cho các mô tả về các chức năng và phương pháp tích hợp.Built-in Functions for the descriptions of built-in functions and methods.

Một đối tượng lớp:

Một ví dụ mới của lớp đó được trả về.

Phương thức thể hiện lớp:

Hàm do người dùng định nghĩa tương ứng được gọi, với một danh sách đối số dài hơn danh sách đối số của cuộc gọi: phiên bản trở thành đối số đầu tiên.

Một phiên bản lớp:

Lớp phải xác định phương pháp 

name ::=  othername
88; Hiệu ứng sau đó giống như khi phương pháp đó được gọi.

6.4. Đang chờ biểu thứcAwait expression¶

Đình chỉ việc thực hiện coroutine trên một đối tượng có thể chờ đợi. Chỉ có thể được sử dụng bên trong một chức năng coroutine.coroutine on an awaitable object. Can only be used inside a coroutine function.

name ::=  othername
9

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

6.5. Nhà điều hành điệnThe power operator¶

Toán tử năng lượng liên kết chặt chẽ hơn các toán tử Unary ở bên trái của nó; Nó liên kết ít chặt chẽ hơn so với các toán tử Unary ở bên phải của nó. Cú pháp là:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
0

Do đó, trong một chuỗi các toán tử năng lượng và các toán tử đơn, các toán tử được đánh giá từ phải sang trái (điều này không hạn chế thứ tự đánh giá cho các toán hạng): 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
19 dẫn đến 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
20.

Toán tử năng lượng có cùng ngữ nghĩa với hàm 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
21 tích hợp, khi được gọi với hai đối số: nó mang lại đối số bên trái của nó được nâng lên cho sức mạnh của đối số bên phải của nó. Các đối số số lần đầu tiên được chuyển đổi thành một loại chung và kết quả là loại đó.

Đối với các toán hạng INT, kết quả có cùng loại với các toán hạng trừ khi đối số thứ hai là âm; Trong trường hợp đó, tất cả các đối số được chuyển đổi thành float và kết quả nổi được phân phối. Ví dụ: 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
22 trả về 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
23, nhưng 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
24 trả về 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
25.

Tăng 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
26 lên một sức mạnh tiêu cực dẫn đến 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
27. Tăng một số âm cho một công suất phân số dẫn đến một số 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
28. (Trong các phiên bản trước, nó đã tăng 
name ::=  othername
04.)

Hoạt động này có thể được tùy chỉnh bằng phương pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
30 đặc biệt.

6.6. Các hoạt động không theo số học và bitwise khôngUnary arithmetic and bitwise operations¶

Tất cả các hoạt động số học và bitwise không có cùng ưu tiên:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
1

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
31 (trừ) không mang lại sự phủ định của đối số số của nó; Hoạt động có thể được ghi đè với phương pháp đặc biệt 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
32.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
33 (cộng) không thay đổi đối số số của nó; Hoạt động có thể được ghi đè với phương pháp đặc biệt 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
34.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
35 (đảo ngược) không mang lại sự đảo ngược bitwise của đối số số nguyên của nó. Sự đảo ngược bitwise của 
name ::=  othername
79 được định nghĩa là 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
37. Nó chỉ áp dụng cho các số tích hợp hoặc cho các đối tượng tùy chỉnh ghi đè phương thức đặc biệt 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
38.

Trong cả ba trường hợp, nếu đối số không có loại thích hợp, ngoại lệ 

generator_expression ::=  "(" expression comp_for ")"
6 sẽ được nêu ra.

6.7. Hoạt động số học nhị phânBinary arithmetic operations¶

Các hoạt động số học nhị phân có mức độ ưu tiên thông thường. Lưu ý rằng một số hoạt động này cũng áp dụng cho một số loại không phải là số. Ngoài toán tử điện, chỉ có hai cấp độ, một cấp cho các toán tử nhân và một cho toán tử phụ gia:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
2

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12 (phép nhân) mang lại sản phẩm của các đối số của nó. Các đối số phải cả hai là số hoặc một đối số phải là một số nguyên và một đối số phải là một chuỗi. Trong trường hợp trước, các số được chuyển đổi thành một loại chung và sau đó nhân với nhau. Trong trường hợp sau, sự lặp lại trình tự được thực hiện; Một yếu tố lặp lại tiêu cực mang lại một chuỗi trống.

Hoạt động này có thể được tùy chỉnh bằng các phương thức 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
41 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
42 đặc biệt.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
43 (AT) được dự định sẽ được sử dụng để nhân ma trận. Không có loại Python xây dựng thực hiện toán tử này.

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

Các nhà khai thác 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
44 (bộ phận) và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
45 (phân chia sàn) mang lại thương số cho các lập luận của họ. Các đối số số lần đầu tiên được chuyển đổi thành một loại chung. Sự phân chia số nguyên mang lại một chiếc phao, trong khi phân chia sàn của số nguyên dẫn đến một số nguyên; Kết quả là sự phân chia toán học với chức năng ‘sàn được áp dụng cho kết quả. Phân chia theo 0 làm tăng ngoại lệ 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
27.

Hoạt động này có thể được tùy chỉnh bằng các phương thức 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
47 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
48 đặc biệt.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
49 (modulo) mang lại phần còn lại từ sự phân chia của đối số đầu tiên theo thứ hai. Các đối số số lần đầu tiên được chuyển đổi thành một loại chung. Một đối số đúng không làm tăng ngoại lệ 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
27. Các đối số có thể là số điểm nổi, ví dụ, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
51 bằng 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
52 (vì 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
53 bằng 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
54.) Toán tử modulo luôn mang lại kết quả với cùng một dấu hiệu với toán hạng thứ hai của nó (hoặc không); Giá trị tuyệt đối của kết quả nhỏ hơn hoàn toàn so với giá trị tuyệt đối của toán hạng thứ hai 1.

Các toán tử phân chia sàn và các toán tử modulo được kết nối bằng danh tính sau: 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
55. Phân chia sàn và modulo cũng được kết nối với chức năng tích hợp 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
56: 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
57. 2.

Ngoài việc thực hiện thao tác modulo trên các số, toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
49 cũng bị quá tải bởi các đối tượng chuỗi để thực hiện định dạng chuỗi kiểu cũ (còn được gọi là nội suy). Cú pháp cho định dạng chuỗi được mô tả trong tham chiếu thư viện Python, phần định dạng chuỗi kiểu printf.printf-style String Formatting.

Hoạt động modulo có thể được tùy chỉnh bằng phương pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
59 đặc biệt.

Toán tử phân chia sàn, toán tử modulo và hàm 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
56 không được xác định cho các số phức. Thay vào đó, hãy chuyển đổi thành số điểm nổi bằng hàm 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
61 nếu thích hợp.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
33 (bổ sung) mang lại tổng số đối số của nó. Các đối số phải cả hai là số hoặc cả hai là chuỗi cùng loại. Trong trường hợp trước, các số được chuyển đổi thành một loại chung và sau đó được thêm vào với nhau. Trong trường hợp sau, các chuỗi được nối.

Hoạt động này có thể được tùy chỉnh bằng các phương thức 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
63 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
64 đặc biệt.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
31 (phép trừ) mang lại sự khác biệt của các đối số của nó. Các đối số số lần đầu tiên được chuyển đổi thành một loại chung.

Hoạt động này có thể được tùy chỉnh bằng phương pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
66 đặc biệt.

6.8. Hoạt động thay đổiShifting operations¶

Các hoạt động thay đổi được ưu tiên thấp hơn các hoạt động số học:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
3

Các nhà khai thác chấp nhận số nguyên làm đối số. Họ chuyển đối số đầu tiên sang trái hoặc phải theo số lượng bit được đưa ra bởi đối số thứ hai.

Hoạt động này có thể được tùy chỉnh bằng các phương thức 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
67 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
68 đặc biệt.

Một sự thay đổi đúng bởi n bit được định nghĩa là phân chia sàn bởi 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
69. Một sự thay đổi bên trái theo n bit được định nghĩa là nhân với 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
69.

6.9. Hoạt động bitwise nhị phânBinary bitwise operations¶

Mỗi trong ba hoạt động bitwise có mức độ ưu tiên khác nhau:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
4

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
71 mang lại bitwise và của các đối số của nó, phải là số nguyên hoặc một trong số chúng phải là một đối tượng tùy chỉnh ghi đè 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
72 hoặc 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
73 Các phương thức đặc biệt.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
74 mang lại XOR bitwise (độc quyền hoặc) của các đối số của nó, phải là số nguyên hoặc một trong số chúng phải là một đối tượng tùy chỉnh ghi đè lên các phương thức đặc biệt 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
75 hoặc 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
76.

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
77 mang lại bitwise (bao gồm) hoặc của các đối số của nó, phải là số nguyên hoặc một trong số chúng phải là một đối tượng tùy chỉnh ghi đè 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
78 hoặc 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
79 Các phương thức đặc biệt.

6.10. So sánh lorComparisons¶

Không giống như C, tất cả các hoạt động so sánh trong Python đều có cùng mức độ ưu tiên, thấp hơn so với bất kỳ hoạt động số học, dịch chuyển hoặc bitwise nào. Cũng không giống như C, các biểu thức như 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
80 có cách giải thích thông thường trong toán học:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
5

So sánh mang lại giá trị boolean: 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 hoặc 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82. Phương pháp so sánh phong phú tùy chỉnh có thể trả về các giá trị phi Boolean. Trong trường hợp này, Python sẽ gọi 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
83 về giá trị đó trong bối cảnh Boolean.

So sánh có thể được chuỗi tùy ý, ví dụ, 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
84 tương đương với 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
85, ngoại trừ 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
86 chỉ được đánh giá một lần (nhưng trong cả hai trường hợp 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
87 không được đánh giá khi 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
88 được tìm thấy là sai).

Chính thức, nếu A, B, C, xông, Y, Z là biểu thức và OP1, OP2, Mạnh, OPN là các toán tử so sánh, sau đó 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
89 tương đương với 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
90, ngoại trừ mỗi biểu thức được đánh giá nhiều nhất một lần.

Lưu ý rằng 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
91 không có nghĩa là bất kỳ loại so sánh nào giữa A và C, do đó, ví dụ, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
92 là hoàn toàn hợp pháp (mặc dù có lẽ không đẹp).

6.10.1. So sánh giá trịValue comparisons¶

Các toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
93, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
94, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
95, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
96, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
97 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
98 So sánh các giá trị của hai đối tượng. Các đối tượng không cần phải có cùng loại.

Các đối tượng, giá trị và loại chương nói rằng các đối tượng có giá trị (ngoài loại và danh tính). Giá trị của một đối tượng là một khái niệm khá trừu tượng trong Python: ví dụ, không có phương thức truy cập kinh điển nào cho một giá trị đối tượng. Ngoài ra, không có yêu cầu rằng giá trị của một đối tượng nên được xây dựng theo một cách cụ thể, ví dụ: bao gồm tất cả các thuộc tính dữ liệu của nó. Các toán tử so sánh thực hiện một khái niệm cụ thể về giá trị của một đối tượng là gì. Người ta có thể nghĩ về chúng là xác định giá trị của một đối tượng một cách gián tiếp, bằng cách thực hiện so sánh của chúng.Objects, values and types states that objects have a value (in addition to type and identity). The value of an object is a rather abstract notion in Python: For example, there is no canonical access method for an object’s value. Also, there is no requirement that the value of an object should be constructed in a particular way, e.g. comprised of all its data attributes. Comparison operators implement a particular notion of what the value of an object is. One can think of them as defining the value of an object indirectly, by means of their comparison implementation.

Bởi vì tất cả các loại là các phân nhóm (trực tiếp hoặc gián tiếp) của 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
99, chúng thừa hưởng hành vi so sánh mặc định từ 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
99. Các loại có thể tùy chỉnh hành vi so sánh của chúng bằng cách thực hiện các phương pháp so sánh phong phú như 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
01, được mô tả trong tùy chỉnh cơ bản.Basic customization.

Hành vi mặc định để so sánh bình đẳng (

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
95 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
98) dựa trên danh tính của các đối tượng. Do đó, so sánh bình đẳng của các trường hợp có cùng nhận dạng dẫn đến sự bình đẳng và so sánh bình đẳng của các trường hợp với các danh tính khác nhau dẫn đến bất bình đẳng. Một động lực cho hành vi mặc định này là mong muốn rằng tất cả các đối tượng phải là phản xạ (nghĩa là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
04 ngụ ý 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
05).

Một so sánh đơn hàng mặc định (

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
93, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
94, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
97 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
96) không được cung cấp; Một nỗ lực tăng 
generator_expression ::=  "(" expression comp_for ")"
6. Một động lực cho hành vi mặc định này là thiếu một bất biến tương tự như đối với sự bình đẳng.

Hành vi của so sánh bình đẳng mặc định, rằng các trường hợp với các danh tính khác nhau luôn không đồng đều, có thể trái ngược với những loại sẽ cần có định nghĩa hợp lý về giá trị đối tượng và bình đẳng dựa trên giá trị. Các loại như vậy sẽ cần phải tùy chỉnh hành vi so sánh của họ, và trên thực tế, một số loại tích hợp đã thực hiện điều đó.

Danh sách sau đây mô tả hành vi so sánh của các loại tích hợp quan trọng nhất.

  • Số lượng các loại số tích hợp (loại số-int, float, phức tạp) và các loại thư viện tiêu chuẩn 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    11 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    12 có thể được so sánh trong và trên các loại của chúng, với hạn chế các số phức tạp không hỗ trợ so sánh thứ tự. Trong giới hạn của các loại liên quan, chúng so sánh chính xác về mặt toán học (về mặt thuật toán) mà không mất độ chính xác.Numeric Types — int, float, complex) and of the standard library types 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    11 and 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    12 can be compared within and across their types, with the restriction that complex numbers do not support order comparison. Within the limits of the types involved, they compare mathematically (algorithmically) correct without loss of precision.

    Các giá trị không phải là một số 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    13 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    14 là đặc biệt. Bất kỳ sự so sánh được đặt hàng của một số với một giá trị không một số là sai. Một hàm ý phản trực giác là các giá trị không phải là một số không bằng với chính chúng. Ví dụ: nếu 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    15, 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    16, 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    17 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    18 đều sai, trong khi 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    19 là đúng. Hành vi này tuân thủ IEEE 754.

  • dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
    6 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    21 là những người độc thân. PEP 8 khuyên rằng các so sánh cho các singletons phải luôn luôn được thực hiện với 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    22 hoặc 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    23, không bao giờ là nhà khai thác bình đẳng.PEP 8 advises that comparisons for singletons should always be done with 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    22 or 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    23, never the equality operators.

  • Trình tự nhị phân (các trường hợp của 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    24 hoặc 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    25) có thể được so sánh trong và trên các loại của chúng. Họ so sánh từ vựng bằng cách sử dụng các giá trị số của các yếu tố của chúng.

  • Các chuỗi (các trường hợp của 

    name ::=  othername
    74) so ​​sánh từ vựng bằng cách sử dụng các điểm mã unicode số (kết quả của hàm tích hợp 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    27) của các ký tự của chúng. 3

    Chuỗi và trình tự nhị phân không thể được so sánh trực tiếp.

  • Trình tự (các trường hợp của 

    name ::=  othername
    69, 
    name ::=  othername
    75 hoặc 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    30) chỉ có thể được so sánh trong mỗi loại của chúng, với hạn chế rằng phạm vi không hỗ trợ so sánh thứ tự. So sánh bình đẳng giữa các loại này dẫn đến bất bình đẳng và việc so sánh đặt hàng giữa các loại này tăng 
    generator_expression ::=  "(" expression comp_for ")"
    6.

    Trình tự so sánh từ vựng bằng cách sử dụng so sánh các yếu tố tương ứng. Các thùng chứa tích hợp thường giả sử các đối tượng giống hệt nhau bằng với chính chúng. Điều đó cho phép họ bỏ qua các bài kiểm tra bình đẳng cho các đối tượng giống hệt nhau để cải thiện hiệu suất và duy trì các bất biến nội bộ của chúng.

    So sánh từ vựng giữa các bộ sưu tập tích hợp hoạt động như sau:

    • Đối với hai bộ sưu tập để so sánh bằng nhau, chúng phải cùng loại, có cùng độ dài và mỗi cặp phần tử tương ứng phải so sánh bằng nhau (ví dụ, 

      literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
      32 là sai vì loại không giống nhau).

    • Các bộ sưu tập hỗ trợ so sánh thứ tự được đặt hàng giống như các yếu tố không đồng đều đầu tiên của chúng (ví dụ, 

      literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
      33 có cùng giá trị với 
      literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
      34). Nếu một phần tử tương ứng không tồn tại, bộ sưu tập ngắn hơn được đặt hàng đầu tiên (ví dụ: 
      literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
      35 là đúng).

  • Ánh xạ (các trường hợp của 

    name ::=  othername
    71) so sánh bằng nhau khi và chỉ khi chúng có các cặp ____337 bằng nhau. So sánh bình đẳng của các khóa và giá trị thực thi tính phản xạ.

    So sánh đơn hàng (

    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    93, 
    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    94, 
    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    97 và 
    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    96) tăng 
    generator_expression ::=  "(" expression comp_for ")"
    6.

  • Các bộ (các trường hợp của 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    43 hoặc 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    44) có thể được so sánh trong và trên các loại của chúng.

    Họ xác định các toán tử so sánh đơn hàng có nghĩa là các bài kiểm tra tập hợp con và superset. Những mối quan hệ này không xác định tổng số thứ tự (ví dụ: hai bộ 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    45 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    46 không bằng nhau, cũng không phải là tập hợp của nhau, cũng không phải là siêu của nhau). Theo đó, các bộ không phải là đối số phù hợp cho các chức năng phụ thuộc vào tổng số đặt hàng (ví dụ: 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    47, 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    48 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    49 tạo ra kết quả không xác định được đưa ra danh sách các bộ làm đầu vào).

    So sánh các bộ thực thi tính phản xạ của các yếu tố của nó.

  • Hầu hết các loại tích hợp khác không có phương pháp so sánh được thực hiện, vì vậy chúng thừa hưởng hành vi so sánh mặc định.

Các lớp do người dùng xác định tùy chỉnh hành vi so sánh của họ nên tuân theo một số quy tắc nhất quán, nếu có thể:

  • So sánh bình đẳng nên là phản xạ. Nói cách khác, các đối tượng giống hệt nhau nên so sánh bằng nhau:

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    04 ngụ ý 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    05

  • So sánh nên đối xứng. Nói cách khác, các biểu thức sau đây phải có cùng kết quả:

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    05 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    53

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    54 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    55

    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    88 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    57

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    34 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    59

  • So sánh nên được chuyển tiếp. Các ví dụ sau (không khởi công) minh họa rằng:

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    60 ngụ ý 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    61

    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    85 ngụ ý 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    63

  • So sánh nghịch đảo nên dẫn đến phủ định boolean. Nói cách khác, các biểu thức sau đây phải có cùng kết quả:

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    05 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    65

    atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
    88 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    67 (để đặt hàng tổng số)

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    68 và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    69 (để đặt hàng tổng số)

    Hai biểu thức cuối cùng áp dụng cho các bộ sưu tập hoàn toàn được đặt hàng (ví dụ: các chuỗi, nhưng không đặt ra các bộ hoặc ánh xạ). Xem thêm Công cụ trang trí 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    70.

  • Kết quả 

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    71 phải phù hợp với sự bình đẳng. Các đối tượng bằng nhau nên có cùng giá trị băm, hoặc được đánh dấu là không thể.

Python không thực thi các quy tắc nhất quán này. Trên thực tế, các giá trị không có số là một ví dụ cho việc không tuân theo các quy tắc này.

6.10.2. Hoạt động kiểm tra thành viênMembership test operations¶

Các nhà khai thác 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
73 Kiểm tra thành viên. 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
74 đánh giá thành 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 nếu X là thành viên của S và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82 khác. 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
77 Trả về sự phủ định của 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
78. Tất cả các chuỗi tích hợp và các loại đặt hỗ trợ điều này cũng như từ điển, trong đó 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72 kiểm tra xem từ điển có khóa nhất định hay không. Đối với các loại container như Danh sách, Tuple, Set, Frozenset, Dict hoặc Collections.Deque, biểu thức 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
80 tương đương với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81.

Đối với các loại chuỗi và byte, 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
80 là 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 khi và chỉ khi x là một chuỗi con của y. Một thử nghiệm tương đương là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
84. Các chuỗi trống luôn được coi là một chuỗi con của bất kỳ chuỗi nào khác, do đó 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
85 sẽ trả về 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81.

Đối với các lớp do người dùng xác định xác định phương thức 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
87, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
88 trả về 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 nếu 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
90 trả về giá trị thực và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82 khác.

Đối với các lớp do người dùng xác định không xác định 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
87 nhưng xác định 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
93, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
80 là 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 nếu một số giá trị 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
87, trong đó biểu thức 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
97 là đúng, được tạo ra trong khi lặp lại trên 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
86. Nếu một ngoại lệ được nâng lên trong quá trình lặp, như thể 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72 đã nêu ra ngoại lệ đó.

Cuối cùng, giao thức lặp kiểu cũ được thử: nếu một lớp xác định 

name ::=  othername
65, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
80 là 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 khi và chỉ khi có chỉ số số nguyên không âm I sao cho 
parenth_form ::=  "(" [starred_expression] ")"
03 và không có chỉ số số nguyên thấp hơn làm tăng ngoại lệ 
parenth_form ::=  "(" [starred_expression] ")"
04. (Nếu bất kỳ ngoại lệ nào khác được nâng lên, như thể 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72 đã nêu ra ngoại lệ đó).

Nhà điều hành 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
73 được xác định là có giá trị sự thật nghịch đảo là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72.

6.10.3. So sánh danh tínhIdentity comparisons¶

Các toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
22 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
23 cho một danh tính đối tượng: 
parenth_form ::=  "(" [starred_expression] ")"
10 là đúng khi và chỉ khi x và y là cùng một đối tượng. Danh tính đối tượng được xác định bằng cách sử dụng hàm 
parenth_form ::=  "(" [starred_expression] ")"
11. 
parenth_form ::=  "(" [starred_expression] ")"
12 mang lại giá trị sự thật nghịch đảo. 4

6.11. Hoạt động BooleanBoolean operations¶

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
6

Trong bối cảnh của các hoạt động Boolean, và cả khi các biểu thức được sử dụng bởi các câu lệnh dòng điều khiển, các giá trị sau được hiểu là sai: 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82, 
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for
6, số 0 của tất cả , bộ và đông lạnh). Tất cả các giá trị khác được hiểu là đúng. Các đối tượng do người dùng xác định có thể tùy chỉnh giá trị sự thật của chúng bằng cách cung cấp phương thức 
parenth_form ::=  "(" [starred_expression] ")"
15.

Nhà điều hành 

parenth_form ::=  "(" [starred_expression] ")"
16 mang lại 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81 nếu đối số của nó là sai, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82 khác.

Biểu thức 

parenth_form ::=  "(" [starred_expression] ")"
19 đầu tiên đánh giá x; Nếu x là sai, giá trị của nó được trả về; Mặt khác, y được đánh giá và giá trị kết quả được trả về.

Biểu thức 

parenth_form ::=  "(" [starred_expression] ")"
20 đầu tiên đánh giá x; Nếu x là đúng, giá trị của nó được trả về; Mặt khác, y được đánh giá và giá trị kết quả được trả về.

Lưu ý rằng cả 

parenth_form ::=  "(" [starred_expression] ")"
21 và 
parenth_form ::=  "(" [starred_expression] ")"
22 đều không hạn chế giá trị và loại họ trở lại 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
81, mà thay vào đó trả về đối số được đánh giá cuối cùng. Điều này đôi khi hữu ích, ví dụ: nếu 
parenth_form ::=  "(" [starred_expression] ")"
25 là một chuỗi cần được thay thế bằng giá trị mặc định nếu trống, biểu thức 
parenth_form ::=  "(" [starred_expression] ")"
26 mang lại giá trị mong muốn. Vì 
parenth_form ::=  "(" [starred_expression] ")"
16 phải tạo ra một giá trị mới, nó trả về một giá trị boolean bất kể loại đối số của nó (ví dụ, 
parenth_form ::=  "(" [starred_expression] ")"
28 tạo ra 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82 thay vì 
parenth_form ::=  "(" [starred_expression] ")"
30.)

6.12. Biểu thức phân côngAssignment expressions¶

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
7

Một biểu thức gán (đôi khi còn được gọi là một biểu thức có tên là hay hay Walrus Walrus) gán một 

name ::=  othername
98 cho 
parenth_form ::=  "(" [starred_expression] ")"
32, đồng thời trả về giá trị của 
name ::=  othername
98.

Một trường hợp sử dụng phổ biến là khi xử lý các biểu thức thông thường phù hợp:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
8

Hoặc, khi xử lý luồng tệp trong các đoạn:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
9

Các biểu thức gán phải được bao quanh bởi dấu ngoặc đơn khi được sử dụng làm biểu hiện phụ trong việc cắt lát, có điều kiện, lambda, từ khóa và biểu thức hiểu và hiểu và trong các câu lệnh 

parenth_form ::=  "(" [starred_expression] ")"
34 và 
parenth_form ::=  "(" [starred_expression] ")"
35. Ở tất cả các nơi khác mà chúng có thể được sử dụng, dấu ngoặc đơn không bắt buộc, bao gồm cả trong các câu lệnh 
parenth_form ::=  "(" [starred_expression] ")"
4 và 
parenth_form ::=  "(" [starred_expression] ")"
37.

Mới trong phiên bản 3.8: Xem PEP 572 để biết thêm chi tiết về các biểu thức gán.See PEP 572 for more details about assignment expressions.

6.13. Biểu thức có điều kiệnConditional expressions¶

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
0

Các biểu thức có điều kiện (đôi khi được gọi là toán tử ternary của người Hồi giáo) có mức độ ưu tiên thấp nhất trong tất cả các hoạt động của Python.

Biểu thức 

parenth_form ::=  "(" [starred_expression] ")"
38 trước tiên đánh giá điều kiện, c chứ không phải x. Nếu C là đúng, x được đánh giá và giá trị của nó được trả về; Nếu không, y được đánh giá và giá trị của nó được trả về.

Xem PEP 308 để biết thêm chi tiết về biểu thức có điều kiện.PEP 308 for more details about conditional expressions.

6.14. Lambdas¶Lambdas¶

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
1

Các biểu thức Lambda (đôi khi được gọi là dạng lambda) được sử dụng để tạo các hàm ẩn danh. Biểu thức 

parenth_form ::=  "(" [starred_expression] ")"
39 mang lại một đối tượng hàm. Đối tượng không tên hoạt động giống như một đối tượng hàm được xác định với:

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
2

Xem phần Định nghĩa chức năng cho cú pháp của danh sách tham số. Lưu ý rằng các chức năng được tạo bằng các biểu thức Lambda không thể chứa các câu lệnh hoặc chú thích.Function definitions for the syntax of parameter lists. Note that functions created with lambda expressions cannot contain statements or annotations.

6.15. Danh sách biểu hiệnExpression lists¶

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
3

Ngoại trừ khi một phần của danh sách hoặc màn hình đặt, một danh sách biểu thức chứa ít nhất một dấu phẩy mang lại một tuple. Độ dài của tuple là số lượng biểu thức trong danh sách. Các biểu thức được đánh giá từ trái sang phải.

Một dấu hoa thị 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12 biểu thị việc giải nén có thể lặp lại. Toán tử của nó phải là một điều không thể. Các ITEBLE được mở rộng thành một chuỗi các mục, được bao gồm trong bộ tuple, danh sách hoặc bộ mới, tại trang web của việc giải nén.iterable. The iterable is expanded into a sequence of items, which are included in the new tuple, list, or set, at the site of the unpacking.

Mới trong phiên bản 3.5: Khả năng giải nén trong danh sách biểu thức, ban đầu được đề xuất bởi PEP 448.Iterable unpacking in expression lists, originally proposed by PEP 448.

Dấu phẩy kéo dài chỉ được yêu cầu để tạo ra một tuple duy nhất (a.k.a. một singleton); Đó là tùy chọn trong tất cả các trường hợp khác. Một biểu thức duy nhất không có dấu phẩy kéo dài không tạo ra một tuple, mà là mang lại giá trị của biểu thức đó. (Để tạo một tuple trống, hãy sử dụng một cặp dấu ngoặc đơn trống: 

parenth_form ::=  "(" [starred_expression] ")"
41.)

6.16. Đơn đặt hàng đánh giáEvaluation order¶

Python đánh giá các biểu thức từ trái sang phải. Lưu ý rằng trong khi đánh giá một nhiệm vụ, phía bên phải được đánh giá trước phía bên trái.

Trong các dòng sau, các biểu thức sẽ được đánh giá theo thứ tự số học của hậu tố của chúng:

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
4

6.17. Ưu tiên điều hành¶Operator precedence¶

Bảng sau đây tóm tắt sự ưu tiên của toán tử trong Python, từ ưu tiên cao nhất (nhất là ràng buộc) đến ưu tiên thấp nhất (ít ràng buộc nhất). Người vận hành trong cùng một hộp có cùng mức độ ưu tiên. Trừ khi cú pháp được đưa ra một cách rõ ràng, các toán tử là nhị phân. Các toán tử trong cùng một nhóm hộp từ trái sang phải (ngoại trừ các biểu thức số liệu và có điều kiện, nhóm từ phải sang trái).

Lưu ý rằng so sánh, kiểm tra thành viên và kiểm tra danh tính, tất cả đều có cùng mức độ ưu tiên và có tính năng chuỗi từ trái sang phải như được mô tả trong phần so sánh.Comparisons section.

Nhà điều hành

Sự mô tả

parenth_form ::=  "(" [starred_expression] ")"
42,

parenth_form ::=  "(" [starred_expression] ")"
43, 
parenth_form ::=  "(" [starred_expression] ")"
44, 
parenth_form ::=  "(" [starred_expression] ")"
45

Biểu thức ràng buộc hoặc dấu ngoặc đơn, hiển thị danh sách, hiển thị từ điển, đặt màn hình

parenth_form ::=  "(" [starred_expression] ")"
46, 
parenth_form ::=  "(" [starred_expression] ")"
47, 
parenth_form ::=  "(" [starred_expression] ")"
48, 
parenth_form ::=  "(" [starred_expression] ")"
49

Đăng ký, cắt, cuộc gọi, tham chiếu thuộc tính

parenth_form ::=  "(" [starred_expression] ")"
50

Đang chờ biểu hiện

list_display ::=  "[" [starred_list | comprehension] "]"
7

Số mũ 5

parenth_form ::=  "(" [starred_expression] ")"
52, 
parenth_form ::=  "(" [starred_expression] ")"
53, 
parenth_form ::=  "(" [starred_expression] ")"
54

Tích cực, tiêu cực, bitwise không

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
12, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
43, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
44, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
45, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
49

Phép nhân, phép nhân ma trận, phân chia, phân chia sàn, phần còn lại 6

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
33, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
31

Cộng và trừ

parenth_form ::=  "(" [starred_expression] ")"
62, 
parenth_form ::=  "(" [starred_expression] ")"
63

Sự thay đổi

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
71

Bitwise và

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
74

BitWise XOR

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
77

Bitwise hoặc

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
73, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
22, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
23, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
93, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
97, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
94, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
96, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
98, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
95

So sánh, bao gồm các bài kiểm tra thành viên và bài kiểm tra danh tính

parenth_form ::=  "(" [starred_expression] ")"
77

Boolean không

parenth_form ::=  "(" [starred_expression] ")"
21

Boolean và

parenth_form ::=  "(" [starred_expression] ")"
22

Boolean hoặc

parenth_form ::=  "(" [starred_expression] ")"
4 - 
parenth_form ::=  "(" [starred_expression] ")"
81

Biểu thức điều kiện

parenth_form ::=  "(" [starred_expression] ")"
82

Biểu hiện Lambda

parenth_form ::=  "(" [starred_expression] ")"
83

Biểu thức gán

Chú thích

1

Mặc dù 

parenth_form ::=  "(" [starred_expression] ")"
84 là toán học thực sự, nhưng đối với các phao có thể không đúng về số lượng do Roundoff. Ví dụ, và giả sử một nền tảng mà một chiếc phao python là số chính xác kép của IEEE 754, để 
parenth_form ::=  "(" [starred_expression] ")"
85 có cùng dấu với 
parenth_form ::=  "(" [starred_expression] ")"
86, kết quả được tính toán là 
parenth_form ::=  "(" [starred_expression] ")"
87, có số bằng số bằng 
parenth_form ::=  "(" [starred_expression] ")"
86. Hàm 
parenth_form ::=  "(" [starred_expression] ")"
89 trả về một kết quả có dấu hiệu khớp với dấu hiệu của đối số đầu tiên và do đó trả về 
parenth_form ::=  "(" [starred_expression] ")"
90 trong trường hợp này. Cách tiếp cận nào phù hợp hơn phụ thuộc vào ứng dụng.

2

Nếu x rất gần với bội số chính xác của y, thì 

parenth_form ::=  "(" [starred_expression] ")"
91 có thể lớn hơn 
parenth_form ::=  "(" [starred_expression] ")"
92 do làm tròn. Trong những trường hợp như vậy, Python trả về kết quả sau, để bảo tồn rằng 
parenth_form ::=  "(" [starred_expression] ")"
93 rất gần với 
name ::=  othername
79.

3

Tiêu chuẩn Unicode phân biệt giữa các điểm mã (ví dụ: U+0041) và các ký tự trừu tượng (ví dụ: chữ hoa Latin Latin A). Mặc dù hầu hết các ký tự trừu tượng trong Unicode chỉ được biểu diễn bằng một điểm mã, có một số ký tự trừu tượng có thể được biểu diễn bằng cách sử dụng một chuỗi nhiều hơn một điểm mã. Ví dụ, ký tự trừu tượng chữ Latin Latin Capital C với Cedilla có thể được biểu diễn dưới dạng một ký tự được định trước duy nhất tại vị trí mã U+00C7, hoặc là một chuỗi của một ký tự cơ sở tại vị trí mã U+0043 (chữ cái Latin Capital C), tiếp theo là một ký tự kết hợp tại vị trí mã U+0327 (kết hợp Cedilla).

Các toán tử so sánh trên các chuỗi so sánh ở cấp độ của các điểm mã Unicode.Điều này có thể phản trực giác với con người.Ví dụ, 

parenth_form ::=  "(" [starred_expression] ")"
95 là 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
82, mặc dù cả hai chuỗi đều đại diện cho cùng một ký tự trừu tượng chữ Latin Latin Capital C với Cedilla.

Để so sánh các chuỗi ở cấp độ của các ký tự trừu tượng (nghĩa là, theo cách trực quan với con người), sử dụng 

parenth_form ::=  "(" [starred_expression] ")"
97.

4

Do thu thập rác tự động, danh sách miễn phí và tính chất động của các mô tả, bạn có thể nhận thấy hành vi dường như bất thường trong một số cách sử dụng của toán tử ____322, giống như những người liên quan đến so sánh giữa các phương thức thể hiện hoặc hằng số.Kiểm tra tài liệu của họ để biết thêm thông tin.

5

Toán tử năng lượng 

list_display ::=  "[" [starred_list | comprehension] "]"
7 liên kết ít chặt chẽ hơn một toán tử số học hoặc bitwise unary ở bên phải của nó, nghĩa là 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
00 là 
comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]
01.

6

Toán tử 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
49 cũng được sử dụng để định dạng chuỗi;Ưu tiên tương tự được áp dụng.

programming python Python ternary return Ternary operator Python In Python Implement operator python Python If else Python

Bài Viết Liên Quan

Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Món Ngon Bánh
Họ tiếng nhật của bạn là gì năm 2024
Họ tiếng nhật của bạn là gì năm 2024

là ai Hỏi Đáp Là gì
Ý nghĩa của header from top là gì năm 2024
Ý nghĩa của header from top là gì năm 2024

mẹo hay Hỏi Đáp Là gì Top List Top Header la gì Footer la gì
Tự học tiếng anh như thế nào hiệu quả năm 2024
Tự học tiếng anh như thế nào hiệu quả năm 2024

mẹo hay Hỏi Đáp Thế nào Học Tốt Học Tiếng anh Học tiếng Anh
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Khỏe Đẹp Cơ thể
Tuổi đinh mão xây nhà năm nào tốt năm 2024
Tuổi đinh mão xây nhà năm nào tốt năm 2024

mẹo hay Xây Đựng Xây Nhà
Khoán chi đến sản phẩm cuối cùng là gì năm 2024
Khoán chi đến sản phẩm cuối cùng là gì năm 2024

là ai Hỏi Đáp Là gì
Các yếu tố cấu thành văn hóa tổ chức năm 2024
Các yếu tố cấu thành văn hóa tổ chức năm 2024

mẹo hay
Thế nào là số vô tỉ cho ví dụ năm 2024
Thế nào là số vô tỉ cho ví dụ năm 2024

mẹo hay Hỏi Đáp Thế nào Ví dụ
Quà trung thu tiếng anh là gì năm 2024
Quà trung thu tiếng anh là gì năm 2024

là ai Hỏi Đáp Là gì Học Tốt Tiếng anh Mid-Autumn gift
Đẻ mổ tối đa được bao nhiêu lần năm 2024
Đẻ mổ tối đa được bao nhiêu lần năm 2024

bao nhieu Hỏi Đáp Bao nhiêu
Thiết kế quán trà sữa bao nhiêu tiền năm 2024
Thiết kế quán trà sữa bao nhiêu tiền năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Món Ngon Trà sữa
Top nước hoa hồng se khít lỗ chân lông năm 2024
Top nước hoa hồng se khít lỗ chân lông năm 2024

mẹo hay Top List Top
Lỗi nồi chiên không dầu philips tiếng kêu rất to năm 2024
Lỗi nồi chiên không dầu philips tiếng kêu rất to năm 2024

mẹo hay
Daylight is coming like a rentless milkman upstairs là gì năm 2024
Daylight is coming like a rentless milkman upstairs là gì năm 2024

là ai Hỏi Đáp Là gì
Đặt cọc mua đất bao nhiêu phần trăm năm 2024
Đặt cọc mua đất bao nhiêu phần trăm năm 2024

bao nhieu Hỏi Đáp Bao nhiêu
Vở bài tập toán lớp 5 trang 51 52 năm 2024
Vở bài tập toán lớp 5 trang 51 52 năm 2024

mẹo hay Khỏe Đẹp Bài tập
Ngôn ngữ chính của singapore là gì năm 2024
Ngôn ngữ chính của singapore là gì năm 2024

là ai Hỏi Đáp Là gì
Văn mẫu lớp 8 bài viết số 1 đề 2 năm 2024
Văn mẫu lớp 8 bài viết số 1 đề 2 năm 2024

mẹo hay Soạn văn 8
Nhẫn tỳ hưu bạc giá bao nhiêu năm 2024
Nhẫn tỳ hưu bạc giá bao nhiêu năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Cryto Giá

Quảng Cáo

Có thể bạn quan tâm

Mục tiêu bài học chi tiết đánh giá được năm 2024
1 tháng trước . bởi ThunderousFlask
Asias next top model 5 tap 6 năm 2024
1 tháng trước . bởi HorribleBattling
Cầu gỗ lim huế bao nhiêu tiền năm 2024
1 tháng trước . bởi YieldingSwimmer
Cân bằng sinh học là gì cho ví dụ năm 2024
1 tháng trước . bởi UmbilicalProceeding
Tổng hợp kiến thức toán ôn thi đại học năm 2024
1 tháng trước . bởi ImpossibleEquation
Đề kiểm tra toán lớp 3 tuần 3 năm 2024
1 tháng trước . bởi FundamentalistTemplate
Cây dù che nắng giá bao nhiêu năm 2024
1 tháng trước . bởi TraditionalPhrasing
Quy trình ứng dụng cntt trong kiểm tra đánh giá năm 2024
1 tháng trước . bởi AdrenalProjection
Bài 94 trang 46 sách giáo khoa toán lớp 6 năm 2024
1 tháng trước . bởi SurplusInactivity
Khắc phục lỗi thẻ nhớ không cho coppy dữ liệu năm 2024
1 tháng trước . bởi FlattenedSaturday

Toplist được quan tâm

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
5 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
5 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
5 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
5 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
5 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
5 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
5 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
5 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
5 tháng trước

Quảng cáo

Xem Nhiều

Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024
45 phút trước
Thế nào là số vô tỉ cho ví dụ năm 2024
1 tuần trước
Đẻ mổ tối đa được bao nhiêu lần năm 2024
1 tuần trước
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024
1 ngày trước
Tự học tiếng anh như thế nào hiệu quả năm 2024
3 ngày trước
Thiết kế quán trà sữa bao nhiêu tiền năm 2024
1 tuần trước
Tuổi đinh mão xây nhà năm nào tốt năm 2024
4 ngày trước
Khoán chi đến sản phẩm cuối cùng là gì năm 2024
5 ngày trước
Họ tiếng nhật của bạn là gì năm 2024
2 ngày trước
Các yếu tố cấu thành văn hóa tổ chức năm 2024
6 ngày trước

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

DMCA.com Protection Status
Bản quyền © 2021 Học Tốt Inc.