[] xung quanh một biến python có nghĩa là gì?

Question

Một tuyên bố đơn giản được bao gồm trong một dòng logic duy nhất. Một số câu lệnh đơn giản có thể xảy ra trên một dòng được phân tách bằng dấu chấm phẩy. Cú pháp cho các câu lệnh đơn giản là

Nội dung chính Show

7. 1. Câu lệnh biểu đạt¶
7. 2. Câu lệnh gán¶
7. 2. 1. Câu lệnh gán tăng cường¶
7. 2. 2. Các câu lệnh gán được chú thích¶
7. 3. Câu lệnh expression_stmt ::= starred_expression 39¶
7. 4. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 19¶
7. 5. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 71¶
7. 6. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 74¶
7. 7. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 10¶
7. 8. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 13¶
7. 9. Câu lệnh expression_stmt ::= starred_expression 15¶
7. 10. Câu lệnh expression_stmt ::= starred_expression 26¶
7. 11. Câu lệnh expression_stmt ::= starred_expression 34¶
7. 11. 1. Báo cáo tương lai¶
7. 12. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4¶
7. 13. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 5¶
[] có nghĩa là gì trong Python?
Dấu ngoặc vuông trống có nghĩa là gì trong Python?
Dấu ngoặc {} dùng để làm gì?
Dấu ngoặc vuông kép có nghĩa là gì trong Python?

simple_stmt ::=  expression_stmt
                 | assert_stmt
                 | assignment_stmt
                 | augmented_assignment_stmt
                 | annotated_assignment_stmt
                 | pass_stmt
                 | del_stmt
                 | return_stmt
                 | yield_stmt
                 | raise_stmt
                 | break_stmt
                 | continue_stmt
                 | import_stmt
                 | future_stmt
                 | global_stmt
                 | nonlocal_stmt

7. 1. Câu lệnh biểu đạt¶

Các câu lệnh biểu thức được sử dụng (chủ yếu là tương tác) để tính toán và ghi một giá trị hoặc (thường) để gọi một thủ tục (một hàm trả về kết quả không có ý nghĩa; trong Python, các thủ tục trả về giá trị

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

0). Các cách sử dụng khác của câu lệnh biểu thức được cho phép và đôi khi hữu ích. Cú pháp cho một câu lệnh biểu thức là

expression_stmt ::=  starred_expression

Một câu lệnh biểu thức đánh giá danh sách biểu thức (có thể là một biểu thức)

Trong chế độ tương tác, nếu giá trị không phải là

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

0, nó sẽ được chuyển đổi thành một chuỗi bằng cách sử dụng hàm

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

2 tích hợp và chuỗi kết quả được ghi vào đầu ra tiêu chuẩn trên một dòng (ngoại trừ nếu kết quả là

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

0, do đó thủ tục gọi . )

7. 2. Câu lệnh gán¶

Các câu lệnh gán được sử dụng để (tái) liên kết tên với các giá trị và để sửa đổi các thuộc tính hoặc mục của các đối tượng có thể thay đổi

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

(Xem phần Chính để biết các định nghĩa cú pháp cho thuộc tính tham chiếu, đăng ký và cắt. )

Một câu lệnh gán đánh giá danh sách biểu thức (hãy nhớ rằng đây có thể là một biểu thức đơn hoặc danh sách được phân tách bằng dấu phẩy, danh sách sau mang lại một bộ) và gán đối tượng kết quả duy nhất cho từng danh sách đích, từ trái sang phải

Bài tập được xác định theo cách đệ quy tùy thuộc vào dạng của mục tiêu (danh sách). Khi mục tiêu là một phần của đối tượng có thể thay đổi (tham chiếu thuộc tính, đăng ký hoặc cắt), đối tượng có thể thay đổi cuối cùng phải thực hiện phép gán và quyết định về tính hợp lệ của nó và có thể đưa ra ngoại lệ nếu phép gán không được chấp nhận. Các quy tắc được tuân theo bởi các loại khác nhau và các ngoại lệ nêu ra được đưa ra cùng với định nghĩa của các loại đối tượng (xem phần Hệ thống phân cấp loại tiêu chuẩn ).

Việc gán một đối tượng cho một danh sách đích, tùy ý đặt trong dấu ngoặc đơn hoặc dấu ngoặc vuông, được định nghĩa đệ quy như sau

Nếu danh sách mục tiêu là một mục tiêu không có dấu phẩy ở cuối, tùy chọn trong ngoặc đơn, thì đối tượng được gán cho mục tiêu đó
Khác
- Nếu danh sách mục tiêu chứa một mục tiêu có tiền tố là dấu hoa thị, được gọi là mục tiêu "được gắn dấu sao". Đối tượng phải là một đối tượng có thể lặp lại với ít nhất nhiều mục bằng số mục tiêu trong danh sách mục tiêu, trừ đi một. Các mục đầu tiên của iterable được chỉ định, từ trái sang phải, cho các mục tiêu trước mục tiêu được gắn dấu sao. Các mục cuối cùng của lần lặp được gán cho các mục tiêu sau mục tiêu được gắn dấu sao. Một danh sách các mục còn lại trong iterable sau đó được gán cho mục tiêu được gắn dấu sao (danh sách có thể trống)
- Khác. Đối tượng phải là một đối tượng có thể lặp lại với cùng số mục như có các mục tiêu trong danh sách mục tiêu và các mục được gán, từ trái sang phải, cho các mục tiêu tương ứng

Việc gán một đối tượng cho một mục tiêu được định nghĩa đệ quy như sau

Nếu mục tiêu là một mã định danh (tên)
- Nếu tên không xuất hiện trong câu lệnh
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
  4 hoặc
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
  5 trong khối mã hiện tại. tên được liên kết với đối tượng trong không gian tên cục bộ hiện tại
- Nếu không thì. tên được liên kết với đối tượng trong không gian tên chung hoặc không gian tên bên ngoài được xác định bởi
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
  5, tương ứng
Tên được phục hồi nếu nó đã bị ràng buộc. Điều này có thể khiến số lượng tham chiếu cho đối tượng trước đó được liên kết với tên về 0, khiến đối tượng bị hủy cấp phát và hàm hủy của nó (nếu có) được gọi
Nếu mục tiêu là một tham chiếu thuộc tính. Biểu thức chính trong tham chiếu được đánh giá. Nó sẽ mang lại một đối tượng với các thuộc tính có thể gán được; . Đối tượng đó sau đó được yêu cầu gán đối tượng đã gán cho thuộc tính đã cho;
Ghi chú. Nếu đối tượng là một thể hiện của lớp và tham chiếu thuộc tính xảy ra ở cả hai phía của toán tử gán, biểu thức bên phải, thì
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
9 có thể truy cập thuộc tính thể hiện hoặc (nếu không tồn tại thuộc tính thể hiện) thuộc tính lớp. Mục tiêu bên trái
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
9 luôn được đặt làm thuộc tính thể hiện, tạo nó nếu cần. Do đó, hai lần xuất hiện của
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
9 không nhất thiết đề cập đến cùng một thuộc tính. nếu biểu thức bên phải đề cập đến một thuộc tính lớp, thì bên trái sẽ tạo một thuộc tính thể hiện mới làm mục tiêu của phép gán
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
Mô tả này không nhất thiết áp dụng cho các thuộc tính mô tả, chẳng hạn như các thuộc tính được tạo bằng
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
62
Nếu mục tiêu là đăng ký. Biểu thức chính trong tham chiếu được đánh giá. Nó sẽ mang lại một đối tượng chuỗi có thể thay đổi (chẳng hạn như danh sách) hoặc đối tượng ánh xạ (chẳng hạn như từ điển). Tiếp theo, biểu thức chỉ số được đánh giá
Nếu đối tượng chính là một đối tượng chuỗi có thể thay đổi (chẳng hạn như danh sách), thì chỉ số dưới phải mang lại một số nguyên. Nếu nó âm, độ dài của chuỗi được thêm vào nó. Giá trị kết quả phải là một số nguyên không âm nhỏ hơn độ dài của chuỗi và chuỗi được yêu cầu gán đối tượng đã gán cho mục của nó với chỉ mục đó. Nếu chỉ mục nằm ngoài phạm vi, thì
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
63 được nâng lên (gán cho một chuỗi được chỉ định không thể thêm các mục mới vào danh sách)
Nếu đối tượng chính là đối tượng ánh xạ (chẳng hạn như từ điển), thì chỉ số dưới phải có loại tương thích với loại khóa của ánh xạ và sau đó ánh xạ được yêu cầu tạo một cặp khóa/mốc để ánh xạ chỉ số dưới tới đối tượng được chỉ định. Điều này có thể thay thế một cặp khóa/giá trị hiện có bằng cùng một giá trị khóa hoặc chèn một cặp khóa/giá trị mới (nếu không tồn tại khóa có cùng giá trị)
Đối với các đối tượng do người dùng định nghĩa, phương thức
```
class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
```
64 được gọi với các đối số thích hợp
Nếu mục tiêu là một lát cắt. Biểu thức chính trong tham chiếu được đánh giá. Nó sẽ mang lại một đối tượng chuỗi có thể thay đổi (chẳng hạn như danh sách). Đối tượng được gán phải là một đối tượng chuỗi cùng loại. Tiếp theo, các biểu thức giới hạn dưới và giới hạn trên được đánh giá, trong phạm vi chúng hiện diện; . Các giới hạn nên đánh giá số nguyên. Nếu một trong hai giới hạn là âm, độ dài của chuỗi được thêm vào nó. Các giới hạn kết quả được cắt bớt để nằm giữa 0 và độ dài của chuỗi, bao gồm. Cuối cùng, đối tượng chuỗi được yêu cầu thay thế lát cắt bằng các mục của chuỗi được chỉ định. Độ dài của lát có thể khác với độ dài của trình tự được chỉ định, do đó thay đổi độ dài của trình tự mục tiêu, nếu trình tự mục tiêu cho phép.

Chi tiết triển khai CPython. Trong triển khai hiện tại, cú pháp cho các mục tiêu được coi là giống như đối với các biểu thức và cú pháp không hợp lệ bị từ chối trong giai đoạn tạo mã, gây ra các thông báo lỗi ít chi tiết hơn

Mặc dù định nghĩa về phép gán ngụ ý rằng sự trùng lặp giữa bên trái và bên phải là 'đồng thời' (ví dụ:

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

65 hoán đổi hai biến), đôi khi sự chồng chéo trong tập hợp các biến được gán cho xảy ra từ trái sang phải . Chẳng hạn, chương trình sau in ra

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

66

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

6

Xem thêm

PEP 3132 - Giải nén lặp lại mở rộng

Thông số kỹ thuật cho tính năng

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

67

7. 2. 1. Câu lệnh gán tăng cường¶

Phép gán tăng cường là sự kết hợp, trong một câu lệnh, của phép toán nhị phân và câu lệnh gán

expression_stmt ::=  starred_expression

3

(Xem phần Gốc để biết định nghĩa cú pháp của ba ký hiệu cuối cùng. )

Một phép gán tăng cường đánh giá mục tiêu (không giống như các câu lệnh gán thông thường, không thể giải nén) và danh sách biểu thức, thực hiện thao tác nhị phân cụ thể cho loại phép gán trên hai toán hạng và gán kết quả cho mục tiêu ban đầu. Mục tiêu chỉ được đánh giá một lần

Một biểu thức gán tăng cường như

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

68 có thể được viết lại thành

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

69 để đạt được hiệu quả tương tự, nhưng không chính xác như nhau. Trong phiên bản tăng cường,

expression_stmt ::=  starred_expression

30 chỉ được đánh giá một lần. Ngoài ra, khi có thể, thao tác thực tế được thực hiện tại chỗ, nghĩa là thay vì tạo một đối tượng mới và gán đối tượng đó cho mục tiêu, thay vào đó, đối tượng cũ sẽ được sửa đổi

Không giống như các bài tập thông thường, các bài tập tăng cường đánh giá vế trái trước khi đánh giá vế phải. Ví dụ, trước tiên,

expression_stmt ::=  starred_expression

31 tra cứu

expression_stmt ::=  starred_expression

32, sau đó đánh giá

expression_stmt ::=  starred_expression

33 và thực hiện phép cộng, cuối cùng, nó ghi kết quả trở lại

expression_stmt ::=  starred_expression

32

Ngoại trừ việc gán cho các bộ và nhiều mục tiêu trong một câu lệnh, phép gán được thực hiện bởi các câu lệnh gán tăng cường được xử lý giống như cách gán bình thường. Tương tự, ngoại trừ hành vi tại chỗ có thể xảy ra, phép toán nhị phân được thực hiện bằng phép gán tăng cường cũng giống như phép toán nhị phân thông thường

Đối với các mục tiêu là tham chiếu thuộc tính, cảnh báo trước về thuộc tính lớp và phiên bản áp dụng như đối với các nhiệm vụ thông thường.

7. 2. 2. Các câu lệnh gán được chú thích¶

Chú thích là sự kết hợp, trong một câu lệnh, của một chú thích biến hoặc thuộc tính và một câu lệnh gán tùy chọn.

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

1

Sự khác biệt so với Các câu lệnh gán bình thường là chỉ cho phép một mục tiêu duy nhất.

Đối với các tên đơn giản làm mục tiêu gán, nếu trong phạm vi lớp hoặc mô-đun, các chú thích được đánh giá và lưu trữ trong một thuộc tính mô-đun hoặc lớp đặc biệt

expression_stmt ::=  starred_expression

35, đó là ánh xạ từ điển từ các tên biến (được đọc sai nếu là riêng tư) đến các chú thích được đánh giá. Thuộc tính này có thể ghi và được tạo tự động khi bắt đầu thực thi phần thân của lớp hoặc mô-đun, nếu các chú thích được tìm thấy tĩnh

Đối với các biểu thức là mục tiêu gán, các chú thích được đánh giá nếu trong phạm vi lớp hoặc mô-đun, nhưng không được lưu trữ

Nếu một tên được chú thích trong một phạm vi chức năng, thì tên này là cục bộ cho phạm vi đó. Chú thích không bao giờ được đánh giá và lưu trữ trong phạm vi chức năng

Nếu phía bên tay phải xuất hiện, một phép gán có chú thích sẽ thực hiện phép gán thực tế trước khi đánh giá các chú thích (nếu có). Nếu phía bên tay phải không có mặt cho mục tiêu biểu thức, thì trình thông dịch sẽ đánh giá mục tiêu ngoại trừ lệnh gọi

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

64 hoặc

expression_stmt ::=  starred_expression

37 cuối cùng

Xem thêm

PEP 526 - Cú pháp cho chú thích biến

Đề xuất đã thêm cú pháp để chú thích các loại biến (bao gồm biến lớp và biến thể hiện), thay vì thể hiện chúng thông qua nhận xét

PEP 484 - Nhập gợi ý

Đề xuất đã thêm mô-đun

expression_stmt ::=  starred_expression

38 để cung cấp cú pháp tiêu chuẩn cho các chú thích loại có thể được sử dụng trong các công cụ và IDE phân tích tĩnh

Đã thay đổi trong phiên bản 3. 8. Giờ đây, các phép gán có chú thích cho phép các biểu thức giống nhau ở phía bên tay phải như các phép gán thông thường. Trước đây, một số biểu thức (như biểu thức bộ không được đặt trong ngoặc đơn) gây ra lỗi cú pháp.

7. 3. Câu lệnh expression_stmt ::= starred_expression 39¶

Các câu lệnh khẳng định là một cách thuận tiện để chèn các xác nhận gỡ lỗi vào chương trình

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

7

Dạng đơn giản,

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

10, tương đương với

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

9

Dạng mở rộng,

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

11, tương đương với

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

1

Những sự tương đương này giả định rằng

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

12 và

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

13 đề cập đến các biến tích hợp với các tên đó. Trong triển khai hiện tại, biến tích hợp sẵn

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

12 là

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

15 trong các trường hợp bình thường,

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

16 khi yêu cầu tối ưu hóa (tùy chọn dòng lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

17). Trình tạo mã hiện tại không phát ra mã nào cho câu lệnh xác nhận khi tối ưu hóa được yêu cầu tại thời điểm biên dịch. Lưu ý rằng không cần thiết phải bao gồm mã nguồn cho biểu thức bị lỗi trong thông báo lỗi;

Chuyển nhượng cho

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

12 là bất hợp pháp. Giá trị cho biến tích hợp được xác định khi trình thông dịch bắt đầu

7. 4. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 19¶

expression_stmt ::=  starred_expression

0

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

19 là một phép toán null — khi nó được thực thi, không có gì xảy ra. Nó hữu ích như một trình giữ chỗ khi một câu lệnh được yêu cầu về mặt cú pháp, nhưng không cần thực thi mã nào, chẳng hạn

expression_stmt ::=  starred_expression

1

7. 5. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 71¶

expression_stmt ::=  starred_expression

2

Việc xóa được định nghĩa đệ quy rất giống với cách xác định phép gán. Thay vì đánh vần nó một cách chi tiết, đây là một số gợi ý

Xóa danh sách mục tiêu xóa đệ quy từng mục tiêu, từ trái sang phải

Việc xóa tên sẽ xóa ràng buộc của tên đó khỏi không gian tên cục bộ hoặc toàn cầu, tùy thuộc vào việc tên đó có xuất hiện trong câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 trong cùng một khối mã hay không. Nếu tên không bị ràng buộc, một ngoại lệ

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

73 sẽ được đưa ra

Việc xóa tham chiếu thuộc tính, đăng ký và cắt lát được chuyển đến đối tượng chính có liên quan;

Đã thay đổi trong phiên bản 3. 2. Trước đây, việc xóa một tên khỏi không gian tên cục bộ là bất hợp pháp nếu tên đó xuất hiện dưới dạng một biến tự do trong một khối lồng nhau.

7. 6. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 74¶

expression_stmt ::=  starred_expression

3

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

74 chỉ có thể xảy ra lồng nhau về mặt cú pháp trong định nghĩa hàm, không nằm trong định nghĩa lớp lồng nhau

Nếu có một danh sách biểu thức, nó sẽ được đánh giá, nếu không thì _____10 được thay thế

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

74 để lại lệnh gọi hàm hiện tại với danh sách biểu thức (hoặc

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

0) làm giá trị trả về

Khi

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

74 chuyển điều khiển ra khỏi câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

90 với mệnh đề

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

91, mệnh đề

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

91 đó được thực thi trước khi thực sự rời khỏi chức năng

Trong một hàm tạo, câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

74 chỉ ra rằng trình tạo đã hoàn thành và sẽ làm cho

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

94 được nâng lên. Giá trị trả về (nếu có) được dùng làm đối số để xây dựng

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

94 và trở thành thuộc tính

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

96

Trong một hàm tạo không đồng bộ, một câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

74 trống cho biết rằng trình tạo không đồng bộ đã hoàn thành và sẽ khiến cho

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

98 được nâng lên. Câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

74 không trống là lỗi cú pháp trong hàm tạo không đồng bộ

7. 7. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 10¶

expression_stmt ::=  starred_expression

4

Một câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

10 về mặt ngữ nghĩa tương đương với một biểu thức năng suất . Câu lệnh năng suất có thể được sử dụng để bỏ qua dấu ngoặc đơn mà nếu không sẽ được yêu cầu trong câu lệnh biểu thức năng suất tương đương. Ví dụ: báo cáo năng suất

expression_stmt ::=  starred_expression

5

tương đương với các câu lệnh biểu thức năng suất

expression_stmt ::=  starred_expression

6

Các câu lệnh và biểu thức lợi nhuận chỉ được sử dụng khi xác định một hàm trình tạo và chỉ được sử dụng trong phần thân của hàm trình tạo. Sử dụng năng suất trong định nghĩa hàm là đủ để khiến định nghĩa đó tạo hàm tạo thay vì hàm thông thường.

Để biết đầy đủ chi tiết về ngữ nghĩa của

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

10, hãy tham khảo phần Yield expression .

7. 8. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 13¶

expression_stmt ::=  starred_expression

7

Nếu không có biểu thức nào,

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

13 sẽ kích hoạt lại ngoại lệ hiện đang được xử lý, còn được gọi là ngoại lệ đang hoạt động. Nếu hiện tại không có ngoại lệ đang hoạt động, ngoại lệ

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

15 sẽ xuất hiện cho biết đây là lỗi

Mặt khác,

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

13 đánh giá biểu thức đầu tiên là đối tượng ngoại lệ. Nó phải là một lớp con hoặc một thể hiện của

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

17. Nếu nó là một lớp, thể hiện ngoại lệ sẽ được lấy khi cần bằng cách khởi tạo lớp mà không có đối số

Loại ngoại lệ là lớp của thể hiện ngoại lệ, giá trị là chính thể hiện đó

Một đối tượng truy nguyên thường được tạo tự động khi một ngoại lệ được đưa ra và gắn với nó dưới dạng thuộc tính

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

18, có thể ghi được. Bạn có thể tạo một ngoại lệ và đặt truy nguyên của riêng mình trong một bước bằng cách sử dụng phương thức ngoại lệ

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

19 (trả về cùng một phiên bản ngoại lệ, với truy nguyên được đặt thành đối số của nó), như vậy

expression_stmt ::=  starred_expression

8

Mệnh đề

expression_stmt ::=  starred_expression

00 được sử dụng cho chuỗi ngoại lệ. nếu được cung cấp, biểu thức thứ hai phải là một lớp hoặc thể hiện ngoại lệ khác. Nếu biểu thức thứ hai là một trường hợp ngoại lệ, thì nó sẽ được gắn vào ngoại lệ được nêu dưới dạng thuộc tính

expression_stmt ::=  starred_expression

01 (có thể ghi được). Nếu biểu thức là một lớp ngoại lệ, thì lớp đó sẽ được khởi tạo và thể hiện ngoại lệ kết quả sẽ được đính kèm với ngoại lệ được nêu dưới dạng thuộc tính

expression_stmt ::=  starred_expression

01. Nếu ngoại lệ nêu ra không được xử lý, cả hai ngoại lệ sẽ được in

expression_stmt ::=  starred_expression

9

Một cơ chế tương tự hoạt động hoàn toàn nếu một ngoại lệ mới được đưa ra khi một ngoại lệ đã được xử lý. Một ngoại lệ có thể được xử lý khi một mệnh đề

expression_stmt ::=  starred_expression

03 hoặc

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

91, hoặc một câu lệnh

expression_stmt ::=  starred_expression

05, được sử dụng. Sau đó, ngoại lệ trước được đính kèm dưới dạng thuộc tính

expression_stmt ::=  starred_expression

06 của ngoại lệ mới

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

0

Chuỗi ngoại lệ có thể bị triệt tiêu rõ ràng bằng cách chỉ định

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

0 trong mệnh đề

expression_stmt ::=  starred_expression

00

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

1

Thông tin bổ sung về ngoại lệ có trong phần Ngoại lệ và thông tin về xử lý ngoại lệ có trong phần The try statement.

Đã thay đổi trong phiên bản 3. 3. ______10 hiện được phép là

expression_stmt ::=  starred_expression

10 trong

expression_stmt ::=  starred_expression

11.

Mới trong phiên bản 3. 3. Thuộc tính

expression_stmt ::=  starred_expression

12 để chặn hiển thị tự động ngữ cảnh ngoại lệ.

Đã thay đổi trong phiên bản 3. 11. Nếu truy nguyên của ngoại lệ đang hoạt động được sửa đổi trong mệnh đề

expression_stmt ::=  starred_expression

03, thì câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

13 tiếp theo sẽ tăng lại ngoại lệ với truy nguyên đã sửa đổi. Trước đây, ngoại lệ đã được đưa ra lại với truy nguyên mà nó có khi bị bắt.

7. 9. Câu lệnh expression_stmt ::= starred_expression 15¶

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

2

expression_stmt ::=  starred_expression

15 chỉ có thể xảy ra lồng nhau về mặt cú pháp trong vòng lặp

expression_stmt ::=  starred_expression

17 hoặc

expression_stmt ::=  starred_expression

18, nhưng không được lồng trong định nghĩa hàm hoặc lớp trong vòng lặp đó

Nó kết thúc vòng lặp kèm theo gần nhất, bỏ qua mệnh đề

expression_stmt ::=  starred_expression

19 tùy chọn nếu vòng lặp có một

Nếu một vòng lặp

expression_stmt ::=  starred_expression

17 bị kết thúc bởi

expression_stmt ::=  starred_expression

15, mục tiêu điều khiển vòng lặp sẽ giữ giá trị hiện tại của nó

Khi

expression_stmt ::=  starred_expression

15 chuyển điều khiển ra khỏi câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

90 với mệnh đề ________ 391, mệnh đề ________ 391 đó được thực thi trước khi thực sự rời khỏi vòng lặp

7. 10. Câu lệnh expression_stmt ::= starred_expression 26¶

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

3

expression_stmt ::=  starred_expression

26 chỉ có thể xảy ra lồng nhau về mặt cú pháp trong vòng lặp

expression_stmt ::=  starred_expression

17 hoặc

expression_stmt ::=  starred_expression

18, nhưng không được lồng trong định nghĩa hàm hoặc lớp trong vòng lặp đó. Nó tiếp tục với chu kỳ tiếp theo của vòng lặp kèm theo gần nhất

Khi

expression_stmt ::=  starred_expression

26 chuyển điều khiển ra khỏi câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

90 với mệnh đề

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

91, mệnh đề

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

91 đó được thực thi trước khi thực sự bắt đầu chu kỳ vòng lặp tiếp theo

7. 11. Câu lệnh expression_stmt ::= starred_expression 34¶

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

4

Câu lệnh nhập cơ bản (không có mệnh đề

expression_stmt ::=  starred_expression

00) được thực hiện theo hai bước

tìm một mô-đun, tải và khởi tạo nó nếu cần
xác định tên hoặc tên trong không gian tên cục bộ cho phạm vi nơi xảy ra câu lệnh
```
expression_stmt ::=  starred_expression
```
34

Khi câu lệnh chứa nhiều mệnh đề (được phân tách bằng dấu phẩy), hai bước được thực hiện riêng cho từng mệnh đề, giống như thể các mệnh đề đã được tách ra thành các câu lệnh nhập riêng lẻ

Chi tiết của bước đầu tiên, tìm và tải mô-đun, được mô tả chi tiết hơn trong phần trên hệ thống nhập , đồng thời . Lưu ý rằng các lỗi trong bước này có thể cho biết không thể định vị mô-đun hoặc đã xảy ra lỗi khi khởi chạy mô-đun, bao gồm cả việc thực thi mã của mô-đun.

Nếu mô-đun được yêu cầu được truy xuất thành công, mô-đun đó sẽ được cung cấp trong không gian tên cục bộ theo một trong ba cách

Nếu tên mô-đun được theo sau bởi
```
expression_stmt ::=  starred_expression
```
37, thì tên theo sau
```
expression_stmt ::=  starred_expression
```
37 sẽ được liên kết trực tiếp với mô-đun đã nhập
Nếu không có tên nào khác được chỉ định và mô-đun đang được nhập là mô-đun cấp cao nhất, thì tên của mô-đun sẽ được liên kết trong không gian tên cục bộ dưới dạng tham chiếu đến mô-đun đã nhập
Nếu mô-đun được nhập không phải là mô-đun cấp cao nhất, thì tên của gói cấp cao nhất chứa mô-đun đó được liên kết trong không gian tên cục bộ dưới dạng tham chiếu đến gói cấp cao nhất. Mô-đun đã nhập phải được truy cập bằng tên đủ điều kiện của nó chứ không phải trực tiếp

Biểu mẫu

expression_stmt ::=  starred_expression

00 sử dụng quy trình phức tạp hơn một chút

tìm mô-đun được chỉ định trong mệnh đề
```
expression_stmt ::=  starred_expression
```
00, tải và khởi tạo mô-đun nếu cần;
cho từng số nhận dạng được chỉ định trong mệnh đề
```
expression_stmt ::=  starred_expression
```
34
1. kiểm tra xem mô-đun đã nhập có thuộc tính theo tên đó không
2. nếu không, hãy thử nhập mô-đun con có tên đó và sau đó kiểm tra lại mô-đun đã nhập để tìm thuộc tính đó
3. nếu không tìm thấy thuộc tính,
```
expression_stmt ::=  starred_expression
```
  42 được nâng lên
4. mặt khác, một tham chiếu đến giá trị đó được lưu trữ trong không gian tên cục bộ, sử dụng tên trong mệnh đề
```
expression_stmt ::=  starred_expression
```
  37 nếu có, nếu không thì sử dụng tên thuộc tính

ví dụ

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

5

Nếu danh sách các mã định danh được thay thế bằng một dấu sao (

expression_stmt ::=  starred_expression

44), thì tất cả các tên công khai được xác định trong mô-đun sẽ bị ràng buộc trong không gian tên cục bộ cho phạm vi xảy ra câu lệnh

expression_stmt ::=  starred_expression

34

Tên công khai được xác định bởi một mô-đun được xác định bằng cách kiểm tra không gian tên của mô-đun để tìm một biến có tên là

expression_stmt ::=  starred_expression

46; . Các tên được đưa ra trong

expression_stmt ::=  starred_expression

46 đều được coi là công khai và bắt buộc phải tồn tại. Nếu

expression_stmt ::=  starred_expression

46 không được xác định, tập hợp tên công khai bao gồm tất cả các tên được tìm thấy trong không gian tên của mô-đun không bắt đầu bằng ký tự gạch dưới (

expression_stmt ::=  starred_expression

49).

expression_stmt ::=  starred_expression

46 phải chứa toàn bộ API công khai. Mục đích là để tránh vô tình xuất các mục không phải là một phần của API (chẳng hạn như mô-đun thư viện đã được nhập và sử dụng trong mô-đun)

Hình thức nhập thẻ đại diện -

expression_stmt ::=  starred_expression

51 - chỉ được phép ở cấp độ mô-đun. Cố gắng sử dụng nó trong định nghĩa lớp hoặc chức năng sẽ làm tăng

expression_stmt ::=  starred_expression

52

Khi chỉ định mô-đun cần nhập, bạn không cần phải chỉ định tên tuyệt đối của mô-đun. Khi một mô-đun hoặc gói được chứa trong một gói khác, có thể thực hiện nhập tương đối trong cùng gói hàng đầu mà không cần phải đề cập đến tên gói. Bằng cách sử dụng các dấu chấm ở đầu trong mô-đun hoặc gói được chỉ định sau

expression_stmt ::=  starred_expression

00, bạn có thể chỉ định độ cao để duyệt qua hệ thống phân cấp gói hiện tại mà không cần chỉ định tên chính xác. Một dấu chấm ở đầu có nghĩa là gói hiện tại nơi mô-đun thực hiện nhập tồn tại. Hai dấu chấm có nghĩa là lên một cấp độ gói. Ba chấm là tăng hai cấp độ, v.v. Vì vậy, nếu bạn thực thi

expression_stmt ::=  starred_expression

54 từ một mô-đun trong gói

expression_stmt ::=  starred_expression

55 thì cuối cùng bạn sẽ nhập

expression_stmt ::=  starred_expression

56. Nếu bạn thực hiện

expression_stmt ::=  starred_expression

57 từ bên trong

expression_stmt ::=  starred_expression

58, bạn sẽ nhập

expression_stmt ::=  starred_expression

59. Thông số kỹ thuật cho nhập tương đối có trong phần Nhập tương đối gói .

expression_stmt ::=  starred_expression

60 được cung cấp để hỗ trợ các ứng dụng xác định động các mô-đun sẽ được tải

Tăng sự kiện kiểm tra

expression_stmt ::=  starred_expression

34 với các đối số

expression_stmt ::=  starred_expression

62,

expression_stmt ::=  starred_expression

63,

expression_stmt ::=  starred_expression

64,

expression_stmt ::=  starred_expression

65,

expression_stmt ::=  starred_expression

66.

7. 11. 1. Báo cáo tương lai¶

Câu lệnh tương lai là một chỉ thị cho trình biên dịch rằng một mô-đun cụ thể sẽ được biên dịch bằng cú pháp hoặc ngữ nghĩa sẽ có sẵn trong một bản phát hành Python được chỉ định trong tương lai khi tính năng này trở thành tiêu chuẩn

Câu lệnh tương lai nhằm mục đích dễ dàng di chuyển sang các phiên bản Python trong tương lai đưa ra các thay đổi không tương thích đối với ngôn ngữ. Nó cho phép sử dụng các tính năng mới trên cơ sở từng mô-đun trước khi phát hành trong đó tính năng này trở thành tiêu chuẩn

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

6

Một tuyên bố trong tương lai phải xuất hiện gần đầu mô-đun. Các dòng duy nhất có thể xuất hiện trước một tuyên bố trong tương lai là

chuỗi tài liệu mô-đun (nếu có),
bình luận,
dòng trống, và
tuyên bố tương lai khác

Tính năng duy nhất yêu cầu sử dụng câu lệnh tương lai là

expression_stmt ::=  starred_expression

67 (xem PEP 563)

Tất cả các tính năng lịch sử được kích hoạt bởi câu lệnh tương lai vẫn được Python 3 công nhận. Danh sách bao gồm

expression_stmt ::=  starred_expression

68,

expression_stmt ::=  starred_expression

69,

expression_stmt ::=  starred_expression

70,

expression_stmt ::=  starred_expression

71,

expression_stmt ::=  starred_expression

72,

expression_stmt ::=  starred_expression

73,

expression_stmt ::=  starred_expression

74 và

expression_stmt ::=  starred_expression

75. Tất cả chúng đều dư thừa vì chúng luôn được bật và chỉ được giữ để tương thích ngược

Một tuyên bố trong tương lai được công nhận và xử lý đặc biệt tại thời điểm biên dịch. Các thay đổi về ngữ nghĩa của các cấu trúc lõi thường được thực hiện bằng cách tạo các mã khác nhau. Thậm chí có thể xảy ra trường hợp một tính năng mới giới thiệu cú pháp không tương thích mới (chẳng hạn như một từ dành riêng mới), trong trường hợp đó, trình biên dịch có thể cần phân tích cú pháp mô-đun theo cách khác. Các quyết định như vậy không thể bị đẩy ra cho đến khi thời gian chạy

Đối với bất kỳ bản phát hành cụ thể nào, trình biên dịch biết tên tính năng nào đã được xác định và phát sinh lỗi thời gian biên dịch nếu một câu lệnh trong tương lai chứa một tính năng mà nó không biết

Ngữ nghĩa thời gian chạy trực tiếp giống như đối với bất kỳ câu lệnh nhập nào. có một mô-đun chuẩn

expression_stmt ::=  starred_expression

76, được mô tả sau và nó sẽ được nhập theo cách thông thường vào thời điểm câu lệnh tương lai được thực thi

Ngữ nghĩa thời gian chạy thú vị phụ thuộc vào tính năng cụ thể được kích hoạt bởi câu lệnh tương lai

Lưu ý rằng không có gì đặc biệt về tuyên bố

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

7

Đó không phải là một tuyên bố trong tương lai;

Mã được biên dịch bởi các lệnh gọi hàm dựng sẵn

expression_stmt ::=  starred_expression

77 và

expression_stmt ::=  starred_expression

78 xảy ra trong mô-đun

expression_stmt ::=  starred_expression

79 chứa câu lệnh tương lai, theo mặc định, sẽ sử dụng cú pháp hoặc ngữ nghĩa mới được liên kết với câu lệnh tương lai. Điều này có thể được kiểm soát bởi các đối số tùy chọn đối với

expression_stmt ::=  starred_expression

78 — xem tài liệu về chức năng đó để biết chi tiết

Một câu lệnh trong tương lai được nhập vào lời nhắc của trình thông dịch tương tác sẽ có hiệu lực trong phần còn lại của phiên thông dịch. Nếu một trình thông dịch được bắt đầu với tùy chọn

expression_stmt ::=  starred_expression

81, được chuyển một tên tập lệnh để thực thi và tập lệnh bao gồm một câu lệnh trong tương lai, nó sẽ có hiệu lực trong phiên tương tác được bắt đầu sau khi tập lệnh được thực thi

Xem thêm

PEP 236 - Quay lại __tương lai__

Đề xuất ban đầu cho cơ chế __future__

7. 12. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4¶

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

8

Câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 là một khai báo chứa toàn bộ khối mã hiện tại. Điều đó có nghĩa là các mã định danh được liệt kê sẽ được hiểu là toàn cầu. Sẽ không thể gán cho một biến toàn cầu nếu không có

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4, mặc dù các biến tự do có thể đề cập đến các biến toàn cục mà không được khai báo toàn cầu

Các tên được liệt kê trong câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 không được sử dụng trong cùng một khối mã có văn bản trước câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 đó

Các tên được liệt kê trong câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 không được định nghĩa là tham số chính thức hoặc là mục tiêu trong câu lệnh

expression_stmt ::=  starred_expression

05 hoặc mệnh đề

expression_stmt ::=  starred_expression

03 hoặc trong danh sách mục tiêu

expression_stmt ::=  starred_expression

17, định nghĩa

expression_stmt ::=  starred_expression

91, định nghĩa hàm, câu lệnh

expression_stmt ::=  starred_expression

34 hoặc chú thích biến

Chi tiết triển khai CPython. Việc triển khai hiện tại không thực thi một số hạn chế này, nhưng các chương trình không nên lạm dụng quyền tự do này, vì các triển khai trong tương lai có thể thực thi chúng hoặc âm thầm thay đổi ý nghĩa của chương trình

Ghi chú của lập trình viên.

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 là một chỉ thị cho trình phân tích cú pháp. Nó chỉ áp dụng cho mã được phân tích cú pháp cùng lúc với câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4. Cụ thể, một câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 chứa trong một chuỗi hoặc đối tượng mã được cung cấp cho hàm

expression_stmt ::=  starred_expression

77 tích hợp không ảnh hưởng đến khối mã chứa lệnh gọi hàm và mã chứa trong một chuỗi như vậy không bị ảnh hưởng bởi các câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

4 trong mã chứa hàm . Điều tương tự cũng áp dụng cho các hàm

expression_stmt ::=  starred_expression

98 và

expression_stmt ::=  starred_expression

78

7. 13. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 5¶

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

9

Câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

5 làm cho các mã định danh được liệt kê tham chiếu đến các biến bị ràng buộc trước đó trong phạm vi kèm theo gần nhất ngoại trừ các biến toàn cầu. Điều này rất quan trọng vì hành vi mặc định để ràng buộc là tìm kiếm không gian tên cục bộ trước. Câu lệnh cho phép mã được đóng gói để khởi động lại các biến bên ngoài phạm vi cục bộ bên cạnh phạm vi (mô-đun) toàn cầu

Các tên được liệt kê trong câu lệnh

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

5 không được xung đột với các ràng buộc có sẵn trong phạm vi cục bộ

[] có nghĩa là gì trong Python?

Dấu ngoặc chỉ số ([]) có nhiều công dụng trong Python. Đầu tiên, chúng được sử dụng để xác định "danh sách chữ", cho phép bạn khai báo một danh sách và nội dung của nó trong chương trình của bạn. Dấu ngoặc chỉ mục cũng được sử dụng để viết các biểu thức đánh giá một mục trong danh sách hoặc một ký tự trong chuỗi.

Dấu ngoặc vuông trống có nghĩa là gì trong Python?

Đây là để cho biết rằng bạn có một "danh sách" trống chứ không phải bất kỳ biến nào . Nó cũng cho phép bạn gọi các phương thức cụ thể như. nối thêm được sử dụng trong mã của bạn cho subst_words.

Dấu ngoặc {} dùng để làm gì?

Dấu ngoặc vuông được sử dụng để chèn giải thích, chỉnh sửa, làm rõ hoặc nhận xét vào tài liệu được trích dẫn . Dấu ngoặc luôn được sử dụng theo cặp; . Đừng nhầm lẫn dấu ngoặc [ ] với dấu ngoặc đơn ( ).

Dấu ngoặc vuông kép có nghĩa là gì trong Python?

Bạn có thể sử dụng dấu ngoặc đơn hoặc dấu ngoặc kép. Dấu ngoặc đơn sẽ xuất Chuỗi Pandas, trong khi dấu ngoặc kép sẽ xuất Khung dữ liệu Pandas .

programming python

[] xung quanh một biến python có nghĩa là gì?

7. 1. Câu lệnh biểu đạt¶

7. 2. Câu lệnh gán¶

7. 2. 1. Câu lệnh gán tăng cường¶

7. 2. 2. Các câu lệnh gán được chú thích¶

7. 3. Câu lệnh expression_stmt ::= starred_expression 39¶

7. 4. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 19¶

7. 5. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 71¶

7. 6. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 74¶

7. 7. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 10¶

7. 8. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 13¶

7. 9. Câu lệnh expression_stmt ::= starred_expression 15¶

7. 10. Câu lệnh expression_stmt ::= starred_expression 26¶

7. 11. Câu lệnh expression_stmt ::= starred_expression 34¶

7. 11. 1. Báo cáo tương lai¶

7. 12. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4¶

7. 13. Câu lệnh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 5¶

[] có nghĩa là gì trong Python?

Dấu ngoặc vuông trống có nghĩa là gì trong Python?

Dấu ngoặc {} dùng để làm gì?

Dấu ngoặc vuông kép có nghĩa là gì trong Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội