Hướng dẫn conditional statements python - câu lệnh điều kiện python

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Các tuyên bố có điều kiện trong Python [nếu/Elif/Else] This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Conditional Statements in Python [if/elif/else]

Từ các hướng dẫn trước đây trong loạt bài này, giờ đây bạn có khá nhiều mã python trong vành đai của bạn. Tất cả mọi thứ bạn đã thấy cho đến nay đều bao gồm thực thi tuần tự, trong đó các câu lệnh luôn được thực hiện sau lần tiếp theo, theo chính xác thứ tự được chỉ định.sequential execution, in which statements are always performed one after the next, in exactly the order specified.

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 một loạt các câu lệnh lặp đi lặp lại hoặc chọn giữa các bộ 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. Một cấu trúc điều khiển chỉ đạo thứ tự thực hiện các câu lệnh trong một chương trình [được gọi là luồng điều khiển của chương trình].control structures come in. A control structure directs the order of execution of the statements in a program [referred to as the program’s control flow].

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

C:\Users\john\Documents>python foo.py
After conditional
0. You’ll encounter your first Python control structure, the
C:\Users\john\Documents>python foo.py
After conditional
0 statement.

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

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

Trong một chương trình Python, tuyên bố

C:\Users\john\Documents>python foo.py
After conditional
0 là cách bạn thực hiện loại quyết định này. Nó cho phép thực hiện có điều kiện của một câu lệnh hoặc nhóm các câu lệnh dựa trên giá trị của một biểu thức.conditional execution of a statement or group of statements based on the value of an expression.

Đề cương của hướng dẫn này như sau:

  • Đầu tiên, bạn sẽ nhận được một cái nhìn tổng quan nhanh về câu lệnh
    C:\Users\john\Documents>python foo.py
    After conditional
    
    0 ở dạng đơn giản nhất.
  • Tiếp theo, sử dụng câu lệnh
    C:\Users\john\Documents>python foo.py
    After conditional
    
    0 làm mô hình, bạn sẽ thấy lý do 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 hợp chất. Bạn sẽ học cách làm thế nào điều này được thực hiện trong Python.compound statements or blocks. You’ll learn how this is done in Python.
  • Cuối cùng, bạn sẽ gắ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? Ở đây chúng tôi đi!

Giới thiệu về Tuyên bố
C:\Users\john\Documents>python foo.py
After conditional
0

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

C:\Users\john\Documents>python foo.py
After conditional
0 cơ bản nhất. Ở dạng đơn giản nhất, có vẻ như sau:

Trong biểu mẫu hiển thị ở trên:

  • C:\Users\john\Documents>python foo.py
    After conditional
    
    6 là một biểu thức được đánh giá trong bối cảnh boolean, như được thảo luận trong phần về các toán tử logic trong các toán tử và biểu thức trong hướng dẫn Python.
  • C:\Users\john\Documents>python foo.py
    After conditional
    
    7 là một tuyên bố 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
6 là đúng [đánh giá theo giá trị đó là sự thật là], thì
C:\Users\john\Documents>python foo.py
After conditional
7 được thực thi. Nếu
C:\Users\john\Documents>python foo.py
After conditional
6 là sai, thì
C:\Users\john\Documents>python foo.py
After conditional
7 bị bỏ qua và không được thực thi.

Lưu ý rằng đại tràng [

# Does line execute?                        Yes    No
#                                           ---    --
if 'foo' in ['foo', 'bar', 'baz']:        #  x
    print['Outer condition is true']      #  x

    if 10 > 20:                           #  x
        print['Inner condition 1']        #        x

    print['Between inner conditions']     #  x

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

Dưới đây là một số ví dụ về loại tuyên bố

C:\Users\john\Documents>python foo.py
After conditional
0 này:

>>>

>>> x = 0
>>> y = 5

>>> if x >> if y >> if x:                                # Falsy
...     print['yes']
...
>>> if y:                                # Truthy
...     print['yes']
...
yes

>>> if x or y:                           # Truthy
...     print['yes']
...
yes
>>> if x and y:                          # Falsy
...     print['yes']
...

>>> if 'aul' in 'grault':                # Truthy
...     print['yes']
...
yes
>>> if 'quux' in ['foo', 'bar', 'baz']:  # Falsy
...     print['yes']
...

Báo cáo nhóm: thụt và khối

Càng xa càng tốt.

Nhưng hãy để nói rằng bạn muốn đánh giá một điều kiện và sau đó làm nhiều hơn một điều nếu đó là sự thật:

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 đã giành chiến thắng làm bất cứ điều gì trong số này.]

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

# Does line execute?                        Yes    No
#                                           ---    --
if 'foo' in ['foo', 'bar', 'baz']:        #  x
    print['Outer condition is true']      #  x

    if 10 > 20:                           #  x
        print['Inner condition 1']        #        x

    print['Between inner conditions']     #  x

    if 10 python foo.py
After conditional
7. Cần phải có một số cách để nói rằng nếu
C:\Users\john\Documents>python foo.py
After conditional
6 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. Một khối được coi là cú pháp như một thực thể duy nhất. Khi đó là mục tiêu của câu lệnh

C:\Users\john\Documents>python foo.py
After conditional
0 và
C:\Users\john\Documents>python foo.py
After conditional
6 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
6 là sai, thì không ai trong số họ là.compound statement or block. A block is regarded syntactically as a single entity. When it is the target of an
C:\Users\john\Documents>python foo.py
After conditional
0 statement, and
C:\Users\john\Documents>python foo.py
After conditional
6 is true, then all the statements in the block are executed. If
C:\Users\john\Documents>python foo.py
After conditional
6 is false, then none of them are.

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 tất cả chúng đều cung cấp nó theo cùng một cách. Hãy để xem Python làm như thế nào.

Python: Nó tất cả về thụt lề

Python tuân theo một hội nghị được gọi là quy tắc ngoài bên, một thuật ngữ được đặt ra bởi nhà khoa học máy tính người Anh Peter J. Landin. . 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 đây về cấu trúc chương trình Python mà thụt 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 hợp chất. Trong một chương trình Python, các tuyên bố liền kề được thụt vào cùng cấp độ được coi là một phần của cùng một khối.

Do đó, một tuyên bố hợp chất ____30 trong Python trông như thế này:

 1if :
 2    
 3    
 4    ...
 5    
 6

Ở đây, tất cả các câu lệnh ở cấp độ thụt khớp [dòng 2 đến 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
6 là đúng hoặc bỏ qua nếu
C:\Users\john\Documents>python foo.py
After conditional
6 là sai. Dù bằng cách nào, việc thực hiện tiến hành với
C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
5 [dòng 6] sau đó.

Hợp chất python nếu tuyên bố

Lưu ý rằng không có mã thông báo biểu thị kết thúc 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.

Xem xét tệp tập lệnh này

C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
6:

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

Chạy

C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
6 tạo ra đầu ra này:

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

Bốn câu

C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
8 trên các 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ó là sai, vì vậy tất cả các câu trong khối đều bị bỏ qua. Sau khi kết thúc câu lệnh hợp chất
C:\Users\john\Documents>python foo.py
After conditional
0 đã đạt được [cho dù các câu lệnh trong khối trên các dòng 2 đến 5 có được thực thi hay không], việc thực hiện tiến hành câu lệnh đầu tiên có mức thụt nhẹ hơn: câu lệnh
C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
8 trên dòng 6.

Các khối có thể được lồng đến độ sâu tùy ý. Mỗi thụt lề xác định một khối mới và mỗi khối 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.

Dưới đây là một tệp tập lệnh phức tạp hơn được gọi là

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
1:

# Does line execute?                        Yes    No
#                                           ---    --
if 'foo' in ['foo', 'bar', 'baz']:        #  x
    print['Outer condition is true']      #  x

    if 10 > 20:                           #  x
        print['Inner condition 1']        #        x

    print['Between inner conditions']     #  x

    if 10 python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition

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

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

Chiến thuật được sử dụng bởi hầu hết các ngôn ngữ lập trình là chỉ định các mã thông báo đặc biệt đánh dấu sự khởi đầu và kết thúc của một khối. Ví dụ, trong các khối perl được xác định với các cặp niềng răng xoăn [

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
2] như thế này:

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;

C/C ++, Java và một loạt các ngôn ngữ khác sử dụng niềng răng xoăn theo cách này.

Hợp chất IF Tuyên bố trong C/C ++, Perl và Java

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

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
3 và
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
4 để kèm theo các khối.

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

Tốt hơn là trong mắt của người xử lý. 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 thứ. Tranh luận về giá trị của quy tắc ngoài bên có thể chạy khá nóng.

Về mặt tích cực:

  • Việc sử dụng vết lõm của Python là sạch sẽ, súc tích 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 ngoài, thụt mã của mã hoàn toàn độc lập với hàm định nghĩa khối và hàm mã. Nó có thể viết mã được thụt vào theo cách không thực sự phù hợp với cách mã thực thi, do đó tạo ra một ấn tượng sai lầm khi một người chỉ liếc nhìn nó. Loại sai lầm này hầu như không thể mắc phải trong Python.
  • Sử dụng thụt lề để 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à bạn có thể nên sử dụng.

Về mặt tiêu cực:

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

Dù muốn hay không, nếu bạn lập trình trong Python, bạn sẽ bị mắc kẹt với quy tắc ngoài mặt. Tất cả các cấu trúc kiểm soát trong Python sử dụng nó, như bạn sẽ thấy trong một số hướng dẫn trong tương lai.

Đối với những gì nó có giá trị, nhiều lập trình viên đã quen với các ngôn ngữ có phương tiện định nghĩa khối truyền thống hơn ban đầu đã bị thu hồi theo cách Python, nhưng đã thoải mái với nó và thậm chí còn phát triển để thích nó.

Các mệnh đề
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
5 và
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
6

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

C:\Users\john\Documents>python foo.py
After conditional
0 để thực hiện có điều kiện một câu lệnh hoặc một khối của một số câu lệnh. Đó là thời gian để tìm hiểu những gì bạn có thể làm.

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

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
5:

if :
    
else:
    

Nếu

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

Trong ví dụ này,

if :
    
else:
    
1 nhỏ hơn
if :
    
else:
    
2, do đó bộ đầu tiên [dòng 4 đến 5] được thực thi và bộ thứ hai [dòng 7 đến 8] bị bỏ qua:

>>>

 1>>> x = 20
 2
 3>>> if x >>

 1>>> x = 120
 2>>>
 3>>> if x python foo.py
After conditional
6 và thực thi bộ tương ứng với lần đầu tiên là đúng. Nếu không có biểu thức nào là đúng và mệnh đề
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
5 được chỉ định, thì bộ của nó được thực thi:

 1if :
 2    
 3    
 4    ...
 5    
 6
0

Một số lượng tùy ý của các mệnh đề

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
6 có thể được chỉ định. Điều khoản
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
5 là tùy chọn. Nếu nó có mặt, chỉ có thể có một, và nó phải được chỉ định cuối cùng:

>>>

 1if :
 2    
 3    
 4    ...
 5    
 6
1

Nhiều nhất, một trong các khối mã được chỉ định sẽ được thực thi. Nếu một điều khoản

# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
5 được bao gồm và tất cả các điều kiện là sai, thì không có khối nào sẽ được thực thi.

Một tuyên bố

C:\Users\john\Documents>python foo.py
After conditional
0 với các mệnh đề
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
6 sử dụng đánh giá ngắn mạch, tương tự như những gì bạn đã thấy với các toán tử
 1>>> x = 20
 2
 3>>> if x >> x = 20
 2
 3>>> if x >>

 1if :
 2    
 3    
 4    ...
 5    
 6
2

Biểu thức thứ hai chứa một bộ phận theo 0 và lần thứ ba tham chiếu một biến không xác định

 1>>> x = 20
 2
 3>>> if x python foo.py
After conditional
0

Đó là thông lệ để viết

 1>>> x = 20
 2
 3>>> if x python foo.py
After conditional
7 thụt vào dòng sau như sau:

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

C:\Users\john\Documents>python foo.py
After conditional
0 trên một dòng. Sau đây có chức năng tương đương với ví dụ trên:

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

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

 1if :
 2    
 3    
 4    ...
 5    
 6
3

Nhưng nó có nghĩa gì? Có hai cách giải thích có thể:

  1. Nếu

    C:\Users\john\Documents>python foo.py
    After conditional
    
    6 là đúng, thực thi
     1>>> x = 120
     2>>>
     3>>> if x >> x = 120
     2>>>
     3>>> if x python foo.py
    After conditional
    
    6 có đúng hay không.

  2. Nếu

    C:\Users\john\Documents>python foo.py
    After conditional
    
    6 là đúng, thực thi tất cả
     1>>> x = 120
     2>>>
     3>>> if x >> x = 120
     2>>>
     3>>> if x >> x = 120
     2>>>
     3>>> if x >>

     1if :
     2    
     3    
     4    ...
     5    
     6
    
    4

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

    # [This is Perl, not Python]
    if [] {
        ;
        ;
        ...
        ;
    }
    ;
    
    6 hoặc
    # [This is Perl, not Python]
    if [] {
        ;
        ;
        ...
        ;
    }
    ;
    
    5:

    >>>

     1if :
     2    
     3    
     4    ...
     5    
     6
    
    5

    Mặc dù tất cả những điều này hoạt động, và thông dịch viên cho phép nó, 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 là đối với các tuyên bố

    C:\Users\john\Documents>python foo.py
    After conditional
    
    0 phức tạp. PEP 8 đặc biệt khuyến nghị chống lại nó.

    Như thường lệ, nó có phần là một vấn đề của hương vị. Hầu hết mọi người sẽ tìm 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 :
     2    
     3    
     4    ...
     5    
     6
    
    6

    Tuy nhiên, nếu một tuyên bố

    C:\Users\john\Documents>python foo.py
    After conditional
    
    0 đủ đơn giản, việc đặt tất cả trên một dòng có thể là hợp lý. Một cái gì đó như thế này có lẽ sẽ nâng cao bất cứ ai bị hack quá nhiều:

     1if :
     2    
     3    
     4    ...
     5    
     6
    
    7

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

Python hỗ trợ một thực thể ra quyết định bổ sung được gọi là biểu thức có điều kiện. .

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

 1if :
 2    
 3    
 4    ...
 5    
 6
8

Điều này khác với các mẫu câu lệnh

C:\Users\john\Documents>python foo.py
After conditional
0 được liệt kê ở trên vì nó không phải là cấu trúc điều khiển chỉ đạo dòng thực hiện 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 :
 2    
 3    
 4    ...
 5    
 6
05 được đánh giá trước. Nếu đó là sự thật, biểu thức sẽ đánh giá thành
 1if :
 2    
 3    
 4    ...
 5    
 6
06. Nếu là sai, biểu thức sẽ đánh giá thành
 1if :
 2    
 3    
 4    ...
 5    
 6
07.

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

>>>

 1if :
 2    
 3    
 4    ...
 5    
 6
9

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

 1if :
 2    
 3    
 4    ...
 5    
 6
08, đó chỉ là đ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 bạn từ đầu.

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

C:\Users\john\Documents>python foo.py
After conditional
0 tiêu chuẩn với mệnh đề
# [This is Perl, not Python]
if [] {
    ;
    ;
    ...
    ;
}
;
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']
0

Nhưng một biểu thức 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']
1

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

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

 1if :
 2    
 3    
 4    ...
 5    
 6
11 liên kết chặt chẽ hơn biểu thức có điều kiện, do đó
 1if :
 2    
 3    
 4    ...
 5    
 6
12 và
 1if :
 2    
 3    
 4    ...
 5    
 6
13 được đánh giá trước, sau đó là biểu thức có điều kiện. Các 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']
2

Hãy nhớ rằng biểu thức có điều kiện hoạt động giống như một biểu thức cú pháp. Nó có thể được sử dụng như một phần của một biểu thức dài hơn. Biểu thức có điều kiện có mức độ ưu tiên thấp hơn hầu như tất cả các toán tử khác, do đó, dấu ngoặc đơn là cần thiết để tự nhóm 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']
3

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

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

 1if :
 2    
 3    
 4    ...
 5    
 6
11 liên kết chặt chẽ hơn biểu thức có điều kiện, do đó
 1if :
 2    
 3    
 4    ...
 5    
 6
12 và
 1if :
 2    
 3    
 4    ...
 5    
 6
13 được đánh giá trước, sau đó là biểu thức có điều kiện. Các 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ả:

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

 1if :
 2    
 3    
 4    ...
 5    
 6
14 được đánh giá trước. Kết quả là
 1if :
 2    
 3    
 4    ...
 5    
 6
15, đó là
 1if :
 2    
 3    
 4    ...
 5    
 6
16, do đó
 1if :
 2    
 3    
 4    ...
 5    
 6
17 được gán
 1if :
 2    
 3    
 4    ...
 5    
 6
18 =
 1if :
 2    
 3    
 4    ...
 5    
 6
19:

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

Trong biểu thức

 1if :
 2    
 3    
 4    ...
 5    
 6
20:

>>>

 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

Nếu

 1if :
 2    
 3    
 4    ...
 5    
 6
05 là đúng,
 1if :
 2    
 3    
 4    ...
 5    
 6
06 được trả lại và
 1if :
 2    
 3    
 4    ...
 5    
 6
07 không được đánh giá.

Nếu

 1if :
 2    
 3    
 4    ...
 5    
 6
05 là sai,
 1if :
 2    
 3    
 4    ...
 5    
 6
07 được trả về và
 1if :
 2    
 3    
 4    ...
 5    
 6
06 không được đá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']
5

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:

Trong cả hai trường hợp, các điều khoản
 1if :
 2    
 3    
 4    ...
 5    
 6
27 không được đánh giá, vì vậy không có ngoại lệ nào được nêu ra.

Các biểu thức có điều kiện cũng có thể được xích lại với nhau, như một loại thay thế ____ 30/________ 66/________ 65, như thể hiện ở đây:

Nó không rõ ràng rằng điều này có bất kỳ lợi thế đáng kể nào so với câu lệnh tương ứng ____ 30/________ 66/________ 65, nhưng nó là Python chính xác về mặt 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']
6

Tuyên bố Python

 1if :
 2    
 3    
 4    ...
 5    
 6
34

Thỉnh thoảng, bạn có thể thấy rằng bạn muốn viết cái được gọi là sơ khai mã: một trình giữ chỗ cho nơi cuối cùng bạn sẽ đặt một khối mã mà bạn đã thực hiện.

Trong các ngôn ngữ nơi 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ư niềng răng xoăn trong Perl và C, các trình phân cách trống có thể được sử dụng để xác định cuống mã. Ví dụ: sau đây là mã Perl hoặc C hợp pháp: C:

Ở đây, niềng răng xoăn trống xác định một khối trống. Perl hoặc C sẽ đánh giá biểu thức

if :
    
else:
    
1, và sau đó ngay cả khi đó là sự thật, lặng lẽ không làm gì 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']
7

Bởi vì Python sử dụng thụt lề thay vì các 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

C:\Users\john\Documents>python foo.py
After conditional
0 với
# Does line execute?                        Yes    No
#                                           ---    --
if 'foo' in ['foo', 'bar', 'baz']:        #  x
    print['Outer condition is true']      #  x

    if 10 > 20:                           #  x
        print['Inner condition 1']        #        x

    print['Between inner conditions']     #  x

    if 10 python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
6:

 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

Nếu bạn cố gắng chạy
C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition
6, bạn sẽ nhận được điều này:

Tuyên bố Python

 1if :
 2    
 3    
 4    ...
 5    
 6
34 giải quyết vấn đề này. Nó không thay đổi hành vi chương trình. Nó được sử dụng như một người giữ chỗ để giữ cho thông dịch viên hạnh phúc trong mọi tình huống mà một tuyên bố đượ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ì:

  • Bây giờ
    C:\Users\john\Documents>python blocks.py
    Outer condition is true
    Between inner conditions
    Inner condition 2
    End of outer condition
    After outer condition
    
    6 chạy mà không có lỗi:control structures. These are compound statements that alter program control flow—the order of execution of program statements.
  • Sự kết luậnblock or suite.
  • Với việc hoàn thành hướng dẫn này, bạn bắt đầu viết mã Python vượt xa thực thi tuần tự đơn giản:
    C:\Users\john\Documents>python foo.py
    After conditional
    
    0
    statement, which makes it possible to conditionally execute a statement or block based on evaluation of program data.

Bạn đã được giới thiệu về khái niệm cấu trúc kiểm soát. Đây là những tuyên bố hỗn hợp thay đổi luồng kiểm soát chương trình, thứ tự thực hiện các tuyên bố chương trình.

Bạn đã học cách nhóm các câu lệnh cá nhân với nhau thành một khối hoặc bộ.

 1if :
 2    
 3    
 4    ...
 5    
 6
43 statement and the
 1if :
 2    
 3    
 4    ...
 5    
 6
44
statement. These structures facilitate iteration, execution of a statement or block of statements repeatedly.

Bạn đã gặp phải cấu trúc điều khiển đầu tiên của mình, câu lệnh

C:\Users\john\Documents>python foo.py
After conditional
0, cho phép thực thi có điều kiện một câu lệnh hoặc khối dựa trên đánh giá dữ liệu chương trình. This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Conditional Statements in Python [if/elif/else]

Bài Viết Liên Quan

Chủ Đề