百萬年薪python之路 -- day06


1.小數據池和代碼塊

# 小數據池 -- 緩存機制(駐留機制)

# == 判斷兩邊內容是否相等

# a = 10
# b = 10
# print(a == b)

# is 是

# a = 10
# b = 10
# print(a is b)  is判斷基於內存地址進行判斷

# print(id(a))
# print(id(b))

# 小數據池的數字范圍: -5 ~ 256

# a = -2.5 * 2
# b = -2.5 * 2
# print(id(a))
# print(id(b))  #float不行


# a = "alex你好" *2
# b = "alex你好" *2
# print(id(a))
# print(id(b))


# 代碼塊:一個文件,一個函數,一個類,一個模塊,終端中每一個行是一個代碼塊
# 支持:

# 數字:
#   在同一代碼塊下 只要內容相同就采用相同的內存地址(-5以后就不是)
#   數字在做乘法的時候范圍 -5 ~ 256  ****
#   數字在做乘法的時候不能使用浮點數
# 字符串:
#   在同一代碼塊下 只要內容相同就采用相同的內存地址
#   乘法的時候總長度不能超過20   ****
#   乘法的時候中文,特殊符號乘以1或0
# 布爾值:
#   在同一代碼塊下 只要內容相同就采用相同的內存地址

# 小數據池:
# 數字:  -5 ~ 256   ****
# 字符串:
#       在同一代碼塊下 只要內容相同就采用相同的內存地址
#       乘法的時候總長度不能超過20   ****
#       乘法的時候中文,特殊符號乘以0
# 布爾值:
#       在同一代碼塊下 只要內容相同就采用相同的內存地址
# 小數據池的驗證方法,必須脫離代碼塊才能進行驗證
# 先執行代碼塊的規則,在執行小數據的規則 --(駐留機制)

# 必會:
# ==  判斷等號兩邊的值是否相等   ****
# is  判斷兩邊的內存地址是否相等  ****

2.深淺拷貝

建議參考:http://39.97.99.7/python/13%20深淺拷貝.html

對於list, set, dict來說, 直接賦值. 其實是把內存地址交給變量. 並不是復制⼀份內容.
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也發⽣了改變

淺拷貝:只會拷貝第一層. 第二層的內容不會拷貝. 所以被稱為淺拷貝

1.淺拷貝在修改新拷貝的列表中(不可變和可變)的元素的時候,原列表不進行改變

2.淺拷貝在新拷貝的列表中的可變數據類型中進行增刪改的時候,源列表進行改變

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]))
結果:
["章超印", "周道鎔","朱凡宇", ["章超印", "周道鎔","朱凡宇", '他們是多么的帥']]
["章超印", "周道鎔","朱凡宇", ["章超印", "周道鎔","朱凡宇", '他們是多么的帥']]
2385045841544   2385045841544
深拷貝:本質是不可變數據類型共用一個,可變數據類型另開辟一塊空間(復制一份) 不會產生一個改變另一個跟着改變的問題
import copy
lst1 = ["章超印", "周道鎔","朱凡宇", ["章超印", "周道鎔","朱凡宇"]]
lst2 = copy.deepcopy(lst1)
lst1[3].append("他們是多么的帥")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3]))

結果:
['章超印', '周道鎔', '朱凡宇', ['章超印', '周道鎔', '朱凡宇', '他們是多么的帥']]
['章超印', '周道鎔', '朱凡宇', ['章超印', '周道鎔', '朱凡宇']]
1724477331208    1724477331272

面試題:

a = [1, 2]
a[1] = a
print(a[1]) 

結果:
[1, [...]]

3.集合 (set) -- 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)

set 增刪改查

增加

方法:

add()

s = {"zcy","zdr",123}
s.add(Ture)
print(s)
s.add("zdr")    # 重復的東西不添加到set
print(s)

update()

s = {"zcy","zdr",123,Ture,(123,456)}
s.update("123") #迭代添加,進入集合后每一個字符都成為集合的成員
print(s)
s.update(["123"])   #"123"這個字符串成為了集合的成員
print(s)
刪除

方法:

​ pop()

s = {"zcy","zdr",123,Ture,(123,456)}
item = s.pop() # 隨機彈出⼀個.有返回值
print(s)
print(item)

​ remove()

s.remove("zdr") # 指定元素刪除
# s.remove("周道鎔") # 不存在這個元素. 刪除會報錯
print(s)

​ clear()

s = {" "}
s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出來是set() 因為要和dict區分的.
print(s) 

結果:
# set()


s = {}
s.clear()
print()

結果:
{}
修改

set集合中的數據沒有索引. 也沒有辦法去定位⼀個元素. 所以沒有辦法進⾏直接修改.

我們可以采⽤先刪除后添加的⽅式來完成修改操作

s = {"zcy","zdr",123,Ture,(123,456)}
s.remove("zdr") # 直接刪除元素
s.add("周道鎔")
print(s)
查詢
# set是⼀個可迭代對象. 所以可以進⾏for循環
s = {"zcy","zdr",123,Ture,(123,456)}
for e in s:
 print(e)
常用操作

交集:兩個集合中的共有元素

&

intersection()

s1 = {"周道鎔", "章超印", "朱凡宇"}
s2 = {"戴軍", "章超印", "楊紅興"}
# 交集
# 兩個集合中的共有元素
print(s1 & s2) # {'章超印'}
print(s1.intersection(s2)) # {'章超印'}

並集

|

union()

s1 = {"周道鎔", "章超印", "朱凡宇"}
s2 = {"戴軍", "章超印", "楊紅興"}
# 並集
print(s1 | s2) # {"周道鎔", "章超印", "朱凡宇","戴軍", "楊紅興"}
print(s1.union(s2)) # {"周道鎔", "章超印", "朱凡宇","戴軍", "楊紅興"}

差集

difference()

s1 = {"周道鎔", "章超印", "朱凡宇"}
s2 = {"戴軍", "章超印", "楊紅興"}
# 差集
print(s1 - s2) # {"周道鎔", "朱凡宇"}得到第⼀個中單獨存在的
print(s1.difference(s2)) # {"周道鎔", "朱凡宇"}

反交集

^

symmetric_difference()

s1 = {"周道鎔", "章超印", "朱凡宇"}
s2 = {"戴軍", "章超印", "楊紅興"}
# 反差集
print(s1 ^ s2) # {"周道鎔", "朱凡宇","戴軍", "章超印", "楊紅興"} 兩個集合中單獨存在的數據 
print(s1.symmetric_difference(s2))# {"周道鎔", "朱凡宇","戴軍", "章超印", "楊紅興"}

子集

<

issubset()

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

超集

​ >

issuperset()

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

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

frozenset() 凍結集合 可以作字典的鍵

s = frozenset(["周道鎔", "章超印", "朱凡宇","楊紅興"])
dic = {s:'123'} # 可以正常使⽤了
print(dic)

結果:
{frozenset({'楊紅興', '朱凡宇', '章超印', '周道鎔'}): '123'}

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com