2021小白Python入门学习记录Day3（win10系统、Python3.9、使用Pycharm）python高级数据类型(字符串、列表、元组、字典、集合) 及其操作
'''
每日更新內容為10天前當天學習內容，想通過寫博客的方式復習和記錄，歡迎大佬提意見、糾錯和萌新學習與討論。
'''
目錄
一、序列（字符串、列表、元組）
序列簡介
序列操作
（一）字符串 str
1.字符串定義
2.部分字符串操作
（二）列表? list
1.列表簡介
2.定義一個列表
3.列表操作
4.列表切片
（三）元組??tuple
1.元組簡介
2.定義一個元組
3.元組操作和注意事項
4.元組切片
#? ?序列操作內置函數（補充）
二、非序列類型（無序）? 字典和集合
（一）字典 dict
1.字典簡介
2.字典的多種創建方式
3.字典操作
（二）集合? set
1.集合簡介
2.創建一個集合
3.集合操作
三、部分公有操作： 合并+? ? ? 復制*? ? ?判斷對象是否存在in
1.合并
2.復制
3.判斷對象是否存在
一、序列（字符串、列表、元組）
序列簡介
序列：在python當中 序列就是一組按照順序排列的值【數據集合】
在python中 存在三種內置的序列類型：? 字符串、列表、元組
優點：可以支持索引和切片的操作（有序）
特征：第一個正索引為0，指向的是左端，第一個索引為負數的時候，指向的是右端
切片：【高級特性】可以根據下標來獲取序列對象的任意[部分]數據（不會越界
語法結構： 序列名[start:end:step]? ?step默認為1 和range()一樣左閉右開 不包含右側end?
range 默認從0開始
序列操作
（部分序列操作在Day6 補上）
此處介紹：
capitalize() #首字母變大寫
endswith/startswith() #判斷是否以x結束/開始?
find() #檢測x是否在字符串中，返回的是第一個的下標值,沒有找到返回-1
isalnum() #判斷是否是字母和數字
isalpha() #判斷是否是字母
isdigit() #判斷是否是數字
islower() #判斷是否是小寫
join() #循環取出所有值用xx去連接
lower/upper #大小寫轉換
swapcase #大寫變小寫，小寫變大寫
lstrip/rstrip/strip #移除左/右/兩側空格
split() #分割字符串
title() #把每個單詞的首字母變成大寫
replace(old,new,count=None) #old被換字符串，new替換字符串，count換多少個。無count表示全部替換
count() #統計出現的次數
index() #檢測字符串中是否包含子字符串，返回的是第一個的下標值,沒有找到報錯
len()可獲取字符串長度，列表中的數據個數
.reverse()反序
后續補充 序列操作內置函數（在 #序列操作內置函數（補充））：
all() ? #判斷可迭代參數（str、列表、元組）中所有元素是否都為True 除了0、空(''或None)、False外都算True（空列表，空元組返回True） 類似and
any() #判斷可迭代參數（str、列表、元組）中是否有一個元素為True 有一個為True 就返回True 類似or
sorted() #對所有可迭代的對象進行排序操作
list的sort()返回的是對已經存在的列表進行操作（修改），而內建函數sorted返回的是一個新的list，而不是在原來的基礎上進行的操作
reversed() ? #對所有可迭代的對象進行反序操作 ?
list的reverse() ? ?list反轉 ?對已經存在的列表進行操作（修改）
zip() # 將可迭代對象中的元素 打包成一個個元組組成的列表或者元組? 每項為一個元組
enumerate() ?將一個可遍歷的數據對象 組合成一個索引序列 一般用于for循環 每項為一個元組
list(enumerate(對象,[start=0]))
（一）字符串 str
1.字符串定義
Test='python' # 定義一個字符串 print(type(Test)) # 查看數據類型 print('獲取第一個字符%s'%Test[0]) print('獲取第二個字符%s'%Test[1]) for item in Test: # 序列遍歷 這里是字符串 （列表、元組都適用）print(item,end=' ') # 改變end參數為空格運行結果：
?序列的下標都是從0開始的Test[0]為第一個元素
2.部分字符串操作
（1）.capitalize() .lower() .upper() #大小寫變換
name='peter' print('姓名首字母轉換大寫%s'%name.capitalize()) # .capitalize首字母轉換大寫 print(name.lower()) # lower全變小寫 print(name.upper()) # upper全變大寫運行結果：
（2）.strip()? #去除空格? ?lstrip? 、rstrip
a=' hello ' b=a.strip() #去除兩邊空格 print(b) print(a.lstrip()) #刪除左邊空格 print(a.rstrip()) #刪除右邊空格運行結果：
（3）id()函數可以查看一個對象的內存地址（變量都能使用，并非序列專用）
通過b=a來復制字符串? ?只是把a對象的內存地址付給了b??
a=' hello ' # 復制字符串 print('a的內存地址%d'%id(a)) # id()函數可以查看一個對象的內存地址 b=a # 在此只是把a對象的內存地址賦給了b print('b的內存地址%d'%id(b)) print(b)運行結果：
?（4）.find()?和 .index() 查找? ? ?（find為字符串專用，）
dataStr='I love python p' print(dataStr.find('p')) # .find找到目標對象在序列對象的第一個下標值 下標值從0開始 print(dataStr.find('love')) # .find找到第一個字母下標值 print(dataStr.find('1')) # .find沒有找到返回-1 print(dataStr.index('p')) #檢測字符串中是否包含子字符串，返回的是第一個的下標值 index沒找到會報錯運行結果：
?find 和 index 的區別：find沒找到時返回 -1 ；index沒找到會報錯
都是返回首次找到的下標
（5）.startswith() 和 .endswith() 首? 尾判斷
dataStr='I love python p' print(dataStr.startswith('I')) #判斷是否為 I 開頭 這里返回True print(dataStr.endswith('s')) #判斷是否以 s 結束 這里返回False運行結果：
（6）len() 獲取字符串長度? ? （可以獲取列表或元組的數據個數）
strA='我喜歡python' print(len(strA)) #len()可獲取字符串長度，列表中的數據個數運行結果：
（7）split() #分割字符串
a='sad s a 4 6 87' print(a.split(' ')) # 括號里填寫把什么當作分隔符 這里我用空格 返回一個列表?運行結果：
?3.字符串切片
# 字符串切片 strMsg='hello world' # slice [start:end:step] print('輸出完整的數據：'+strMsg) # 輸出完整的數據 可以用加號來合并字符串 print('輸出第一個字符：'+strMsg[0]) #輸出第一個字符 print('輸出第一個到第8個字符步長為2：'+strMsg[0:9:2]) print('這里取到下標為2，3，4的數據：'+strMsg[2:5]) #不包含右側 這里取到下標為2，3，4的數據 print('第三個字符到最后：'+strMsg[2:]) #第三個字符到最后 print('首位到下標為2的數據：'+strMsg[:3]) #0-2 print('倒序輸出：'+strMsg[::-1]) #倒序輸出 負號表示方向從右向左遍歷 print('倒序輸出-3到-8：'+strMsg[-3:-9:-1]) #倒序輸出 負號表示方向從右向左遍歷 print('錯誤示范：'+strMsg[-3:-2:-1]) #倒序輸出 沒有數據運行結果：
這里注意在序列（字符串、鏈表、元組）中不管是正序還是倒序 每個字符對應的下標都是不會變的
?
切片時首下標和尾下標 要按步數規定的順序寫（可以正負下標混用），如果錯誤 就會像錯誤示范一樣沒有數據輸出
正序和倒序切片時都不含end下標（末位）的字符 （左閉右開）
（二）列表? list
1.列表簡介
列表list：python中非常重要的數據結構，是一種有序的數據集合
特點：
1.支持增刪改查
2.列表中的數據是可以變化的【數據項可以變化，內存地址不會改變】
3.用[]來表示列表類型，數據項之間用逗號來分割，注意：數據項可以是任何類型的數據
4.支持索引和切片來進行操作
2.定義一個列表
# 列表 li=[] #空列表 li=[1,2,3,'你好'] print(type(li)) print(li)運行結果：
3.列表操作
append() 追加
insert(位置下標，插入內容) 插入
len() 獲取數據個數 前面講過
extend() 擴展，相當于批量追加?
index(查找物，從哪開始查，到哪結束) #檢測字符串中是否包含子字符串，返回的是第一個的下標值,沒有找到會報錯
del 刪除
remove() 移除具體數據項
pop() 移除某個下標對應的數據項
我們先定義一個列表
listA=['abcd',35,11.22,'q1i',True]?（1）.append()? 追加
print('------------追加----------append-------') print('追加之前',listA) listA.append(['fff','ddd']) listA.append('ppap') listA.append(8888) print('追加之后',listA)運行結果：
?（2）.insert(位置下標，插入內容) 插入
print('------------插入----------insert-------') listA.insert(1,'這是我剛插入的數據') listA.insert(1,8888) print(listA)運行結果：
（3）.extend()? 擴展，相當于批量追加?
print('------------批量追加-------extend-------') rsdata=list(range(6)) #強制轉換為list對象 0~5 range默認從0開始 # print(type(rsdata)) listA.extend(rsdata) listA.extend([888,999,99]) print(listA)運行結果：
（4）修改
print('------------修改-----------------------') listA[0]=88888 #直接修改對應下標的項 print('修改之后',listA)運行結果：
（5）del 刪除? ? （del可以用在很多地方 這里不細講）? 這里新定義了一個listB
print('------------刪除-------------del-------') listB=list(range(10,30)) #新定義一個列表 print(listB) #輸出完整列表 del listB[0] #刪除第一項的 print(listB) # 批量刪除 del listB[1:3] #刪除第二到第三項 相當于刪除對應切片 print(listB)運行結果：
?（6）.remove() 移除具體數據項? ?
print('------------移除具體數據項-------------remove-------') listB.remove(20) #移除指定項 print(listB)運行結果：
（7）.pop() 移除某個下標對應的數據項
print('------------移除相應下標的數據項-------------pop-------') listB.pop(1) #移除下標1對應的項 print(listB)?運行結果：
注意：.remove()和.pop()? ?是有區別的 一個是移除具體的數據項? 后一個是移除對應下標的數據項
（8）.index(查找物，從哪開始查，到哪結束) #檢測字符串中是否包含子字符串，返回的是第一個的下標值,沒有找到會報錯
print('------------查找具體數據項的下標-------------index-------') print(listB.index(19,3,6)) #這里相當于是在下標為3-5（不含右側6）（相當于第4，5，6項）的數據項中查找 19 這個數據?運行結果：
4.列表切片
# 切片 listA=['abcd',35,11.22,'q1i',True] print(listA) #輸出完整的對象 print(listA[0]) #輸出第一個元素 print(listA[1:3]) #第二個到第三個元素 print(listA[2:]) #從第三個開始到最后所有元素 print(listA[::-1]) #負數從右向左開始輸出 print(listA*2) #輸出兩次 輸出多次列表中的數據*n?運行結果：
?序列的切片都是類似的 這里有一個listA*2? 相當于listA+listA 這種操作在序列中都可用
（三）元組??tuple
1.元組簡介
元組tuple：是一種不可變的序列，在創建之后，不能做任何的修改
1.不可變（但是可以更改元組內的列表內的項）比如([0,2],'a',3)的[0,2]內數據可變
2.用()創建元組類型，數據項用逗號來分割
3.可以是任何的類型
4.定義一個元組時，當元組中只有一個元素時，要加上逗號，不然解釋器會當作整形來處理
5.同樣支持切片操作
2.定義一個元組
tupleA=() #空元組 tupleA=('abcde',89,9.12,[11,22,33],(11,2)) print(type(tupleA)) print(tupleA)運行結果：
3.元組操作和注意事項
（1）更改元組中的列表項（使用上面定義的tupleA）
元組不可變（但是可以更改元組內的列表內的項）比如([0,2],'a',3)的[0,2]內數據可變
print(type(tupleA[3])) #該數據項為列表類型 tupleA[3][0]=12 # 則可以更改元組內的列表 相當于改變元組下標為3的項的列表的首項為12 print(tupleA)?運行結果：
（2）定義一個元組時，當元組中只有一個元素時，要加上逗號，不然解釋器會當作整形來處理
tupleB=(1) print(type(tupleB)) # 為int tupleB=('1') print(type(tupleB)) # 為str tupleB=(1,) #此時才為元組tuple print(type(tupleB))運行結果：
（3）.count() 統計元素個數? 序列通用（字符串使用時括號內要為字符串類型）
tupleC=(0,1,1,2,3,4,1) print(tupleC.count(1)) #統計元素個數?運行結果：
4.元組切片
# 元組切片 print(tupleA[2:4]) #切片 print(tupleA[::-1]) # 倒序 print(tupleA[::-2]) # 倒序步長為2 步長決定順序，下標不變 print(tupleA[-4:-1:1]) #下標0 1 2 3 4 分別負下標 -1 -2 -3 -4 -5 且不變 print(tupleA[:0:-1]) # 倒序到第一個 print(tupleA[-1:-4:-1]) print(tupleA[-1:-5:1]) #為空 步數規定順序為正序 而start和end為倒序不一致 則沒有數據?運行結果：
#? ?序列操作內置函數（補充）
all() ? #判斷可迭代參數（str、列表、元組）中所有元素是否都為True 除了0、空(''或None)、False外都算True（空列表，空元組返回True） 類似and
any() #判斷可迭代參數（str、列表、元組）中是否有一個元素為True 有一個為True 就返回True 類似or
sorted() #對所有可迭代的對象進行排序操作
（list的sort()返回的是對已經存在的列表進行操作（修改），而內建函數sorted返回的是一個新的list，而不是在原來的基礎上進行的操作）
reversed() ? #對所有可迭代的對象進行反序操作 ?
（list的reverse() ? ?list反轉 ?對已經存在的列表進行操作（修改））
zip() # 將可迭代對象中的元素 打包成一個個元組組成的列表或者元組? 每項為一個元組
enumerate() ?將一個可遍歷的數據對象 組合成一個索引序列 一般用于for循環 每項為一個元組
list(enumerate(對象,[start=0]))
（1）all() ? #判斷可迭代參數（str、列表、元組）中所有元素是否都為True? ?類似and ? ? ?
? ? ? ? ? 除了0、空(''或None)、False外都算True（空列表，空元組返回True）
# all() print(all([])) #True 空列表，空元組返回True print(all(())) #True 空列表，空元組返回True print(all([1,2,3,4,False])) #False print(all([1,2,3,0])) #False print(all([1,2,3,''])) #False print(all([1,2,3,None])) #False運行結果：
（2）any() #判斷可迭代參數（str、列表、元組）中是否有一個元素為True 有一個為True 就返回True 類似or
# any() print(any([1,None,'',0,False])) #結果為True print(any([None,'',0,False])) #False（3）sorted() #對所有可迭代的對象進行排序 但沒有改變原對象
sort()為列表專用 可以改變原列表
# sort()為列表專用 li1=[1,5,6,3] print(li1) # 運行結果：[1, 5, 6, 3] li3=li1 # 前面介紹過這里相當于傳的內存地址 所以后續變一個 兩個都變 在其他操作中類似 li1.sort() #直接在原列表中排序 print(li3,li1) #運行結果：[1, 3, 5, 6] [1, 3, 5, 6]兩都會變?sorted()內置函數就不會更改原對象
print(sorted(li2)) #[1, 5, 21, 51, 798] 默認升序 print(li2) #[1, 5, 798, 51, 21] 不會變 print(sorted(li2,reverse=False)) #[1,5,21,51,798] reverse=False升序 print(sorted(li2,reverse=True)) #[798,51,21,5,1] reverse=True降序 print(sorted(['a','f','D','S','z'])) #['D','S','a','f','z'] 默認先大寫A~Z再小寫a~z print(sorted(['a','f','D','S','z'],key=str.lower)) #['a','D','f','S','z'] # key=str.lower不區分大小寫a~z排序 tupleA=(10,5,7,4,9) print(sorted(tupleA,reverse=False)) #[4, 5, 7, 9, 10] 排元組返回列表運行結果：
?（4）reversed() ? #對所有可迭代的對象進行反序操作?但沒有改變原對象
reverse()為列表專用??可以改變原列表? 對原列表進行反序變換
# reverse()列表專用 lia=[1,5,7,6] lia.reverse() print(lia) # 結果為：[6, 7, 5, 1] 反序reversed() 反序但不改變原對象? 打印時要加上類型
lib=[1,2,3,4,5] print(tuple(reversed(lib))) # 結果為：(5, 4, 3, 2, 1) 必須加類型 print(list(reversed(lib))) # [5, 4, 3, 2, 1] print(list(reversed(range(10)))) #[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]（5）zip() # 將可迭代對象中的元素 打包成一個個元組組成的列表或者元組? 每項為一個元組
# 打印時必須加上類型? 不然報錯
# zip() print(list(zip([1,2,3],['a','b','c','d','e'],[11,12,13]))) # 打印時必須加上類型 [(1, 'a', 11), (2, 'b', 12), (3, 'c', 13)] print(tuple(zip([1,2,3],['a','b','c','d','e']))) ((1, 'a'), (2, 'b'), (3, 'c')) print(tuple(zip([1,2,3],))) ((1,), (2,), (3,))運行結果：
（6）enumerate() ?將一個可遍歷的數據對象 組合成一個有序號的索引序列 一般用于for循環 每項為一個元組
枚舉序列：這里用列表
# enumerate() #枚舉對象 listobj=['a','b','c','d'] for index,item in enumerate(listobj,start=4): #start默認從0開始print(index,item)pass print('------------------------------')運行結果
?
也可以用來枚舉字典：
# 定義一個字典 dicobj={} # 錄入鍵值對 dicobj['name']='李飛' dicobj['hobby']='體操' dicobj['pro']='運動員' print(dicobj) for item in enumerate(dicobj.values()): # 枚舉字典的值 也可以用.key()枚舉健 #用.item()枚舉鍵值組成的元組print(item)運行結果：
?
二、非序列類型（無序）? 字典和集合
（一）字典 dict
1.字典簡介
字典：也是python中重要的數據類型,字典是由'鍵值對'組成的集合，通常使用鍵來訪問數據，效率非常高，和list一樣，支持對數據的添加、修改、刪除
特點：
1.不是序列類型 沒有下標概念，是一個無序的 鍵值集合 是python內置的高級數據類型
2.用{}來表示字典對象，每個 鍵值對 用逗號分隔
3.鍵 必須是不可變的類型【元組，數字，字符串】，值可以是任意的類型
4.每個鍵必定是唯一的，如果存在重復的鍵，后者會覆蓋前者
2.字典的多種創建方式
（1）直接輸入創建
#字典 dict #如何創建字典 dictA={} #空字典 # print(type(dictA)) #dict類型 dictA={'pro':'游泳','school':'北體'} #直接輸入創建 # print(dictA)運行結果：
?（2）傳入關鍵字法創建字典
dicB=dict(wds='wadfasd',agggee=188) # 傳入關鍵字 print(dicB) #{'wds': 'wadfasd', 'agggee': 188}運行結果：
?
（3）映射函數方式來構造字典
dicC=dict(zip(['one','tow','three'],[1,2,3])) # 映射函數方式來構造字典 print(dicC) #{'one': 1, 'tow': 2, 'three': 3}運行結果：
（4）可迭代對象方式來構造字典
dicD=dict([('a',1),('b',2),('c',3)]) # 可迭代對象方式來構造字典 print(dicD) #{'a': 1, 'b': 2, 'c': 3}運行結果：
3.字典操作
.keys ?獲取所有鍵
.values 獲取所有值
.items ?獲取所有項 ?其中每一項都為一個元組item=(key,value)
.update({'':}) ?#update更新 或 新增
.pop 或 del 通過鍵刪除? 取出
?
（1）添加字典數據? 接著上面（1）的 dictA
#添加字典數據 dictA['name']='李飛' #key:value 鍵：值 dictA['age']='21' dictA['pos']='運動員' #結束添加 print(dictA) #輸出完整的字典 print(len(dictA)) #數據長度運行結果：
（2）通過鍵獲取值或修改值
print(dictA['name']) #通過鍵獲取對應的值 dictA['name']='吳凡' #通過鍵修改值 print(dictA)?運行結果：
（3）.update() 更新鍵對應的值 或者 新增鍵值對
dictA.update({'age':'19'}) #update修改 dictA.update({'heigh':'1.86'}) #update新增 print(dictA)運行結果：
（3）.keys()? ?.value()? ? .items()
# 獲取所有的鍵 print(dictA.keys()) # 獲取所有的值 print(dictA.values()) # #獲取所有的鍵和值 print(dictA.items())?運行結果：
（4）挨個輸出所有鍵值對
for item in dictA.items():print(item) #挨個輸出所有的鍵和值運行結果：
結果為一個個的元組
也可以按自己定格式取：
for key,value in dictA.items():print('%s==%s'%(key,value)) #挨個按格式取（5）del刪除? 和 pop? 取出
#刪除 del dictA['name'] #刪除 print(dictA)print(dictA.pop('age')) #pop 取出 pop是有返回值的 print(dictA)?運行結果：
del 是刪除鍵是'name'的條目
?pop() 方法刪除字典給定鍵 key 及對應的值，返回值為被刪除的值。key 值必須給出。 否則，返回 default值? 所以pop() 更相當于取出
（6）了解字典怎么排序? ? （僅了解）
# 如何排序 # 按字母排序 print(sorted(dictA.items(),key=lambda d:d[0] )) #按照key排序print(sorted(dictA.items(),key=lambda d:d[1] )) #按照value排序運行結果：
（二）集合? set
1.集合簡介
set(集合) 也是python中的一種數據類型，是一個 無序 且 不重復 的元素集合 不支持索引和切片 類似于字典 但只有key 沒有value2.創建一個集合
# 創建集合 set1={1,2,'a',100} #直接創建 print(type(set1)) # set類型 list1=[1,2,'c','a'] set2=set(list1) #強轉為集合 print(set2)注意：空集合默認為字典類型
3.集合操作
# 集合操作內置函數 # add() #增添 # clear() #清空 # difference() #a.difference(b) 兩個集合的差集，a中存在，b中不存在的 也可用a-b # intersection() #a.intersection(b) 取交集 也可用a&b # union() #a.union(b) 取并集 也可用a | b # pop() #隨機從集合中拿出某個數據（拿出后移除） # discard() #指定數據移除 # update() #更新集合 a.update(b) 把b數據增添進a 改變了a（1）.add() #增添
# add set2.add('python') #增添 print(set2)運行結果：
注意：集合是無序的 所以每次運行結果都可能不一樣
（2）.clear() #清空
# clear set2.clear() #清空 print(set2)運行結果：
# 下面（3） （4）? （5） 為集合的差集 并集 交集運算
（3）.difference() #a.difference(b) 兩個集合的差集，a中存在，b中不存在的 也可用a-b
# # 差集 set1={1,2,'a',100} set3={1,2,3} print(set1.difference(set3)) #a.difference(b) 兩個集合的差集，a中存在，b中不存在的 print(set1-set3) #a.difference(b)相同作用?運行結果：
（4）.intersection() #a.intersection(b) 取交集 也可用a&b
# 交集 print(set1.intersection(set3)) #a.intersection(b) 取交集 print(set1&set3) #a.intersection(b)相同作用?運行結果：
（5）.union() #a.union(b) 取并集 也可用a | b
# 并集 print(set1.union(set3)) #a.union(b) 取并集 print(set1 | set3) #a.union(b)相同作用?運行結果：
（6）.pop() #隨機從集合中拿出某個數據（拿出后移除） 相當于取出
# pop 隨機取出 print(set1) qudata=set1.pop() print(qudata) print(set1)?運行結果：
（7）.discard() #指定數據移除
# discard() #指定數據移除 print(set1) set1.discard(100) print(set1)?運行結果：
（8）.update() #更新集合 a.update(b) 把b數據增添進a 改變了a
# update set4={3,4,5,'m'} print(set4) print(set3) set4.update(set3) #a.update(b) 把b數據增添進a 改變了a print(set4)?運行結果：
（9）set 不重復特性
set0={1,1,0,0,0,3,3,3} print(set0)?運行結果：
三、部分公有操作： 合并+? ? ? 復制*? ? ?判斷對象是否存在in
1.合并
# 合并+ # 字符串合并 strA='人生苦短' strB='我用python' print(strA+strB) # 列表合并 listA=list(range(10)) listB=list(range(10,20)) print(listA+listB)運行結果：
2.復制
# 復制* print(strA*3) print(listA*3)?運行結果：
3.判斷對象是否存在
# 對象是否存在in print('------字符串------') print('生'in strA) #結果為Trueprint('-------列表-------') print(10 in listA) #Falseprint('-------字典-------') dictA={'name':'sam'} print('age'in dictA) #False print('name'in dictA) #True print('sam'in dictA) #False 在字典中in 對象只能是鍵 不能是值否則返回Falseprint('--------集合-------') setA={'wuhu',88} print(88 in setA) #True?運行結果：
感謝你看到最后！? 如果有錯誤歡迎留言指正！? ?（一不小心寫了1.4w字）
（前三天生病沒有更新。。。）
總結
以上是生活随笔為你收集整理的2021小白Python入门学习记录Day3（win10系统、Python3.9、使用Pycharm）python高级数据类型(字符串、列表、元组、字典、集合) 及其操作的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 虚拟存储管理+地址变换+软考系统架构设计
- 下一篇： Python使用百度地图API实现地点信