史上最全python基礎記錄
一、Python簡介
1. 了解Python
Python是一種解釋型（這意味着開發過程中沒有了編譯這個環節）、面向對象（支持面向對象的風格或代碼封裝在對象的編程技術）、動態數據類型的交互式（可在命令行中通過Python提示符及直接代碼執行程序）高級程序設計語言。
2. Python介紹
Python是時下最流行、最火爆的編程語言，具體原因：
簡單、易學，適應人群廣泛
免費、開源
應用領域廣泛
3. Python特點
易於學習：Python有相對較少的關鍵字，結構簡單，和一個明確定義的語法，學習起來更加簡單。
易於閱讀：Python代碼定義的更清晰。
易於維護：Python的成功在於它的源代碼是相當容易維護的。
一個廣泛的標准庫：Python的最大的優勢之一是豐富的庫，跨平台的，在UNIX，Windows和Macintosh兼容很好。
互動模式：互動模式的支持，您可以從終端輸入執行代碼並獲得結果的語言，互動的測試和調試代碼片斷。
可移植：基於其開放源代碼的特性，Python已經被移植（也就是使其工作）到許多平台。
可擴展：如果你需要一段運行很快的關鍵代碼，或者是想要編寫一些不願開放的算法，你可以使用C或C++完成那部分程序，然后從你的Python程序中調用。
數據庫：Python提供所有主要的商業數據庫的接口。
GUI編程：Python支持GUI可以創建和移植到許多系統調用。
可嵌入: 你可以將Python嵌入到C/C++程序，讓你的程序的用戶獲得"腳本化"的能力。
4. Python發展歷史
Python發展歷史：https://baike.baidu.com/item/Python/407313?fr=aladdin
5. Python版本
Python 2.X
Python 3.X
二、Python解釋器
1. 解釋器的作用
Python解釋器作用：運行文件
Python解釋器種類
PyPy，基於Python語言開發的解釋器。
Jython，運行在Java平台的解釋器，直接把Python代碼編譯成Java字節碼執行。
IronPython，運行在微軟.Net平台上的Python解釋器，可以直接把Python代碼編譯成.Net的字節碼。
CPython，C語言開發的解釋器[官方]，應用廣泛的解釋器。
IPython，基於CPython的一種交互式解釋器。
其他解釋器
2. 解釋器的安裝
Python解釋器的安裝：https://blog.csdn.net/weixin_43495473/article/details/103559812
三、PyCharm安裝與使用
1. PyCharm的作用
PyCharm是一種Python IDE（集成開發環境），帶有一整套可以幫助用戶在使用Python語言開發時提高其效率的工具，內部集成的功能如下：
Project管理
智能提示
語法高亮
代碼跳轉
調試代碼
解釋代碼(解釋器)
框架和庫
…
2. PyCharm安裝與使用
PyCharm的安裝：https://blog.csdn.net/weixin_43495473/article/details/103560198
四、注釋
1. 注釋的作用
通過用自己熟悉的語言，在程序中對某些代碼進行標注說明，這就是注釋的作用，能夠大大增強程序的可讀性。
2. 注釋的分類及語法
注釋分為兩類：單行注釋 和 多行注釋。
單行注釋
只能注釋一行內容，語法如下：
# 注釋內容
多行注釋
可以注釋多行內容，一般用在注釋一段代碼的情況， 語法如下：
""" 第一行注釋 第二行注釋 第三行注釋"""
''' 注釋1 注釋2 注釋3'''
快捷鍵： ctrl + /
注意：解釋器不執行任何的注釋內容。
五、變量
1. 變量的作用
變量，簡單來說，其實就是計算機內存中的一塊儲存空間，用來存儲CPU需要使用的數據。而這個儲存空間需要一個名字，這個名字的統稱就叫變量。
作用：
用來臨時保存數據
便於項目的后期升級維護
節約內存
2. 定義變量
變量名 = 值
變量名自定義，要滿足標識符命名規則。
2.1 標識符
標識符命名規則是Python中定義各種名字的時候的統一規范，具體如下：
由數字、字母、下划線組成
不能數字開頭
不能使用內置關鍵字
嚴格區分大小寫
2.2 命名習慣
見名知義。
大駝峰：即每個單詞首字母都大寫，例如：MyName。
小駝峰：第二個（含）以后的單詞首字母大寫，例如：myName。
下划線：例如：my_name。
2.3 使用變量
my_name = "張三"
print(my_name)
myAge = 23
print(myAge)
2.4 認識bug
所謂bug，就是程序中的錯誤。如果程序有錯誤，需要程序員排查問題，糾正錯誤。
2.5 Debug工具
Debug工具是PyCharm IDE中集成的用來調試程序的工具，在這里程序員可以查看程序的執行細節和流程或者調解bug。
Debug工具使用步驟：
打斷點
Debug調試
六、數據類型
在 Python 里為了應對不同的業務需求，也把數據分為不同的類型。
檢測數據類型的方法：type(變量名或者數值)
a = 1print(type(a)) # <class 'int'> -- 整型
b = 1.1print(type(b)) # <class 'float'> -- 浮點型
c = Trueprint(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": "張三", "age": 20}print(type(g)) # <class 'dict'> -- 字典
思考：
為什么Python會提出這么多種的數據類型?
有限的內存, 無限的變量, 合理的使用內存
Python中，程序員定義變量需要關心變量的類型嗎?
Python弱類型語言
程序員不需要關心變量的類型, 只需要把數據書寫正確即可，python會通過自動推到出您變量的類型。
七、輸出
作用：程序輸出內容給用戶。
print('hello Python')
age = 18
print(age)
# 需求：輸出“今年我的年齡是18歲”
1. 格式化輸出
%06d，表示輸出的整數顯示位數，不足以0補全，超出當前位數則原樣輸出。
%.2f，表示小數點后顯示的小數位數。
2. 內置函數format
format()用於字符串格式化，功能非常強大，格式是str.format()，format函數可以接受不限個參數，位置可以不按順序。
3. f-格式化字符串
f-string是格式化字符串的一種很好的新方法。與其他格式化方式相比，它不僅更易讀，更簡潔，不易出錯，而且速度更快！格式為：f'{表達式}'。
4. 體驗格式化字符串
name = "張三"age = 23weight = 75.5student_id = 1
# 我的名字是張三
print('我的名字是%s' % name)
# 我的學號是0001
print('我的學號是%04d' % student_id)
# 我的體重是75.50公斤
print('我的體重是%.2f公斤' % weight)
# 我的名字是張三，今年23歲了
print('我的名字是%s，今年%d歲了' % (name, age))
# 我的名字是張三，明年24歲了
print('我的名字是%s，明年%d歲了' % (name, age + 1))
# 我的名字是張三，明年24歲了
print('我的名字是{0}, 明年{1}歲了'.format(name, age+1))
# 我的名字是李思，今年18歲了
print('我的名字是{0}, 今年{1}歲了'.format("李思", 18))
# 我的名字是張三，明年24歲了
print(f'我的名字是{name}, 明年{age + 1}歲了')
5. 補充知識
字符串輸出的本質其實就是拼接字符串，那么我們都用%s完全也是可以的。很多時候，我們不用區分整型、浮點型等，直接用%s輸出就可以了。
print('我的名字是%s，今年%s歲了，我的體重是%s公斤' % (name, age ,weight))
6. 轉義字符
\n：換行。
\t：制表符，一個tab鍵（4個空格）的距離。
7. 結束符
# print會默認換行輸出print('輸出的內容', end="\n")
在Python中，print()， 默認自帶end="\n"這個換行結束符，所以導致每兩個print直接會換行展示，用戶可以按需求更改結束符。
# 改變Python換行輸出
print('內容', end=" ")
print('內容', end="···")
八、輸入
在Python中，程序接收用戶輸入的數據的功能即是輸入。
1. 輸入的語法
input("提示信息")
2. 輸入的特點
當程序執行到input，等待用戶輸入，輸入完成之后才繼續向下執行。
在Python中，input接收用戶輸入后，一般存儲到變量，方便使用。
在Python中，input會把接收到的任意用戶輸入的數據都當做字符串處理。
password = input('請輸入您的密碼：')
print(f'您輸入的密碼是{password}')
# <class 'str'>
print(type(password))
九、轉換數據類型
1. 轉換數據類型的作用
問：input()接收用戶輸入的數據都是字符串類型，如果用戶輸入1，想得到整型該如何操作？
答：轉換數據類型即可，即將字符串類型轉換成整型。
2. 轉換數據類型的函數
3. 體驗轉換數據類型
需求：input接收用戶輸入，用戶輸入“1”，將這個數據1轉換成整型。
# 1. 接收用戶輸入
num = input('請輸入您的幸運數字：')
# 2. 打印結果
print(f"您的幸運數字是{num}")
# 3. 檢測接收到的用戶輸入的數據類型 -- str類型
print(type(num))
# 4. 轉換數據類型為整型 -- int類型
print(type(int(num)))
# 1. float() -- 轉換成浮點型
num1 = 1print(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. 運算符的分類
算數運算符
賦值運算符
復合賦值運算符
比較運算符
邏輯運算符
2. 算數運算符
混合運算優先級順序：()高於 ** 高於 * / // % 高於 + -
3. 賦值運算符
1.單個變量賦值
num = 1print(num)
2. 多個變量賦值
num1, float1, str1 = 10, 0.5, 'hello world'print(num1)print(float1)print(str1)
3. 多變量賦相同值
a = b = 10print(a)print(b)
4. 復合賦值運算符
a = 100
a += 1# 輸出101
a = a + 1,最終
a = 100 + 1
print(a)
b = 2b *= 3# 輸出6 b = b * 3,最終b = 2 * 3print(b)
c = 10c += 1 + 2# 輸出13, 先算運算符右側1 + 2 = 3， c += 3 , 推導出c = 10 + 3print(c)
5. 比較運算符
比較運算符也叫關系運算符， 通常用來判斷。
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) # True
6. 邏輯運算符
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)) # True
7. 補充知識
數字之間的邏輯運算
a = 0b = 1c = 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) # 1print(a or c) # 2print(b or c) # 1
十一、條件語句
1. 了解條件語句
Python條件語句是通過一條或多條語句的執行結果（True或者False）來決定執行的代碼塊。
2. if語法
if 條件: 條件成立執行的代碼1 條件成立執行的代碼2 ......
2.1 體驗if語句
if True:
print('條件成立執行的代碼1')
print('條件成立執行的代碼2')
# 下方的代碼沒有縮進到if語句塊，所以和if條件無關print('我是無論條件是否成立都要執行的代碼')
2.2 簡單版：網吧上網
需求分析：如果用戶年齡大於等於18歲，即成年，輸出"已經成年，可以上網"。
age = 20
if age >= 18:
print('已經成年，可以上網')
print('系統關閉')
2.3 進階版：網吧上網
新增需求：用戶可以輸出自己的年齡，然后系統進行判斷是否成年，成年則輸出"您的年齡是’用戶輸入的年齡’，已經成年，可以上網"。
# input接受用戶輸入的數據是字符串類型，條件是age和整型18做判斷，所以這里要int轉換數據類型
age = int(input('請輸入您的年齡：'))
if age >= 18:
print(f'您的年齡是{age},已經成年，可以上網')
print('系統關閉')
3. if…else…
作用：條件成立執行if下方的代碼; 條件不成立執行else下方的代碼。
if 條件: 條件成立執行的代碼1 條件成立執行的代碼2 ......else: 條件不成立執行的代碼1 條件不成立執行的代碼2 ......
思考：網吧上網的實例，如果成年，允許上網，如果不成年呢？是不是應該回復用戶不能上網？
3.1 實用版：網吧上網
age = int(input('請輸入您的年齡：'))
if age >= 18:
print(f'您的年齡是{age},已經成年，可以上網')
else:
print(f'您的年齡是{age},未成年，請自行回家寫作業')
print('系統關閉')
注意：如果條件成立執行了某些代碼，那么其他的情況的代碼將不會執行。
4. 多重判斷
if 條件1: 條件1成立執行的代碼1 條件1成立執行的代碼2 ......elif 條件2： 條件2成立執行的代碼1 條件2成立執行的代碼2 ............else: 以上條件都不成立執行執行的代碼
多重判斷也可以和else配合使用。一般else放在整個if語句的最后，表示以上條件都不成立的時候執行的代碼。
思考：中國合法工作年齡為18-60歲，即如果年齡小於18的情況為童工，不合法；如果年齡在18-60歲之間為合法工齡；大於60歲為法定退休年齡。
4.1 實例：工齡判斷
age = int(input('請輸入您的年齡：'))if age < 18:
print(f'您的年齡是{age},童工一枚')elif (age >= 18) and (age <= 60):print(f'您的年齡是{age},合法工齡')elif age > 60:
print(f'您的年齡是{age},可以退休')
5. if嵌套
if 條件1： 條件1成立執行的代碼 條件1成立執行的代碼
if 條件2： 條件2成立執行的代碼 條件2成立執行的代碼
注意：條件2的if也是出於條件1的縮進關系內部。
思考：坐公交：如果有錢可以上車，沒錢不能上車；上車后如果有空座，則可以坐下；如果沒空座，就要站着。怎么書寫程序？
5.1 實例：坐公交
1.判斷是否能上車
""" 1. 如果有錢，則可以上車 2. 上車后，如果有空座，可以坐下 上車后，如果沒有空座，則站着等空座位 如果沒錢，不能上車"""
# 假設用 money = 1 表示有錢, money = 0表示沒有錢
money = 1
if money == 1:
print('土豪，不差錢，順利上車')
else:
print('沒錢，不能上車，追着公交車跑')
2. 判斷是否能坐下
""" 1. 如果有錢，則可以上車 2. 上車后，如果有空座，可以坐下 上車后，如果沒有空座，則站着等空座位 如果沒錢，不能上車"""# 假設用 money = 1 表示有錢, money = 0表示沒有錢; seat = 1 表示有空座，seat = 0 表示沒有空座m
oney = 1
seat = 0
if money == 1:
print('土豪，不差錢，順利上車')
if seat == 1:
print('有空座，可以坐下')
else:
print('沒有空座，站等')
else:
print('沒錢，不能上車，追着公交車跑')
5.2 if嵌套執行流程
6. 應用：猜拳游戲
需求分析：
參與游戲的角色
隨機出拳
手動出拳
玩家
電腦
判斷輸贏
玩家 電腦
石頭 剪刀
剪刀 布
布 石頭
玩家出拳 和 電腦出拳相同
平局
電腦獲勝
玩家獲勝
隨機做法：
1.導出random模塊
import 模塊名
2. 使用random模塊中的隨機整數功能
random.randint(開始,結束)
6.1 初始版：猜拳游戲
"""提示：0-石頭，1-剪刀，2-布3. 出拳玩家輸入出拳電腦隨機出拳
4. 判斷輸贏玩家獲勝平局電腦獲勝"""
# 導入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('電腦獲勝')
6.2 進階版：猜拳游戲
"""石頭剪刀布游戲玩家VS電腦站在玩家的角度，分析勝利、失敗、平局0-石頭，1-剪刀，2-布"""# 導入隨機數模塊import random
import random
import sys
print("-----歡迎來到人機對戰小游戲-----")
name = input("請輸入您的游戲名：")
while True:
stats = input("歡迎“%s”來到本游戲，開始游戲輸入Y，退出游戲輸入N，請您輸入：" % name)
if stats == "Y" or stats == "y":
print("游戲開始……")
print("石頭輸入0、剪刀輸入1、布輸入2")
break
elif stats == "N" or stats == "n":
print("游戲結束……")
sys.exit(0)
else:
print("請按照要求重新輸入！")
print("-------------加載中-------------")
def Game(user, comp):
if (user== 0 and comp== 1) or (user== 1 and comp== 2) or (user== 2 and comp== 0):
print("機器輸入%d，您贏了！" % comp)
elif user == comp:
print("機器輸入%d，平局了！" % comp)
else:
print("機器輸入%d，您輸了！" % comp)
res = input("重新游戲請輸入X，退出游戲按任意鍵")
if res == "X" or res == "x":
return
else:
sys.exit(0)
while True:
user = int(input("請您出拳，輸入相應數字！"))
if user == 0 or user == 1 or user == 2:
comp = random.randint(0, 2)
Game(user, comp)
else:
print("輸入數字有誤，請確認后，重新輸入！")7. 三目運算符三目運算符也叫三元運算符。
語法如下：
值1 if 條件 else 值2
快速體驗：
a = 1
b = 2
c = a if a > b else b
print(c)
十二、循環簡介
1. 循環的作用
讓代碼更高效的重復執行。
2. 循環的分類
在Python中，循環分為while和for兩種，最終實現效果相同。
3. while的語法
while 條件: 條件成立重復執行的代碼1 條件成立重復執行的代碼2 ......
4. while循環快速體驗
需求：復現重復執行10次print('Hello World')。
分析：初始值是0次，終點是10次，重復做的事情輸出“Hello World”。
# 循環的計數器
i = 0
while i < 10:
print('Hello World')
i += 1
print('任務結束')
5. while的應用
5.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做累加。
5.2 應用二：計算1-100偶數累加和
分析：1-100的偶數和，即 2 + 4 + 6 + 8…，得到偶數的方法如下：
偶數即是和2取余結果為0的數字，可以加入條件語句判斷是否為偶數，為偶數則累加
初始值為0 / 2 , 計數器每次累加2
方法一：條件判斷和2取余數則累加
# 方法一：條件判斷和2取余數為0則累加計算
i = 1result = 0
while i <= 100:
if i % 2 == 0:
result += i
i += 1
# 輸出2550
print(result)
方法二：計數器控制
# 方法二：計數器控制增量為2
i = 0
result = 0
while i <= 100:
result += i
i += 2
# 輸出2550
print(result)
6. break和continue
break和continue是循環中滿足一定條件退出循環的兩種不同方式。
6.1 理解
舉例：一共吃5個蘋果，吃完第一個，吃第二個…，這里"吃蘋果"的動作是不是重復執行？
情況一：如果吃的過程中，吃完第三個吃飽了，則不需要再吃第4個和第五個蘋果，即是吃蘋果的動作停止，這里就是break控制循環流程，即終止此循環。
情況二：如果吃的過程中，吃到第三個吃出一個大蟲子…,是不是這個蘋果就不吃了，開始吃第四個蘋果，這里就是continue控制循環流程，即退出當前一次循環繼而執行下一次循環代碼。
6.2 break實例
i = 1
while i <= 5:
if i == 4:
print(f'吃飽了不吃了')
break
print(f'吃了第{i}個蘋果')
i += 1
6.3 continue實例
i = 1
while i <= 5:
if i == 3:
print(f'大蟲子，第{i}個不吃了')
# 在continue之前一定要修改計數器，否則會陷入死循環
i += 1
continue
print(f'吃了第{i}個蘋果')
i += 1
7. while循環嵌套
7.1 語法
while 條件1: 條件1成立執行的代碼 ...... while 條件2: 條件2成立執行的代碼 ......
總結：所謂while循環嵌套，就是一個while里面嵌套一個while的寫法，每個while和之前的基礎語法是相同的。
7.2 執行過程
當內部循環執行完成之后，再執行下一次外部循環的條件判斷。
7.3 while循環嵌套應用
應用一：打印星號（正方形）
# 重復打印5行星星
j = 0
while j <= 4:
# 一行星星的打印
i = 0
while i <= 4:
# 一行內的星星不能換行，取消print默認結束符\n
print('*', end='')
i += 1
# 每行結束要換行，這里借助一個空的print，利用print默認結束符換行
print()
j += 1
應用二：打印星號（三角形）
# 重復打印5行星星
# j表示行號
j = 0
while j <= 4:
# 一行星星的打印
i = 0
# i表示每行里面星星的個數，這個數字要和行號相等所以i要和j聯動
while i <= j:
print('*', end='')
i += 1
print()
j += 1
應用二：九九乘法表
# 重復打印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
8. for循環
8.1 語法
for 臨時變量 in 序列:
重復執行的代碼1
重復執行的代碼2 ......
8.2 快速體驗
str1 = 'Hello World'
for i in str1:
print(i)
8.3 break
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
8.4 continue
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
十三、else
循環可以和else配合使用，else下方縮進的代碼指的是當循環正常結束之后要執行的代碼。
1. while…else
1.1 語法
while 條件: 條件成立重復執行的代碼else: 循環正常結束之后要執行的代碼
1.2 示例
i = 1
while i <= 5:
print('Hello World')
i += 1else:
print('執行完畢')
1.3 退出循環的方式
1.break終止循環
i = 1
while i <= 5:
if i == 3:
print("提前結束")
break
print('Hello World')
i += 1
else:
print('執行完畢')
所謂else指的是循環正常結束之后要執行的代碼，即如果是break終止循環的情況，else下方縮進的代碼將不執行。
2.continue控制循環
i = 1
while i <= 5:
if i == 3:
print("打斷一下")
i += 1
continue
print('Hello World')
i += 1
else:
print('執行完畢')
因為continue是退出當前一次循環，繼續下一次循環，所以該循環在continue控制下是可以正常結束的，當循環結束后，則執行了else縮進的代碼。
2. for…else
2.1 語法
for 臨時變量 in 序列: 重復執行的代碼 ...else: 循環正常結束之后要執行的代碼
所謂else指的是循環正常結束之后要執行的代碼，即如果是break終止循環的情況，else下方縮進的代碼將不執行。
2.2 示例
str1 = 'Hello World'
for i in str1:
print(i)
else:
print('循環正常結束之后執行的代碼')
2.3 退出循環的方式
1.break終止循環
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
else:
print('循環正常結束之后執行的代碼')
沒有執行else縮進的代碼。
2.continue控制循環
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
else:
print('循環正常結束之后執行的代碼')
因為continue是退出當前一次循環，繼續下一次循環，所以該循環在continue控制下是可以正常結束的，當循環結束后，則執行了else縮進的代碼。
十四、字符串
1. 認識字符串
字符串是 Python 中最常用的數據類型。我們一般使用引號來創建字符串。創建字符串很簡單，只要為變量分配一個值即可。
a = 'hello world'b = "abcdefg"print(type(a))print(type(b))
注意：控制台顯示結果為<class 'str'>， 即數據類型為str(字符串)。
2. 字符串特征
一對引號字符串
name1 = 'Tom'na
me2 = "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'
3. 字符串輸出
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)print(f'我的名字是{name}')
4. 字符串輸入
在Python中，使用input()接收用戶輸入。
name = input('請輸入您的名字：')
print(f'您輸入的名字是{name}')
print(type(name))
password = input('請輸入您的密碼：')
print(f'您輸入的密碼是{password}')
print(type(password))
5. 下標
5.1 概念
“下標”又叫“索引”，就是編號。比如火車座位號，座位號的作用：按照編號快速找到對應的座位。同理，下標的作用即是通過下標快速找到對應的數據。
5.2 快速體驗
需求：字符串name = "abcdef"，取到不同下標對應的數據。
代碼
name = "abcdef"
print(name[1])
print(name[0])
print(name[2])
輸出結果
注意：下標從0開始。
6. 切片
切片是指對操作的對象截取其中一部分的操作。字符串、列表、元組都支持切片操作。
6.1 語法
序列[開始位置下標:結束位置下標:步長]
注意：
不包含結束位置下標對應的數據， 正負整數均可；
步長是選取間隔，正負整數均可，默認步長為1。
6.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
7. 常用操作方法
字符串的常用操作方法有查找、修改和判斷三大類。
7.1 查找
所謂字符串查找方法即是查找子串在字符串中的位置或出現的次數。
find()：檢測某個子串是否包含在這個字符串中，如果在返回這個子串開始的位置下標，否則則返回-1。
語法
字符串序列.find(子串, 開始位置下標, 結束位置下標)
注意：開始和結束位置下標可以省略，表示在整個字符串序列中查找。
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 22
print(mystr.find('ands')) # -1
index()：檢測某個子串是否包含在這個字符串中，如果在返回這個子串開始的位置下標，否則則報異常。
語法
字符串序列.index(子串, 開始位置下標, 結束位置下標)
注意：開始和結束位置下標可以省略，表示在整個字符串序列中查找。
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 22
print(mystr.index('ands')) # 報錯
rfind()：和find()功能相同，但查找方向為
右側
開始。
rindex()：和index()功能相同，但查找方向為
右側
開始。
count()：返回某個子串在字符串中出現的次數。
語法
字符串序列.count(子串, 開始位置下標, 結束位置下標)
注意：開始和結束位置下標可以省略，表示在整個字符串序列中查找。
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.count('and')) # 3
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1
7.2 修改
所謂修改字符串，指的就是通過函數的形式修改字符串中的數據。
replace()：替換字符串。
語法
字符串序列.replace(舊子串, 新子串, 替換次數)
注意：替換次數如果查出子串出現次數，則替換次數為該子串出現次數。
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.replace('and', 'he'))# 結果：hello world he buran he list he Python
print(mystr.replace('and', 'he', 10))# 結果：hello world he buran he list he Python
print(mystr)# 結果：hello world and buran and list and Python
注意：數據按照是否能直接修改分為可變類型和不可變類型兩種。字符串類型的數據修改的時候不能改變原有字符串，屬於不能直接修改數據的類型即是不可變類型。
split()：按照指定字符分割字符串。
語法
字符串序列.split(分割字符, num)
注意：num表示的是分割字符出現的次數，即將來返回數據個數為num+1個。
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.split('and'))# 結果：['hello world ', ' buran ', ' list ', ' Python']
print(mystr.split('and', 2))# 結果：['hello world ', ' buran ', ' list and Python']
print(mystr.split(' '))# 結果：['hello', 'world', 'and', 'buran', 'and', 'list', 'and', 'Python']
print(mystr.split(' ', 2))# 結果：['hello', 'world', 'and buran and list and Python']
注意：如果分割字符是原有字符串中的子串，分割后則丟失該子串。
join()：用一個字符或子串合並字符串，即是將多個字符串合並為一個新的字符串。
1.語法
字符或子串.join(多字符串組成的序列)
2. 快速體驗
list1 = ['hello', 'buran', 'list']t1 = ('aa', 'b', 'cc', 'ddd')
print('_'.join(list1))# hello_buran_list
print('...'.join(t1))# 結果：aa...b...cc...ddd
capitalize()：將字符串第一個字符轉換成大寫。
mystr = "hello world and buran and list and Python"
print(mystr.capitalize())# 結果：Hello world and buran and list and python
注意：capitalize()函數轉換后，只字符串第一個字符大寫，其他的字符全都小寫。
title()：將字符串每個單詞首字母轉換成大寫。
mystr = "hello world and buran and list and Python"
print(mystr.title())# 結果：Hello World And Buran And List And Python
lower()：將字符串中大寫轉小寫。
mystr = "hello world and buran and list and Python"
print(mystr.lower())# 結果：hello world and buran and list and python
upper()：將字符串中小寫轉大寫。
mystr = "hello world and buran and list and Python"
print(mystr.upper())# 結果：HELLO WORLD AND BURAN AND LIST AND PYTHON
lstrip()：刪除字符串左側空白字符。
rstrip()：刪除字符串右側空白字符。
strip()：刪除字符串兩側空白字符。
ljust()：返回一個原字符串左對齊,並使用指定字符(默認空格)填充至對應長度 的新字符串。
rjust()：返回一個原字符串右對齊,並使用指定字符(默認空格)填充至對應長度 的新字符串，語法和ljust()相同。
center()：返回一個原字符串居中對齊,並使用指定字符(默認空格)填充至對應長度 的新字符串，語法和ljust()相同。
7.3 判斷
所謂判斷即是判斷真假，返回的結果是布爾型數據類型：True 或 False。
startswith()：檢查字符串是否是以指定子串開頭，是則返回 True，否則返回 False。如果設置開始和結束位置下標，則在指定范圍內檢查。
語法
字符串序列.startswith(子串, 開始位置下標, 結束位置下標)
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.startswith('hello'))# 結果：True
print(mystr.startswith('hello', 5, 20))# 結果：False
endswith()：：檢查字符串是否是以指定子串結尾，是則返回 True，否則返回 False。如果設置開始和結束位置下標，則在指定范圍內檢查。
語法
字符串序列.endswith(子串, 開始位置下標, 結束位置下標)
快速體驗
mystr = "hello world and buran and list and Python"
print(mystr.endswith('Python'))# 結果：True
print(mystr.endswith('python'))# 結果：False
print(mystr.endswith('Python', 2, 20))# 結果：False
isalpha()：如果字符串至少有一個字符並且所有字符都是字母則返回 True, 否則返回 False。
mystr1 = 'hello'mystr2 = 'hello12345'
print(mystr1.isalpha())# 結果：True
print(mystr2.isalpha())# 結果：False
isdigit()：如果字符串只包含數字則返回 True 否則返回 False。
mystr1 = 'aaa12345'mystr2 = '12345'
print(mystr1.isdigit())# 結果：False
print(mystr2.isdigit())# 結果：False
isalnum()：如果字符串至少有一個字符並且所有字符都是字母或數字則返 回 True,否則返回 False。
mystr1 = 'aaa12345'mystr2 = '12345-'
print(mystr1.isalnum())# 結果：True
print(mystr2.isalnum())# 結果：False
isspace()：如果字符串中只包含空白，則返回 True，否則返回 False。
mystr1 = '1 2 3 4 5'mystr2 = ' '
print(mystr1.isspace())# 結果：Falseprint(mystr2.isspace())# 結果：True
十五、列表
1. 列表的格式
[數據1, 數據2, 數據3, 數據4......]
列表可以一次性有序存儲多個不同類型的數據。
2. 列表的常用操作
列表的作用是一次性存儲多個數據，程序員可以對這些數據進行的操作有：增、刪、改、查。
2.1 查找
下標
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose
函數
index()：返回指定數據所在位置的下標 。
列表序列.index(數據, 開始位置下標, 結束位置下標)
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
注意：如果查找的數據不存在則報錯。
count()：統計指定數據在當前列表中出現的次數。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1
len()：訪問列表長度，即列表中數據的個數。
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3
2.2 判斷是否存在
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)
2.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(數據)
單個數據：
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 結果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)
序列數據：
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)
2.3 刪除
del
del 目標# del(目標)
刪除列表：
name_list = ['Tom', 'Lily', 'Rose']
# 結果：報錯提示：name 'name_list' is not defineddel name_list
print(name_list)
刪除指定數據：
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) # 結果： []
2.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)
num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 結果：[1, 2, 3, 5, 6, 8]
print(num_list)
注意：reverse表示排序規則，reverse = True 降序， reverse = False 升序（默認）
2.5 復制
函數：copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 結果：['Tom', 'Lily', 'Rose']
print(name_li2)
3. 列表的循環遍歷
需求：依次打印列表中的各個數據。
3.1 while
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
3.2 for
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)
4. 列表嵌套
所謂列表嵌套指的就是一個列表里面包含了其他的子列表。
應用場景：要存儲班級一、二、三三個班級學生姓名，且每個班級的學生姓名在一個列表。
name_list = [['小明', '小紅', '小綠'], ['Tom', 'Lily', 'Rose'], ['張三', '李四', '王五']]
思考：如何查找到數據"李四"？
# 第一步：按下標查找到李四所在的列表
print(name_list[2])
# 第二步：從李四所在的列表里面，再按下標找到數據李四
print(name_list[2][1])
十六、元組
一個元組可以存儲多個數據，元組內的數據是不能修改的。
1. 定義元組
元組特點：定義元組使用小括號，且逗號隔開各個數據，數據可以是不同的數據類型。
# 多個數據元組t1 = (10, 20, 30)
# 單個數據元組t2 = (10,)
注意：如果定義的元組只有一個數據，那么這個數據后面也好添加逗號，否則數據類型為唯一的這個數據的數據類型。
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
2. 元組的常見操作
元組數據不支持修改，只支持查找，具體如下：
按下標查找數據
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
index()：查找某個數據，如果數據存在返回對應的下標，否則報錯，語法和列表、字符串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
count()：統計某個數據在當前元組出現的次數。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
len()：統計元組中數據的個數。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4
3. 元組的注意事項
元組內的直接數據如果修改則立即報錯。
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)
十七、字典
字典里面的數據是以“鍵值對”形式出現，字典數據和數據順序沒有關系，即字典不支持下標，后期無論數據如何變化，只需要按照對應的鍵的名字查找數據即可。
1. 創建字典的語法
字典特點：
符號為
大括號
數據為
鍵值對
形式出現
各個鍵值對之間用
逗號
隔開
# 有數據字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典dict2 = {}
dict3 = dict()
注意：一般稱冒號前面的為鍵(key)，簡稱k；冒號后面的為值(value)，簡稱v。
2. 字典常見操作
2.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)
注意：字典為可變類型。
2.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) # {}
2.3 改
寫法：字典序列[key] = 值
注意：如果key存在則修改這個key對應的值 ；如果key不存在則新增此鍵值對。
2.4 查
key值查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1['name']) # Tom
print(dict1['id']) # 報錯
如果當前查找的key存在，則返回對應的值；否則則報錯。
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')) # None
keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])
items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
3. 字典的循環遍歷
3.1 遍歷字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key in dict1.keys(): print(key)
3.2 遍歷字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for value in dict1.values(): print(value)
3.3 遍歷字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for item in dict1.items(): print(item)
3.4 遍歷字典的鍵值對
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key, value in dict1.items(): print(f'{key} = {value}')
十八、集合
集合具有確定性，無序性和去重性。
1. 創建集合
創建集合使用{}或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. 集合常見操作方法
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) # {'a', 100, 200, 10, 'b', 'c', 20}
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. 運算符
1.1 +
# 1. 字符串 str1 = 'aa'str2 = 'bb'str3 = str1 + str2print(str3) # aabb
# 2. 列表 list1 = [1, 2]list2 = [10, 20]list3 = list1 + list2print(list3) # [1, 2, 10, 20]
# 3. 元組 t1 = (1, 2)t2 = (10, 20)t3 = t1 + t2print(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') # Trueprint('a' not in 'abcd') # False
# 2. 列表list1 = ['a', 'b', 'c', 'd']print('a' in list1) # Trueprint('a' not in list1) # False
# 3. 元組t1 = ('a', 'b', 'c', 'd')print('aa' in t1) # Falseprint('aa' not in t1) # True
2. 公共方法
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)) # 2
2.2 del()
# 1. 字符串str1 = 'abcdefg'del str1print(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)) # 40
2.4 min()
# 1. 字符串str1 = 'abcdefg'print(min(str1)) # a
# 2. 列表list1 = [10, 20, 30, 40]print(min(list1)) # 10
2.5 range()
# 1 2 3 4 5 6 7 8 9for i in range(1, 10, 1): print(i)
# 1 3 5 7 9for i in range(1, 10, 2): print(i)
# 0 1 2 3 4 5 6 7 8 9for 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. 容器類型轉換
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.1 快速體驗
需求：創建一個0-10的列表。
while循環實現
# 1. 准備一個空列表list1 = []
# 2. 書寫循環，依次追加數字到空列表list1中i = 0while 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)
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)
2. 字典推導式
字典推導式作用：快速合並列表為字典或提取字典中目標數據。
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}
3. 集合推導式
需求：創建一個集合，數據為下方列表的2次方。
list1 = [1, 1, 2]
# 代碼如下：
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4}
end