一、變量的命名

目標

標識符和關鍵字
變量的命名規則

0.1 標識符和關鍵字

1.1 標識符

標示符就是程序員定義的 變量名、函數名

名字需要有 見名知義 的效果，見下圖：

標示符可以由字母、下劃線 和數字組成
不能以數字開頭
不能與關鍵字重名

思考：下面的標示符哪些是正確的，哪些不正確爲什麼？

fromNo12
from#12
my_Boolean
my-Boolean
Obj2
2ndObj
myInt
My_tExt
_test
test!32
haha(da)tt
jack_rose
jack&rose
GUI
G.U.I

1.2 關鍵字

關鍵字 就是在 Python 內部已經使用的標識符
關鍵字 具有特殊的功能和含義
開發者 不允許定義和關鍵字相同的名字的標示符

通過以下命令可以查看 Python 中的關鍵字

In [1]: import keyword
In [2]: print(keyword.kwlist)

提示：關鍵字的學習及使用，會在後面的課程中不斷介紹

import 關鍵字 可以導入一個 “工具包”

在 Python 中不同的工具包，提供有不同的工具

02. 變量的命名規則

命名規則 可以被視爲一種慣例，並無絕對與強制
目的是爲了 增加代碼的識別和可讀性

注意 Python 中的 標識符 是 區分大小寫的

在定義變量時，爲了保證代碼格式，= 的左右應該各保留一個空格
在 Python 中，如果 變量名 需要由二個或 多個單詞 組成時，可以按照以下方式命名
1. 每個單詞都使用小寫字母
2. 單詞與單詞之間使用 _下劃線 連接
- 例如：first_name、last_name、qq_number、qq_password

駝峯命名法

當 變量名 是由二個或多個單詞組成時，還可以利用駝峯命名法來命名
小駝峯式命名法
- 第一個單詞以小寫字母開始，後續單詞的首字母大寫
- 例如：firstName、lastName
大駝峯式命名法
- 每一個單詞的首字母都採用大寫字母
- 例如：FirstName、LastName、CamelCase

二、判斷（if）語句

目標

開發中的應用場景
if 語句體驗
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)  # 該語句是錯誤的，下限必須小於上限

三、運算符

目標

算數運算符
比較（關係）運算符
邏輯運算符
賦值運算符
運算符的優先級

數學符號表鏈接：https://zh.wikipedia.org/wiki/數學符號表

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	邏輯運算符

四、循環

目標

程序的三大流程
while 循環基本使用
break 和 continue
while 循環嵌套

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")

    # 處理計數器 i
    i = i + 1

print("循環結束後的 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 += 1

print("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 += 1

print("0~100之間偶數求和結果 = %d" % result)

03. break 和 continue

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

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

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

3.1 break

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

i = 0

while i < 10:

    # break 某一條件滿足時，退出循環，不再執行後續重複的代碼
    # i == 3
    if i == 3:
        break

    print(i)

    i += 1

print("over")

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

3.2 continue

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

i = 0

while i < 10:

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

        continue

    # 重複執行的代碼
    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 = 1

while row <= 5:

    print("*" * row)

    row += 1

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

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

在默認情況下，print 函數輸出內容之後，會自動在內容末尾增加換行
如果不希望末尾增加換行，可以在 print 函數輸出內容的後面增加 , end=""
其中 "" 中間可以指定 print 函數輸出內容之後，繼續希望顯示的內容
語法格式如下：

# 向控制檯輸出內容結束之後，不會換行
print("*", end="")

# 單純的換行
print("")

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

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

需求

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

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

開發步驟

1> 完成 5 行內容的簡單輸出
2> 分析每行內部的 * 應該如何處理？
- 每行顯示的星星和當前所在的行數是一致的
- 嵌套一個小的循環，專門處理每一行中 列 的星星顯示

row = 1

while row <= 5:

    # 假設 python 沒有提供字符串 * 操作
    # 在循環內部，再增加一個循環，實現每一行的 星星 打印
    col = 1

    while 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