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 數
—— 非零即真 -
假
False
0
-
-
複數型 (
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