Python從入門到精通
變數的基本使用
程式就是用來處理資料的，而變數就是用來儲存資料的
目標
-
變數定義
-
變數的型別
-
變數的命名
01. 變數定義
-
在 Python 中，每個變數 在使用前都必須賦值，變數 賦值以後 該變數 才會被建立
-
等號（=）用來給變數賦值
-
=左邊是一個變數名 -
=右邊是儲存在變數中的值
-
變數名 = 值
變數定義之後，後續就可以直接使用了
1) 變數演練1 —— iPython
# 定義 qq_number 的變數用來儲存 qq 號碼 In [1]: qq_number = "1234567" # 輸出 qq_number 中儲存的內容 In [2]: qq_number Out[2]: '1234567' # 定義 qq_password 的變數用來儲存 qq 密碼 In [3]: qq_password = "123" # 輸出 qq_password 中儲存的內容 In [4]: qq_password Out[4]: '123'
使用互動式方式，如果要檢視變數內容，直接輸入變數名即可，不需要使用
2) 變數演練 2 —— PyCharm
# 定義 qq 號碼變數 qq_number = "1234567" # 定義 qq 密碼變數 qq_password = "123" # 在程式中，如果要輸出變數的內容，需要使用 print 函式 print(qq_number) print(qq_password)
使用直譯器執行，如果要輸出變數的內容，必須要要使用
3) 變數演練 3 —— 超市買蘋果
可以用 其他變數的計算結果 來定義變數
變數定義之後，後續就可以直接使用了
需求
-
蘋果的價格是 8.5 元/斤
-
買了 7.5 斤 蘋果
-
計算付款金額
# 定義蘋果價格變數 price = 8.5 # 定義購買重量 weight = 7.5 # 計算金額 money = price * weight print(money)
思考題
-
如果 只要買蘋果，就返 5 塊錢
-
請重新計算購買金額
# 定義蘋果價格變數 price = 8.5 # 定義購買重量 weight = 7.5 # 計算金額 money = price * weight # 只要買蘋果就返 5 元 money = money - 5 print(money)
提問
-
上述程式碼中，一共定義有幾個變數？
-
三個：
price／weight／money
-
-
money = money - 5是在定義新的變數還是在使用變數？-
直接使用之前已經定義的變數
-
變數名 只有在 第一次出現 才是 定義變數
-
變數名 再次出現，不是定義變數，而是直接使用之前定義過的變數
-
-
在程式開發中，可以修改之前定義變數中儲存的值嗎？
-
可以
-
變數中儲存的值，就是可以 變 的
-
02. 變數的型別
-
在記憶體中建立一個變數，會包括：
-
變數的名稱
-
變數儲存的資料
-
變數儲存資料的型別
-
變數的地址（標示）
-
2.1 變數型別的演練 —— 個人資訊
需求
-
定義變數儲存小明的個人資訊
-
姓名：小明
-
年齡：18 歲
-
性別：是男生
-
身高：1.75 米
-
體重：75.0 公斤
利用 單步除錯 確認變數中儲存資料的型別
提問
-
在演練中，一共有幾種資料型別？
-
4 種
-
str—— 字串 -
bool—— 布林（真假） -
int—— 整數 -
float—— 浮點數（小數）
-
-
在
Python中定義變數時需要指定型別嗎？-
不需要
-
Python可以根據=等號右側的值，自動推匯出變數中儲存資料的型別
-
2.2 變數的型別
-
在
Python中定義變數是 不需要指定型別（在其他很多高階語言中都需要） -
資料型別可以分為 數字型 和 非數字型
-
數字型
-
整型 (
int) -
浮點型（
float） -
布林型（
bool）-
真
True非 0 數—— 非零即真 -
假
False0
-
-
複數型 (
complex)-
主要用於科學計算，例如：平面場問題、波動問題、電感電容等問題
-
-
-
非數字型
-
字串
-
列表
-
元組
-
字典
-
提示：在 Python 2.x 中，整數 根據儲存數值的長度還分為：
int（整數）
long（長整數）
-
使用
type函式可以檢視一個變數的型別
In [1]: type(name)
2.3 不同型別變數之間的計算
1) 數字型變數 之間可以直接計算
-
在 Python 中，兩個數字型變數是可以直接進行 算數運算的
-
如果變數是
bool型，在計算時-
True對應的數字是1 -
False對應的數字是0
-
演練步驟
-
定義整數
i = 10 -
定義浮點數
f = 10.5 -
定義布林型
b = True
-
在 iPython 中，使用上述三個變數相互進行算術運算
2) 字串變數 之間使用 + 拼接字串
-
在 Python 中，字串之間可以使用
+拼接生成新的字串
In [1]: first_name = "三" In [2]: last_name = "張" In [3]: first_name + last_name Out[3]: '三張'
3) 字串變數 可以和 整數 使用 * 重複拼接相同的字串
In [1]: "-" * 50 Out[1]: '--------------------------------------------------'
4) 數字型變數 和 字串 之間 不能進行其他計算
In [1]: first_name = "zhang" In [2]: x = 10 In [3]: x + first_name --------------------------------------------------------------------------- TypeError: unsupported operand type(s) for +: 'int' and 'str' 型別錯誤：`+` 不支援的操作型別：`int` 和 `str`
2.4 變數的輸入
-
所謂 輸入，就是 用程式碼 獲取 使用者通過 鍵盤 輸入的資訊
-
例如：去銀行取錢，在 ATM 上輸入密碼
-
在 Python 中，如果要獲取使用者在 鍵盤 上的輸入資訊，需要使用到
input函式
1) 關於函式
-
一個 提前準備好的功能(別人或者自己寫的程式碼)，可以直接使用，而 不用關心內部的細節
-
目前已經學習過的函式
| 函式 | 說明 |
|---|---|
| print(x) | 將 x 輸出到控制檯 |
| type(x) | 檢視 x 的變數型別 |
2) input 函式實現鍵盤輸入
-
在 Python 中可以使用
input函式從鍵盤等待使用者的輸入 -
使用者輸入的 任何內容 Python 都認為是一個 字串
-
語法如下：
字串變數 = input("提示資訊：")
3) 型別轉換函式
| 函式 | 說明 |
|---|---|
| int(x) | 將 x 轉換為一個整數 |
| float(x) | 將 x 轉換到一個浮點數 |
4) 變數輸入演練 —— 超市買蘋果增強版
需求
-
收銀員輸入 蘋果的價格，單位：元／斤
-
收銀員輸入 使用者購買蘋果的重量，單位：斤
-
計算並且 輸出 付款金額
演練方式 1
# 1. 輸入蘋果單價
price_str = input("請輸入蘋果價格：")
# 2. 要求蘋果重量
weight_str = input("請輸入蘋果重量：")
# 3. 計算金額
# 1> 將蘋果單價轉換成小數
price = float(price_str)
# 2> 將蘋果重量轉換成小數
weight = float(weight_str)
# 3> 計算付款金額
money = price * weight
print(money)
提問
-
演練中，針對 價格 定義了幾個變數？
-
兩個
-
price_str記錄使用者輸入的價格字串 -
price記錄轉換後的價格數值
-
-
思考 —— 如果開發中，需要使用者通過控制檯 輸入 很多個 數字，針對每一個數字都要定義兩個變數，方便嗎？
演練方式 2 —— 買蘋果改進版
-
定義 一個 浮點變數 接收使用者輸入的同時，就使用
float函式進行轉換
price = float(input("請輸入價格:"))
-
改進後的好處：
-
節約空間，只需要為一個變數分配空間
-
起名字方便，不需要為中間變數起名字
-
改進後的“缺點”：
-
初學者需要知道，兩個函式能夠巢狀使用，稍微有一些難度
提示
-
如果輸入的不是一個數字，程式執行時會出錯，有關資料轉換的高階話題，後續會講！
2.5 變數的格式化輸出
蘋果單價
9.00元／斤，購買了5.00斤，需要支付45.00元
-
在 Python 中可以使用
print函式將資訊輸出到控制檯 -
如果希望輸出文字資訊的同時，一起輸出 資料，就需要使用到 格式化操作符
-
%被稱為 格式化操作符，專門用於處理字串中的格式-
包含
%的字串，被稱為 格式化字串 -
%和不同的 字元 連用，不同型別的資料 需要使用 不同的格式化字元
-
| 格式化字元 | 含義 |
|---|---|
| %s | 字串 |
| %d | 有符號十進位制整數，%06d 表示輸出的整數顯示位數，不足的地方使用 0 補全 |
| %f | 浮點數，%.2f 表示小數點後只顯示兩位 |
| %% | 輸出 % |
-
語法格式如下：
print("格式化字串" % 變數1)
print("格式化字串" % (變數1, 變數2...))
格式化輸出演練 —— 基本練習
需求
-
定義字串變數
name，輸出 我的名字叫 小明，請多多關照！ -
定義整數變數
student_no，輸出 我的學號是 000001 -
定義小數
price、weight、money，輸出 蘋果單價 9.00 元／斤，購買了 5.00 斤，需要支付 45.00 元 -
定義一個小數
scale，輸出 資料比例是 10.00%
print("我的名字叫 %s，請多多關照！" % name)
print("我的學號是 %06d" % student_no)
print("蘋果單價 %.02f 元／斤，購買 %.02f 斤，需要支付 %.02f 元" % (price, weight, money))
print("資料比例是 %.02f%%" % (scale * 100))
課後練習 —— 個人名片
需求
-
在控制檯依次提示使用者輸入：姓名、公司、職位、電話、郵箱
-
按照以下格式輸出：
************************************************** 公司名稱 姓名 (職位) 電話：電話 郵箱：郵箱 **************************************************
實現程式碼如下：
"""
在控制檯依次提示使用者輸入：姓名、公司、職位、電話、電子郵箱
"""
name = input("請輸入姓名：")
company = input("請輸入公司：")
title = input("請輸入職位：")
phone = input("請輸入電話：")
email = input("請輸入郵箱：")
print("*" * 50)
print(company)
print()
print("%s (%s)" % (name, title))
print()
print("電話：%s" % phone)
print("郵箱：%s" % email)
print("*" * 50)
變數的命名
目標
-
識別符號和關鍵字
-
變數的命名規則
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中，如果 變數名 需要由 二個 或 多個單詞 組成時，可以按照以下方式命名-
每個單詞都使用小寫字母
-
單詞與單詞之間使用
_下劃線 連線
-
例如：
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) # 該語句是錯誤的，下限必須小於上限
運算子
目標
-
算數運算子
-
比較（關係）運算子
-
邏輯運算子
-
賦值運算子
-
運算子的優先順序
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<br />否則只要 x 或者 y 有一個值為 False，就返回 False |
| or | x or y | 只要 x 或者 y 有一個值為 True，就返回 True<br />只有 x 和 y 的值都為 False，才會返回 False |
| not | not x | 如果 x 為 True，返回 False<br />如果 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
開發步驟
-
-
列印 9 行小星星
-
* ** *** **** ***** ****** ******* ******** *********
-
-
將每一個
*替換成對應的行與列相乘
-
# 定義起始行
row = 1
# 最大列印 9 行
while row <= 9:
# 定義起始列
col = 1
# 最大列印 row 列
while col <= row:
# end = ""，表示輸出結束後，不換行
# "\t" 可以在控制檯輸出一個製表符，協助在輸出文字時對齊
print("%d * %d = %d" % (col, row, row * col), end="\t")
# 列數 + 1
col += 1
# 一行列印完成的換行
print("")
# 行數 + 1
row += 1
字串中的轉義字元
-
\t在控制檯輸出一個 製表符，協助在輸出文字時 垂直方向 保持對齊 -
\n在控制檯輸出一個 換行符
製表符 的功能是在不使用表格的情況下在 垂直方向 按列對齊文字
| 轉義字元 | 描述 |
|---|---|
| \\ | 反斜槓符號 |
| \' | 單引號 |
| \" | 雙引號 |
| \n | 換行 |
| \t | 橫向製表符 |
| \r | 回車 |
函式基礎
目標
-
函式的快速體驗
-
函式的基本使用
-
函式的引數
-
函式的返回值
-
函式的巢狀呼叫
-
在模組中定義函式
01. 函式的快速體驗
1.1 快速體驗
-
所謂函式，就是把 具有獨立功能的程式碼塊 組織為一個小模組，在需要的時候 呼叫
-
函式的使用包含兩個步驟：
-
定義函式 —— 封裝 獨立的功能
-
呼叫函式 —— 享受 封裝 的成果
-
-
函式的作用，在開發程式時，使用函式可以提高編寫的效率以及程式碼的 重用
演練步驟
-
新建
04_函式專案 -
複製之前完成的 乘法表 檔案
-
修改檔案，增加函式定義
multiple_table(): -
新建另外一個檔案，使用
import匯入並且呼叫函式
02. 函式基本使用
2.1 函式的定義
定義函式的格式如下：
def 函式名(): 函式封裝的程式碼 ……
-
def是英文define的縮寫 -
函式名稱 應該能夠表達 函式封裝程式碼 的功能，方便後續的呼叫
-
函式名稱 的命名應該 符合 識別符號的命名規則
-
可以由 字母、下劃線 和 數字 組成
-
不能以數字開頭
-
不能與關鍵字重名
-
2.2 函式呼叫
呼叫函式很簡單的，通過 函式名() 即可完成對函式的呼叫
2.3 第一個函式演練
需求
-
-
編寫一個打招呼
say_hello的函式，封裝三行打招呼的程式碼
-
-
-
在函式下方呼叫打招呼的程式碼
-
name = "小明"
# 直譯器知道這裡定義了一個函式
def say_hello():
print("hello 1")
print("hello 2")
print("hello 3")
print(name)
# 只有在呼叫函式時，之前定義的函式才會被執行
# 函式執行完成之後，會重新回到之前的程式中，繼續執行後續的程式碼
say_hello()
print(name)
用 單步執行 F8 和 F7 觀察以下程式碼的執行過程
-
定義好函式之後，只表示這個函式封裝了一段程式碼而已
-
如果不主動呼叫函式，函式是不會主動執行的
思考
-
能否將 函式呼叫 放在 函式定義 的上方？
-
不能！
-
因為在 使用函式名 呼叫函式之前，必須要保證
Python已經知道函式的存在 -
否則控制檯會提示
NameError: name 'say_hello' is not defined(名稱錯誤：say_hello 這個名字沒有被定義)
-
2.4 PyCharm 的除錯工具
-
F8 Step Over 可以單步執行程式碼，會把函式呼叫看作是一行程式碼直接執行
-
F7 Step Into 可以單步執行程式碼，如果是函式，會進入函式內部
2.5 函式的文件註釋
-
在開發中，如果希望給函式添加註釋，應該在 定義函式 的下方，使用 連續的三對引號
-
在 連續的三對引號 之間編寫對函式的說明文字
-
在 函式呼叫 位置，使用快捷鍵
CTRL + Q可以檢視函式的說明資訊
注意：因為 函式體相對比較獨立，函式定義的上方，應該和其他程式碼（包括註釋）保留 兩個空行
03. 函式的引數
演練需求
-
開發一個
sum_2_num的函式 -
函式能夠實現 兩個數字的求和 功能
演練程式碼如下：
def sum_2_num():
num1 = 10
num2 = 20
result = num1 + num2
print("%d + %d = %d" % (num1, num2, result))
sum_2_num()
思考一下存在什麼問題
函式只能處理 固定數值 的相加
如何解決？
-
如果能夠把需要計算的數字，在呼叫函式時，傳遞到函式內部就好了！
3.1 函式引數的使用
-
在函式名的後面的小括號內部填寫 引數
-
多個引數之間使用
,分隔
def sum_2_num(num1, num2):
result = num1 + num2
print("%d + %d = %d" % (num1, num2, result))
sum_2_num(50, 20)
3.2 引數的作用
-
函式，把 具有獨立功能的程式碼塊 組織為一個小模組，在需要的時候 呼叫
-
函式的引數，增加函式的 通用性，針對 相同的資料處理邏輯，能夠 適應更多的資料
-
在函式 內部，把引數當做 變數 使用，進行需要的資料處理
-
函式呼叫時，按照函式定義的引數順序，把 希望在函式內部處理的資料，通過引數 傳遞
-
3.3 形參和實參
-
形參：定義 函式時，小括號中的引數，是用來接收引數用的，在函式內部 作為變數使用
-
實參：呼叫 函式時，小括號中的引數，是用來把資料傳遞到 函式內部 用的
04. 函式的返回值
-
在程式開發中，有時候，會希望 一個函式執行結束後，告訴呼叫者一個結果，以便呼叫者針對具體的結果做後續的處理
-
返回值 是函式 完成工作後，最後 給呼叫者的 一個結果
-
在函式中使用
return關鍵字可以返回結果 -
呼叫函式一方，可以 使用變數 來 接收 函式的返回結果
注意：
return表示返回，後續的程式碼都不會被執行
def sum_2_num(num1, num2):
"""對兩個數字的求和"""
return num1 + num2
# 呼叫函式，並使用 result 變數接收計算結果
result = sum_2_num(10, 20)
print("計算結果是 %d" % result)
05. 函式的巢狀呼叫
-
一個函式裡面 又呼叫 了 另外一個函式，這就是 函式巢狀呼叫
-
如果函式
test2中，呼叫了另外一個函式test1-
那麼執行到呼叫
test1函式時，會先把函式test1中的任務都執行完 -
才會回到
test2中呼叫函式test1的位置，繼續執行後續的程式碼
-
def test1():
print("*" * 50)
print("test 1")
print("*" * 50)
def test2():
print("-" * 50)
print("test 2")
test1()
print("-" * 50)
test2()
函式巢狀的演練 —— 列印分隔線
體會一下工作中 需求是多變 的
需求 1
-
定義一個
print_line函式能夠列印*組成的 一條分隔線
def print_line(char):
print("*" * 50)
需求 2
-
定義一個函式能夠列印 由任意字元組成 的分隔線
def print_line(char): print(char * 50)
需求 3
-
定義一個函式能夠列印 任意重複次數 的分隔線
def print_line(char, times): print(char * times)
需求 4
-
定義一個函式能夠列印 5 行 的分隔線，分隔線要求符合需求 3
提示：工作中針對需求的變化，應該冷靜思考，不要輕易修改之前已經完成的，能夠正常執行的函式！
def print_line(char, times): print(char * times) def print_lines(char, times): row = 0 while row < 5: print_line(char, times) row += 1
06. 使用模組中的函式
模組是 Python 程式架構的一個核心概念
-
模組 就好比是 工具包，要想使用這個工具包中的工具，就需要 匯入 import 這個模組
-
每一個以副檔名
py結尾的Python原始碼檔案都是一個 模組 -
在模組中定義的 全域性變數 、 函式 都是模組能夠提供給外界直接使用的工具
6.1 第一個模組體驗
步驟
-
新建
hm_10_分隔線模組.py-
複製
hm_09_列印多條分隔線.py中的內容，最後一行print程式碼除外 -
增加一個字串變數
-
name = "黑馬程式設計師"
-
新建
hm_10_體驗模組.py檔案，並且編寫以下程式碼：
import hm_10_分隔線模組
hm_10_分隔線模組.print_line("-", 80)
print(hm_10_分隔線模組.name)
體驗小結
-
可以 在一個 Python 檔案 中 定義 變數 或者 函式
-
然後在 另外一個檔案中 使用
import匯入這個模組 -
匯入之後，就可以使用
模組名.變數/模組名.函式的方式，使用這個模組中定義的變數或者函式
模組可以讓 曾經編寫過的程式碼 方便的被 複用！
6.2 模組名也是一個識別符號
-
標示符可以由 字母、下劃線 和 數字 組成
-
不能以數字開頭
-
不能與關鍵字重名
注意：如果在給 Python 檔案起名時，以數字開頭 是無法在
PyCharm中通過匯入這個模組的
6.3 Pyc 檔案（瞭解）
C是compiled編譯過 的意思
操作步驟
-
瀏覽程式目錄會發現一個
__pycache__的目錄 -
目錄下會有一個
hm_10_分隔線模組.cp