search

Cưỡng chế trong python

1 năms trước
Trả lời: 0
Lượt xem: 196

Nhiều ngôn ngữ lập trình có một thứ gọi là ép kiểu;

Show

Python không có kiểu ép buộc

Các loại số và cưỡng chế

Nếu chúng ta cộng một số nguyên (2) và một số dấu phẩy động (3.5) trong Python, chúng ta sẽ nhận được một số

Python không ép buộc số nguyên thành số dấu phẩy động; . Thay vào đó, Python đã ủy quyền cho các số nguyên và số dấu phẩy động và yêu cầu các đối tượng đó tự cộng lại với nhau

Bất cứ khi nào Python nhìn thấy x + y, nó sẽ gọi phương thức __add__ trên x chuyển y cho nó

>>> x.__add__(y)
NotImplemented

Trong trường hợp này, Python đã nhận lại được NotImplemented vì các số nguyên không biết cách tự cộng chúng vào các số có dấu phẩy động. Giá trị NotImplemented đặc biệt này được trả về bởi phương thức__add__ của đối tượng số nguyên để cho Python biết rằng x (an 

>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
2) không biết cách hỗ trợ toán tử 
>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
3 với y (a 
>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
5)

Khi Python nhìn thấy giá trị NotImplemented đặc biệt này, nó sẽ cố gắng hỏi y liệu nó có biết cách thêm chính nó vào x. Để làm điều này, Python gọi phương thức 

>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
9 trên y, truyền nó vào x

Điều này thêm số dấu phẩy động vào số nguyên từ phía bên phải của dấu cộng (22 là "phải" trong 

>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
9) và trả về 24

Vì vậy, không có kiểu ép buộc nào được thực hiện ở đây, thay vào đó, một trong các loại đối tượng này biết cách hoạt động với loại đối tượng khác khi được sử dụng với toán tử cộng

Các đối tượng Python không hỗ trợ ép buộc kiểu

Một phản ví dụ của điều này là chuỗi

Điều gì xảy ra nếu chúng ta cố gắng sử dụng toán tử 

>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
3 giữa một chuỗi và một số trong Python?

>>> name = "Trey"
>>> x
2
>>> name + x
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str

Nhiều ngôn ngữ lập trình sẽ tạo chuỗi 26 ở trên. họ sẽ nối chuỗi đó và số đó bằng cách ép số đó vào chuỗi. Thay vào đó, trong Python, chúng tôi gặp lỗi (xem [TypeError. chỉ có thể nối str (không phải "int") thành str][concat str] để biết thêm về lỗi cụ thể đó)

Lý do là chuỗi trong Python không biết cách sử dụng toán tử cộng với số và số trong Python không biết cách sử dụng toán tử cộng với chuỗi nghĩa là code của chúng ta không hoạt động

Vì vậy, để thực sự hoàn thành những gì chúng tôi đang tìm kiếm, chúng tôi cần chuyển đổi số thành một chuỗi một cách rõ ràng

Chúng tôi đã tạo một chuỗi mới từ số đó 2 và chúng tôi đang nối nó với chuỗi của chúng tôi 28 để có một chuỗi khác

Summary

Python don't have type coercion. Python doesn't ever implicitly converts one object to another type of object

You'll always either rely on at least one of the objects you're working with knowing how to operate with the other type of object or you'll have to explicitly convert one of your objects to another type of object

Syntax Notes. 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

and no semantics are given, the semantics of this form of 

parenth_form ::=  "(" [starred_expression] ")"
4 are the same as for 
parenth_form ::=  "(" [starred_expression] ")"
5

6. 1. Arithmetic conversions

Khi mô tả 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 phổ biến”, đ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

  • If either argument is a complex number, the other is converted to complex;

  • otherwise, if either argument is a floating point number, the other is converted to floating point;

  • otherwise, both must be integers and no conversion is necessary

Some additional rules apply for certain operators (e. g. , a string as a left argument to the ‘%’ operator). Extensions must define their own conversion behavior

6. 2. Atoms

Atoms are the most basic elements of expressions. The simplest atoms are identifiers or literals. Forms enclosed in parentheses, brackets or braces are also categorized syntactically as atoms. The syntax for atoms is

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

6. 2. 1. Identifiers (Names)

An identifier occurring as an atom is a name. See section for lexical definition and section for documentation of naming and binding

When the name is bound to an object, evaluation of the atom yields that object. When a name is not bound, an attempt to evaluate it raises a exception

xáo trộn tên riêng. 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 

parenth_form ::=  "(" [starred_expression] ")"
7 occurring in a class named 
parenth_form ::=  "(" [starred_expression] ")"
8 will be transformed to 
parenth_form ::=  "(" [starred_expression] ")"
9. 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. Literals

Python supports string and bytes literals and various numeric literals

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

Evaluation of a literal yields an object of the given type (string, bytes, integer, floating point number, complex number) with the given value. The value may be approximated in the case of floating point and imaginary (complex) literals. See section for details

All literals correspond to immutable data types, and hence the object’s identity is less important than its value. Multiple evaluations of literals with the same value (either the same occurrence in the program text or a different occurrence) may obtain the same object or a different object with the same value

6. 2. 3. Parenthesized forms

A parenthesized form is an optional expression list enclosed in parentheses

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

A parenthesized expression list yields whatever that expression list yields. if the list contains at least one comma, it yields a tuple; otherwise, it yields the single expression that makes up the expression list

An empty pair of parentheses yields an empty tuple object. Since tuples are immutable, the same rules as for literals apply (i. e. , two occurrences of the empty tuple may or may not yield the same object)

Note that tuples are not formed by the parentheses, but rather by use of the comma. The exception is the empty tuple, for which parentheses are required — allowing unparenthesized “nothing” in expressions would cause ambiguities and allow common typos to pass uncaught

6. 2. 4. Displays for lists, sets and dictionaries

For constructing a list, a set or a dictionary Python provides special syntax called “displays”, each of them in two flavors

  • either the container contents are listed explicitly, or

  • they are computed via a set of looping and filtering instructions, called a comprehension

Common syntax elements for comprehensions are

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]

The comprehension consists of a single expression followed by at least one 

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]
0 clause and zero or more 
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]
0 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]
2 clauses. In this case, the elements of the new container are those that would be produced by considering each of the 
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]
0 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]
2 clauses a block, nesting from left to right, and evaluating the expression to produce an element each time the innermost block is reached

However, aside from the iterable expression in the leftmost 

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]
0 clause, the comprehension is executed in a separate implicitly nested scope. This ensures that names assigned to in the target list don’t “leak” into the enclosing scope

The iterable expression in the leftmost 

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]
0 clause is evaluated directly in the enclosing scope and then passed as an argument to the implicitly nested scope. Subsequent 
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]
0 clauses and any filter condition in the leftmost 
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]
0 clause cannot be evaluated in the enclosing scope as they may depend on the values obtained from the leftmost iterable. For example. 
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]
9

To ensure the comprehension always results in a container of the appropriate type, 

list_display ::=  "[" [starred_list | comprehension] "]"
0 and 
list_display ::=  "[" [starred_list | comprehension] "]"
1 expressions are prohibited in the implicitly nested scope

Since Python 3. 6, in an function, an 

list_display ::=  "[" [starred_list | comprehension] "]"
3 clause may be used to iterate over a . A comprehension in an 
list_display ::=  "[" [starred_list | comprehension] "]"
2 function may consist of either a 
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]
0 or 
list_display ::=  "[" [starred_list | comprehension] "]"
3 clause following the leading expression, may contain additional 
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]
0 or 
list_display ::=  "[" [starred_list | comprehension] "]"
3 clauses, and may also use expressions. If a comprehension contains either 
list_display ::=  "[" [starred_list | comprehension] "]"
3 clauses or 
list_display ::=  "[" [starred_list | comprehension] "]"
9 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

New in version 3. 6. Asynchronous comprehensions were introduced.

Changed in version 3. 8. 

list_display ::=  "[" [starred_list | comprehension] "]"
0 and 
list_display ::=  "[" [starred_list | comprehension] "]"
1 prohibited in the implicitly nested scope.

Đã thay đổi trong phiên bản 3. 11. Việc hiểu không đồng bộ hiện được phép hiểu bên trong các chức năng không đồng bộ. Hiểu bên ngoài hoàn toàn trở thành không đồng bộ.

6. 2. 5. Hiển thị danh sách

Hiển thị danh sách là một chuỗi các biểu thức có thể trống được đặt trong dấu 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 một cách hiểu. 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 phần 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 hiển thị

Hiển thị tập hợp được biểu thị bằng dấu ngoặc nhọn và có thể phân biệt với hiển thị từ điển do không có dấu hai chấm ngăn cách các khóa và giá trị

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

Một màn hình tập hợp tạo ra một đối tượng tập hợp có thể thay đổi mới, nội dung được chỉ định bởi một chuỗi các biểu thức hoặc một cách hiểu. 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 phần 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 rỗng không thể được xây dựng với 

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

6. 2. 7. Hiển thị từ điển

Hiển thị từ điển là một chuỗi các cặp khóa/mốc có thể trống được đặt trong dấu ngoặc nhọ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ác cặp khóa/dữ liệu được phân tách bằng dấu phẩy được cung cấp, chúng sẽ được đánh giá từ trái sang phải để xác định các mục nhập 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 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à giá trị cuối cùng được cung cấp

Dấu hoa thị kép 

set_display ::=  "{" (starred_list | comprehension) "}"
5 biểu thị việc giải nén từ điển. Toán hạng của nó phải là một. 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à các lần giải nén từ điển trước đó

Mới trong phiên bản 3. 5. Giải nén vào màn hình từ điển, do PEP 448 đề xuất ban đầu.

Khả năng hiểu chính tả, trái ngược với khả năng hiểu danh sách và tập hợp, cần hai biểu thức được phân tách bằng dấu hai chấm, theo sau là các mệnh đề “for” và “if” thông thường. Khi quá trình hiểu được chạy, các thành phần khóa và giá trị kết quả được chèn vào từ điển mới theo thứ tự chúng được tạo

Các hạn chế về loại giá trị khóa được liệt kê trước đó trong phần. (Tóm lại, loại khóa phải là , loại trừ tất cả các đối tượng có thể thay đổi. ) Không phát hiện xung đột giữa các phím trùng lặp;

Đã thay đổi trong phiên bản 3. 8. Trước Python 3. 8, trong phần hiểu chính tả, 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.

6. 2. 8. Biểu thức trình tạo

Biểu thức trình tạo là một ký hiệu trình tạo nhỏ gọn trong ngoặc đơn

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

Một biểu thức trình tạo mang lại một đối tượng trình tạo mới. Cú pháp của nó giống như cú pháp để hiểu, ngoại trừ việc nó được đặt trong dấu ngoặc đơn thay vì dấu ngoặc nhọn hoặc dấu ngoặc nhọn

Các biến được sử dụng trong biểu thức trình tạo được đánh giá một cách lười biếng khi phương thức được gọi cho đối tượng trình tạo (theo cách tương tự như các trình tạo thông thường). Tuy nhiên, biểu thức lặp trong 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]
0 ngoài cùng bên trái được đánh giá ngay lập tức, do đó, một lỗi do nó tạo ra sẽ được phát ra tại điểm mà biểu thức trình tạo được xác định, thay vì tại điểm mà giá trị đầu tiên được truy xuất. Các 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]
0 tiếp theo và bất kỳ điều kiện lọc nào trong 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]
0 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ừ lần lặp ngoài cùng bên trái. Ví dụ. 
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
0

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

Để tránh cản trở hoạt động dự kiến ​​của chính biểu thức trình tạo, các biểu thức 

list_display ::=  "[" [starred_list | comprehension] "]"
0 và 
list_display ::=  "[" [starred_list | comprehension] "]"
1 bị cấm trong trình tạo được xác định ngầm định

Nếu một biểu thức trình tạo chứa các mệnh đề hoặc biểu thức 

list_display ::=  "[" [starred_list | comprehension] "]"
3 thì nó được gọi là biểu thức trình tạo không đồng bộ. Một biểu thức trình tạo không đồng bộ trả về một đối tượng trình tạo không đồng bộ mới, là một trình lặp không đồng bộ (xem phần )

Mới trong phiên bản 3. 6. Các biểu thức trình tạo không đồng bộ đã được giới thiệu.

Đã thay đổi trong phiên bản 3. 7. Trước Python 3. 7, các biểu thức trình tạo không đồng bộ chỉ có thể xuất hiện trong coroutines. Bắt đầu với 3. 7, bất kỳ hàm nào cũng có thể sử dụng biểu thức trình tạo không đồng bộ.

Changed in version 3. 8. 

list_display ::=  "[" [starred_list | comprehension] "]"
0 and 
list_display ::=  "[" [starred_list | comprehension] "]"
1 prohibited in the implicitly nested scope.

6. 2. 9. Biểu thức năng suất

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]

Biểu thức năng suất được sử dụng khi xác định hàm hoặc chức năng 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 phần thân của hàm sẽ khiến hàm đó trở thành hàm tạo và sử dụng nó trong phần thân của hàm sẽ khiến hàm coroutine đó trở thành hàm tạo không đồng bộ. Ví dụ

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

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

list_display ::=  "[" [starred_list | comprehension] "]"
0 không được phép như một phần của phạm vi được xác định ngầm định được sử dụng để thực hiện các biểu thức hiểu và trình tạo

Đã thay đổi trong phiên bản 3. 8. Các biểu thức lợi nhuận bị cấm trong các phạm vi lồng nhau ngầm được sử dụng để triển khai các biểu thức trình tạo và hiểu.

Các chức năng của trình tạo được mô tả bên dưới, trong khi các chức năng của trình tạo không đồng bộ được mô tả riêng trong phần

Khi một hàm tạo được gọi, nó sẽ trả về một trình vòng lặp được gọi là trình tạo. Trình tạo đó sau đó điều khiển việc thực thi chức năng của trình tạo. Quá trình thực thi bắt đầu khi một trong các phương thức của trình tạo được gọi. Tại thời điểm đó, quá trình thực thi tiếp tục với biểu thức năng suất đầu tiên, ở đó biểu thức này lại bị treo, trả về giá trị của cho trình gọi của trình tạo hoặc 

generator_expression ::=  "(" expression comp_for ")"
1 nếu bị bỏ qua. Bằng cách treo, chúng tôi muốn nói rằng tất 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 biến cục bộ, con trỏ lệnh, 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 tiếp tục 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 lệnh 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 được sử dụng (thường thông qua a hoặc nội trang) thì kết quả là. Mặt khác, nếu được sử dụng, thì kết quả sẽ là giá trị được truyền vào phương thức đó

Tất cả những điều này làm cho các chức năng của trình tạo khá giống với coroutines; . Sự khác biệt duy nhất là một hàm tạo không thể kiểm soát nơi thực thi sẽ tiếp tục sau khi nó mang lại kết quả;

Biểu thức năng suất được phép ở bất kỳ đâu trong cấu trúc. Nếu trình tạo không được tiếp tục trước khi nó được hoàn thiện (bằng cách đạt đến số tham chiếu bằng 0 hoặc bằng cách thu gom rác), phương thức của trình tạo-iterator sẽ được gọi, cho phép mọi mệnh đề đang chờ xử lý thực thi

Khi sử dụng 

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]
1, biểu thức được cung cấp phải là biểu thức có thể lặp lại. Các giá trị được tạo bằng cách lặp lại có thể lặp lại đó được chuyển trực tiếp đến người gọi các phương thức của trình tạo hiện tại. Mọi giá trị được truyền vào with và mọi ngoại lệ được truyền vào with đều được chuyển đến trình vòng lặp bên dưới nếu nó có các phương thức phù hợp. Nếu đây không phải là trường hợp, thì sẽ tăng hoặc , trong khi sẽ chỉ tăng ngoại lệ được thông qua ngay lập tức

Khi trình vòng lặp cơ bản hoàn tất, thuộc tính 

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]
8 của phiên bản được nâng lên sẽ trở thành giá trị của biểu thức năng suất. Nó có thể được đặt rõ ràng khi nâng cao hoặc tự động khi trình tạo phụ là trình tạo (bằng cách trả về một giá trị từ trình tạo phụ)

Đã thay đổi trong phiên bản 3. 3. Đã thêm 

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]
1 để ủy quyền luồng điều khiển cho một bộ phụ.

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 tay phải của câu lệnh gán

Xem thêm

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

Đề xuất thêm trình tạo và câu lệnh vào Python

PEP 342 - Coroutines thông qua Trình tạo nâng cao

Đề xuất nâng cao API và cú pháp của trình tạo, giúp chúng có thể sử dụng được như các coroutine đơn giản

PEP 380 - Cú pháp ủy quyền cho Trình tạo con

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

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
03, giúp việc ủy ​​quyền cho các máy phát điện phụ trở nên dễ dàng

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

Đề xuất mở rộng trên PEP 492 bằng cách thêm các khả năng của trình tạo vào các chức năng coroutine

6. 2. 9. 1. Phương pháp trình tạo lặp

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

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 đang thực thi sẽ tạo ra một ngoại lệ

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

Bắt đầu thực hiện chức năng tạo hoặc tiếp tục nó ở biểu thức năng suất được thực hiện lần cuối. Khi một hàm tạo được tiếp tục với một phương thức, biểu thức năng suất hiện tại luôn ước tính thành. Sau đó, quá trình thực thi tiếp tục đến biểu thức lợi nhuận tiếp theo, trong đó trình tạo lại bị treo và giá trị của hàm được trả về cho người gọi. Nếu trình tạo thoát mà không mang lại giá trị khác, một ngoại lệ sẽ được đưa ra

Phương pháp này thường được gọi ngầm, e. g. bởi một vòng lặp, hoặc bởi chức năng tích hợp

máy phát điện. gửi(giá trị)

Tiếp tục thực thi và “gửi” một giá trị vào hàm 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 trả về giá trị tiếp theo do trình tạo tạo ra hoặc tăng nếu trình tạo thoát mà không mang lại giá trị khác. Khi được gọi để khởi động trình tạo, nó phải được gọi với tư cách là đối số, vì không có biểu thức năng suất nào có thể nhận giá trị

máy phát điện. ném(giá trị)trình tạo. ném(loại[ , value[, traceback]])

Tăng một ngoại lệ tại điểm mà trình tạo bị tạm dừng và trả về giá trị tiếp theo do hàm tạo tạo ra. Nếu trình tạo thoát mà không mang lại giá trị khác, một ngoại lệ sẽ được đưa ra. Nếu hàm tạo không bắt được ngoại lệ được truyền vào hoặc đưa ra một ngoại lệ khác, thì ngoại lệ đó sẽ lan truyền đến người gọi

Trong sử dụng thông thường, đ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

Tuy nhiên, để tương thích ngược, chữ ký thứ hai được hỗ trợ, tuân theo quy ước từ các phiên bản Python cũ hơn. Đối số kiểu 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 kiểu được gọi để lấy một thể hiện. Nếu truy nguyên được cung cấp, thì nó được đặt thành ngoại lệ, nếu không, bất kỳ thuộc tính 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
18 hiện có nào được lưu trữ trong giá trị có thể bị xóa

máy phát điện. đóng()

Tăng a tại điểm chức năng tạo bị tạm dừng. Nếu chức năng tạo sau đó thoát ra một cách duyên dáng, đã bị đóng hoặc tăng (do không bắt ngoại lệ), đóng sẽ trả về trình gọi của nó. Nếu trình tạo mang lại một giá trị, thì a được nâng lên. Nếu trình tạo phát sinh bất kỳ ngoại lệ nào khác, nó sẽ được truyền tới người gọi. không làm gì nếu trình tạo đã thoát do ngoại lệ hoặc thoát bình thường

6. 2. 9. 2. Ví dụ

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 tạo

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

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

list_display ::=  "[" [starred_list | comprehension] "]"
1, hãy xem trong “Có gì mới trong Python. ”

6. 2. 9. 3. Hàm tạo không đồng bộ

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

Khi một hàm tạo 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à đối tượng trình tạo không đồng bộ. Đối tượng đó sau đó kiểm soát việc thực hiện chức năng tạo. Một đối tượng trình tạo không đồng bộ thường được sử dụng trong một câu lệnh trong hàm coroutine tương tự như cách một đối tượng trình tạo sẽ được sử dụng trong một câu lệnh

Gọi một trong các phương thức của trình tạo không đồng bộ trả về một đối tượng và quá trình thực thi bắt đầu khi đối tượng này được chờ trên. Tại thời điểm đó, quá trình thực thi sẽ chuyển sang biểu thức năng suất đầu tiên, tại đây nó lại bị tạm dừng, trả về giá trị của quy trình đăng ký đang chờ. Như với một trình tạo, tạm ngưng có nghĩa là tất cả trạng thái cục bộ được giữ lại, bao gồm các liên kết hiện tại của biến cục bộ, con trỏ lệnh, 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 quá trình thực thi được tiếp tục bằng cách đợi đối tượng tiếp theo được trả về bởi các phương thức của trình tạo không đồng bộ, 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 lệnh 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 được sử dụng thì kết quả là. Mặt khác, nếu được sử dụng, thì kết quả sẽ là giá trị được truyền vào phương thức đó

Nếu trình tạo không đồng bộ xảy ra thoát sớm trước , tác vụ của trình gọi bị hủy hoặc các trường hợp ngoại lệ khác, thì mã dọn dẹp không đồng bộ của trình tạo sẽ chạy và có thể đưa ra các ngoại lệ hoặc truy cập các biến ngữ cảnh trong ngữ cảnh không mong muốn–có thể sau thời gian tồn tại của các tác vụ tùy thuộc vào, hoặc . Để ngăn chặn điều này, người gọi phải đóng trình tạo async một cách rõ ràng bằng cách gọi phương thức để hoàn thiện trình tạo và cuối cùng tách nó khỏi vòng lặp sự kiện

Trong hàm tạo không đồng bộ, biểu thức năng suất được phép ở bất kỳ đâu trong cấu trúc. Tuy nhiên, nếu trình tạo không đồng bộ không được tiếp tục lại trước khi nó được hoàn thiện (bằng cách đạt đến số tham chiếu bằng không hoặc bằng cách thu gom rác), thì biểu thức năng suất trong cấu trúc 

generator_expression ::=  "(" expression comp_for ")"
8 có thể dẫn đến lỗi thực thi các mệnh đề đ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 bộ tạo không đồng bộ là gọi phương thức của bộ tạo-iterator không đồng bộ và chạy đối tượng coroutine kết quả, do đó cho phép mọi mệnh đề 
yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]
0 đang chờ xử lý thực thi

Để xử lý việc hoàn thiện khi kết thúc vòng lặp sự kiện, một vòng lặp sự kiện phải xác định một hàm hoàn thiện nhận một trình lặp-trình tạo không đồng bộ và có lẽ gọi và thực thi coroutine. Finalizer này có thể được đăng ký bằng cách gọi. Khi được lặp lại lần đầu tiên, một trình lặp-trình tạo không đồng bộ sẽ lưu trữ trình hoàn thiện đã đăng ký để được gọi khi hoàn thiện. Để biết ví dụ tham khảo về phương pháp hoàn thiện, hãy xem triển khai của 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
40 trong Lib/asyncio/base_events. py

Biểu thức 

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]
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. Các phương thức tạo-lặp không đồng bộ

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

quy trình đại lý. __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 lần cuối. Khi một hàm tạo không đồng bộ được tiếp tục với một phương thức, biểu thức năng suất hiện tại luôn ước tính thành giá trị có thể chờ được trả về, mà khi chạy sẽ tiếp tục đến biểu thức năng suất tiếp theo. Giá trị của biểu thức năng suất là giá trị của ngoại lệ được đưa ra bởi quy trình hoàn thành. Nếu trình tạo không đồng bộ thoát mà không mang lại giá trị khác, thay vào đó, có thể chờ đợi sẽ đưa ra một ngoại lệ, báo hiệu rằng quá trình lặp lại không đồng bộ đã hoàn thành

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

quy trình đại lý. asend(giá trị)

Trả về một sự chờ đợi mà khi chạy sẽ tiếp tục thực hiện trình tạo không đồng bộ. Đối với phương thức dành cho bộ tạo, phương thức này “gửi” một giá trị vào hàm bộ 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. Phương thức có thể chờ đợi được trả về sẽ trả về giá trị tiếp theo do trình tạo tạo ra dưới dạng giá trị của raise hoặc tăng nếu trình tạo không đồng bộ thoát mà không mang lại giá trị khác. Khi được gọi để khởi động trình tạo không đồng bộ, nó phải được gọi với tư cách là đối số, vì không có biểu thức năng suất nào có thể nhận giá trị

quy trình đại lý. throw(loại[ , value[, traceback]])

Trả về một sự chờ đợi làm tăng ngoại lệ loại 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
54 tại điểm mà trình tạo không đồng bộ bị tạm dừng và trả về giá trị tiếp theo do hàm trình tạo tạo ra làm giá trị của ngoại lệ đã nêu. Nếu trình tạo không đồng bộ thoát mà không mang lại giá trị khác, một ngoại lệ sẽ được đưa ra bởi lệnh chờ. Nếu hàm tạo không bắt được ngoại lệ được truyền vào hoặc đưa ra một ngoại lệ khác, thì khi lệnh có thể chờ được chạy, ngoại lệ đó sẽ lan truyền đến người gọi của lệnh có thể chờ

quy trình đại lý. đóng()

Trả về một sự chờ đợi mà khi chạy sẽ ném một hàm vào trình tạo không đồng bộ tại điểm mà nó bị tạm dừng. Nếu chức năng tạo không đồng bộ sau đó thoát ra một cách duyên dáng, đã bị đóng hoặc tăng (do không bắt ngoại lệ), thì hàm chờ được trả về sẽ đưa ra một ngoại lệ. Bất kỳ sự chờ đợi nào khác được trả về bởi các cuộc gọi tiếp theo tới trình tạo không đồng bộ sẽ đưa ra một ngoại lệ. Nếu trình tạo không đồng bộ mang lại một giá trị, thì a được tăng lên bởi giá trị có thể chờ đợi. Nếu trình tạo không đồng bộ đưa ra bất kỳ ngoại lệ nào khác, thì nó sẽ được truyền tới người gọi của lệnh chờ. Nếu trình tạo không đồng bộ đã thoát do một ngoại lệ hoặc thoát bình thường, thì các lệnh gọi tiếp theo sẽ trả về một giá trị có thể chờ đợi mà không làm gì cả

6. 3. Các bầu cử sơ bộ

Bầu cử sơ bộ đạ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à

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

6. 3. 1. Tham chiếu thuộc tính

Tham chiếu thuộc tính là thuộc tính chính theo sau là dấu chấm và tên

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

Chính phải đánh giá một đối tượng thuộc loại hỗ trợ tham chiếu thuộc tính, điều mà hầu hết các đối tượng 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. Quá trình sản xuất này có thể được tùy chỉnh bằng cách ghi đè phương thức 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
63. Nếu thuộc tính này không có sẵn, ngoại lệ sẽ được đưa ra. 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ý

Việc đăng ký một phiên bản của một sẽ thường chọn một phần tử từ vùng chứa. Việc đăng ký một sẽ thường trả lại một đối tượng

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

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á 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ả hai và. 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 đến một trong các phương thức này. Để biết thêm chi tiết về thời điểm _____11_______67 được gọi thay vì ____11_______68, hãy xem

Nếu danh sách biểu thức chứa ít nhất một dấu phẩy, nó sẽ đánh giá là chứa các mục của danh sách biểu thức. Nếu không, danh sách biểu thức sẽ đánh giá giá trị của thành viên duy nhất của danh sách

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

  1. ánh xạ. Nếu giá trị chính là a , thì danh sách biểu thức phải đánh giá 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ạ dựng sẵn là lớp

  2. trình tự. Nếu giá trị chính là a , thì danh sách biểu thức phải đánh giá thành an hoặc a (như được thảo luận trong phần sau). Ví dụ về các lớp trình tự dựng sẵn bao gồm các lớp , và

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. Tuy nhiên, tất cả các trình tự dựng sẵn đều cung cấp một phương thức diễn giải các chỉ số âm bằng cách thêm độ dài của trình tự vào chỉ mục sao cho, ví dụ: 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
78 chọn mục cuối cùng của 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
79. Giá trị kết quả phải là một số nguyên không âm nhỏ hơn số mục trong chuỗi và đăng ký chọn mục có chỉ mục là giá trị đó (đếm từ 0). Vì hỗ trợ cho các chỉ số âm và cắt xảy ra trong phương thức 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
65 của đối tượng, nên các lớp con ghi đè phương thức này sẽ cần thêm hỗ trợ đó một cách rõ ràng

A là một loại dãy đặc biệt có các phần tử là các ký tự. Một ký tự không phải là một kiểu dữ liệu riêng biệt mà là một chuỗi có đúng một ký tự

6. 3. 3. Cắt lát

Một lần cắt chọn một loạt các mục trong một đối tượng chuỗi (e. g. , một chuỗi, bộ hoặc danh sách). Các lát cắt có thể được sử dụng làm biểu thức hoặc làm mục tiêu trong bài tập hoặc câu lệnh. Cú pháp cho một slice

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

Có sự mơ hồ trong cú pháp chính thức ở đây. bất cứ thứ gì trông giống như một danh sách biểu thức cũng giống như một danh sách lát, vì vậy bất kỳ đăng ký nào cũng có thể được hiểu là một lát. Thay vì làm phức tạp thêm cú pháp, điều này được làm rõ bằng cách xác định rằng trong trường hợp này, diễn giải dưới dạng đăng ký được ưu tiên hơn diễn giải dưới dạng 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)

Ngữ nghĩa của một slice như sau. Chính được lập chỉ mục (sử dụng cùng một phương pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
65 như đăng ký thông thường) với một khóa được tạo từ danh sách lát, như sau. Nếu danh sách lát chứa ít nhất một dấu phẩy, khóa là một bộ chứa chuyển đổi của các mục lát; . Việc chuyển đổi một mục lá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 ) có các thuộc tính 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
84, 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
85 và 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
86 là các giá trị của các biểu thức đã cho lần lượt là giới hạn dưới, giới hạn trên và bước, thay thế ____45_______1 cho các biểu thức bị thiếu

6. 3. 4. Cuộc gọi

Một cuộc gọi gọi một đối tượng có thể gọi được (e. g. , a ) với một loạt có thể trống

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

Dấu phẩy tùy chọn có thể xuất hiện 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á một đối tượng có thể gọi được (hàm do người dùng định nghĩa, hàm tích hợp, phương thức của đối tượng tích hợp, đối tượng lớp, phương thức của thể hiện lớp và tất cả các đối tượng có phương thức 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
88 đều có thể gọi được). Tất cả các biểu thức đối số được đánh giá trước khi thực hiện cuộc gọi. Vui lòng tham khảo phần cú pháp của danh sách chính thức

Nếu có đối số từ khóa, trước tiên chúng được chuyển đổi thành đối số vị trí, như sau. Đầu tiên, một danh sách các vị trí chưa đượ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 vị trí đầ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 mã định danh giống với tên tham số chính thức đầu tiên, thì vị trí đầu tiên được sử dụng, v.v.). Nếu vị trí đã được lấp đầy, một ngoại lệ sẽ được đưa ra. Mặt khác, đối số được đặt vào chỗ trống, lấp đầy nó (ngay cả khi biểu thức là 

generator_expression ::=  "(" expression comp_for ")"
1, nó sẽ lấp đầy chỗ trống). Khi tất cả các đối số đã được xử lý, các vị trí vẫn chưa được lấp đầy sẽ được lấp đầy bằng 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 sẽ được chia sẻ bởi tất cả các lệnh gọi không chỉ định giá trị đối số cho vị trí tương ứng; điều này nên . ) Nếu có bất kỳ vị trí nào chưa được lấp đầy mà không có giá trị mặc định nào được chỉ định, một ngoại lệ sẽ được đưa ra. Mặt khác, danh sách các vị trí đã lấp đầ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 hàm tích hợp có tham số vị trí không có tên, ngay cả khi chúng được 'đặt tên' cho mục đích tài liệu và do đó không thể được cung cấp theo từ khóa. Trong CPython, đây là trường hợp các hàm được triển khai trong C sử dụng để phân tích các đối số của chúng

Nếu có nhiều đối số vị trí hơn số vị trí tham số chính thức, thì một ngoại lệ sẽ được đưa ra, trừ khi có tham số chính thức sử dụng cú pháp 

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

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, một ngoại lệ sẽ được đưa ra, trừ khi có tham số chính thức sử dụng cú pháp 

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

Nếu cú ​​pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
97 xuất hiện trong lời gọi hàm, thì 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
98 phải đánh giá thành một. Các phần tử từ các lần lặp này được xử lý như thể chúng là các đối số vị trí bổ sung. Đối với lời gọi 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
99, nếu y đánh giá một dãy y1, …, yM, điều này tương đương với một lời gọi với M+4 đối số vị trí x1, x2, y1, …, yM, x3, x4

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

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
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ố 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
01 nào – xem bên dưới). Vì thế

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

Việc cả đối số từ khóa và cú pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
97 được sử dụng trong cùng một lệnh gọi là điều bất thường, vì vậy trong thực tế, sự nhầm lẫn này thường không xảy ra

Nếu cú ​​pháp 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
01 xuất hiện trong lời gọi hàm, thì 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
98 phải đánh giá một , nội dung của nó được coi là đối số từ khóa bổ sung. Nếu một tham số khớp với một khóa đã được cung cấp một giá trị (bởi một đối số từ khóa rõ ràng hoặc từ một giải nén khác), một ngoại lệ sẽ được đưa ra

Khi sử dụng 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
01, 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 để gán từ khóa có tên bằng với khóa. Khóa không nhất thiết phải là mã định danh Python (e. g. 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
07 được chấp nhận, 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 khớp với tham số chính thức, cặp khóa-giá trị được thu thập bởi tham số 
set_display ::=  "{" (starred_list | comprehension) "}"
5, nếu có hoặc nếu không có, một ngoại lệ sẽ được đưa ra

Các tham số hình thức sử dụng cú pháp 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
94 hoặc 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
96 không thể được sử dụng làm vùng đố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 lệnh gọi hàm chấp nhận bất kỳ số lần giải nén 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
12 và 
set_display ::=  "{" (starred_list | comprehension) "}"
5 nào, các đối số vị trí có thể tuân theo các lần giải nén lặp lại (
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
12) và các đối số từ khóa có thể tuân theo các lần giải nén từ điển (
set_display ::=  "{" (starred_list | comprehension) "}"
5). Ban đầu được đề xuất bởi PEP 448.

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

generator_expression ::=  "(" expression comp_for ")"
1, trừ khi nó đưa ra một ngoại lệ. Cách tính giá trị này tùy thuộc vào loại đối tượng có thể gọi được

Nếu nó là-

chức năng do người dùng định nghĩa

Khối mã cho hàm được thực thi, truyền cho nó danh sách đối số. The first thing the code block will do is bind the formal parameters to the arguments; this is described in section . When the code block executes a statement, this specifies the return value of the function call

a built-in function or method

The result is up to the interpreter; see for the descriptions of built-in functions and methods

a class object

A new instance of that class is returned

a class instance method

The corresponding user-defined function is called, with an argument list that is one longer than the argument list of the call. the instance becomes the first argument

a class instance

The class must define a 

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
88 method; the effect is then the same as if that method was called

6. 4. Await expression

Suspend the execution of on an object. Can only be used inside a 

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

New in version 3. 5

6. 5. The power operator

The power operator binds more tightly than unary operators on its left; it binds less tightly than unary operators on its right. The syntax is

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

Thus, in an unparenthesized sequence of power and unary operators, the operators are evaluated from right to left (this does not constrain the evaluation order for the operands). 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
19 results in 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
20

The power operator has the same semantics as the built-in function, when called with two arguments. it yields its left argument raised to the power of its right argument. The numeric arguments are first converted to a common type, and the result is of that type

For int operands, the result has the same type as the operands unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
22 returns 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
23, but 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
24 returns 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
25

Raising 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
26 to a negative power results in a . Raising a negative number to a fractional power results in a number. (In earlier versions it raised a . )

This operation can be customized using the special 

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

6. 6. Unary arithmetic and bitwise operations

All unary arithmetic and bitwise operations have the same priority

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

The unary 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
31 (minus) operator yields the negation of its numeric argument; the operation can be overridden with the 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
32 special method

The unary 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
33 (plus) operator yields its numeric argument unchanged; the operation can be overridden with the 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
34 special method

The unary 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
35 (invert) operator yields the bitwise inversion of its integer argument. The bitwise inversion of 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
79 is defined as 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
37. It only applies to integral numbers or to custom objects that override the 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
38 special method

In all three cases, if the argument does not have the proper type, a exception is raised

6. 7. Binary arithmetic operations

Các phép toán số học nhị phân có các mức ưu tiên thông thường. Note that some of these operations also apply to certain non-numeric types. Apart from the power operator, there are only two levels, one for multiplicative operators and one for additive operators

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

The 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
12 (multiplication) operator yields the product of its arguments. The arguments must either both be numbers, or one argument must be an integer and the other must be a sequence. In the former case, the numbers are converted to a common type and then multiplied together. In the latter case, sequence repetition is performed; a negative repetition factor yields an empty sequence

This operation can be customized using the special 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
41 and 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
42 methods

Toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
43 (at) được dùng để nhân ma trận. Không có loại Python dựng sẵn nào triển khai toán tử này

New in version 3. 5

Các toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
44 (phép chia) và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
45 (phép chia tầng) mang lại thương số cho các đối số của chúng. Các đối số số trước tiên được chuyển đổi thành một loại phổ biến. Phép chia các số nguyên tạo ra một số float, trong khi phép chia sàn các số nguyên dẫn đến một số nguyên; . Chia cho số 0 làm tăng ngoại lệ

Hoạt động này có thể được tùy chỉnh bằng cách sử dụng các phương pháp đặc biệt 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
47 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
48

Toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
49 (mô-đun) mang lại phần còn lại từ phép chia đối số thứ nhất cho đối số thứ hai. Các đối số số trước tiên được chuyển đổi thành một loại phổ biến. Một đối số không bên phải làm tăng ngoại lệ. Các đối số có thể là số dấu phẩy động, e. g. , 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
51 bằng với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
52 (vì 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
53 bằng với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
54. ) Toán tử modulo luôn mang lại kết quả có cùng dấu với toán hạng thứ hai (hoặc 0);

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
55. Phân chia tầng và modulo cũng được kết nối với chức năng tích hợp. 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
57.

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
49 còn được nạp chồng 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à phép nội suy). Cú pháp định dạng chuỗi được mô tả trong phần Tham khảo thư viện Python

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
59 đặc biệt

Toán tử chia sàn, toán tử modulo và hàm không được xác định cho các số phức. Thay vào đó, hãy chuyển đổi thành số dấu phẩy động bằng hàm nếu thích hợp

Toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
33 (bổ sung) mang lại tổng các đối số của nó. Các đối số phải 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 cộng lại 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ách sử dụng các phương pháp đặc biệt 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
63 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
64

Toán tử (phép trừ) 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
31 mang lại sự khác biệt của các đối số của nó. Các đối số số trước tiên được chuyển đổi thành một loại phổ biến

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
66 đặc biệt

6. 8. Thao tác dịch chuyển

Các phép toán dịch chuyển có mức độ ưu tiên thấp hơn các phép toán số học

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

Các toán tử này chấp nhận số nguyên làm đối số. Chúng dịch chuyển đối số thứ nhất sang trái hoặc phải theo số bit được cung cấp bởi đối số thứ hai

Hoạt động này có thể được tùy chỉnh bằng cách sử dụng các phương pháp đặc biệt 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
67 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
68

Dịch chuyển sang phải n bit được định nghĩa là chia sàn cho 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
69. Dịch trái n bit được định nghĩa là phép nhân với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
69

6. 9. Các phép toán theo bit nhị phân

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

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

Toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
71 tạo ra AND theo bit 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à đối tượng tùy chỉnh ghi đè phương thức đặc biệt của 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
72 hoặc 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
73

Toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
74 tạo ra XOR bitwise (OR độc quyền) 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à đối tượng tùy chỉnh ghi đè các phương thức đặc biệt của 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
75 hoặc 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
76

Toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
77 mang lại OR theo bit (bao gồm) 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à đối tượng tùy chỉnh ghi đè phương pháp đặc biệt của 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
78 hoặc 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
79

6. 10. So sánh

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
80 có cách hiểu thông thường trong toán học

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

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81 hoặc 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82. Các phương thức so sánh phong phú tùy chỉnh có thể trả về các giá trị không phải là boolean. Trong trường hợp này, Python sẽ gọi giá trị đó trong ngữ cảnh boolean

So sánh có thể được xâu chuỗi tùy ý, e. g. , 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
84 tương đương với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
85, ngoại trừ việc 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
86 chỉ được đánh giá một lần (nhưng trong cả hai trường hợp, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
87 hoàn toàn không được đánh giá khi 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
88 bị phát hiện là sai)

Về hình thức, nếu a, b, c, …, y, z là các biểu thức và op1, op2, …, opN là các toán tử so sánh, thì 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
89 tương đương với 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
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 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
91 không ngụ ý bất kỳ loại so sánh nào giữa a và c, do đó, e. g. , 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
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ị

Các toán tử 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
93, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
94, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
95, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
96, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
97 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
98 so sánh giá trị của hai đối tượng. Các đối tượng không cần phải có cùng loại

Chương nói rằng các đối tượng có một 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 chính tắc cho giá trị của đối tượng. Ngoài ra, không có yêu cầu rằng giá trị của một đối tượng phải được xây dựng theo một cách cụ thể, e. g. 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 như 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

Bởi vì tất cả các loại đều là kiểu con (trực tiếp hoặc gián tiếp) của , nên chúng kế thừa hành vi so sánh mặc định từ. Các loại có thể tùy chỉnh hành vi so sánh của chúng bằng cách triển khai các phương pháp so sánh phong phú như 

parenth_form ::=  "(" [starred_expression] ")"
01, được mô tả trong

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

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
95 và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
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 danh tính dẫn đến bình đẳng và so sánh bình đẳng của các trường hợp có danh tính khác nhau dẫn đến bất bình đẳng. Độ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 có tính phản xạ (i. e. 
parenth_form ::=  "(" [starred_expression] ")"
04 ngụ ý 
parenth_form ::=  "(" [starred_expression] ")"
05)

So sánh đơn hàng mặc định (

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
93, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
94, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
97, và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
96) không được cung cấp; . Độ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 bình đẳng

Hành vi so sánh đẳng thức mặc định, rằng các trường hợp có danh tính khác nhau luôn không bằng nhau, có thể trái ngược với loại nào 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 tùy chỉnh hành vi so sánh của chúng và trên thực tế, một số loại tích hợp đã làm được đ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ố của các loại số tích hợp sẵn () và của các loại thư viện tiêu chuẩn và có thể được so sánh trong và giữa các loại của chúng, với hạn chế là các số phức 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 (thuật toán) mà không làm mất độ chính xác

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

    parenth_form ::=  "(" [starred_expression] ")"
    13 và 
    parenth_form ::=  "(" [starred_expression] ")"
    14 là đặc biệt. Mọi so sánh theo thứ tự của một số với một giá trị không phải là số đều sai. Một hàm ý phản trực giác là các giá trị không phải là số không bằng chính chúng. Ví dụ: nếu 
    parenth_form ::=  "(" [starred_expression] ")"
    15, 
    parenth_form ::=  "(" [starred_expression] ")"
    16, 
    parenth_form ::=  "(" [starred_expression] ")"
    17 và 
    parenth_form ::=  "(" [starred_expression] ")"
    18 đều sai, trong khi 
    parenth_form ::=  "(" [starred_expression] ")"
    19 là đúng. Hành vi này phù hợp với IEEE 754

  • generator_expression ::=  "(" expression comp_for ")"
    1 và 
    parenth_form ::=  "(" [starred_expression] ")"
    21 là những người độc thân. PEP 8 khuyên rằng việc so sánh đối với các đơn tử phải luôn được thực hiện với 
    parenth_form ::=  "(" [starred_expression] ")"
    22 hoặc 
    parenth_form ::=  "(" [starred_expression] ")"
    23, không bao giờ là toán tử đẳng thức

  • Các chuỗi nhị phân (ví dụ hoặc ) có thể được so sánh trong và giữa các loại của chúng. Họ so sánh từ điển bằng cách sử dụng các giá trị số của các phần tử của họ

  • Các chuỗi (ví dụ về ) so sánh theo từ điển 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) của các ký tự của chúng.

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

  • Các chuỗi (các trường hợp của , hoặc ) chỉ có thể được so sánh trong mỗi loại của chúng, với hạn chế là các 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à so sánh thứ tự giữa các loại này làm tăng

    Các chuỗi so sánh từ điển bằng cách sử dụng so sánh các phần tử tương ứng. Các bộ chứa tích hợp thường giả sử các đối tượng giống hệt nhau bằng 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 bên trong của chúng

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

    • Để hai tập hợp có thể 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 được so sánh bằng nhau (ví dụ: 

      parenth_form ::=  "(" [starred_expression] ")"
      32 là sai vì loại không giống nhau)

    • Các tập hợp hỗ trợ so sánh thứ tự được sắp xếp giống như các phần tử không bằng nhau đầu tiên của chúng (ví dụ: 

      parenth_form ::=  "(" [starred_expression] ")"
      33 có cùng giá trị với 
      parenth_form ::=  "(" [starred_expression] ")"
      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 sẽ được sắp xếp trước (ví dụ: 
      parenth_form ::=  "(" [starred_expression] ")"
      35 là đúng)

  • Các ánh xạ (trường hợp của ) so sánh bằng nhau khi và chỉ khi chúng có các cặp 

    parenth_form ::=  "(" [starred_expression] ")"
    37 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 thứ tự (

    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    93, 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    94, 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    97, và 
    literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
    96) tăng

  • Các bộ (trường hợp của hoặc ) có thể được so sánh trong và giữa các loại của chúng

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

    parenth_form ::=  "(" [starred_expression] ")"
    45 và 
    parenth_form ::=  "(" [starred_expression] ")"
    46 không bằng nhau, cũng không phải là tập hợp con của nhau, cũng không phải tập hợp con của nhau). Theo đó, các tập hợp không phải là đối số thích hợp cho các hàm phụ thuộc vào tổng số thứ tự (ví dụ: , và tạo ra kết quả không xác định với danh sách các tập hợp làm đầu vào)

    So sánh các tập hợp thực thi tính phản xạ của các phần tử của nó

  • Hầu hết các loại tích hợp khác không có phương thức so sánh nào được triển khai, vì vậy chúng kế thừa hành vi so sánh mặc định

Các lớp do người dùng định nghĩa tùy chỉnh hành vi so sánh của chúng phải tuân theo một số quy tắc nhất quán, nếu có 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 phải là 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 tư cách thành viên

Các nhà khai thác và kiểm tra tư cách thành viên. 

parenth_form ::=  "(" [starred_expression] ")"
74 đánh giá thành 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81 nếu x là thành viên của s và 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82 nếu không. 
parenth_form ::=  "(" [starred_expression] ")"
77 trả về phủ định của 
parenth_form ::=  "(" [starred_expression] ")"
74. Tất cả các chuỗi và loại tập hợp tích hợp đều hỗ trợ điều này cũng như từ điển, trong đó 
parenth_form ::=  "(" [starred_expression] ")"
72 kiểm tra xem từ điển có khóa đã cho hay không. Đối với các loại vùng chứa như danh sách, bộ dữ liệu, bộ, bộ đóng băng, dict hoặc bộ sưu tập. deque, biểu thức 
parenth_form ::=  "(" [starred_expression] ")"
80 tương đương với 
parenth_form ::=  "(" [starred_expression] ")"
81

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

parenth_form ::=  "(" [starred_expression] ")"
80 là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81 khi và chỉ khi x là một chuỗi con của y. Một bài kiểm tra tương đương là 
parenth_form ::=  "(" [starred_expression] ")"
84. Các chuỗi rỗng luôn được coi là chuỗi con của bất kỳ chuỗi nào khác, vì vậy, 
parenth_form ::=  "(" [starred_expression] ")"
85 sẽ trả về 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81

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

parenth_form ::=  "(" [starred_expression] ")"
87, 
parenth_form ::=  "(" [starred_expression] ")"
80 trả về 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81 nếu 
parenth_form ::=  "(" [starred_expression] ")"
90 trả về giá trị thực và ngược lại là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82

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

parenth_form ::=  "(" [starred_expression] ")"
87 nhưng định nghĩa 
parenth_form ::=  "(" [starred_expression] ")"
93, 
parenth_form ::=  "(" [starred_expression] ")"
80 là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81 nếu một số giá trị 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
87, mà biểu thức 
parenth_form ::=  "(" [starred_expression] ")"
97 là đúng, được tạo ra trong khi lặp lại trên 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
86. Nếu một ngoại lệ được đưa ra trong quá trình lặp lại, thì coi như ngoại lệ đó được đưa ra

Cuối cùng, giao thức lặp kiểu cũ đã được thử. nếu một lớp định nghĩa 

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

Toán tử được định nghĩa là có giá trị chân lý nghịch đảo của

6. 10. 3. So sánh danh tính

Các toán tử và kiểm tra danh tính của một đối tượng. 

parenth_form ::=  "(" [starred_expression] ")"
04 là đúng khi và chỉ khi x và y là cùng một đối tượng. Danh tính của Đối tượng được xác định bằng 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]
12 mang lại giá trị thực nghịch đảo.

6. 11. Các phép toán Boolean

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

Trong ngữ cảnh của các phép toán Boolean và cả khi các biểu thức được sử dụng bởi các câu lệnh luồng điều khiển, các giá trị sau được hiểu là sai. 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82, 
generator_expression ::=  "(" expression comp_for ")"
1, số 0 của tất cả các loại, chuỗi và vùng chứa trống (bao gồm chuỗi, bộ dữ liệu, danh sách, từ điển, bộ và bộ đóng băng). All other values are interpreted as true. User-defined objects can customize their truth value by providing a 
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]
15 method

The operator yields 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81 if its argument is false, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82 otherwise

The expression 

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]
19 first evaluates x; if x is false, its value is returned; otherwise, y is evaluated and the resulting value is returned

The expression 

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]
20 first evaluates x; if x is true, its value is returned; otherwise, y is evaluated and the resulting value is returned

Note that neither nor restrict the value and type they return to 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82 and 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
81, but rather return the last evaluated argument. This is sometimes useful, e. g. , if 
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]
25 is a string that should be replaced by a default value if it is empty, the expression 
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]
26 yields the desired value. Because has to create a new value, it returns a boolean value regardless of the type of its argument (for example, 
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]
28 produces 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82 rather than 
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]
30. )

6. 12. Assignment expressions

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

An assignment expression (sometimes also called a “named expression” or “walrus”) assigns an to an , while also returning the value of the

One common use case is when handling matched regular expressions

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

Or, when processing a file stream in chunks

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

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 thức phụ trong biểu thức cắt, điều kiện, lambda, đối số từ khóa và biểu thức hiểu-nếu và trong các 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]
34 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]
35. Ở tất cả những nơi khác mà chúng có thể được sử dụng, dấu ngoặc đơn không bắt buộc, kể cả 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]
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]
37

Mới trong phiên bản 3. 8. Xem PEP 572 để biết thêm chi tiết về biểu thức gán.

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

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

Biểu thức điều kiện (đôi khi được gọi là “toán tử bậc ba”) có mức ưu tiên thấp nhất trong tất cả các phép toán Python

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]
38 đầu 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ề;

Xem PEP 308 để biết thêm chi tiết về biểu thức điều kiện

6. 14. Lambda

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

Biểu thức lambda (đôi khi được gọi là biểu mẫu lambda) được sử dụng để tạo hàm ẩn danh. 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]
39 mang lại một đối tượng chức năng. Đối tượng chưa được đặt tên hoạt động giống như một đối tượng chức năng được xác định bằng

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

Xem phần cú pháp của danh sách tham số. Lưu ý rằng các hàm được tạo bằng biểu thức lambda không thể chứa câu lệnh hoặc chú thích

6. 15. Danh sách biểu thức

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

Ngoại trừ khi là một phần của danh sách hoặc tập hợp hiển thị, danh sách biểu thức chứa ít nhất một dấu phẩy sẽ tạo ra một bộ. Độ dài của bộ dữ liệu là số biểu thức trong danh sách. Các biểu thức được đánh giá từ trái sang phải

Dấu hoa thị 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
12 biểu thị quá trình giải nén có thể lặp lại. Toán hạng của nó phải là một. Iterable được mở rộng thành một chuỗi các mục, được bao gồm trong bộ, danh sách hoặc bộ mới, tại vị trí giải nén

Mới trong phiên bản 3. 5. Giải nén lặp lại trong danh sách biểu thức, do PEP 448 đề xuất ban đầu.

Dấu phẩy ở cuối chỉ được yêu cầu để tạo một bộ đơn (a. k. a. một người độc thân); . Một biểu thức duy nhất không có dấu phẩy ở cuối không tạo ra một bộ dữ liệu, mà mang lại giá trị của biểu thức đó. (Để tạo một bộ trống, hãy sử dụng một cặp dấu ngoặc đơn trố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]
41. )

6. 16. Trình tự đánh giá

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 bài tập, phía bên tay 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 các hậu tố của chúng

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

6. 17. Thứ tự ưu tiên của toán tử

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

Lưu ý rằng các phép so sánh, kiểm tra tư cách 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 xâu chuỗi từ trái sang phải như được mô tả trong phần

Nhà điều hành

Sự miêu tả

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]
42,

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]
43, 
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]
44, 
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]
45

Biểu thức ràng buộc hoặc trong ngoặc đơn, hiển thị danh sách, hiển thị từ điển, hiển thị tập hợp

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]
46, 
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]
47, 
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]
48, 
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]
49

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

chờ đợi biểu hiện

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

lũy thừa

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]
52, 
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]
53, 
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]
54

Tích cực, tiêu cực, bitwise KHÔNG

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
12, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
43, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
44, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
45, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
49

Phép nhân, phép nhân ma trận, phép chia, phép chia tầng, phần dư

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
33, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
31

Cộng và trừ

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]
62, 
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]
63

Ca làm việc

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

Bitwise AND

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

Bitwise XOR

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

Bitwise HOẶC

, , , , 

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
93, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
97, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
94, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
96, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
98, 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
95

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

Boolean KHÔNG

Boolean VÀ

Boolean 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]
81

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

biểu thức lambda

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]
83

biểu thức gán

chú thích

Mặc 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]
84 đúng về mặt toán học, nhưng đối với số float, nó có thể không đúng về mặt số do làm tròn. Ví dụ: và giả sử một nền tảng trên đó Python float là số có độ chính xác kép IEEE 754, để 
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]
85 có cùng dấu với 
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]
86, thì kết quả được tính toán 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]
87, chính xác bằng số với 
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]
86. Thay vào đó, hàm trả về một kết quả có dấu khớp với dấu của đối số đầu tiên và do đó trả 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]
90 trong trường hợp này. Cách tiếp cận nào phù hợp hơn tùy thuộc vào ứng dụng

Nếu x rất gần với bội số nguyên chính xác của y, thì 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]
91 lớn hơn một số so với 
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]
92 do làm tròn. Trong những trường hợp như vậy, Python trả về kết quả cuối cùng, để đảm bảo rằ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]
93 rất gần với 
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom
79

Tiêu chuẩn Unicode phân biệt giữa các điểm mã (e. g. U+0041) và ký tự trừu tượng (e. g. “CHỮ VỐN LATIN A”). Trong khi 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ã, ngoài ra còn có một số ký tự trừu tượng có thể được biểu diễn bằng một chuỗi gồm nhiều hơn một điểm mã. Ví dụ: ký tự trừu tượng “CHỮ VỐN LATIN C VỚI CEDILLA” có thể được biểu diễn dưới dạng một ký tự được soạn trước duy nhất tại vị trí mã U+00C7 hoặc dưới dạng một chuỗi ký tự cơ sở tại vị trí mã U+0043 (CHỮ IN HOA LATIN C),

Các toán tử so sánh trên các chuỗi so sánh ở mức điểm mã Unicode. Điều này có thể phản trực giác với con ngườ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]
95 là 
literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber
82, mặc dù cả hai chuỗi đại diện cho cùng một ký tự trừu tượng “CHỮ VỐN LATIN C VỚI CEDILLA”

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

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

Toán tử lũy thừa 

set_display ::=  "{" (starred_list | comprehension) "}"
5 liên kết ít chặt chẽ hơn toán tử một ngôi số học hoặc bitwise ở bên phải của nó, nghĩa là, 
list_display ::=  "[" [starred_list | comprehension] "]"
00 là 
list_display ::=  "[" [starred_list | comprehension] "]"
01

programming python

Bài Viết Liên Quan

Danh sách trống bất biến Python
Danh sách trống bất biến Python

Khóa học lập trình viên python
Khóa học lập trình viên python

WordPress lấy ID trang trong hàm PHP
WordPress lấy ID trang trong hàm PHP

Làm cách nào để thêm một cột vào khung dữ liệu csv trong python?
Làm cách nào để thêm một cột vào khung dữ liệu csv trong python?

Câu hỏi và câu trả lời về bài kiểm tra CSS
Câu hỏi và câu trả lời về bài kiểm tra CSS

Ngày lễ ngân hàng 2023 Andhra Pradesh
Ngày lễ ngân hàng 2023 Andhra Pradesh

Các ký tự đặc biệt được sử dụng để làm gì trong Python?
Các ký tự đặc biệt được sử dụng để làm gì trong Python?

Python hỗ trợ Mcq cho loại chương trình nào?
Python hỗ trợ Mcq cho loại chương trình nào?

Samsung A22 4G giá bao nhiêu
Samsung A22 4G giá bao nhiêu

Tính tuổi trong Excel từ ngày sinh
Tính tuổi trong Excel từ ngày sinh

MỚI CẬP NHẬP

Triều đại mới của nhật bản có tên là gì năm 2024
14 phúts trước . bởi SensuousIllustration
335 đường hoàng văn thụ thành phố thái nguyên năm 2024
35 phúts trước . bởi DiscouragingSperm
Dây giày dạ quang khác bình thường như thế nào năm 2024
38 phúts trước . bởi UnderstandableDemonstration
Chị của a họ thì gọi là gì năm 2024
50 phúts trước . bởi ElectoralMorale
Sữa tắm the body shop loại nào thơm năm 2024
54 phúts trước . bởi MaudlinPuberty
Bài 63 trang 14 sbt toán 9 tập 1 năm 2024
1 giờs trước . bởi DoggedEditor
Bài tập cho tre 3 den 6 tháng tuổi năm 2024
1 giờs trước . bởi SwirlingEnvoy
Hướng dẫn fix lỗi 100 disk win 10 năm 2024
2 giờs trước . bởi ClassicSenator
Thể chất tiếng anh là gì năm 2024
2 giờs trước . bởi BlissfulQuart
Lỗi kết nối máy chủ không on định cf năm 2024
2 giờs trước . bởi UnwrittenQuorum

Xem Nhiều

Chúng ta cùng cảnh ngộ nghĩa tiếng anh là gì năm 2024
3 ngàys trước . bởi CoronaryClerk
Chứng khoán có dấu sao nghĩa là gì năm 2024
4 ngàys trước . bởi GrainyDwelling
Top 20 view của bts twice và black pink youtube năm 2024
5 ngàys trước . bởi SolicitousArchitecture
On the weekend là thì gì năm 2024
2 ngàys trước . bởi FierceCovering
Co số điện thoại di động nào 9 đó năm 2024
11 giờs trước . bởi SilverTo-day
Himax premium lub ts40 là gì năm 2024
6 giờs trước . bởi DeepeningMirth
81 2 nguyễn văn giai quận 1 f dakao năm 2024
13 giờs trước . bởi First-rateMedics
Lỗi font tiếng việt send sms from web to phone năm 2024
5 ngàys trước . bởi InauguralClutches
Các phương pháp dạy học tích cực môn hóa học năm 2024
3 ngàys trước . bởi HastyClearing
Giấy cam kết tiếng anh là gì năm 2024
3 ngàys trước . bởi CountlessAdjustment

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Bản quyền © 2024 Inc.