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

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à

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 thức

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à viết 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 tích hợp sẵn và chuỗi kết quả được tự 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 do . )

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 đị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

Chuyển nhượng được xác định đệ quy tùy thuộc vào hình thức 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 )

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 hoặc 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 , 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, thì biểu thức bên phả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 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 phía 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

  • 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 đố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, đượ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

    x = [0, 1]
    i = 0
    i, x[i] = 1, 2         # i is updated, then x[i] is updated
    print(x)
    
    4 đượ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ắt có thể khác với độ dài của trình tự được chỉ định, do đó làm 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 quá trình 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ệ sẽ 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 vế trái và vế phải là 'đồng thời' (ví dụ:

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)
5 hoán đổi hai biến), nhưng đôi khi sự trùng lặp 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
x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)
6

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)

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

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)
7

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

augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="

(Xem phần định nghĩa cú pháp của ba ký hiệu cuối. )

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ư

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)
8 có thể được viết lại thành
x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)
9 để đạt được hiệu quả tương tự, nhưng không hoàn toàn bằng nhau. Trong phiên bản tăng cường,
augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
0 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ụ:

augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
1 lần đầu tiên tìm kiếm
augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
2, sau đó nó đánh giá
augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
3 và thực hiện phép cộng, cuối cùng, nó ghi kết quả trở lại
augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
2

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 thông 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, áp dụng tương tự 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

phép gán 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

annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]

Sự khác biệt so với 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

augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
5 đó 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 đối với mục tiêu diễn đạt, thì thông dịch viên sẽ đánh giá mục tiêu ngoại trừ lần gọi

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)
4 hoặc
augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
7 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 để 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 augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 9

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

assert_stmt ::=  "assert" expression ["," expression]

Dạng đơn giản,

annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]
0, tương đương với

if __debug__:
    if not expression: raise AssertionError

Dạng mở rộng,

annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]
1, tương đương với

if __debug__:
    if not expression1: raise AssertionError(expression2)

Những sự tương đương này giả định rằng và đề cập đến các biến tích hợp với các tên đó. Trong quá trình triển khai hiện tại, biến tích hợp là

annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]
5 trong các trường hợp bình thường,
annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]
6 khi yêu cầu tối ưu hóa (tùy chọn dòng lệnh). 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 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 annotated_assignment_stmt ::= augtarget ":" expression ["=" (starred_expression | yield_expression)] 9

expression_stmt ::=  starred_expression
0

là một hoạt động 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 assert_stmt ::= "assert" expression ["," expression] 1

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 một câu lệnh 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ệ sẽ được nêu 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 assert_stmt ::= "assert" expression ["," expression] 4

expression_stmt ::=  starred_expression
3

chỉ có thể xảy ra lồng nhau về mặt cú pháp trong định nghĩa hàm, không phải 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ì ____1_______0 được thay thế

rời khỏ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 chuyển quyền kiểm soát ra khỏi câu lệnh có mệnh đề, mệnh đề

if __debug__:
    if not expression: raise AssertionError
1 đó được thực thi trước khi thực sự rời khỏi hàm

Trong một hàm trình tạo, câu lệnh chỉ ra rằng trình tạo đã hoàn thành và sẽ được nâng lên. Giá trị trả về (nếu có) được dùng làm đối số để xây dựng và trở thành thuộc tính

if __debug__:
    if not expression: raise AssertionError
6

Trong hàm tạo không đồng bộ, một câu lệnh trống cho biết rằng trình tạo không đồng bộ đã hoàn thành và sẽ gây ra sự cố. Câu lệnh

assert_stmt ::=  "assert" expression ["," expression]
4 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 if __debug__: if not expression1: raise AssertionError(expression2) 0

expression_stmt ::=  starred_expression
4

Một câu lệnh tương đương về mặt ngữ nghĩa với mộ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

Biểu thức và câu lệnh lợi nhuận chỉ được sử dụng khi xác định hàm và chỉ được sử dụng trong phần thân của hàm 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, hãy tham khảo phần

7. 8. Câu lệnh if __debug__: if not expression1: raise AssertionError(expression2) 3

expression_stmt ::=  starred_expression
7

Nếu không có biểu thức nào, hãy tăng 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 không có ngoại lệ đang hoạt động, một ngoại lệ sẽ xuất hiện cho biết đây là lỗi

Mặt khác, đá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. 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

if __debug__:
    if not expression1: raise AssertionError(expression2)
8, 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ệ (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 để xâu 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 hoặc mệnh đề hoặc một câu lệnh đượ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 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ề các trường hợp ngoại lệ có trong phần và thông tin về cách xử lý các trường hợp ngoại lệ có trong phần

Đã thay đổi trong phiên bản 3. 3. hiện được cho 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ột mệnh đề, thì câu lệnh

if __debug__:
    if not expression1: raise AssertionError(expression2)
3 tiếp theo sẽ nêu 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

chỉ có thể xảy ra lồng nhau về mặt cú pháp trong vòng lặp hoặc, 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 bị kết thúc bởi , mục tiêu điều khiển vòng lặp sẽ giữ nguyên giá trị hiện tại của nó

Khi chuyển điều khiển ra khỏi câu lệnh có mệnh đề, mệnh đề

if __debug__:
    if not expression: raise AssertionError
1 đó đượ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

chỉ có thể xảy ra lồng nhau về mặt cú pháp trong vòng lặp hoặc, 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 chuyển điều khiển ra khỏi câu lệnh có mệnh đề, mệnh đề

if __debug__:
    if not expression: raise AssertionError
1 đó được thực thi trước khi thực sự bắt đầu chu trình 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 đề) được thực hiện theo hai bước

  1. tìm một mô-đun, tải và khởi tạo nó nếu cần

  2. xác định tên hoặc tên trong không gian tên cục bộ cho phạm vi nơi câu lệnh xảy ra

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 , phần này cũng mô tả các loại gói và mô-đun khác nhau có thể được nhập, cũng như tất cả các hook có thể được sử dụng để tùy chỉnh . 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 đượ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 sử dụng quy trình phức tạp hơn một chút

  1. tìm mô-đun được chỉ định trong mệnh đề, tải và khởi tạo mô-đun nếu cần;

  2. cho mỗi định danh được chỉ định trong các điều khoản

    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 thuộc tính không được tìm thấy, đượ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 (_______2_______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

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 cung cấp 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 các 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. Việc cố gắng sử dụng nó trong các định nghĩa lớp hoặc hàm sẽ làm tăng

Khi chỉ định mô-đun nào sẽ nhập, bạn không 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 khi 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 khẩu tương đối có trong phần

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

Đưa ra một

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. Các câu lệnh trong 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

Đặc điểm duy nhất yêu cầu sử dụng câu 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. Những 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 tiêu chuẩn, đượ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;

Theo mặc định, mã được biên dịch bởi các lệnh gọi đến các hàm tích hợp và xảy ra trong một mô-đun

expression_stmt ::=  starred_expression
79 chứa câu lệnh tương lai 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 để — 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 tại dấu nhắc phiên dịch tương tác sẽ có hiệu lực trong phần còn lại của phiên phiên dịch. Nếu một trình thông dịch được bắt đầu với tùy chọn, đượ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 là một tuyên bố giữ cho 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. Không thể gán cho một biến toàn cục mà 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ầu mà không được khai báo toàn cầu

Các tên được liệt kê trong một câu lệnh không được sử dụng trong cùng một khối mã theo 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 không được định nghĩa là tham số hình thức, hoặc là đích trong câu lệnh hoặc mệnh đề, hoặc trong danh sách đích, định nghĩa, định nghĩa hàm, câu lệnh 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. 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 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 lệnh gọi hàm. Điều tương tự cũng áp dụng cho các hàm và

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 khiến 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 không bao gồm toàn cầu. Điều này rất quan trọng vì hành vi mặc định để liên kết 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 một câu lệnh, không giống như những tên được liệt kê trong một câu lệnh, phải tham chiếu đến các liên kết có sẵn trong một phạm vi kèm theo (không thể xác định rõ ràng phạm vi trong đó một liên kết mới sẽ được tạo)

[] được gọi bằng Python là gì?

Dấu ngoặc đơn . () (AKA "dấu ngoặc tròn") .

Sự khác biệt giữa () [] {} là gì?

() là dấu ngoặc đơn. Chúng được sử dụng để cung cấp thông tin bổ sung và nhận xét cho một câu. [] là dấu ngoặc vuông, dùng để cung cấp ngữ cảnh cho câu có thông tin bị lược bỏ. {} là dấu ngoặc nhọn, không có công dụng trong văn học nhưng thường được sử dụng trong lập trình

có nghĩa là gì [. 3 có nghĩa là con trăn?

[3. ] là chỉ số dưới có nghĩa là chỉ số . Như được hiển thị ở đây, nó được gọi là một lát cắt.