Làm cách nào để bạn thực thi câu lệnh if trong python?

Từ các hướng dẫn trước trong loạt bài này, giờ đây bạn đã có khá nhiều mã Python cần thiết. Mọi thứ bạn đã thấy cho đến nay đều bao gồm việc thực thi tuần tự, trong đó các câu lệnh luôn được thực hiện nối tiếp nhau, theo đúng thứ tự đã chỉ định

Nhưng thế giới thường phức tạp hơn thế. Thông thường, một chương trình cần bỏ qua một số câu lệnh, thực hiện lặp lại một loạt câu lệnh hoặc chọn giữa các nhóm câu lệnh thay thế để thực thi

Đó là nơi các cấu trúc điều khiển xuất hiện. Cấu trúc điều khiển chỉ đạo thứ tự thực hiện các câu lệnh trong chương trình [được gọi là luồng điều khiển của chương trình]

Đây là những gì bạn sẽ học trong hướng dẫn này. Bạn sẽ bắt gặp cấu trúc điều khiển Python đầu tiên của mình, câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5

Trong thế giới thực, chúng ta thường phải đánh giá thông tin xung quanh mình và sau đó chọn cách hành động này hay cách khác dựa trên những gì chúng ta quan sát được.

Nếu thời tiết đẹp thì tôi sẽ cắt cỏ. [Ngụ ý rằng nếu thời tiết không đẹp thì tôi sẽ không cắt cỏ. ]

Trong một chương trình Python, câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 là cách bạn thực hiện kiểu ra quyết định này. Nó cho phép thực thi có điều kiện một câu lệnh hoặc một nhóm câu lệnh dựa trên giá trị của một biểu thức

Các phác thảo của hướng dẫn này là như sau

  • Đầu tiên, bạn sẽ có cái nhìn tổng quan nhanh về câu lệnh
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    5 ở dạng đơn giản nhất
  • Tiếp theo, sử dụng câu lệnh
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    5 làm mẫu, bạn sẽ thấy tại sao các cấu trúc điều khiển yêu cầu một số cơ chế để nhóm các câu lệnh lại với nhau thành các câu lệnh hoặc khối phức hợp. Bạn sẽ học cách thực hiện điều này trong Python
  • Cuối cùng, bạn sẽ liên kết tất cả lại với nhau và học cách viết mã ra quyết định phức tạp

Sẳn sàng?

Lấy bài kiểm tra. Kiểm tra kiến ​​thức của bạn với bài kiểm tra tương tác “Câu lệnh có điều kiện Python” của chúng tôi. Sau khi hoàn thành, bạn sẽ nhận được điểm số để có thể theo dõi quá trình học tập của mình theo thời gian

Lấy bài kiểm tra "

Giới thiệu Tuyên bố
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5

Chúng ta sẽ bắt đầu bằng cách xem xét loại câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 cơ bản nhất. Ở dạng đơn giản nhất, nó trông như thế này

if :
    

Ở dạng hiển thị ở trên

  • C:\Users\john\Documents>python foo.py
    After conditional
    
    1 là một biểu thức được đánh giá trong ngữ cảnh Boolean, như đã thảo luận trong phần về Toán tử logic trong hướng dẫn Toán tử và Biểu thức trong Python
  • C:\Users\john\Documents>python foo.py
    After conditional
    
    2 là một câu lệnh Python hợp lệ, phải được thụt vào. [Bạn sẽ thấy tại sao rất sớm. ]

Nếu

C:\Users\john\Documents>python foo.py
After conditional
1 là true [được đánh giá thành giá trị “true”], thì
C:\Users\john\Documents>python foo.py
After conditional
2 được thực thi. Nếu
C:\Users\john\Documents>python foo.py
After conditional
1 là sai, thì
C:\Users\john\Documents>python foo.py
After conditional
2 sẽ bị bỏ qua và không được thực thi

Lưu ý rằng dấu hai chấm [

C:\Users\john\Documents>python foo.py
After conditional
7] sau
C:\Users\john\Documents>python foo.py
After conditional
1 là bắt buộc. Một số ngôn ngữ lập trình yêu cầu đặt
C:\Users\john\Documents>python foo.py
After conditional
1 trong ngoặc đơn, nhưng Python thì không

Dưới đây là một số ví dụ về loại câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 này

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
7

Ghi chú. Nếu bạn đang thử các ví dụ này một cách tương tác trong phiên REPL, bạn sẽ thấy rằng khi bạn nhấn Enter sau khi nhập câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
81, không có gì xảy ra.

Vì đây là câu lệnh nhiều dòng nên bạn cần nhấn Enter lần thứ hai để thông dịch viên thông dịch rằng bạn đã hoàn thành câu lệnh đó. Dòng mới bổ sung này không cần thiết trong mã được thực thi từ tệp tập lệnh.

Loại bỏ các quảng cáo

Báo cáo nhóm. Thụt đầu dòng và khối

Càng xa càng tốt

Nhưng giả sử bạn muốn đánh giá một điều kiện và sau đó thực hiện nhiều việc nếu điều kiện đó đúng

Nếu thời tiết đẹp thì tôi sẽ

  • Cắt cỏ
  • Loại bỏ các vườn
  • Dắt chó đi dạo

[Nếu thời tiết không đẹp thì tôi sẽ không làm bất cứ điều gì trong số này. ]

Trong tất cả các ví dụ hiển thị ở trên, mỗi

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
82 chỉ được theo sau bởi một
C:\Users\john\Documents>python foo.py
After conditional
2 duy nhất. Cần phải có cách nào đó để nói “Nếu
C:\Users\john\Documents>python foo.py
After conditional
1 là đúng, hãy làm tất cả những điều sau đây. ”

Cách tiếp cận thông thường được thực hiện bởi hầu hết các ngôn ngữ lập trình là xác định một thiết bị cú pháp nhóm nhiều câu lệnh thành một câu lệnh hoặc khối phức hợp. Một khối được coi về mặt cú pháp như một thực thể duy nhất. Khi nó là mục tiêu của câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 và
C:\Users\john\Documents>python foo.py
After conditional
1 là đúng, thì tất cả các câu lệnh trong khối được thực thi. Nếu
C:\Users\john\Documents>python foo.py
After conditional
1 là sai, thì không ai trong số họ là

Hầu như tất cả các ngôn ngữ lập trình đều cung cấp khả năng xác định các khối, nhưng không phải tất cả chúng đều cung cấp theo cùng một cách. Hãy xem Python làm điều đó như thế nào

con trăn. Đó là tất cả về vết lõm

Python tuân theo một quy ước được gọi là quy tắc bên ngoài, một thuật ngữ được đặt ra bởi nhà khoa học máy tính người Anh Peter J. Landin. [Thuật ngữ này được lấy từ luật việt vị trong hiệp hội bóng đá. ] Các ngôn ngữ tuân thủ quy tắc bên ngoài xác định các khối bằng cách thụt đầu dòng. Python là một trong những ngôn ngữ quy tắc bên ngoài tương đối nhỏ

Nhớ lại từ hướng dẫn trước về cấu trúc chương trình Python rằng thụt đầu dòng có ý nghĩa đặc biệt trong chương trình Python. Bây giờ bạn biết tại sao. thụt lề được sử dụng để xác định các câu lệnh hoặc khối ghép. Trong một chương trình Python, các câu lệnh liền kề được thụt vào cùng một mức được coi là một phần của cùng một khối

Do đó, một câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 ghép trong Python trông như thế này

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
6

Ở đây, tất cả các câu lệnh ở mức thụt đầu dòng phù hợp [dòng 2 đến dòng 5] được coi là một phần của cùng một khối. Toàn bộ khối được thực thi nếu

C:\Users\john\Documents>python foo.py
After conditional
1 là đúng hoặc bỏ qua nếu
C:\Users\john\Documents>python foo.py
After conditional
1 là sai. Dù bằng cách nào, quá trình thực thi vẫn tiếp tục với
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
91 [dòng 6] sau đó

Hợp chất Python if Tuyên bố

Lưu ý rằng không có mã thông báo nào biểu thị phần cuối của khối. Thay vào đó, phần cuối của khối được biểu thị bằng một dòng được thụt vào ít hơn các dòng của chính khối đó

Ghi chú. Trong tài liệu Python, một nhóm các câu lệnh được xác định bằng cách thụt đầu dòng thường được gọi là một bộ. Loạt bài hướng dẫn này sử dụng thuật ngữ khối và bộ thay thế cho nhau

Xem xét tệp kịch bản này

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
92

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']

Đang chạy

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
92 tạo ra kết quả này

C:\Users\john\Documents>python foo.py
After conditional

Bốn câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
94 trên dòng 2 đến 5 được thụt vào cùng cấp với nhau. Chúng tạo thành khối sẽ được thực thi nếu điều kiện là đúng. Nhưng nó sai, vì vậy tất cả các câu lệnh trong khối đều bị bỏ qua. Sau khi kết thúc câu lệnh phức hợp
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 [cho dù các câu lệnh trong khối từ dòng 2 đến dòng 5 có được thực thi hay không], quá trình thực thi sẽ chuyển sang câu lệnh đầu tiên có mức thụt đầu dòng nhỏ hơn. câu lệnh
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
94 trên dòng 6

Các khối có thể được lồng vào nhau theo độ sâu tùy ý. Mỗi vết lõm xác định một khối mới và mỗi vết lõm kết thúc khối trước đó. Cấu trúc kết quả là đơn giản, nhất quán và trực quan

Đây là một tập lệnh phức tạp hơn có tên là

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
97

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
8

Đầu ra được tạo khi chạy tập lệnh này được hiển thị bên dưới

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
9

Ghi chú. Trong trường hợp bạn đang thắc mắc, quy tắc bên lề là lý do cần có thêm dòng mới khi nhập câu lệnh nhiều dòng trong phiên REPL. Mặt khác, trình thông dịch không có cách nào để biết rằng câu lệnh cuối cùng của khối đã được nhập

Loại bỏ các quảng cáo

Các ngôn ngữ khác làm gì?

Có lẽ bạn đang tò mò những lựa chọn thay thế là gì. Các khối được xác định như thế nào trong các ngôn ngữ không tuân thủ quy tắc bên ngoài?

Chiến thuật được hầu hết các ngôn ngữ lập trình sử dụng là chỉ định các mã thông báo đặc biệt đánh dấu điểm bắt đầu và kết thúc của một khối. Ví dụ, trong Perl, các khối được định nghĩa bằng cặp dấu ngoặc nhọn [

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
98] như thế này

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
1

C/C++, Java và toàn bộ các ngôn ngữ khác sử dụng dấu ngoặc nhọn theo cách này

Kết hợp câu lệnh if trong C/C++, Perl và Java

Các ngôn ngữ khác, chẳng hạn như Algol và Pascal, sử dụng từ khóa

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
99 và
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
10 để bao quanh các khối

Cái nào tốt hơn?

Tốt hơn là trong mắt của kẻ si tình. Nhìn chung, các lập trình viên có xu hướng cảm thấy khá mạnh mẽ về cách họ làm mọi việc. Tranh luận về giá trị của luật việt vị có thể diễn ra khá sôi nổi

Về mặt tích cực

  • Việc sử dụng thụt đầu dòng của Python sạch sẽ, ngắn gọn và nhất quán
  • Trong các ngôn ngữ lập trình không sử dụng quy tắc bên lề, việc thụt đầu dòng mã hoàn toàn độc lập với định nghĩa khối và chức năng mã. Có thể viết mã được thụt lề theo cách không thực sự khớp với cách mã thực thi, do đó tạo ra ấn tượng sai lầm khi một người chỉ nhìn lướt qua nó. Loại lỗi này hầu như không thể mắc phải trong Python
  • Việc sử dụng thụt đầu dòng để xác định các khối buộc bạn phải duy trì các tiêu chuẩn định dạng mã mà có lẽ bạn vẫn nên sử dụng

Về mặt tiêu cực

  • Nhiều lập trình viên không thích bị bắt buộc phải làm mọi thứ theo một cách nhất định. Họ có xu hướng có quan điểm mạnh mẽ về những gì có vẻ tốt và những gì không, và họ không muốn bị ép buộc vào một lựa chọn cụ thể.
  • Một số trình soạn thảo chèn hỗn hợp các ký tự dấu cách và tab vào bên trái của các dòng thụt lề, điều này khiến trình thông dịch Python khó xác định mức độ thụt lề. Mặt khác, thường có thể định cấu hình trình chỉnh sửa không làm điều này. Dù sao đi nữa, nó thường không được coi là mong muốn có sự kết hợp giữa các tab và khoảng trắng trong mã nguồn, bất kể ngôn ngữ là gì

Dù muốn hay không, nếu bạn đang lập trình bằng Python, bạn sẽ mắc kẹt với quy tắc bên lề. Tất cả các cấu trúc điều khiển trong Python đều sử dụng nó, như bạn sẽ thấy trong một số hướng dẫn sau này

Đối với những gì nó đáng giá, nhiều lập trình viên đã quen với các ngôn ngữ có định nghĩa khối truyền thống hơn ban đầu đã quay trở lại với cách của Python nhưng đã cảm thấy thoải mái với nó và thậm chí đã trở nên thích nó hơn

Các mệnh đề
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11 và
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12

Bây giờ bạn đã biết cách sử dụng câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 để thực thi có điều kiện một câu lệnh hoặc một khối gồm nhiều câu lệnh. Đã đến lúc tìm hiểu xem bạn có thể làm gì khác

Đôi khi, bạn muốn đánh giá một điều kiện và chọn một đường dẫn nếu nó đúng nhưng chỉ định một đường dẫn thay thế nếu nó không đúng. Điều này được thực hiện với một mệnh đề

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
8

Nếu

C:\Users\john\Documents>python foo.py
After conditional
1 là đúng, bộ đầu tiên được thực thi và bộ thứ hai bị bỏ qua. Nếu
C:\Users\john\Documents>python foo.py
After conditional
1 là sai, bộ đầu tiên sẽ bị bỏ qua và bộ thứ hai được thực thi. Dù bằng cách nào, quá trình thực thi sẽ tiếp tục sau bộ thứ hai. Cả hai bộ được xác định bằng thụt đầu dòng, như được mô tả ở trên

Trong ví dụ này,

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
17 nhỏ hơn
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
18, vì vậy bộ đầu tiên [dòng 4 đến dòng 5] được thực thi và bộ thứ hai [dòng 7 đến 8] được bỏ qua

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
3

Mặt khác, ở đây, ________ 417 lớn hơn ________ 418, vì vậy bộ đầu tiên được chuyển qua và bộ thứ hai được thực thi

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
70

Ngoài ra còn có cú pháp để thực hiện phân nhánh dựa trên một số lựa chọn thay thế. Đối với điều này, hãy sử dụng một hoặc nhiều mệnh đề

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12 [viết tắt của other if]. Python lần lượt đánh giá từng
C:\Users\john\Documents>python foo.py
After conditional
1 và thực thi bộ phần mềm tương ứng với giá trị đầu tiên là đúng. Nếu không có biểu thức nào đúng và mệnh đề
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11 được chỉ định, thì bộ của nó được thực thi

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
71

Có thể chỉ định số lượng tùy ý các mệnh đề

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12. Mệnh đề
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11 là tùy chọn. Nếu nó hiện diện, thì chỉ có thể có một và nó phải được chỉ định cuối cùng

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
72

Tối đa, một trong các khối mã được chỉ định sẽ được thực thi. Nếu không bao gồm mệnh đề

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11 và tất cả các điều kiện đều sai, thì sẽ không có khối nào được thực thi

Ghi chú. Sử dụng một chuỗi dài dòng

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5/
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12/
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11 có thể hơi kém trang nhã, đặc biệt khi các hành động là những câu đơn giản như
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
94. Trong nhiều trường hợp, có thể có một cách Pythonic hơn để thực hiện điều tương tự

Đây là một giải pháp thay thế khả thi cho ví dụ trên bằng cách sử dụng phương pháp

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
31

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
73

Nhớ lại từ hướng dẫn về từ điển Python rằng phương thức

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
31 tìm kiếm từ điển cho khóa đã chỉ định và trả về giá trị được liên kết nếu tìm thấy hoặc giá trị mặc định đã cho nếu không tìm thấy

Câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 với mệnh đề
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12 sử dụng đánh giá ngắn mạch, tương tự như những gì bạn đã thấy với toán tử
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
35 và
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
36. Khi một trong các biểu thức được tìm thấy là đúng và khối của nó được thực thi, không có biểu thức nào còn lại được kiểm tra. Điều này được thể hiện dưới đây

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
74

Biểu thức thứ hai chứa phép chia cho 0 và biểu thức thứ ba tham chiếu một biến không xác định

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
37. Một trong hai sẽ gây ra lỗi, nhưng cả hai đều không được đánh giá vì điều kiện đầu tiên được chỉ định là đúng

Loại bỏ các quảng cáo

Câu lệnh một dòng
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5

Thông thường viết

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
39 trên một dòng và
C:\Users\john\Documents>python foo.py
After conditional
2 thụt vào dòng tiếp theo như thế này

if :
    

Nhưng được phép viết toàn bộ câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 trên một dòng. Sau đây là chức năng tương đương với ví dụ trên

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
76

Thậm chí có thể có nhiều hơn một

C:\Users\john\Documents>python foo.py
After conditional
2 trên cùng một dòng, được phân tách bằng dấu chấm phẩy

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
77

Nhưng nó có nghĩa gì?

  1. Nếu

    C:\Users\john\Documents>python foo.py
    After conditional
    
    1 là đúng, thực thi
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    704

    Sau đó, thực hiện

     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    705 vô điều kiện, bất kể
    C:\Users\john\Documents>python foo.py
    After conditional
    
    1 có đúng hay không

  2. Nếu

    C:\Users\john\Documents>python foo.py
    After conditional
    
    1 là đúng, thực hiện tất cả các
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    708. Mặt khác, không thực hiện bất kỳ trong số họ

Python có cách giải thích sau. Dấu chấm phẩy ngăn cách

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
709 có độ ưu tiên cao hơn so với dấu hai chấm theo sau
C:\Users\john\Documents>python foo.py
After conditional
1—trong biệt ngữ máy tính, dấu chấm phẩy được cho là liên kết chặt chẽ hơn dấu hai chấm. Do đó,
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
709 được coi là một bộ và tất cả chúng đều được thực thi hoặc không có cái nào được

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
78

Nhiều câu lệnh cũng có thể được chỉ định trên cùng một dòng với mệnh đề

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12 hoặc
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
79

Mặc dù tất cả những điều này đều hoạt động và trình thông dịch cho phép nhưng nó thường không được khuyến khích với lý do nó dẫn đến khả năng đọc kém, đặc biệt đối với các câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 phức tạp. PEP 8 đặc biệt khuyến nghị chống lại nó

Như thường lệ, đó là một vấn đề của hương vị. Hầu hết mọi người sẽ thấy những điều sau đây hấp dẫn hơn và dễ hiểu hơn ngay từ cái nhìn đầu tiên so với ví dụ trên

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
60

Tuy nhiên, nếu một câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 đủ đơn giản, thì việc đặt tất cả trên một dòng có thể hợp lý. Một cái gì đó như thế này có lẽ sẽ không nâng cao quá nhiều cho bất cứ ai

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
61

Biểu thức điều kiện [Toán tử ternary của Python]

Python hỗ trợ một thực thể ra quyết định bổ sung được gọi là biểu thức điều kiện. [Nó còn được gọi là toán tử có điều kiện hoặc toán tử bậc ba ở nhiều nơi trong tài liệu Python. ] Biểu thức điều kiện đã được đề xuất bổ sung cho ngôn ngữ trong PEP 308 và được Guido bật đèn xanh vào năm 2005

Ở dạng đơn giản nhất, cú pháp của biểu thức điều kiện như sau

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
62

Điều này khác với các dạng câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 được liệt kê ở trên vì nó không phải là cấu trúc điều khiển điều khiển luồng thực thi chương trình. Nó hoạt động giống như một toán tử xác định một biểu thức. Trong ví dụ trên,
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
717 được đánh giá đầu tiên. Nếu nó đúng, biểu thức ước tính là
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
718. Nếu nó sai, biểu thức ước tính là
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
719

Lưu ý thứ tự không rõ ràng. biểu thức ở giữa được ước tính trước và dựa trên kết quả đó, một trong các biểu thức ở cuối được trả về. Dưới đây là một số ví dụ hy vọng sẽ giúp làm rõ

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
63

Ghi chú. Biểu thức điều kiện của Python tương tự như cú pháp

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
720 được sử dụng bởi nhiều ngôn ngữ khác—C, Perl và Java để kể tên một số. Trên thực tế, toán tử
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
721 thường được gọi là toán tử bậc ba trong các ngôn ngữ đó, đây có lẽ là lý do biểu thức điều kiện của Python đôi khi được gọi là toán tử bậc ba Python

Bạn có thể thấy trong PEP 308 rằng cú pháp

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
720 đã được xem xét cho Python nhưng cuối cùng bị từ chối để ủng hộ cú pháp được hiển thị ở trên

Một cách sử dụng phổ biến của biểu thức điều kiện là chọn phép gán biến. Ví dụ: giả sử bạn muốn tìm số lớn hơn trong hai số. Tất nhiên, có một chức năng tích hợp sẵn,

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
723, chỉ thực hiện điều này [và hơn thế nữa] mà bạn có thể sử dụng. Nhưng giả sử bạn muốn viết mã của riêng mình từ đầu

Bạn có thể sử dụng câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 tiêu chuẩn với mệnh đề
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
64

Nhưng một biểu thức điều kiện ngắn hơn và cũng dễ đọc hơn

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
65

Hãy nhớ rằng biểu thức điều kiện hoạt động giống như một biểu thức về mặt cú pháp. Nó có thể được sử dụng như một phần của biểu thức dài hơn. Biểu thức điều kiện có mức độ ưu tiên thấp hơn so với hầu như tất cả các toán tử khác, vì vậy cần có dấu ngoặc đơn để nhóm nó lại với nhau

Trong ví dụ sau, toán tử

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
726 liên kết chặt chẽ hơn biểu thức điều kiện, do đó,
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
727 và
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
728 được đánh giá trước, tiếp theo là biểu thức điều kiện. Dấu ngoặc đơn trong trường hợp thứ hai là không cần thiết và không thay đổi kết quả

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
66

Nếu bạn muốn đánh giá biểu thức điều kiện trước, bạn cần bao quanh nó bằng các dấu ngoặc đơn nhóm. Trong ví dụ tiếp theo,

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
729 được đánh giá trước. Kết quả là
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
730, là
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
731, do đó,
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
732 được chỉ định
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
733 =
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
734

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
67

Nếu bạn đang sử dụng biểu thức điều kiện như một phần của biểu thức lớn hơn, có lẽ nên sử dụng dấu ngoặc đơn nhóm để làm rõ ngay cả khi chúng không cần thiết

Biểu thức điều kiện cũng sử dụng đánh giá ngắn mạch như biểu thức logic phức hợp. Các phần của biểu thức điều kiện không được đánh giá nếu chúng không cần thiết

Trong biểu thức

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
735

  • Nếu
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    717 là đúng, thì trả về
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    718 và không đánh giá
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    719
  • Nếu
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    717 là sai, thì trả về
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    719 và không đánh giá
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    718

Như trước đây, bạn có thể xác minh điều này bằng cách sử dụng các thuật ngữ sẽ gây ra lỗi

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
68

Trong cả hai trường hợp, các điều khoản

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
742 không được đánh giá, vì vậy không có ngoại lệ nào được đưa ra

Các biểu thức điều kiện cũng có thể được xâu chuỗi lại với nhau, như một loại cấu trúc thay thế

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5/
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12/
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11, như minh họa ở đây

>>>

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
69

Không rõ là điều này có bất kỳ lợi thế đáng kể nào so với câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5/
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
12/
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
11 tương ứng hay không, nhưng nó đúng cú pháp Python

Loại bỏ các quảng cáo

Tuyên bố Python
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
749

Đôi khi, bạn có thể thấy rằng bạn muốn viết cái được gọi là sơ khai mã. trình giữ chỗ cho nơi cuối cùng bạn sẽ đặt một khối mã mà bạn chưa triển khai

Trong các ngôn ngữ mà các dấu phân cách mã thông báo được sử dụng để xác định các khối, như dấu ngoặc nhọn trong Perl và C, các dấu phân cách trống có thể được sử dụng để xác định sơ khai mã. Ví dụ: sau đây là mã Perl hoặc C hợp pháp

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
0

Ở đây, các dấu ngoặc nhọn trống xác định một khối trống. Perl hoặc C sẽ đánh giá biểu thức

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
17, và sau đó ngay cả khi nó đúng, lặng lẽ không làm gì cả

Bởi vì Python sử dụng thụt đầu dòng thay vì dấu phân cách, nên không thể chỉ định một khối trống. Nếu bạn giới thiệu một câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
5 với
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
82, thì phải có một cái gì đó xuất hiện sau nó, trên cùng một dòng hoặc thụt vào dòng sau

Hãy xem xét kịch bản này

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
92

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
1

Nếu bạn cố chạy

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
92, bạn sẽ nhận được điều này

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
2

Câu lệnh Python

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
749 giải quyết vấn đề này. Nó hoàn toàn không thay đổi hành vi của chương trình. Nó được sử dụng như một trình giữ chỗ để giữ cho trình thông dịch hài lòng trong bất kỳ tình huống nào mà một câu lệnh được yêu cầu về mặt cú pháp, nhưng bạn không thực sự muốn làm bất cứ điều gì

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
3

Bây giờ

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
92 chạy không có lỗi

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
4

Phần kết luận

Với việc hoàn thành hướng dẫn này, bạn đang bắt đầu viết mã Python vượt xa việc thực thi tuần tự đơn giản

  • Bạn đã được giới thiệu về khái niệm cấu trúc điều khiển. Đây là những câu lệnh phức hợp làm thay đổi luồng điều khiển chương trình—thứ tự thực hiện các câu lệnh chương trình
  • Bạn đã học cách nhóm các câu lệnh riêng lẻ lại với nhau thành một khối hoặc bộ
  • Bạn đã gặp cấu trúc điều khiển đầu tiên của mình, câu lệnh
     1if 'foo' in ['bar', 'baz', 'qux']:
     2    print['Expression was true']
     3    print['Executing statement in suite']
     4    print['...']
     5    print['Done.']
     6print['After conditional']
    
    5, cấu trúc này cho phép thực thi một câu lệnh hoặc khối một cách có điều kiện dựa trên đánh giá dữ liệu chương trình

Tất cả những khái niệm này đều rất quan trọng để phát triển mã Python phức tạp hơn

Hai hướng dẫn tiếp theo sẽ trình bày hai cấu trúc điều khiển mới. câu lệnh

 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
758 và câu lệnh
 1if 'foo' in ['bar', 'baz', 'qux']:
 2    print['Expression was true']
 3    print['Executing statement in suite']
 4    print['...']
 5    print['Done.']
 6print['After conditional']
759. Các cấu trúc này tạo điều kiện thuận lợi cho việc lặp đi lặp lại, thực hiện một câu lệnh hoặc khối câu lệnh nhiều lần

Lấy bài kiểm tra. Kiểm tra kiến ​​thức của bạn với bài kiểm tra tương tác “Câu lệnh có điều kiện Python” của chúng tôi. Sau khi hoàn thành, bạn sẽ nhận được điểm số để có thể theo dõi quá trình học tập của mình theo thời gian

Lấy bài kiểm tra "

« Cấu trúc chương trình Python

Câu lệnh có điều kiện trong Python

Vòng lặp "trong khi" của Python »

Đánh dấu là đã hoàn thành

Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Câu lệnh có điều kiện trong Python [if/elif/else]

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về John Sturtz

John là một Pythonista cuồng nhiệt và là thành viên của nhóm hướng dẫn Real Python

» Thông tin thêm về John

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Brad

Joanna

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Bạn sẽ sử dụng câu lệnh if như thế nào trong Python một cách chính xác?

Câu lệnh if-else được sử dụng để thực hiện cả phần đúng và phần sai của một điều kiện nhất định. Nếu điều kiện là đúng, mã khối if sẽ được thực thi và nếu điều kiện là sai, mã khối other sẽ được thực thi .

Các câu lệnh if được thực thi như thế nào?

Câu lệnh IF đánh giá biểu thức điều kiện đã cho. Nếu kết quả là đúng [i. e. khác không], thì các câu lệnh sau thẻ . Nếu kết quả là sai, các câu lệnh đó sẽ bị bỏ qua và quyền kiểm soát sẽ chuyển sang câu lệnh tiếp theo sau thẻ đóng .

Lệnh IF trong Python là gì?

Câu lệnh If trong Python là gì? . Nó chứa một đoạn mã chỉ chạy khi điều kiện đưa ra trong câu lệnh if là đúng. Nếu điều kiện là sai, thì câu lệnh khác tùy chọn sẽ chạy có chứa một số mã cho điều kiện khác

Chủ Đề