1. 基礎數據類型補充 li = ["李嘉誠", "麻花藤", "⻩海峰", "劉嘉玲"] s = "_".join(li) print(s) li = "⻩花⼤閨⼥" s = "_".join(li) print(s) 列表: 迴圈刪除列表中的每⼀個元素 li = [11, 22, 33, 44] ...

1. 基礎數據類型補充

li = ["李嘉誠", "麻花藤", "⻩海峰", "劉嘉玲"]
s = "_".join(li)
print(s)

li = "⻩花⼤閨⼥"
s = "_".join(li)
print(s)

列表: 迴圈刪除列表中的每⼀個元素

li = [11, 22, 33, 44]
for e in li:
　　 li.remove(e)
print(li)

結果:
[22, 44]

分析原因: for的運⾏過程，會有⼀個指針來記錄當前迴圈的元素是哪⼀個，⼀開始這個指針指向第0 個，然後獲取到第0個元素，緊接著刪除第0個。這個時候，原來是第⼀個的元素會⾃動的變成第0個，然後指針向後移動⼀次，指向1元素，這時原來的1已經變成了0，也就不會被刪除了。⽤pop刪除試試看:

li = [11, 22, 33, 44]
for i in range(0, len(li)):
　　del li[i]
print(li)

結果: 報錯
# i= 0, 1, 2 刪除的時候li[0] 被刪除之後. 後⾯⼀個就變成了第0個.
# 以此類推. 當i = 2的時候. list中只有⼀個元素. 但是這個時候刪除的是第2個 肯定報錯啊

經過分析發現，迴圈刪除都不⾏。不論是⽤del還是⽤remove，都不能實現，那麼pop呢?

for el in li:
　　 li.pop() # pop也不⾏
print(li)

結果: 
[11, 22]

只有這樣才是可以的:

for i in range(0, len(li)): # 迴圈len(li)次, 然後從後往前刪除
     li.pop()
print(li)

或者，⽤另⼀個列表來記錄你要刪除的內容，然後迴圈刪除

li = [11, 22, 33, 44]
del_li = []
for e in li:
　　 del_li.append(e)
for e in del_li:
　　 li.remove(e)
print(li)

註意: 由於刪除元素會導致元素的索引改變，所以容易出現問題，儘量不要再迴圈中直接去刪除元素，可以把要刪除的元素添加到另⼀個集合中然後再批量刪除。 dict中的fromkey(),可以幫我們通過list來創建⼀個dict

dic = dict.fromkeys(["jay", "JJ"], ["周傑倫", "麻花藤"])
print(dic)

結果:
{'jay': ['周傑倫', '麻花藤'], 'JJ': ['周傑倫', '麻花藤']}

前⾯列表中的每⼀項都會作為key，後⾯列表中的內容作為value，⽣成dict 好了。註意:

dic = dict.fromkeys(["jay", "JJ"], ["周傑倫", "麻花藤"])
print(dic)

dic.get("jay").append("胡⼤")
print(dic)

結果:
{'jay': ['周傑倫', '麻花藤', '胡⼤'], 'JJ': ['周傑倫', '麻花藤', '胡⼤']}

代碼中只是更改了jay那個列表，但是由於jay和JJ⽤的是同⼀個列表。所以，前⾯那個改了. 後⾯那個也會跟著改 dict中的元素在迭代過程中是不允許進⾏刪除的

dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
# 刪除key中帶有'k'的元素
for k in dic:
　　if 'k' in k:
　　　　del dic[k] # dictionary changed size during iteration, 在迴圈迭代的時候不允許進⾏刪除操作
print(dic)

那怎麼辦呢? 把要刪除的元素暫時先保存在⼀個list中，然後迴圈list，再刪除

dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
dic_del_list = []
# 刪除key中帶有'k'的元素
for k in dic:
　　if 'k' in k:
　　　　 dic_del_list.append(k)


for el in dic_del_list:
　　del dic[el]
print(dic)

類型轉換: 元組 => 列表　　 list(tuple) 列表 => 元組　　tuple(list) list=>str 　　str.join(list) str=>list　　 str.split() 轉換成False的數據: 0,'',None,[],(),{},set() ==> False

2. Set集合

2.1 set的介紹

set集合是python的⼀個基本數據類型，⼀般不是很常⽤。set中的元素是不重覆的、⽆序的，⾥⾯的元素必須是可hash的(int, str, tuple,bool)。我們可以這樣來記，set就是dict類型的數據但是不保存value，只保存key，set也⽤{}表⽰。註意: set集合中的元素必須是可hash的，但是set本⾝是不可hash得，set是可變的。

set1 = {'1','alex',2,True,[1,2,3]} # 報錯
set2 = {'1','alex',2,True,{1:2}} # 報錯
set3 = {'1','alex',2,True,(1,2,[2,3,4])} # 報錯

set中的元素是不重覆的，且⽆序的。

s = {"周傑倫", "周傑倫", "周星星"}
print(s)

結果:
{'周星星', '周傑倫'}

使⽤這個特性.我們可以使⽤set來去掉重覆

# 給list去重覆
lst = [45, 5, "哈哈", 45, '哈哈', 50]
lst = list(set(lst)) # 把list轉換成set, 然後再轉換回list
print(lst)

2.2 set集合增刪改查

2.2.1 增加

s = {"劉嘉玲", '關之琳', "王祖賢"}
s.add("鄭裕玲")
print(s)

s.add("鄭裕玲") # 重覆的內容不會被添加到set集合中
print(s)

s = {"劉嘉玲", '關之琳', "王祖賢"}
s.update("麻花藤") # 迭代更新
print(s)

s.update(["張曼⽟", "李若彤","李若彤"])
print(s)

2.2.2 刪除

s = {"劉嘉玲", '關之琳', "王祖賢","張曼⽟", "李若彤"}
item = s.pop() # 隨機彈出⼀個.
print(s)
print(item)

s.remove("關之琳") # 直接刪除元素
# s.remove("⻢⻁疼") # 不存在這個元素. 刪除會報錯
print(s)

s.clear() # 清空set集合.需要註意的是set集合如果是空的. 列印出來是set() 因為要和
dict區分的.
print(s) # set()

2.2.3 修改

# set集合中的數據沒有索引. 也沒有辦法去定位⼀個元素. 所以沒有辦法進⾏直接修改. 
# 我們可以採⽤先刪除後添加的⽅式來完成修改操作
s = {"劉嘉玲", '關之琳', "王祖賢","張曼⽟", "李若彤"}
# 把劉嘉玲改成趙本⼭
s.remove("劉嘉玲")
s.add("趙本⼭")
print(s)

2.2.4 查詢

# set是⼀個可迭代對象. 所以可以進⾏for迴圈
for el in s:
　　print(el)

2.2.5 常用操作

s1 = {"劉能", "趙四", "⽪⻓⼭"}
s2 = {"劉科⻓", "馮鄉⻓", "⽪⻓⼭"}


# 交集
# 兩個集合中的共有元素
print(s1 & s2) # {'⽪⻓⼭'}
print(s1.intersection(s2)) # {'⽪⻓⼭'}

# 並集
print(s1 | s2) # {'劉科⻓', '馮鄉⻓', '趙四', '⽪⻓⼭', '劉能'}
print(s1.union(s2)) # {'劉科⻓', '馮鄉⻓', '趙四', '⽪⻓⼭', '劉能'}

# 差集
print(s1 - s2) # {'趙四', '劉能'} 得到第⼀個中單獨存在的
print(s1.difference(s2)) # {'趙四', '劉能'}

# 反交集
print(s1 ^ s2) # 兩個集合中單獨存在的數據 {'馮鄉⻓', '劉能', '劉科⻓', '趙四'}
print(s1.symmetric_difference(s2)) # {'馮鄉⻓', '劉能', '劉科⻓', '趙四'}

s1 = {"劉能", "趙四"}
s2 = {"劉能", "趙四", "⽪⻓⼭"}

# ⼦集
print(s1 < s2) # set1是set2的⼦集嗎? True
print(s1.issubset(s2))

# 超集
print(s1 > s2) # set1是set2的超集嗎? False
print(s1.issuperset(s2))

set集合本⾝是可以發⽣改變的，是不可hash的。我們可以使⽤frozenset來保存數據， frozenset是不可變的，也就是⼀個可哈希的數據類型

s = frozenset(["趙本⼭", "劉能", "⽪⻓⼭", "⻓跪"])

dic = {s:'123'} # 可以正常使⽤了
print(dic)

這個不是很常⽤，瞭解⼀下就可以了。

3. 深淺拷貝

lst1 = ["⾦⽑獅王", "紫衫⻰王", "⽩眉鷹王", "⻘翼蝠王"]
lst2 = lst1


print(lst1)
print(lst2)

lst1.append("楊逍")
print(lst1)
print(lst2)

結果:
['⾦⽑獅王', '紫衫⻰王', '⽩眉鷹王', '⻘翼蝠王', '楊逍']
['⾦⽑獅王', '紫衫⻰王', '⽩眉鷹王', '⻘翼蝠王', '楊逍']

dic1 = {"id": 123, "name": "謝遜"}
dic2 = dic1
print(dic1)
print(dic2)

dic1['name'] = "範瑤"
print(dic1)
print(dic2)

結果:
{'id': 123, 'name': '謝遜'}
{'id': 123, 'name': '謝遜'}
{'id': 123, 'name': '範瑤'}
{'id': 123, 'name': '範瑤'}

對於list，set，dict來說，直接賦值，其實是把記憶體地址交給變數，並不是複製⼀份內容。所以， lst1的記憶體指向和lst2是⼀樣的，lst1改變了，lst2也發⽣了改變。淺拷⻉：

lst1 = ["何炅", "杜海濤","周渝⺠"]
lst2 = lst1.copy()
lst1.append("李嘉誠")
print(lst1)
print(lst2)
print(id(lst1), id(lst2))

結果: 
兩個lst完全不⼀樣. 記憶體地址和內容也不⼀樣. 發現實現了記憶體的拷⻉

lst1 = ["何炅", "杜海濤","周渝⺠", ["麻花藤", "⻢芸", "周筆暢"]]
lst2 = lst1.copy()
lst1[3].append("⽆敵是多磨寂寞")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3]))

結果: 
['何炅', '杜海濤', '周渝⺠', ['麻花藤', '⻢芸', '周筆暢', '⽆敵是多磨寂寞']]
['何炅', '杜海濤', '周渝⺠', ['麻花藤', '⻢芸', '周筆暢', '⽆敵是多磨寂寞']]
4417248328 4417248328

淺拷⻉. 只會拷⻉第⼀層. 第⼆層的內容不會拷⻉. 所以被稱為淺拷⻉。深拷⻉：

import copy
lst1 = ["何炅", "杜海濤","周渝⺠", ["麻花藤", "⻢芸", "周筆暢"]]
lst2 = copy.deepcopy(lst1)
lst1[3].append("⽆敵是多磨寂寞")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3]))

結果:
['何炅', '杜海濤', '周渝⺠', ['麻花藤', '⻢芸', '周筆暢', '⽆敵是多磨寂寞']]
['何炅', '杜海濤', '周渝⺠', ['麻花藤', '⻢芸', '周筆暢']]
4447221448 4447233800

都不⼀樣了，深度拷⻉，把元素內部的元素完全進⾏拷⻉複製，不會產⽣⼀個改變另⼀個跟著改變的問題。

python基礎(9):基本數據類型四(set集合)、基礎數據類型補充、深淺拷貝