Python中的判斷語句及循環

文章目錄

• Python中的判斷語句及循環
• 一、判斷（if）語句
• • 01. 開發中的應用場景
  • • 程序中的判斷
    • 判斷的定義
  • 02. if 語句體驗
  • • 2.1 if 判斷語句基本語法
    • 2.2 判斷語句演練 —— 判斷年齡
    • 2.3 else 處理條件不滿足的情況
    • 2.4 判斷語句演練 —— 判斷年齡改進
  • 03. 邏輯運算
  • • 3.1 `and`
    • 3.2 `or`
    • 3.3 `not`
    • • 邏輯運算演練
  • 04. if 語句進階
  • • 4.1 `elif`
    • • elif 演練 —— 女友的節日
    • 4.2 `if` 的嵌套
    • • if 的嵌套 演練 —— 火車站安檢
  • 05. 綜合應用 —— 石頭剪刀布
  • • 5.1 基礎代碼實現
    • 5.2 隨機數的處理
• 二、運算符
• • 01. 算數運算符
  • 02. 比較（關系）運算符
  • 03. 邏輯運算符
  • 04. 賦值運算符
  • 05. 運算符的優先級
• 三、循環
• • 01. 程序的三大流程
  • 02. `while` 循環基本使用
  • • 2.1 `while` 語句基本語法
    • • 第一個 while 循環
      • 死循環
    • 2.2 賦值運算符
    • 2.3 Python 中的計數方法
    • 2.4 循環計算
    • • 需求進階
  • 03. break 和 continue
  • • 3.1 break
    • 3.2 continue
  • 04. `while` 循環嵌套
  • • 4.1 循環嵌套
    • 4.2 循環嵌套演練 —— 九九乘法表
    • • 第 1 步：用嵌套打印小星星
      • 第 2 步：使用循環嵌套打印小星星
      • 第 3 步： 九九乘法表

一、判斷（if）語句

01. 開發中的應用場景

生活中的判斷幾乎是無所不在的，我們每天都在做各種各樣的選擇，如果這樣？如果那樣？……

程序中的判斷

if 今天發工資:先還信用卡的錢if 有剩余:又可以happy了，O(∩_∩)O哈哈~else:噢，no。。。還的等30天 else:盼著發工資

判斷的定義

• 如果 條件滿足，才能做某件事情，
• 如果 條件不滿足，就做另外一件事情，或者什么也不做

正是因為有了判斷，才使得程序世界豐富多彩，充滿變化！

判斷語句 又被稱為 “分支語句”，正是因為有了判斷，才讓程序有了很多的分支

02. if 語句體驗

2.1 if 判斷語句基本語法

在 Python 中，if 語句 就是用來進行判斷的，格式如下：

if 要判斷的條件:條件成立時，要做的事情……

注意：代碼的縮進為一個 tab 鍵，或者 4 個空格 —— 建議使用空格

• 在 Python 開發中，Tab 和空格不要混用！

我們可以把整個 if 語句看成一個完整的代碼塊

2.2 判斷語句演練 —— 判斷年齡

需求

定義一個整數變量記錄年齡

判斷是否滿 18 歲 （>=）

如果滿 18 歲，允許進網吧嗨皮

# 1. 定義年齡變量 age = 18# 2. 判斷是否滿 18 歲 # if 語句以及縮進部分的代碼是一個完整的代碼塊 if age >= 18:print("可以進網吧嗨皮……")# 3. 思考！- 無論條件是否滿足都會執行 print("這句代碼什么時候執行?")

注意：

• if 語句以及縮進部分是一個 完整的代碼塊

2.3 else 處理條件不滿足的情況

思考

在使用 if 判斷時，只能做到滿足條件時要做的事情。那如果需要在 不滿足條件的時候，做某些事情，該如何做呢？

答案

else，格式如下：

if 要判斷的條件:條件成立時，要做的事情…… else:條件不成立時，要做的事情……

注意：

• if 和 else 語句以及各自的縮進部分共同是一個 完整的代碼塊

2.4 判斷語句演練 —— 判斷年齡改進

需求

輸入用戶年齡

判斷是否滿 18 歲 （>=）

如果滿 18 歲，允許進網吧嗨皮

如果未滿 18 歲，提示回家寫作業

# 1. 輸入用戶年齡 age = int(input("今年多大了？"))# 2. 判斷是否滿 18 歲 # if 語句以及縮進部分的代碼是一個完整的語法塊 if age >= 18:print("可以進網吧嗨皮……") else:print("你還沒長大，應該回家寫作業！")# 3. 思考！- 無論條件是否滿足都會執行 print("這句代碼什么時候執行?")

03. 邏輯運算

• 在程序開發中，通常 在判斷條件時，會需要同時判斷多個條件
• 只有多個條件都滿足，才能夠執行后續代碼，這個時候需要使用到 邏輯運算符
• 邏輯運算符 可以把 多個條件 按照 邏輯 進行 連接，變成 更復雜的條件
• Python 中的 邏輯運算符 包括：與 and／或 or／非 not 三種

3.1 and

條件1 and 條件2

• 與／并且
• 兩個條件同時滿足，返回 True
• 只要有一個不滿足，就返回 False

條件 1條件 2結果

成立	成立	成立
成立	不成立	不成立
不成立	成立	不成立
不成立	不成立	不成立

3.2 or

條件1 or 條件2

• 或／或者
• 兩個條件只要有一個滿足，返回 True
• 兩個條件都不滿足，返回 False

條件 1條件 2結果

成立	成立	成立
成立	不成立	成立
不成立	成立	成立
不成立	不成立	不成立

3.3 not

not 條件

• 非／不是

條件結果

成立	不成立
不成立	成立

邏輯運算演練

練習1: 定義一個整數變量 age，編寫代碼判斷年齡是否正確

• 要求人的年齡在 0-120 之間

練習2: 定義兩個整數變量 python_score、c_score，編寫代碼判斷成績

• 要求只要有一門成績 > 60 分就算合格

練習3: 定義一個布爾型變量 is_employee，編寫代碼判斷是否是本公司員工

• 如果不是提示不允許入內

答案 1：

# 練習1: 定義一個整數變量 age，編寫代碼判斷年齡是否正確 age = 100# 要求人的年齡在 0-120 之間 if age >= 0 and age <= 120:print("年齡正確") else:print("年齡不正確")

答案 2：

# 練習2: 定義兩個整數變量 python_score、c_score，編寫代碼判斷成績 python_score = 50 c_score = 50# 要求只要有一門成績 > 60 分就算合格 if python_score > 60 or c_score > 60:print("考試通過") else:print("再接再厲！")

答案 3：

# 練習3: 定義一個布爾型變量 `is_employee`，編寫代碼判斷是否是本公司員工 is_employee = True# 如果不是提示不允許入內 if not is_employee:print("非公勿內")

04. if 語句進階

4.1 elif

• 在開發中，使用 if 可以 判斷條件
• 使用 else 可以處理 條件不成立 的情況
• 但是，如果希望 再增加一些條件，條件不同，需要執行的代碼也不同 時，就可以使用 elif
• 語法格式如下：

if 條件1:條件1滿足執行的代碼…… elif 條件2:條件2滿足時，執行的代碼…… elif 條件3:條件3滿足時，執行的代碼…… else:以上條件都不滿足時，執行的代碼……

• 對比邏輯運算符的代碼

if 條件1 and 條件2:條件1滿足 并且 條件2滿足 執行的代碼……

注意

elif 和 else 都必須和 if 聯合使用，而不能單獨使用

可以將 if、elif 和 else 以及各自縮進的代碼，看成一個 完整的代碼塊

elif 演練 —— 女友的節日

需求

定義 holiday_name 字符串變量記錄節日名稱

如果是 情人節 應該 買玫瑰／看電影

如果是 平安夜 應該 買蘋果／吃大餐

如果是 生日 應該 買蛋糕

其他的日子每天都是節日啊……

holiday_name = "平安夜"if holiday_name == "情人節":print("買玫瑰")print("看電影") elif holiday_name == "平安夜":print("買蘋果")print("吃大餐") elif holiday_name == "生日":print("買蛋糕") else:print("每天都是節日啊……")

4.2 if 的嵌套

elif 的應用場景是：同時 判斷 多個條件，所有的條件是 平級 的

• 在開發中，使用 if 進行條件判斷，如果希望 在條件成立的執行語句中 再 增加條件判斷，就可以使用 if 的嵌套
• if 的嵌套 的應用場景就是：在之前條件滿足的前提下，再增加額外的判斷
• if 的嵌套 的語法格式，除了縮進之外 和之前的沒有區別
• 語法格式如下：

if 條件 1:條件 1 滿足執行的代碼……if 條件 1 基礎上的條件 2:條件 2 滿足時，執行的代碼…… # 條件 2 不滿足的處理else:條件 2 不滿足時，執行的代碼# 條件 1 不滿足的處理 else:條件1 不滿足時，執行的代碼……

if 的嵌套 演練 —— 火車站安檢

需求

定義布爾型變量 has_ticket 表示是否有車票

定義整型變量 knife_length 表示刀的長度，單位：厘米

首先檢查是否有車票，如果有，才允許進行 安檢

安檢時，需要檢查刀的長度，判斷是否超過 20 厘米

• 如果超過 20 厘米，提示刀的長度，不允許上車
• 如果不超過 20 厘米，安檢通過

如果沒有車票，不允許進門

# 定義布爾型變量 has_ticket 表示是否有車票 has_ticket = True# 定義整數型變量 knife_length 表示刀的長度，單位：厘米 knife_length = 20# 首先檢查是否有車票，如果有，才允許進行 安檢 if has_ticket:print("有車票，可以開始安檢...")# 安檢時，需要檢查刀的長度，判斷是否超過 20 厘米# 如果超過 20 厘米，提示刀的長度，不允許上車if knife_length >= 20:print("不允許攜帶 %d 厘米長的刀上車" % knife_length)# 如果不超過 20 厘米，安檢通過else:print("安檢通過，祝您旅途愉快……")# 如果沒有車票，不允許進門 else:print("大哥，您要先買票啊")

05. 綜合應用 —— 石頭剪刀布

目標

強化 多個條件 的 邏輯運算

體會 import 導入模塊（“工具包”）的使用

需求

從控制臺輸入要出的拳 —— 石頭（1）／剪刀（2）／布（3）

電腦 隨機 出拳 —— 先假定電腦只會出石頭，完成整體代碼功能

比較勝負

序號規則

1	石頭 勝 剪刀
2	剪刀 勝 布
3	布 勝 石頭

5.1 基礎代碼實現

• 先 假定電腦就只會出石頭，完成整體代碼功能

# 從控制臺輸入要出的拳 —— 石頭（1）／剪刀（2）／布（3） player = int(input("請出拳 石頭（1）／剪刀（2）／布（3）："))# 電腦 隨機 出拳 - 假定電腦永遠出石頭 computer = 1# 比較勝負 # 如果條件判斷的內容太長，可以在最外側的條件增加一對大括號 # 再在每一個條件之間，使用回車，PyCharm 可以自動增加 8 個空格 if ((player == 1 and computer == 2) or(player == 2 and computer == 3) or(player == 3 and computer == 1)):print("噢耶！！！電腦弱爆了！！！") elif player == computer:print("心有靈犀，再來一盤！") else:print("不行，我要和你決戰到天亮！")

5.2 隨機數的處理

• 在 Python 中，要使用隨機數，首先需要導入 隨機數 的 模塊 —— “工具包”

import random

• 導入模塊后，可以直接在 模塊名稱 后面敲一個 . 然后按 Tab 鍵，會提示該模塊中包含的所有函數

• random.randint(a, b) ，返回 [a, b] 之間的整數，包含 a 和 b

• 例如：

random.randint(12, 20) # 生成的隨機數n: 12 <= n <= 20 random.randint(20, 20) # 結果永遠是 20 random.randint(20, 10) # 該語句是錯誤的，下限必須小于上限

二、運算符

01. 算數運算符

• 是完成基本的算術運算使用的符號，用來處理四則運算

運算符描述實例

+	加	10 + 20 = 30
-	減	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整數部分（商） 9 // 2 輸出結果 4
%	取余數	返回除法的余數 9 % 2 = 1
**	冪	又稱次方、乘方，2 ** 3 = 8

• 在 Python 中 * 運算符還可以用于字符串，計算結果就是字符串重復指定次數的結果

In [1]: "-" * 50 Out[1]: '----------------------------------------'

02. 比較（關系）運算符

運算符描述

==	檢查兩個操作數的值是否 相等，如果是，則條件成立，返回 True
!=	檢查兩個操作數的值是否 不相等，如果是，則條件成立，返回 True
>	檢查左操作數的值是否 大于 右操作數的值，如果是，則條件成立，返回 True
<	檢查左操作數的值是否 小于 右操作數的值，如果是，則條件成立，返回 True
>=	檢查左操作數的值是否 大于或等于 右操作數的值，如果是，則條件成立，返回 True
<=	檢查左操作數的值是否 小于或等于 右操作數的值，如果是，則條件成立，返回 True

Python 2.x 中判斷 不等于 還可以使用 <> 運算符

!= 在 Python 2.x 中同樣可以用來判斷 不等于

03. 邏輯運算符

運算符邏輯表達式描述

and	x and y	只有 x 和 y 的值都為 True，才會返回 True 否則只要 x 或者 y 有一個值為 False，就返回 False
or	x or y	只要 x 或者 y 有一個值為 True，就返回 True 只有 x 和 y 的值都為 False，才會返回 False
not	not x	如果 x 為 True，返回 False 如果 x 為 False，返回 True

04. 賦值運算符

• 在 Python 中，使用 = 可以給變量賦值
• 在算術運算時，為了簡化代碼的編寫，Python 還提供了一系列的 與 算術運算符 對應的 賦值運算符
• 注意：賦值運算符中間不能使用空格

運算符描述實例

=	簡單的賦值運算符	c = a + b 將 a + b 的運算結果賦值為 c
+=	加法賦值運算符	c += a 等效于 c = c + a
-=	減法賦值運算符	c -= a 等效于 c = c - a
*=	乘法賦值運算符	c *= a 等效于 c = c * a
/=	除法賦值運算符	c /= a 等效于 c = c / a
//=	取整除賦值運算符	c //= a 等效于 c = c // a
%=	取 模 (余數)賦值運算符	c %= a 等效于 c = c % a
**=	冪賦值運算符	c **= a 等效于 c = c ** a

05. 運算符的優先級

• 以下表格的算數優先級由高到最低順序排列

運算符描述

**	冪 (最高優先級)
* / % //	乘、除、取余數、取整除
+ -	加法、減法
<= < > >=	比較運算符
== !=	等于運算符
= %= /= //= -= += *= **=	賦值運算符
not or and	邏輯運算符

三、循環

01. 程序的三大流程

• 在程序開發中，一共有三種流程方式：
  • 順序 —— 從上向下，順序執行代碼
  • 分支 —— 根據條件判斷，決定執行代碼的 分支
  • 循環 —— 讓 特定代碼 重復 執行

02. while 循環基本使用

• 循環的作用就是讓 指定的代碼 重復的執行

• while 循環最常用的應用場景就是 讓執行的代碼 按照 指定的次數 重復 執行

• 需求 —— 打印 5 遍 Hello Python

• 思考 —— 如果要求打印 100 遍怎么辦？

2.1 while 語句基本語法

初始條件設置 —— 通常是重復執行的 計數器while 條件(判斷 計數器 是否達到 目標次數):條件滿足時，做的事情1條件滿足時，做的事情2條件滿足時，做的事情3...(省略)...處理條件(計數器 + 1)

注意：

• while 語句以及縮進部分是一個 完整的代碼塊

第一個 while 循環

需求

• 打印 5 遍 Hello Python

# 1. 定義重復次數計數器 i = 1# 2. 使用 while 判斷條件 while i <= 5:# 要重復執行的代碼print("Hello Python")# 處理計數器 ii = i + 1print("循環結束后的 i = %d" % i)

注意：循環結束后，之前定義的計數器條件的數值是依舊存在的

死循環

由于程序員的原因，忘記 在循環內部 修改循環的判斷條件，導致循環持續執行，程序無法終止！

2.2 賦值運算符

• 在 Python 中，使用 = 可以給變量賦值
• 在算術運算時，為了簡化代碼的編寫，Python 還提供了一系列的 與 算術運算符 對應的 賦值運算符
• 注意：賦值運算符中間不能使用空格

運算符描述實例

=	簡單的賦值運算符	c = a + b 將 a + b 的運算結果賦值為 c
+=	加法賦值運算符	c += a 等效于 c = c + a
-=	減法賦值運算符	c -= a 等效于 c = c - a
*=	乘法賦值運算符	c *= a 等效于 c = c * a
/=	除法賦值運算符	c /= a 等效于 c = c / a
//=	取整除賦值運算符	c //= a 等效于 c = c // a
%=	取 模 (余數)賦值運算符	c %= a 等效于 c = c % a
**=	冪賦值運算符	c **= a 等效于 c = c ** a

2.3 Python 中的計數方法

常見的計數方法有兩種，可以分別稱為：

• 自然計數法（從 1 開始）—— 更符合人類的習慣
• 程序計數法（從 0 開始）—— 幾乎所有的程序語言都選擇從 0 開始計數

因此，大家在編寫程序時，應該盡量養成習慣：除非需求的特殊要求，否則 循環 的計數都從 0 開始

2.4 循環計算

在程序開發中，通常會遇到 利用循環 重復計算 的需求

遇到這種需求，可以：

在 while 上方定義一個變量，用于 存放最終計算結果

在循環體內部，每次循環都用 最新的計算結果，更新 之前定義的變量

需求

• 計算 0 ~ 100 之間所有數字的累計求和結果

# 計算 0 ~ 100 之間所有數字的累計求和結果 # 0. 定義最終結果的變量 result = 0# 1. 定義一個整數的變量記錄循環的次數 i = 0# 2. 開始循環 while i <= 100:print(i)# 每一次循環，都讓 result 這個變量和 i 這個計數器相加result += i# 處理計數器i += 1print("0~100之間的數字求和結果 = %d" % result)

需求進階

• 計算 0 ~ 100 之間 所有 偶數 的累計求和結果

開發步驟

編寫循環 確認 要計算的數字

添加 結果 變量，在循環內部 處理計算結果

# 0. 最終結果 result = 0# 1. 計數器 i = 0# 2. 開始循環 while i <= 100:# 判斷偶數if i % 2 == 0:print(i)result += i# 處理計數器i += 1print("0~100之間偶數求和結果 = %d" % result)

03. break 和 continue

break 和 continue 是專門在循環中使用的關鍵字

• break 某一條件滿足時，退出循環，不再執行后續重復的代碼
• continue 某一條件滿足時，不執行后續重復的代碼

break 和 continue 只針對 當前所在循環 有效

3.1 break

• 在循環過程中，如果 某一個條件滿足后，不 再希望 循環繼續執行，可以使用 break 退出循環

i = 0while i < 10:# break 某一條件滿足時，退出循環，不再執行后續重復的代碼# i == 3if i == 3:breakprint(i)i += 1print("over")

break 只針對當前所在循環有效

3.2 continue

• 在循環過程中，如果 某一個條件滿足后，不 希望 執行循環代碼，但是又不希望退出循環，可以使用 continue
• 也就是：在整個循環中，只有某些條件，不需要執行循環代碼，而其他條件都需要執行

i = 0while i < 10:# 當 i == 7 時，不希望執行需要重復執行的代碼if i == 7:# 在使用 continue 之前，同樣應該修改計數器# 否則會出現死循環i += 1continue# 重復執行的代碼print(i)i += 1

• 需要注意：使用 continue 時，條件處理部分的代碼，需要特別注意，不小心會出現 死循環

continue 只針對當前所在循環有效

04. while 循環嵌套

4.1 循環嵌套

• while 嵌套就是：while 里面還有 while

while 條件 1:條件滿足時，做的事情1條件滿足時，做的事情2條件滿足時，做的事情3...(省略)...while 條件 2:條件滿足時，做的事情1條件滿足時，做的事情2條件滿足時，做的事情3...(省略)...處理條件 2處理條件 1

4.2 循環嵌套演練 —— 九九乘法表

第 1 步：用嵌套打印小星星

需求

• 在控制臺連續輸出五行 *，每一行星號的數量依次遞增

* ** *** **** *****

• 使用字符串 * 打印

# 1. 定義一個計數器變量，從數字1開始，循環會比較方便 row = 1while row <= 5:print("*" * row)row += 1

第 2 步：使用循環嵌套打印小星星

知識點 對 print 函數的使用做一個增強

• 在默認情況下，print 函數輸出內容之后，會自動在內容末尾增加換行

• 如果不希望末尾增加換行，可以在 print 函數輸出內容的后面增加 , end=""

• 其中 "" 中間可以指定 print 函數輸出內容之后，繼續希望顯示的內容

• 語法格式如下：

# 向控制臺輸出內容結束之后，不會換行 print("*", end="")# 單純的換行 print("")

end="" 表示向控制臺輸出內容結束之后，不會換行

假設 Python 沒有提供 字符串的 * 操作 拼接字符串

需求

• 在控制臺連續輸出五行 *，每一行星號的數量依次遞增

* ** *** **** ***** row = 1while row <= 5:# 假設 python 沒有提供字符串 * 操作# 在循環內部，再增加一個循環，實現每一行的 星星 打印col = 1while col <= row:print("*", end="")col += 1# 每一行星號輸出完成后，再增加一個換行print("")row += 1

第 3 步： 九九乘法表

需求 輸出 九九乘法表，格式如下：

1 * 1 = 1 1 * 2 = 2 2 * 2 = 4 1 * 3 = 3 2 * 3 = 6 3 * 3 = 9 1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16 1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25 1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36 1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49 1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64 1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81 # 定義起始行 row = 1# 最大打印 9 行 while row <= 9:# 定義起始列col = 1# 最大打印 row 列while col <= row:# end = ""，表示輸出結束后，不換行# "\t" 可以在控制臺輸出一個制表符，協助在輸出文本時對齊print("%d * %d = %d" % (col, row, row * col), end="\t")# 列數 + 1col += 1# 一行打印完成的換行print("")# 行數 + 1row += 1

字符串中的轉義字符

• \t 在控制臺輸出一個 制表符，協助在輸出文本時 垂直方向 保持對齊
• \n 在控制臺輸出一個 換行符

制表符 的功能是在不使用表格的情況下在 垂直方向 按列對齊文本

轉義字符描述

\\	反斜杠符號
\’	單引號
\"	雙引號
\n	換行
\t	橫向制表符
\r	回車

總結

以上是生活随笔為你收集整理的Python中的判断语句及循环的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。