【Python】基礎知識
註釋
一. 註釋的作用
沒有註釋的程式碼
添加註釋的程式碼
通過用自己熟悉的語言，在程式中對某些程式碼進行標註說明，這就是註釋的作用，能夠大大增強程式的可讀性。
二. 註釋的分類及語法
註釋分為兩類：單行註釋 和 多行註釋。
單行註釋
只能註釋一行內容，語法如下：
# 註釋內容多行註釋
可以註釋多行內容，一般用在註釋一段程式碼的情況，語法如下：
"""
第一行註釋
第二行註釋
第三行註釋
"""
'''
註釋1
註釋2
註釋3
'''快捷鍵： ctrl + /
2.1 快速體驗
單行註釋
# 輸出hello world
print('hello world')
print('hello Python') # 輸出(簡單的說明可以放到一行程式碼的後面，一般習慣程式碼後面新增兩個空格再書寫註釋文字)多行註釋
""" 下面三行都是輸出的作用，輸出內容分別是： hello Python hello itcast hello itheima """ print('hello Python') print('hello itcast') print('hello itheima') ''' 下面三行都是輸出的作用，輸出內容分別是： hello Python hello itcast hello itheima ''' print('hello Python') print('hello itcast') print('hello itheima')
注意：直譯器不執行任何的註釋內容。
變數
一. 變數的作用
舉例體驗：我們去圖書館讀書，怎麼樣快速找到自己想要的書籍呢？是不是管理員提前將書放到固定位置，並把這個位置進行了編號，我們只需要在圖書館中按照這個編號查詢指定的位置就能找到想要的書籍。
這個編號其實就是把書籍存放的書架位置起了一個名字，方便後期查詢和使用。
程式中，資料都是臨時儲存在記憶體中，為了更快速的查詢或使用這個資料，通常我們把這個資料在記憶體中儲存之後定義一個名稱，這個名稱就是變數。
變數就是一個儲存資料的的時候當前資料所在的記憶體地址的名字而已。
二. 定義變數
變數名 = 值變數名自定義，要滿足識別符號命名規則。
2.1 識別符號
識別符號命名規則是Python中定義各種名字的時候的統一規範，具體如下：
- 由數字、字母、下劃線組成
- 不能數字開頭
- 不能使用內建關鍵字
- 嚴格區分大小寫
False None True and as assert break class
continue def del elif else except finally for
from global if import in is lambda nonlocal
not or pass raise return try while with
yield2.2 命名習慣
見名知義。
- 大駝峰：即每個單詞⾸字母都大寫，例如： MyName 。
- 小駝峰：第二個（含）以後的單詞⾸字母大寫，例如： myName 。
- 下劃線：例如： my_name 。
2.3 使用變數
my_name = 'TOM'
print(my_name)
schoolName = '程式設計師'
print(schoolName)2.4 認識bug
所謂bug，就是程式中的錯誤。如果程式有錯誤，需要程式設計師排查問題，糾正錯誤。
三. Debug工具
Debug工具是PyCharm IDE中整合的用來除錯程式的工具，在這裡程式設計師可以檢視程式的執行細節和流程或者調解bug。
Debug工具使用步驟：
- 打斷點
- Debug除錯
3.1 打斷點
- 斷點位置
目標要除錯的程式碼塊的第一行程式碼即可，即一個斷點即可。 - 打斷點的方法
單擊目的碼的行號右側空白位置。
3.2 Debug除錯
打成功斷點後，在檔案內部任意位置 — 右鍵 -- Debug'檔名' — 即可調出Debug工具面板 -- 單擊Step Over/F8，即可按步執行程式碼。
3.2.1 Debug輸出面板分類
- Debugger
顯示變數和變數的細節 - Console
輸出內容
四. 認識資料型別
在 Python 裡為了應對不同的業務需求，也把資料分為不同的型別。
檢測資料型別的方法： type()
a = 1
print(type(a)) # <class 'int'> -- 整型
b = 1.1
print(type(b)) # <class 'float'> -- 浮點型
c = True
print(type(c)) # <class 'bool'> -- 布林型
d = '12345'
print(type(d)) # <class 'str'> -- 字串
e = [10, 20, 30]
print(type(e)) # <class 'list'> -- 列表
f = (10, 20, 30)
print(type(f)) # <class 'tuple'> -- 元組
h = {10, 20, 30}
print(type(h)) # <class 'set'> -- 集合
g = {'name': 'TOM', 'age': 20}
print(type(g)) # <class 'dict'> -- 字典輸出
一. 格式化輸出
所謂的格式化輸出即按照一定的格式輸出內容。
1.1 格式化符號
print('hello Python')
age = 18
print(age)
# 需求：輸出“今年我的年齡是18歲” 123456| 格式符號 轉換 | |
|---|---|
| %s | 字串 |
| %d | 有符號的十進位制整數 |
| %f | 浮點數 |
| %c | 字元 |
| %u | 無符號十進位制整數 |
| %o | 八進位制整數 |
| %x | 十六進位制整數（小寫ox） |
| %X | 十六進位制整數（大寫OX） |
| %e | 科學計數法（小寫'e'） |
| %E | 科學計數法（大寫'E'） |
| %g | %f和%e的簡寫 |
| %G | %f和%E的簡寫 |
技巧
- %06d，表示輸出的整數顯示位數，不足以0補全，超出當前位數則原樣輸出
- %.2f，表示小數點後顯示的小數位數。
1.2 體驗
格式化字串除了%s，還可以寫為 f'{表示式}'
age = 18
name = 'TOM'
weight = 75.5
student_id = 1
# 我的名字是TOM
print('我的名字是%s' % name)
# 我的學號是0001
print('我的學號是%4d' % student_id)
# 我的體重是75.50公斤
print('我的體重是%.2f公斤' % weight)
# 我的名字是TOM，今年18歲了
print('我的名字是%s，今年%d歲了' % (name, age))
# 我的名字是TOM，明年19歲了
print('我的名字是%s，明年%d歲了' % (name, age + 1))
# 我的名字是TOM，明年19歲了
print(f'我的名字是{name}, 明年{age + 1}歲了')f-格式化字串是Python3.6中新增的格式化方法，該方法更簡單易讀。
1.3 轉義字元
- \n ：換行。
- \t ：製表符，一個tab鍵（4個空格）的距離。
1.4 結束符
想一想，為什麼兩個print會換行輸出？
print('輸出的內容', end="\n")在Python中，print()， 預設自帶 end="\n" 這個換行結束符，所以導致每兩個 print 直接會換行展示，使用者可以按需求更改結束符。
輸入
一. 輸入
在Python中，程式接收使用者輸入的資料的功能即是輸入。
1.2 輸入的語法
input("提示資訊")1.3 輸入的特點
- 當程式執行到
input，等待使用者輸入，輸入完成之後才繼續向下執行。 - 在Python中，
input接收使用者輸入後，一般儲存到變數，方便使用。 - 在Python中，
input會把接收到的任意使用者輸入的資料都當做字串處理。
password = input('請輸入您的密碼：')
print(f'您輸入的密碼是{password}')
# <class 'str'>
print(type(password))控制檯輸出結果如下：
轉換資料型別
一. 轉換資料型別的作用
問：input()接收使用者輸入的資料都是字串型別，如果使用者輸入1，想得到整型該如何操作？
答：轉換資料型別即可，即將字串型別轉換成整型。
二. 轉換資料型別的函式
| 函式 | 說明 |
|---|---|
| int(x [,base ]) | 將x轉換為一個整數 |
| float(x) | 將x轉換為一個浮點數 |
| complex(real [,imag ]) | 建立一個複數，real為實部，imag為虛部 |
| str(x) | 將物件 x 轉換為字串 |
| repr(x) | 將物件 x 轉換為表示式字串 |
| eval(str) | 用來計算在字串中的有效Python表示式,並返回一個物件 |
| tuple(s) | 將序列 s 轉換為一個元組 |
| list(s) | 將序列 s 轉換為一個列表 |
| chr(x) | 將一個整數轉換為一個Unicode字元 |
| ord(x) | 將一個字元轉換為它的ASCII整數值 |
| hex(x) | 將一個整數轉換為一個十六進位制字串 |
| oct(x) | 將一個整數轉換為一個八進位制字串 |
| bin(x) | 將一個整數轉換為一個二進位制字串 |
三. 快速體驗
需求：input接收使用者輸入，使用者輸入“1”，將這個資料1轉換成整型。
# 1. 接收使用者輸入
num = input('請輸入您的幸運數字：')
# 2. 列印結果
print(f"您的幸運數字是{num}")
# 3. 檢測接收到的使用者輸入的資料型別 -- str型別
print(type(num))
# 4. 轉換資料型別為整型 -- int型別
print(type(int(num)))四. 實驗
# 1. float() -- 轉換成浮點型
num1 = 1
print(float(num1))
print(type(float(num1)))
# 2. str() -- 轉換成字串型別
num2 = 10
print(type(str(num2)))
# 3. tuple() -- 將一個序列轉換成元組
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
# 4. list() -- 將一個序列轉換成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
# 5. eval() -- 將字串中的資料轉換成Python表示式原本型別
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))運算子
運算子的分類
算數運算子
賦值運算子
複合賦值運算子
比較運算子
邏輯運算子
1. 算數運算子
| 運算子 | 描述 | 例項 |
|---|---|---|
| + | 加 | 1 + 1 輸出結果為 2 |
| - | 減 | 1 - 1 輸出結果為 0 |
| * | 乘 | 2 * 2 輸出結果為 4 |
| / | 除 | 10 / 2 輸出結果為 5 |
| // | 整除 9 // 4 輸出結果為2 % 取餘 9 % 4 輸出結果為 1 | |
| ** | 指數 2 ** 4 輸出結果為 16，即 2 * 2 * 2 * 2 | |
| () | 小括號 小括號用來提高運算優先順序，即 (1 + 2) * 3 輸出結果為 9 |
注意：混合運算優先順序順序： () 高於 ** 高於 * / // % 高於 + -
2. 賦值運算子
| 運算子 | 描述 | 例項 |
|---|---|---|
| = | 賦值 | 將 = 右側的結果賦值給等號左側的變數 |
單個變數賦值
num = 1
print(num)多個變數賦值
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)結果如下：
多變數賦相同值
a = b = 10
print(a)
print(b)結果如下：
3. 複合賦值運算子
| 運算子 | 描述 | 例項 |
|---|---|---|
| += | 加法賦值運算子 | 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 |
a = 100
a += 1
# 輸出101 a = a + 1,最終a = 100 + 1
print(a)
b = 2
b *= 3
# 輸出6 b = b * 3,最終b = 2 * 3
print(b)
c = 10
c += 1 + 2
# 輸出13, 先算運算子右側1 + 2 = 3， c += 3 , 推匯出c = 10 + 3
print(c)4. 比較運算子
比較運算子也叫關係運算符，通常用來判斷。
| 運算子 | 描述 | 例項 |
|---|---|---|
| == | 判斷相等。如果兩個運算元的結果相等，則條件結果為真(True)，否則條件結果為假(False) | 如a=3,b=3，則（a == b) 為 True |
| != | 不等於 。如果兩個運算元的結果不相等，則條件為真(True)，否則條件結果為假(False) | 如a=3,b=3，則（a == b) 為 True 如a=1,b=3，則(a != b) 為 True |
| > | 運算子左側運算元結果是否大於右側運算元結果，如果大於，則條件為真，否則為假 | 如a=7,b=3，則(a > b) 為 True |
| < | 運算子左側運算元結果是否小於右側運算元結果，如果小於，則條件為真，否則為假 | 如a=7,b=3，則(a < b) 為 False |
| >= | 運算子左側運算元結果是否大於等於右側運算元結果，如果大於，則條件為真，否則為假 | 如a=7,b=3，則(a < b) 為 False 如a=3,b=3，則(a >= b) 為 True |
| <= | 運算子左側運算元結果是否小於等於右側運算元結果，如果小於，則條件為真，否則為假 | 如a=3,b=3，則(a <= b) 為 True |
a = 7 b = 5
print(a == b) # False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True5. 邏輯運算子
|運算子|邏輯表示式|描述| 例項|
|and|x and y|布林"與"：如果 x 為 False，x and y 返回 False，否則它返回 y 的值。|True and False，返回 False。|
|or| x or y|布林"或"：如果 x 是 True，它返回 True，否則它返回 y 的值。|False or True， 返回 True。|
|not| not x|布林"非"：如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。|not True 返回 False, not False 返回 True|
a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True5.1 拓展
數字之間的邏輯運算
a = 0
b = 1
c = 2
# and運算子，只要有一個值為0，則結果為0，否則結果為最後一個非0數字
print(a and b) # 0
print(b and a) # 0
print(a and c) # 0
print(c and a) # 0
print(b and c) # 2
print(c and b) # 1
# or運算子，只有所有值為0結果才為0，否則結果為第一個非0數字
print(a or b) # 1
print(a or c) # 2
print(b or c) # 1條件語句
一. 瞭解條件語句
假設一個場景：
- 同學們這個年齡去過網咖嗎？
- 去網咖進門想要上網必須做的一件事是做什麼？（考慮重點）
- 為什麼要把身份證給工作人員？
- 是不是就是為了判斷是否成年？
- 是不是如果成年可以上網？如果不成年則不允許上網？
其實這裡所謂的判斷就是條件語句，即條件成立執行某些程式碼，條件不成立則不執行這些程式碼。
二. if 語法
2.1 語法
if 條件:
條件成立執行的程式碼1
條件成立執行的程式碼2
......2.2 快速體驗
if True:
print('條件成立執行的程式碼1')
print('條件成立執行的程式碼2')
# 下方的程式碼沒有縮排到if語句塊，所以和if條件無關
print('我是無論條件是否成立都要執行的程式碼')執行結果如下：
三. 例項：上網
需求分析：如果使用者年齡大於等於18歲，即成年，輸出"已經成年，可以上網"。
3.1 簡單版
age = 20
if age >= 18:
print('已經成年，可以上網')
print('系統關閉')3.2 進階版
新增需求：使用者可以輸出自己的年齡，然後系統進行判斷是否成年，成年則輸出"您的年齡是'使用者輸入的年齡'，已經成年，可以上網"。
# input接受使用者輸入的資料是字串型別，條件是age和整型18做判斷，所以這裡要int轉換資料型別
age = int(input('請輸入您的年齡：'))
if age >= 18:
print(f'您的年齡是{age},已經成年，可以上網')
print('系統關閉')四. if...else...
作用：條件成立執行if下方的程式碼; 條件不成立執行else下方的程式碼。
思考：網咖上網的例項，如果成年，允許上網，如果不成年呢？是不是應該回複用戶不能上網？
4.1 語法
if 條件:
條件成立執行的程式碼1
條件成立執行的程式碼2
......
else:
條件不成立執行的程式碼1
條件不成立執行的程式碼2
......4.2 實用版：網咖上網
age = int(input('請輸入您的年齡：'))
if age >= 18:
print(f'您的年齡是{age},已經成年，可以上網')
else:
print(f'您的年齡是{age},未成年，請自行回家寫作業')
print('系統關閉')注意：如果某些條件成立執行了相關的程式碼，那麼其他的情況的程式碼直譯器根本不會執行。
五、多重判斷
思考：中國合法工作年齡為18-60歲，即如果年齡小於18的情況為童工，不合法；如果年齡在18-60歲之間為合法工齡；大於60歲為法定退休年齡。
5.1 語法
if 條件1:
條件1成立執行的程式碼1
條件1成立執行的程式碼2
......
elif 條件2：
條件2成立執行的程式碼1
條件2成立執行的程式碼2
......
......
else:
以上條件都不成立執行執行的程式碼多重判斷也可以和else配合使用。一般else放到整個if語句的最後，表示以上條件都不成立的時候執行的程式碼。
5.2 例項：工齡判斷
age = int(input('請輸入您的年齡：'))
if age < 18:
print(f'您的年齡是{age},童工一枚')
elif age >= 18 and age <= 60:
print(f'您的年齡是{age},合法工齡')
elif age > 60:
print(f'您的年齡是{age},可以退休')拓展： age >= 18 and age <= 60 可以化簡為 18 <= age <= 60 。
六、if巢狀
思考：坐公交：如果有錢可以上車，沒錢不能上車；上車後如果有空座，則可以坐下；如果沒空座，就要站著。怎麼書寫程式？
6.1 語法
if 條件1：
條件1成立執行的程式碼
條件1成立執行的程式碼
if 條件2：
條件2成立執行的程式碼
條件2成立執行的程式碼注意：條件2的if也是出於條件1的縮排關係內部。
6.2 例項：坐公交
6.2.1 判斷是否能上車
"""
1. 如果有錢，則可以上車
2. 上車後，如果有空座，可以坐下
上車後，如果沒有空座，則站著等空座位
如果沒錢，不能上車
"""
# 假設用 money = 1 表示有錢, money = 0表示沒有錢
money = 1
if money == 1:
print('土豪，不差錢，順利上車')
else:
print('沒錢，不能上車，追著公交車跑')6.2.2 判斷是否能坐下
"""
1. 如果有錢，則可以上車
2. 上車後，如果有空座，可以坐下
上車後，如果沒有空座，則站著等空座位
如果沒錢，不能上車
"""
# 假設用 money = 1 表示有錢, money = 0表示沒有錢; seat = 1 表示有空座，seat = 0 表示
沒有空座
money = 1
seat = 0
if money == 1:
print('土豪，不差錢，順利上車')
if seat == 1:
print('有空座，可以坐下')
else:
print('沒有空座，站等')
else:
print('沒錢，不能上車，追著公交車跑')6.3 if巢狀執行流程
七. 應用：猜拳遊戲
需求分析：
- 參與遊戲的⻆色
- 玩家
- 手動出拳
- 電腦
- 隨機出拳
- 玩家
- 判斷輸贏
- 玩家獲勝
| 玩家 | 電腦 |
|---|---|
| 石頭 | 剪刀 |
| 剪刀 | 布 |
| 布 | 石頭 |
- 平局
- 玩家出拳 和 電腦出拳相同
- 電腦獲勝
隨機做法：
匯出random模組
import 模組名使用random模組中的隨機整數功能
random.randint(開始,結束)
"""
提示：0-石頭，1-剪刀，2-布
1. 出拳
玩家輸入出拳
電腦隨機出拳
2. 判斷輸贏
玩家獲勝
平局
電腦獲勝
"""
# 匯入random模組
import random
# 計算電腦出拳的隨機數字
computer = random.randint(0, 2)
print(computer)
player = int(input('請出拳：0-石頭，1-剪刀，2-布：'))
# 玩家勝利 p0:c1 或 p1:c2 或 p2:c0
if ((player == 0) and (computer == 1) or ((player == 1) and (computer == 2) or ((player == 2) and (computer == 0)):
print('玩家獲勝')
# 平局：玩家 == 電腦
elif player == computer:
print('平局')
else:
print('電腦獲勝')八. 三目運算子
三目運算子也叫三元運算子或三元表示式。
語法如下：
條件成立執行的表示式 if 條件 else 條件不成立執行的表示式快速體驗：
a = 1
b = 2
c = a if a > b else b
print(c)迴圈
一. 迴圈簡介
1.1 迴圈的作用
思考：假如我有個女朋友，有一天我們鬧矛盾生氣了，女朋友說：道歉，說100遍“媳婦兒，我錯了”。這個時候程式設計師會怎麼做？
答：100遍 print('媳婦兒，我錯了')
思考：複製貼上100次嗎？
答：重複執行100次一樣的程式碼，程式中迴圈即可迴圈的作用：讓程式碼更高效的重複執行。
1.2 迴圈的分類
在Python中，迴圈分為 while 和 for 兩種，最終實現效果相同。
二. while的語法
2.1 快速體驗
需求：復現重複執行100次 print('媳婦兒，我錯了') （輸出更簡潔一些，我們這裡設定5次）。
while 條件:
條件成立重複執行的程式碼1
條件成立重複執行的程式碼2
......分析：初始值是0次，終點是5次，重複做的事情輸出“媳婦兒，我錯了”。
# 迴圈的計數器
i = 0
while i < 5:
print('媳婦兒，我錯了')
i += 1
print('任務結束')三. while的應用
3.1 應用一：計算1-100累加和
分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前兩個數字的相加結果 + 下一個數字( 前一個數字 + 1)。
i = 1
result = 0
while i <= 100:
result += i
i += 1
# 輸出5050
print(result)注意：為了驗證程式的準確性，可以先改小數值，驗證結果正確後，再改成1-100做累加。
3.2 應用二：計算1-100偶數累加和
分析：1-100的偶數和，即 2 + 4 + 6 + 8....，得到偶數的方法如下：
- 偶數即是和2取餘結果為0的數字，可以加入條件語句判斷是否為偶數，為偶數則累加
- 初始值為0 / 2 , 計數器每次累加2
3.2.1 方法一：條件判斷和2取餘數則累加
# 方法一：條件判斷和2取餘數為0則累加計算
i = 1
result = 0
while i <= 100:
if i % 2 == 0:
result += i
i += 1
# 輸出2550
print(result)3.2.2 方法二：計數器控制
# 方法二：計數器控制增量為2 i = 0
result = 0
while i <= 100:
result += i
i += 2
# 輸出2550
print(result)四、break和continue
break和continue是迴圈中滿足一定條件退出迴圈的兩種不同方式。
4.1 理解
舉例：一共吃5個蘋果，吃完第一個，吃第二個…，這裡"吃蘋果"的動作是不是重複執行？
情況一：如果吃的過程中，吃完第三個吃飽了，則不需要再吃第4個和第五個蘋果，即是吃蘋果的動作停止，這裡就是break控制迴圈流程，即終止此迴圈。
情況二：如果吃的過程中，吃到第三個吃出一個大蟲子...,是不是這個蘋果就不吃了，開始吃第四個蘋果，這裡就是continue控制迴圈流程，即退出當前一次迴圈繼而執行下一次迴圈程式碼。
4.1.1 情況一：break
i = 1
while i <= 5:
if i == 4:
print(f'吃飽了不吃了')
break
print(f'吃了第{i}個蘋果')
i += 1執行結果：
4.1.2 情況二：continue
i = 1
while i <= 5:
if i == 3:
print(f'大蟲子，第{i}個不吃了')
# 在continue之前一定要修改計數器，否則會陷入死迴圈
i += 1
continue
print(f'吃了第{i}個蘋果')
i += 1執行結果：
五. while迴圈巢狀
5.1 應用場景
故事梗概：有天女朋友又生氣了，懲罰：說3遍“媳婦兒， 我錯了”，這個程式是不是迴圈即可？但如果女朋友說：還要刷今天晚飯的碗，這個程式怎麼書寫？
while 條件:
print('媳婦兒， 我錯了')
print('刷晚飯的碗')但如果女朋友還是生氣，把這套懲罰要連續3天都執行，有如何書寫程式？
while 條件:
while 條件:
print('媳婦兒， 我錯了')
print('刷晚飯的碗')5.2 語法
while 條件1:
條件1成立執行的程式碼
......
while 條件2:
條件2成立執行的程式碼
......總結：所謂while迴圈巢狀，就是一個while裡面巢狀一個while的寫法，每個while和之前的基礎語法是相同的。
5.3 快速體驗：復現場景
5.3.1 程式碼
j = 0
while j < 3:
i = 0
while i < 3:
print('媳婦兒，我錯了')
i += 1
print('刷晚飯的碗')
print('一套懲罰結束----------------')
j += 15.3.2 執行結果
5.3.3 理解執行流程
當內部迴圈執行完成之後，再執行下一次外部迴圈的條件判斷。
六. while迴圈巢狀應用
6.1 應用一：列印星號(正方形)
6.1.1 需求
*****
*****
*****
*****
*****6.1.2 程式碼
分析：一行輸出5個星號，重複列印5行
# 重複列印5行星星
j = 0
while j <= 4:
# 一行星星的列印
i = 0
while i <= 4:
# 一行內的星星不能換行，取消print預設結束符\n
print('*', end='')
i += 1
# 每行結束要換行，這裡藉助一個空的print，利用print預設結束符換行
print()
j += 16.2 應用二：列印星號(三⻆形)
6.2.1 需求
*
**
***
****
*****6.2.2 程式碼
分析：一行輸出星星的個數和行號是相等的，每行：重複列印行號數字個星號，將列印行星號的命令重複執行5次實現列印5行。
# 重複列印5行星星
# j表示行號
j = 0
while j <= 4:
# 一行星星的列印
i = 0
# i表示每行裡面星星的個數，這個數字要和行號相等所以i要和j聯動
while i <= j:
print('*', end='')
i += 1
print()
j += 16.3 九九乘法表
6.3.1 執行結果
6.3.2 程式碼
# 重複列印9行表示式
j = 1
while j <= 9:
# 列印一行裡面的表示式 a * b = a*b
i = 1
while i <= j:
print(f'{i}*{j}={j*i}', end='\t')
i += 1
print()
j += 1七、for迴圈
7.1 語法
for 臨時變數 in 序列:
重複執行的程式碼1
重複執行的程式碼2
......7.2 快速體驗
str1 = 'itheima'
for i in str1:
print(i)執行結果：
7.3 break
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不列印')
break
print(i)執行結果：
7.4 continue
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不列印')
continue
print(i)執行結果：
八. else
迴圈可以和else配合使用，else下方縮排的程式碼指的是當迴圈正常結束之後要執行的程式碼。
8.1 while...else
需求：女朋友生氣了，要懲罰：連續說5遍“媳婦兒，我錯了”，如果道歉正常完畢女朋友就原諒我了，這個程式怎麼寫？
i = 1
while i <= 5:
print('媳婦兒，我錯了')
i += 1
print('媳婦兒原諒我了...')思考： 這個print是不是沒有迴圈也能執行？
8.1.1 語法
while 條件:
條件成立重複執行的程式碼
else:
迴圈正常結束之後要執行的程式碼8.1.2 示例
i = 1
while i <= 5:
print('媳婦兒，我錯了')
i += 1
else:
print('媳婦原諒我了，真開心，哈哈哈哈')8.1.3 退出迴圈的方式
需求：女朋友生氣，要求道歉5遍：媳婦兒，我錯了。道歉到第三遍的時候，媳婦埋怨這一遍說的不真誠，是不是就是要退出迴圈了？這個退出有兩種可能性：
- 更生氣，不打算原諒，也不需要道歉了，程式如何書寫？
- 只一遍不真誠，可以忍受，繼續下一遍道歉，程式如何書寫？
break
i = 1 while i <= 5: if i == 3: print('這遍說的不真誠') break print('媳婦兒，我錯了') i += 1 else: print('媳婦原諒我了，真開心，哈哈哈哈')
所謂else指的是迴圈正常結束之後要執行的程式碼，即如果是break終止迴圈的情況，else下方縮排的程式碼將不執行。continue
i = 1 while i <= 5: if i == 3: print('這遍說的不真誠') i += 1 continue print('媳婦兒，我錯了') i += 1 else: print('媳婦原諒我了，真開心，哈哈哈哈')
因為continue是退出當前一次迴圈，繼續下一次迴圈，所以該迴圈在continue控制下是可以正常結束的，當迴圈結束後，則執行了else縮排的程式碼。
8.2 for...else
8.2.1 語法
for 臨時變數 in 序列:
重複執行的程式碼
...
else:
迴圈正常結束之後要執行的程式碼所謂else指的是迴圈正常結束之後要執行的程式碼，即如果是break終止迴圈的情況，else下方縮排的程式碼將不執行。
8.2.2 示例
str1 = 'itheima'
for i in str1:
print(i)
else:
print('迴圈正常結束之後執行的程式碼')8.2.3 退出迴圈的方式
break終止迴圈
str1 = 'itheima' for i in str1: if i == 'e': print('遇到e不列印') break print(i) else: print('迴圈正常結束之後執行的程式碼')
執行結果：
沒有執行else縮排的程式碼。
continue控制迴圈
str1 = 'itheima' for i in str1: if i == 'e': print('遇到e不列印') continue print(i) else: print('迴圈正常結束之後執行的程式碼')執行結果：
因為continue是退出當前一次迴圈，繼續下一次迴圈，所以該迴圈在continue控制下是可以正常結束的，當迴圈結束後，則執行了else縮排的程式碼。
字串
一. 認識字串
字串是 Python 中最常用的資料型別。我們一般使用引號來建立字串。建立字串很簡單，只要為變數分配一個值即可。
a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))注意：控制檯顯示結果為 <class 'str'> ， 即資料型別為str(字串)。
1.1 字串特徵
一對引號字串
name1 = 'Tom'
name2 = "Rose"三引號字串
name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,
nice to meet you! '''
b = """ i am Rose,
nice to meet you! """注意：三引號形式的字串支援換行。
思考：如果建立一個字串 I'm Tom ?
c = "I'm Tom"
d = 'I\'m Tom'1.2 字串輸出
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')1.3 字串輸入
在Python中，使用 input() 接收使用者輸入。
程式碼
name = input('請輸入您的名字：')
print(f'您輸入的名字是{name}')
print(type(name))
password = input('請輸入您的密碼：')
print(f'您輸入的密碼是{password}')
print(type(password))輸出結果
二、下標
“下標” 又叫 “索引” ，就是編號。比如⽕車座位號，座位號的作用：按照編號快速找到對應的座位。同理，下標的作用即是通過下標快速找到對應的資料。
2.1 快速體驗
需求：字串 name = "abcdef" ，取到不同下標對應的資料。
程式碼
name = "abcdef"
print(name[1])
print(name[0])
print(name[2])輸出結果
注意：下標從0開始。
三、切片
切片是指對操作的物件擷取其中一部分的操作。字串、列表、元組都支援切片操作。
3.1 語法
序列[開始位置下標:結束位置下標:步長]注意
- 不包含結束位置下標對應的資料， 正負整數均可；
- 步長是選取間隔，正負整數均可，預設步長為1。
3.2 體驗
name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 負1表示倒數第一個資料
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba四、常用操作方法
字串的常用操作方法有查詢、修改和判斷三大類。
4.1 查詢
所謂字串查詢方法即是查詢子串在字串中的位置或出現的次數。
find()：檢測某個子串是否包含在這個字串中，如果在返回這個子串開始的位置下標，否則則返回-1。
語法
字串序列.find(子串, 開始位置下標, 結束位置下標)注意：開始和結束位置下標可以省略，表示在整個字串序列中查詢。
快速體驗
mystr = "hello world and itcast and itheima and Python" print(mystr.find('and')) # 12 print(mystr.find('and', 15, 30)) # 23 print(mystr.find('ands')) # -1
index()：檢測某個子串是否包含在這個字串中，如果在返回這個子串開始的位置下標，否則則報異常。
語法
字串序列.index(子串, 開始位置下標, 結束位置下標)注意：開始和結束位置下標可以省略，表示在整個字串序列中查詢。
快速體驗
mystr = "hello world and itcast and itheima and Python" print(mystr.index('and')) # 12 print(mystr.index('and', 15, 30)) # 23 print(mystr.index('ands')) # 報錯
rfind()： 和find()功能相同，但查詢方向為右側開始。
rindex()：和index()功能相同，但查詢方向為右側開始。
count()：返回某個子串在字串中出現的次數
語法
字串序列.count(子串, 開始位置下標, 結束位置下標)注意：開始和結束位置下標可以省略，表示在整個字串序列中查詢。
快速體驗
mystr = "hello world and itcast and itheima and Python" print(mystr.count('and')) # 3 print(mystr.count('ands')) # 0 print(mystr.count('and', 0, 20)) # 1
4.2 修改
所謂修改字串，指的就是通過函式的形式修改字串中的資料。
replace()：替換
語法
字串序列.replace(舊子串, 新子串, 替換次數)注意：替換次數如果查出子串出現次數，則替換次數為該子串出現次數。
快速體驗
mystr = "hello world and itcast and itheima and Python" # 結果：hello world he itcast he itheima he Python print(mystr.replace('and', 'he')) # 結果：hello world he itcast he itheima he Python print(mystr.replace('and', 'he', 10)) # 結果：hello world and itcast and itheima and Python print(mystr)注意：資料按照是否能直接修改分為可變型別和不可變型別兩種。字串型別的資料修改的時候不能改變原有字串，屬於不能直接修改資料的型別即是不可變型別。
split()：按照指定字元分割字串。
語法
字串序列.split(分割字元, num)注意：num表示的是分割字元出現的次數，即將來返回資料個數為num+1個。
快速體驗
mystr = "hello world and itcast and itheima and Python" # 結果：['hello world ', ' itcast ', ' itheima ', ' Python'] print(mystr.split('and')) # 結果：['hello world ', ' itcast ', ' itheima and Python'] print(mystr.split('and', 2)) # 結果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python'] print(mystr.split(' ')) # 結果：['hello', 'world', 'and itcast and itheima and Python'] print(mystr.split(' ', 2))注意：如果分割字元是原有字串中的子串，分割後則丟失該子串。
join()：用一個字元或子串合併字串，即是將多個字串合併為一個新的字串。
語法
字元或子串.join(多字串組成的序列)快速體驗
list1 = ['chuan', 'zhi', 'bo', 'ke'] t1 = ('aa', 'b', 'cc', 'ddd') # 結果：chuan_zhi_bo_ke print('_'.join(list1)) # 結果：aa...b...cc...ddd print('...'.join(t1))
capitalize()：將字串第一個字元轉換成大寫。
mystr = "hello world and itcast and itheima and Python"
# 結果：Hello world and itcast and itheima and python
print(mystr.capitalize())注意：capitalize()函式轉換後，隻字符串第一個字元大寫，其他的字元全都小寫。
title()：將字串每個單詞⾸字母轉換成大寫。
mystr = "hello world and itcast and itheima and Python"
# 結果：Hello World And Itcast And Itheima And Python
print(mystr.title())lower()：將字串中大寫轉小寫。
mystr = "hello world and itcast and itheima and Python"
# 結果：hello world and itcast and itheima and python
print(mystr.lower())upper()：將字串中小寫轉大寫。
mystr = "hello world and itcast and itheima and Python"
# 結果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())lstrip()：刪除字串左側空白字元。
mystr = " hello world an itcast and itheima and Pathon "
# 結果：'hello world an itcast and itheima and Pathon '
mystr.lstrip()rstrip()：刪除字串右側空白字元。
mystr = " hello world an itcast and itheima and Pathon "
# 結果：' hello world an itcast and itheima and Pathon'
mystr.rstrip()strip()：刪除字串兩側空白字元。
mystr = " hello world an itcast and itheima and Pathon "
# 結果：'hello world an itcast and itheima and Pathon'
mystr.strip()ljust()：返回一個原字串左對齊,並使用指定字元(預設空格)填充至對應長度 的新字串。
語法
字串序列.ljust(長度, 填充字元)輸出效果
mystr = 'hello' # 結果'hello.....' mystr.ljust(10, '.') # 結果'hello ' mystr.ljust(10)
rjust()：返回一個原字串右對齊,並使用指定字元(預設空格)填充至對應長度 的新字串，語法和ljust()相同。
center()：返回一個原字串居中對齊,並使用指定字元(預設空格)填充至對應長度 的新字串，語法和ljust()相同。
mystr = 'hello'
# 結果' hello '
mystr.center(10)
# 結果'..hello...'
mystr.center(10, '.')4.3 判斷
所謂判斷即是判斷真假，返回的結果是布林型資料型別：True 或 False。
startswith()：檢查字串是否是以指定子串開頭，是則返回 True，否則返回 False。如果設定開
始和結束位置下標，則在指定範圍內檢查。
語法
字串序列.startswith(子串, 開始位置下標, 結束位置下標)快速體驗
mystr = "hello world and itcast and itheima and Python " # 結果：True print(mystr.startswith('hello')) # 結果False print(mystr.startswith('hello', 5, 20))
endswith()：檢查字串是否是以指定子串結尾，是則返回 True，否則返回 False。如果設定開始和結束位置下標，則在指定範圍內檢查。
語法
字串序列.endswith(子串, 開始位置下標, 結束位置下標)快速體驗
mystr = "hello world and itcast and itheima and Python" # 結果：True print(mystr.endswith('Python')) # 結果：False print(mystr.endswith('python')) # 結果：False print(mystr.endswith('Python', 2, 20))
isalpha()：如果字串至少有一個字元並且所有字元都是字母則返回 True, 否則返回 False。
mystr1 = 'hello'
mystr2 = 'hello12345'
# 結果：True
print(mystr1.isalpha())
# 結果：False
print(mystr2.isalpha())isdigit()：如果字串只包含數字則返回 True 否則返回 False。
mystr1 = 'aaa12345'
mystr2 = '12345'
# 結果： False
print(mystr1.isdigit())
# 結果：True
print(mystr2.isdigit())isalnum()：如果字串至少有一個字元並且所有字元都是字母或數字則返回 True，否則返回 False。
mystr1 = 'aaa12345'
mystr2 = '12345-'
# 結果：True
print(mystr1.isalnum())
# 結果：False
print(mystr2.isalnum())isspace()：如果字串中只包含空白，則返回 True，否則返回 False。
mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 結果：False
print(mystr1.isspace())
# 結果：True
print(mystr2.isspace())列表
一. 列表的應用場景
思考：有一個人的姓名(TOM)怎麼書寫儲存程式？
答：變數。
思考：如果一個班級100位學生，每個人的姓名都要儲存，應該如何書寫程式？宣告100個變數嗎？
答：列表即可， 列表一次性可以儲存多個數據。
二. 列表的格式
[資料1, 資料2, 資料3, 資料4......]列表可以一次性儲存多個數據，且可以為不同資料型別。
三. 列表的常用操作
列表的作用是一次性儲存多個數據，程式設計師可以對這些資料進行的操作有：增、刪、改、查。
3.1 查詢
3.1.1 下標
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose3.1.2 函式
index()：返回指定資料所在位置的下標 。
語法
列表序列.index(資料, 開始位置下標, 結束位置下標)快速體驗
name_list = ['Tom', 'Lily', 'Rose'] print(name_list.index('Lily', 0, 2))注意：如果查詢的資料不存在則報錯。
count()：統計指定資料在當前列表中出現的次數。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1len()：訪問列表長度，即列表中資料的個數。
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 33.1.3 判斷是否存在
in：判斷指定資料在某個列表序列，如果在返回True，否則返回False
name_list = ['Tom', 'Lily', 'Rose']
# 結果：True
print('Lily' in name_list)
# 結果：False
print('Lilys' in name_list)not in：判斷指定資料不在某個列表序列，如果不在返回True，否則返回False
name_list = ['Tom', 'Lily', 'Rose']
# 結果：False
print('Lily' not in name_list)
# 結果：True
print('Lilys' not in name_list) 體驗案例
需求：查詢使用者輸入的名字是否已經存在。
name_list = ['Tom', 'Lily', 'Rose']
name = input('請輸入您要搜尋的名字：')
if name in name_list:
print(f'您輸入的名字是{name}, 名字已經存在')
else:
print(f'您輸入的名字是{name}, 名字不存在')3.2 增加
作用：增加指定資料到列表中。
append()：列表結尾追加資料。
語法
列表序列.append(資料)體驗
name_list = ['Tom', 'Lily', 'Rose'] name_list.append('xiaoming') # 結果：['Tom', 'Lily', 'Rose', 'xiaoming'] print(name_list)列表追加資料的時候，直接在原列表裡面追加了指定資料，即修改了原列表，故列表為可變型別資料。
注意點
如果append()追加的資料是一個序列，則追加整個序列到列表name_list = ['Tom', 'Lily', 'Rose'] name_list.append(['xiaoming', 'xiaohong']) # 結果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']] print(name_list)
extend()：列表結尾追加資料，如果資料是一個序列，則將這個序列的資料逐一新增到列表。
語法
列表序列.extend(資料)快速體驗
2.1 單個數據
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 結果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)2.2 序列資料
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 結果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)insert()：指定位置新增資料。
語法
列表序列.insert(位置下標, 資料)快速體驗
name_list = ['Tom', 'Lily', 'Rose'] name_list.insert(1, 'xiaoming') # 結果：['Tom', 'xiaoming', 'Lily', 'Rose'] print(name_list)
3.3 刪除
del
語法
del 目標快速體驗
2.1 刪除列表
name_list = ['Tom', 'Lily', 'Rose']
# 結果：報錯提示：name 'name_list' is not defined
del name_list
print(name_list)2.2 刪除指定資料
name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 結果：['Lily', 'Rose']
print(name_list)pop()：刪除指定下標的資料(預設為最後一個)，並返回該資料。
語法
列表序列.pop(下標)快速體驗
name_list = ['Tom', 'Lily', 'Rose'] del_name = name_list.pop(1) # 結果：Lily print(del_name) # 結果：['Tom', 'Rose'] print(name_list)
remove()：移除列表中某個資料的第一個匹配項。
語法
列表序列.remove(資料)快速體驗
name_list = ['Tom', 'Lily', 'Rose'] name_list.remove('Rose') # 結果：['Tom', 'Lily'] print(name_list)
clear()：清空列表
name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 結果： []3.4 修改
修改指定下標資料
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 結果：['aaa', 'Lily', 'Rose']
print(name_list)逆置：reverse()
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 結果：[8, 6, 3, 2, 5, 1]
print(num_list)排序：sort()
語法
列表序列.sort(key=None, reverse=False)注意：reverse表示排序規則，reverse = True 降序， reverse = False 升序（預設）
快速體驗
num_list = [1, 5, 2, 3, 6, 8] num_list.sort() # 結果：[1, 2, 3, 5, 6, 8] print(num_list)
3.5 複製
函式：copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 結果：['Tom', 'Lily', 'Rose']
print(name_li2)四. 列表的迴圈遍歷
需求：依次列印列表中的各個資料。
4.1 while
程式碼
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1執行結果
4.2 for
程式碼
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)執行結果
五. 列表巢狀
所謂列表巢狀指的就是一個列表裡面包含了其他的子列表。
應用場景：要儲存班級一、二、三三個班級學生姓名，且每個班級的學生姓名在一個列表。
name_list = [['小明', '小紅', '小綠'], ['Tom', 'Lily', 'Rose'], ['張三', '李四', '王五']]思考： 如何查詢到資料"李四"？
# 第一步：按下標查詢到李四所在的列表
print(name_list[2])
# 第二步：從李四所在的列表裡面，再按下標找到資料李四
print(name_list[2][1])
123451 [資料1, 資料2, 資料3]
name_list = [['小明', '小紅', '小綠'], ['Tom', 'Lily', 'Rose'], ['張三', '李四', '王五']]
name_list[2][1]六. 綜合應用 -- 隨機分配辦公室
需求：有三個辦公室，8位⽼師，8位⽼師隨機分配到3個辦公室
七. 總結
列表的格式
[資料1, 資料2, 資料3]常用操作方法
- index()
- len()
- append()
- pop()
- remove()
列表巢狀
name_list = [['⼩明', '⼩紅', '⼩綠'], ['Tom', 'Lily', 'Rose'], ['張三', '李四', '王五']]
name_list[2][1]元組
一. 元組的應用場景
思考：如果想要儲存多個數據，但是這些資料是不能修改的資料，怎麼做？
答：列表？列表可以一次性儲存多個數據，但是列表中的資料允許更改。
num_list = [10, 20, 30]
num_list[0] = 100一個元組可以儲存多個數據，元組內的資料是不能修改的。
二. 定義元組
元組特點：定義元組使用小括號，且逗號隔開各個資料，資料可以是不同的資料型別。
# 多個數據元組
t1 = (10, 20, 30)
# 單個數據元組
t2 = (10,)注意：如果定義的元組只有一個數據，那麼這個資料後面也好新增逗號，否則資料型別為唯一的這個資料的資料型別
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str三. 元組的常見操作
元組資料不支援修改，只支援查詢，具體如下：
按下標查詢資料
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aaindex()：查詢某個資料，如果資料存在返回對應的下標，否則報錯，語法和列表、字串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0count()：統計某個資料在當前元組出現的次數。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2len()：統計元組中資料的個數。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4注意：元組內的直接資料如果修改則立即報錯
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'但是如果元組裡面有列表，修改列表裡面的資料則是支援的，故自覺很重要。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 訪問到列表
# 結果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)集合
一. 建立集合
建立集合使用 {} 或 set() ， 但是如果要建立空集合只能使用 set() ，因為 {} 用來建立空字典。
s1 = {10, 20, 30, 40, 50}
print(s1)
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)
s3 = set('abcdefg')
print(s3)
s4 = set()
print(type(s4)) # set
s5 = {}
print(type(s5)) # dict特點：
- 集合可以去掉重複資料；
- 集合資料是無序的，故不支援下標
二. 集合常見操作方法
2.1 增加資料
add()
s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1) # {100, 10, 20}因為集合有去重功能，所以，當向集合內追加的資料是當前集合已有資料的話，則不進行任何操作。
update(), 追加的資料是序列。
s1 = {10, 20}
# s1.update(100) # 報錯
s1.update([100, 200])
s1.update('abc')
print(s1)2.2 刪除資料
remove()，刪除集合中的指定資料，如果資料不存在則報錯。
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 報錯
print(s1)discard()，刪除集合中的指定資料，如果資料不存在也不會報錯。
s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)pop()，隨機刪除集合中的某個資料，並返回這個資料。
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)2.3 查詢資料
in：判斷資料在集合序列
not in：判斷資料不在集合序列
s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)字典
一. 字典的應用場景
思考1： 如果有多個數據，例如：'Tom', '男', 20，如何快速儲存？
答：列表
list1 = ['Tom', '男', 20]思考2：如何查詢到資料'Tom'？
答：查詢到下標為0的資料即可。
list1[0]思考3：如果將來資料順序發生變化，如下所示，還能用 list1[0] 訪問到資料'Tom'嗎？。
答：不能，資料'Tom'此時下標為2。
list1 = ['男', 20, 'Tom']思考4：資料順序發生變化，每個資料的下標也會隨之變化，如何保證資料順序變化前後能使用同一的標準查詢資料呢？
答：字典，字典裡面的資料是以鍵值對形式出現，字典資料和資料順序沒有關係，即字典不支援下標，後期無論資料如何變化，只需要按照對應的鍵的名字查詢資料即可。
二. 建立字典的語法
字典特點：
- 符號為大括號
- 資料為鍵值對形式出現
- 各個鍵值對之間用逗號隔開
# 有資料字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()注意：一般稱冒號前面的為鍵(key)，簡稱k；冒號後面的為值(value)，簡稱v。
三. 字典常見操作
3.1 增
寫法：字典序列[key] = 值
注意：如果key存在則修改這個key對應的值；如果key不存在則新增此鍵值對。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 結果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)注意：字典為可變型別。
3.2 刪
del() / del：刪除字典或刪除字典中指定鍵值對。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 結果：{'name': 'Tom', 'age': 20}
print(dict1)clear()：清空字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) # {}3.3 改
寫法：字典序列[key] = 值
注意：如果key存在則修改這個key對應的值 ；如果key不存在則新增此鍵值對。
3.4 查
3.4.1 key值查詢
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 報錯如果當前查詢的key存在，則返回對應的值；否則則報錯。
3.4.2 get()
語法
字典序列.get(key, 預設值)注意：如果當前查詢的key不存在則返回第二個引數(預設值)，如果省略第二個引數，則返回 None。
快速體驗
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None3.4.3 keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])3.4.4 values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])3.4.5 items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])四. 字典的迴圈遍歷
4.1 遍歷字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key) 4.2 遍歷字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)4.3 遍歷字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)4.4 遍歷字典的鍵值對
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key} = {value}')公共操作
一. 運算子
| 運算子 | 描述 | 支援的容器型別 |
|---|---|---|
| + | 合併 | 字串、列表、元組 |
| * | 複製 | 字串、列表、元組 |
| in | 元素是否存在 | 字串、列表、元組、字典 |
| not in | 元素是否不存在 | 字串、列表、元組、字典 |
1.1 +
# 1. 字串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb
# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]
# 3. 元組
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)1.2 *
# 1. 字串
print('-' * 10) # ----------
# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元組
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')1.3 in或not in
# 1. 字串
print('a' in 'abcd') # True
print('a' not in 'abcd') # False
# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('a' not in list1) # False
# 3. 元組
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('aa' not in t1) # True二. 公共方法
| 函式 | 描述 |
|---|---|
| len() | 計算容器中元素個數 |
| del 或 del() | 刪除 |
| max() | 返回容器中元素最大值 |
| min() | 返回容器中元素最小值 |
| range(start, end, step) | 生成從start到end的數字，步長為 step，供for迴圈使用 |
| enumerate() | 函式用於將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列，同時列出資料和資料下標，一般用在 for 迴圈當中。 |
2.1 len()
# 1. 字串
str1 = 'abcdefg'
print(len(str1)) # 7
# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1)) # 4
# 3. 元組
t1 = (10, 20, 30, 40, 50)
print(len(t1)) # 5
# 4. 集合
s1 = {10, 20, 30}
print(len(s1)) # 3
# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1)) # 22.2 del()
# 1. 字串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]2.3 max()
# 1. 字串
str1 = 'abcdefg'
print(max(str1)) # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 402.4 min()
# 1. 字串
str1 = 'abcdefg'
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 102.5 range()
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
print(i)
# 1 3 5 7 9
for i in range(1, 10, 2):
print(i)
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
print(i)注意：range()生成的序列不包含end數字。
2.6 enumerate()
語法
enumerate(可遍歷物件, start=0)注意：start引數用來設定遍歷資料的下標的起始值，預設為0。
快速體驗
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, char in enumerate(list1, start=1):
print(f'下標是{index}, 對應的字元是{char}')三. 容器型別轉換
3.1 tuple()
作用：將某個序列轉換成元組
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))3.2 list()
作用：將某個序列轉換成列表
t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))3.3 set()
作用：將某個序列轉換成集合
list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))注意：
- 集合可以快速完成列表去重
- 集合不支援下標
推導式
一. 列表推導式
作用：用一個表示式建立一個有規律的列表或控制一個有規律列表。
列表推導式又叫列表生成式。
1.1 快速體驗
需求：建立一個0-10的列表。
while迴圈實現
# 1. 準備一個空列表
list1 = []
# 2. 書寫迴圈，依次追加數字到空列表list1中 i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)for迴圈實現
list1 = []
for i in range(10):
list1.append(i)
print(list1)列表推導式實現
list1 = [i for i in range(10)]
print(list1)1.2 帶if的列表推導式
需求：建立0-10的偶數列表
方法一：range()步長實現
list1 = [i for i in range(0, 10, 2)]
print(list1)方法二：if實現
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)1.3 多個for迴圈實現列表推導式
需求：建立列表如下：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]程式碼如下：
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)二. 字典推導式
思考：如果有如下兩個列表：
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']如何快速合併為一個字典？
答：字典推導式
字典推導式作用：快速合併列表為字典或提取字典中目標資料。
2.1 快速體驗
- 建立一個字典：字典key是1-5數字，value是這個數字的2次方。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}- 將兩個列表合併為一個字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)- 提取字典中目標資料
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 需求：提取上述電腦數量大於等於200的字典資料
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1) # {'MBP': 268, 'DELL': 201}三. 集合推導式
需求：建立一個集合，資料為下方列表的2次方。
list1 = [1, 1, 2]程式碼如下：
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4}注意：集合有資料去重功能。