Toán tử dấu phẩy trong C được ký hiệu là ,. Toán tử dấu phẩy trong C có độ ưu tiên thấp nhất. Toán tử dấu phẩy trong C đảm bảo rằng hai hoặc nhiều biểu thức được phân tách bằng dấu phẩy được đánh giá lần lượt từ trái sang phải và kết quả của toàn bộ biểu thức là giá trị của biểu thức ngoài cùng bên phải. Toán tử dấu phẩy trong C chủ yếu là toán tử nhị phân hoạt động trên toán hạng có sẵn đầu tiên, loại bỏ kết quả, đánh giá toán hạng theo sau và sau đó trả về giá trị
Việc sử dụng toán tử dấu phẩy trong C là gì?
Để tách hai hay nhiều biểu thức ta sử dụng toán tử dấu phẩy trong C. Trong đó biểu thức 1 được đánh giá trước và sau đó là biểu thức 2 và giá trị của biểu thức 2 được trả về cho toàn bộ biểu thức. Trong ngôn ngữ lập trình C, dấu phẩy phục vụ một số mục đích. một toán tử và một dấu tách. Do đó, hành vi của nó khác nhau tùy thuộc vào vị trí chúng tôi đặt nó trong một chương trình
Dấu phẩy là Toán tử
Khi muốn gán nhiều số giá trị cho một biến bất kỳ trong chương trình, chúng ta sử dụng dấu phẩy dưới dạng toán tử
#include int main[] { int x; int a = [x=2,x+4]; printf["%d", a]; return 0; }
đầu ra
Giải trình. Toán tử dấu phẩy bên trong điều kiện if hoạt động như hoặc toán tử nếu câu lệnh đúng thì nó sẽ chuyển sang khối đúng, ngược lại nó sẽ chuyển sang khối sai
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 đạ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 30]. 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 30, nó sẽ được chuyển đổi thành một chuỗi bằng cách sử dụng hàmclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 32 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 30, 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 34 hoặcclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 35 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ạiNế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 35, tương ứngTê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 39 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áiclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 39 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ủaclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 39 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ánclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3Mô 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
simple_stmt ::=72expression_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
Nếu mục tiêu là một thuê bao. 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, thì
simple_stmt ::=73 đượ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]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
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
simple_stmt ::=74 được gọi với các đối số phù hợpexpression_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
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 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 bên trái và bên phải là 'đồng thời' [ví dụ:
simple_stmt ::=75 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 raexpression_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
simple_stmt ::=76expression_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
simple_stmt ::=7expression_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
Xem thêm
PEP 3132 - Giải nén lặp lại mở rộngThông số kỹ thuật cho tính năng
simple_stmt ::=77expression_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. 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
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 34[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á đích [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 đích 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ư
simple_stmt ::=78 có thể được viết lại thànhexpression_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
simple_stmt ::=79 để đạ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
|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
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 340 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 đổiKhô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,
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 341 tra cứuclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 342, sau đó đánh giáclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 343 và thực hiện phép cộng, cuối cùng, nó ghi kết quả trở lạiclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 342Ngoạ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.
expression_stmt ::=2starred_expression
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
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 345, đó 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
simple_stmt ::=74 hoặcexpression_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
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 347 cuối cùngXem 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
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 348 để 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ụ phân tích tĩnh và IDEĐã 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
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 349¶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
expression_stmt ::=8starred_expression
Dạng đơn giản,
expression_stmt ::=20, tương đương vớistarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 30Dạng mở rộng,
expression_stmt ::=21, tương đương vớistarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 32Những sự tương đương này giả định rằng
expression_stmt ::=22 vàstarred_expression
expression_stmt ::=23 đề 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 sẵnstarred_expression
expression_stmt ::=22 làstarred_expression
expression_stmt ::=25 trong các trường hợp bình thường,starred_expression
expression_stmt ::=26 khi yêu cầu tối ưu hóa [tùy chọn dòng lệnhstarred_expression
expression_stmt ::=27]. 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;starred_expression
Chuyển nhượng cho
expression_stmt ::=22 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 đầustarred_expression
7. 4. Câu lệnh
expression_stmt ::=29¶starred_expression
expression_stmt ::=0starred_expression
expression_stmt ::=29 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ạnstarred_expression
expression_stmt ::=1starred_expression
7. 5. Câu lệnh
expression_stmt ::=81¶starred_expression
expression_stmt ::=2starred_expression
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ục, 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 34 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ệexpression_stmt ::=83 sẽ được đưa rastarred_expression
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
expression_stmt ::=84¶starred_expression
expression_stmt ::=3starred_expression
expression_stmt ::=84 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 nhaustarred_expression
Nếu có một danh sách biểu thức, nó sẽ được đánh giá, nếu không thì thay thế bằng
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 30expression_stmt ::=84 để lại lệnh gọi hàm hiện tại với danh sách biểu thức [hoặcstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 30] làm giá trị trả vềKhi
expression_stmt ::=84 chuyển điều khiển ra khỏi câu lệnhstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 300 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 301, mệnh đềclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 301 đó được thực thi trước khi thực sự rời khỏi chức năngTrong một hàm tạo, câu lệnh
expression_stmt ::=84 chỉ ra rằng trình tạo đã hoàn thành và sẽ làm chostarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 304 được nâng lên. Giá trị trả về [nếu có] được dùng làm đối số để xây dựngclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 304 và trở thành thuộc tínhclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 306Trong một chức năng tạo không đồng bộ, một câu lệnh
expression_stmt ::=84 trống chỉ ra rằng trình tạo không đồng bộ đã hoàn thành và sẽ khiếnstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 308 được nâng lên. Câu lệnhexpression_stmt ::=84 không trống là lỗi cú pháp trong hàm tạo không đồng bộstarred_expression
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 320¶expression_stmt ::=4starred_expression
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 320 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ấtexpression_stmt ::=5starred_expression
tương đương với các câu lệnh biểu thức năng suất
expression_stmt ::=6starred_expression
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 chi tiết đầy đủ 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 320, 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 323¶expression_stmt ::=7starred_expression
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 323 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 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 325 sẽ xuất hiện cho biết đây là lỗiMặ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 323 đá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ủaclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 327. 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à được đính kèm 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 328, 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 329 [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ậyexpression_stmt ::=8starred_expression
Mệnh đề
expression_stmt ::=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 đính kèm với ngoại lệ được nêu dưới dạng thuộc tínhstarred_expression
expression_stmt ::=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ínhstarred_expression
expression_stmt ::=01. Nếu ngoại lệ nêu ra không được xử lý, cả hai ngoại lệ sẽ được instarred_expression
expression_stmt ::=9starred_expression
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 ::=03 hoặcstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 301, hoặc một câu lệnhexpression_stmt ::=05, được sử dụng. Sau đó, ngoại lệ trước được đính kèm dưới dạng thuộc tínhstarred_expression
expression_stmt ::=06 của ngoại lệ mớistarred_expression
assignment_stmt ::= [0target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
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 30 trong mệnh đềexpression_stmt ::=00starred_expression
assignment_stmt ::= [1target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
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. ______20 hiện được cho phép là
expression_stmt ::=10 trongstarred_expression
expression_stmt ::=11.starred_expression
Mới trong phiên bản 3. 3. Thuộc tính
expression_stmt ::=12 để chặn hiển thị tự động ngữ cảnh ngoại lệ.starred_expression
Đã 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 ::=03, thì câu lệnhstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 323 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 ::=15¶starred_expression
assignment_stmt ::= [2target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
expression_stmt ::=15 chỉ có thể xảy ra lồng nhau về mặt cú pháp trong vòng lặpstarred_expression
expression_stmt ::=17 hoặcstarred_expression
expression_stmt ::=18, nhưng không được lồng trong định nghĩa hàm hoặc lớp trong vòng lặp đóstarred_expression
Nó kết thúc vòng lặp kèm theo gần nhất, bỏ qua mệnh đề
expression_stmt ::=19 tùy chọn nếu vòng lặp có mộtstarred_expression
Nếu một vòng lặp
expression_stmt ::=17 bị kết thúc bởistarred_expression
expression_stmt ::=15, mục tiêu điều khiển vòng lặp sẽ giữ giá trị hiện tại của nóstarred_expression
Khi
expression_stmt ::=15 chuyển điều khiển ra khỏi câu lệnhstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 300 với mệnh đề ________ 401, mệnh đề ________ 401 đó được thực thi trước khi thực sự rời khỏi vòng lặp7. 10. Câu lệnh
expression_stmt ::=26¶starred_expression
assignment_stmt ::= [3target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
expression_stmt ::=26 chỉ có thể xảy ra lồng nhau về mặt cú pháp trong vòng lặpstarred_expression
expression_stmt ::=17 hoặcstarred_expression
expression_stmt ::=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ấtstarred_expression
Khi
expression_stmt ::=26 chuyển điều khiển ra khỏi câu lệnhstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 300 với mệnh đề ________ 401, mệnh đề ________ 401 đó được thực thi trước khi thực sự bắt đầu chu kỳ vòng lặp tiếp theo7. 11. Câu lệnh
expression_stmt ::=34¶starred_expression
assignment_stmt ::= [4target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
Câu lệnh nhập cơ bản [không có mệnh đề
expression_stmt ::=00] được thực hiện theo hai bướcstarred_expression
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 ::=34starred_expression
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 ::=37, thì tên theo saustarred_expression
expression_stmt ::=37 được liên kết trực tiếp với mô-đun đã nhậpstarred_expression
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 ::=00 sử dụng quy trình phức tạp hơn một chútstarred_expression
tìm mô-đun được chỉ định trong mệnh đề
expression_stmt ::=00, tải và khởi tạo mô-đun nếu cần;starred_expression
cho từng số nhận dạng được chỉ định trong mệnh đề
expression_stmt ::=34starred_expression
kiểm tra xem mô-đun đã nhập có thuộc tính theo tên đó không
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 đó
nếu không tìm thấy thuộc tính,
expression_stmt ::=42 được nâng lênstarred_expression
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 ::=37 nếu có, nếu không thì sử dụng tên thuộc tínhstarred_expression
ví dụ
assignment_stmt ::= [5target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
Nếu danh sách các mã định danh được thay thế bằng một dấu sao [
expression_stmt ::=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ệnhstarred_expression
expression_stmt ::=34starred_expression
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 ::=46; . Các tên được cung cấp trongstarred_expression
expression_stmt ::=46 đều được coi là công khai và bắt buộc phải tồn tại. Nếustarred_expression
expression_stmt ::=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 [starred_expression
expression_stmt ::=49].starred_expression
expression_stmt ::=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]starred_expression
Hình thức nhập thẻ đại diện -
expression_stmt ::=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ăngstarred_expression
expression_stmt ::=52starred_expression
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 ::=00, bạn có thể chỉ định mức độ 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 thistarred_expression
expression_stmt ::=54 từ một mô-đun trong góistarred_expression
expression_stmt ::=55 thì cuối cùng bạn sẽ nhậpstarred_expression
expression_stmt ::=56. Nếu bạn thực hiệnstarred_expression
expression_stmt ::=57 từ bên trongstarred_expression
expression_stmt ::=58, bạn sẽ nhậpstarred_expression
expression_stmt ::=59. Thông số kỹ thuật cho nhập tương đối có trong phần Nhập tương đối gói .starred_expression
expression_stmt ::=60 được cung cấp để hỗ trợ các ứng dụng xác định động các mô-đun sẽ được tảistarred_expression
Tăng sự kiện kiểm tra
expression_stmt ::=34 với các đối sốstarred_expression
expression_stmt ::=62,starred_expression
expression_stmt ::=63,starred_expression
expression_stmt ::=64,starred_expression
expression_stmt ::=65,starred_expression
expression_stmt ::=66.starred_expression
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 ::= [6target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
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 ::=67 [xem PEP 563]starred_expression
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 ::=68,starred_expression
expression_stmt ::=69,starred_expression
expression_stmt ::=70,starred_expression
expression_stmt ::=71,starred_expression
expression_stmt ::=72,starred_expression
expression_stmt ::=73,starred_expression
expression_stmt ::=74 vàstarred_expression
expression_stmt ::=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ượcstarred_expression
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 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 chuẩn
expression_stmt ::=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 thistarred_expression
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 ::= [7target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
Đó 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 đến các hàm tích hợp sẵn
expression_stmt ::=77 vàstarred_expression
expression_stmt ::=78 xảy ra trong mô-đunstarred_expression
expression_stmt ::=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ớistarred_expression
expression_stmt ::=78 — xem tài liệu về chức năng đó để biết chi tiếtstarred_expression
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
expression_stmt ::=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 thistarred_expression
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 34¶assignment_stmt ::= [8target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
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 34 là một câu lệnh 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 34, mặc dù các biến tự do có thể tham chiếu đến các biến toàn cục mà không được khai báo toàn cầuCá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 34 không được sử dụng trong cùng một khối mã có văn bản trước câu lệnhclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 34 đó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 34 không được định nghĩa là tham số chính thức hoặc là đích trong câu lệnhexpression_stmt ::=05 hoặc mệnh đềstarred_expression
expression_stmt ::=03 hoặc trong danh sách đíchstarred_expression
expression_stmt ::=17, định nghĩastarred_expression
expression_stmt ::=91, định nghĩa hàm, câu lệnhstarred_expression
expression_stmt ::=34 hoặc chú thích biếnstarred_expression
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 34 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ệnhclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 34. Cụ thể, một câu lệnhclass Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 34 chứa trong một chuỗi hoặc đối tượng mã được cung cấp cho hàmexpression_stmt ::=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ệnhstarred_expression
class Cls: x = 3 # class variable inst = Cls[] inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 34 trong mã chứa hàm . Điều tương tự cũng áp dụng cho các hàmexpression_stmt ::=98 vàstarred_expression
expression_stmt ::=78starred_expression
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 35¶assignment_stmt ::= [9target_list
"="]+ [starred_expression
|yield_expression
] target_list ::=target
[","target
]* [","] target ::=identifier
| "[" [target_list
] "]" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
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 35 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ầuCá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 35 không được xung đột với các liên kết có sẵn trong phạm vi cục bộHôn mê trong Python là gì?
Dấu phẩy tạo thành một bộ, trong Python giống như một danh sách bất biến . Python thực hiện phép gán phá hủy, được tìm thấy trong một số ngôn ngữ khác, chẳng hạn như. g. JavaScript hiện đại. Nói tóm lại, một phép gán đơn có thể ánh xạ một số biến bên trái thành cùng một số giá trị bên phải. foo, thanh = 1, 2.Toán tử nào là dấu phẩy?
Toán tử dấu phẩy về cơ bản là một toán tử nhị phân ban đầu vận hành toán hạng có sẵn đầu tiên, loại bỏ kết quả thu được từ toán hạng đó, đánh giá toán hạng hiện có .Biến dấu phẩy Python là gì?
Điều này có nghĩa là hàm trả về nhiều biến, xảy ra ở dạng một bộ . Sử dụng nhiều biến được phân tách bằng dấu phẩy sẽ giải nén bộ trả về thành các biến.