python基礎知識四 小數據池，深淺拷貝，集合+菜中菜

4、小數據池，深淺拷貝，集合+菜中菜

1小數據池 --緩存機制（駐留機制）

​ '==' 判斷兩邊內容是否相等

​ 'is' 基於內存地址進行判斷是否相同

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

小數據池的數字範圍： -5 ~256

a = -5 
b = -5 
c = -5
print(id(a))
print(id(b))
print(id(c))

#<-5不行
a = -6 
b = -6
print(id(a))
print(id(b))

a = 256
b = 256
print(id(a))
print(id(b))
#>256能夠，可是不是小數據池，是python的代碼塊
a = 257
b = 257
print(id(a))
print(id(b))

1.代碼塊：python自有的屬性

1.代碼塊範圍：（3.7如下版本）

​ 支持：一個文件，一個函數，一個類，一個模塊，終端的每一行是一個代碼塊

2.數字：

1. 在同一代碼塊下，只要內容相同，就採用相同的內存地址，(-5之後就不是)，
2. *數字在作乘法的時候範圍-5 ~ 256
3. 數字在作乘法的時候不能用浮點數

a = -2.5 * 1
b = -2.5 * 1
print(id(a))
print(id(b))

3.字符串：

1. 在同一代碼塊下，只要內容相同，就採用相同的內存地址

2. *作乘法的時候總長度不能超過20(python4.7版本到4096)

3. 乘法的時候中文，特殊符號乘以1或0

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

4.布爾值：

​ 在同一代碼塊下，只要內容相同，就採用相同的內存地址

2.小數據池：

1.數字：

​ 範圍*-5 ~256

2.字符串：

1. 在同一代碼塊下，只要內容相同，就採用相同的內存地址
2. 作乘法的時候總長度不能超過20
3. 乘法的時候中文，特殊符號乘以0

3.bool:

​ 在同一代碼塊下，只要內容相同，就採用相同的內存地址

必會*：

小數據池的驗證方法：必須脫離代碼塊才能驗證(在Windows cmd下驗證)

python規則：先執行代碼塊的規則，在執行小數據池的規則 --(駐留機制)

2.深淺拷貝，賦值

面試必問：賦值，淺拷貝，深拷貝

1.淺拷貝  -- 拷貝第一層元素內存地址,修改第一層元素的時候新拷貝的列表不進行改變
 2.深拷貝  -- 不可變的數據類型共用,可變數據類型開闢一個新的空間,新的空間中的元素若是是不可變類型也是共用
3.賦值 -- 多個變量名指向同一個內存地址

import copy
v1 = "alex"
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2)#結果：True
print(v1 is v3)#結果：True

v1 = [1,2,3]
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2)#結果：False
print(v1 is v3)#結果：False

1.賦值：

​ 多個變量名指向同一個內存地址

#1.賦值
lst = [1,2,3,[5,6,7]]
lst1= list2 
print(lst)
print(lst1)
#賦值後，一個操做，兩個全變，內存地址相同
lst1[-1].append(8)
print(lst)
print(lst1)
print(id(lst),id(lst1))

2.淺拷貝

​ *淺拷貝的時候,只會開闢一個新的容器列表,其餘元素使用的都是源列表中的元素

lst = [1,2,3,[6,5,7]]
lst1 = lst.copy()#新開闢一個空間給lst1
print(lst)
print(lst1)
print(id(lst),id(lst1))#結果：46646536 46647136
#操做1.修改第二層數據，原列表也變
lst1[-1].append(8)
print(lst1)#結果：[1, 2, 3, [6, 5, 7, 8]]
print(lst)#結果：[1, 2, 3, [6, 5, 7, 8]]

#操做2.修改第一層數據，原列表不變
lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst1[3] = 567
print(lst1)#結果：[1, 2, 3, 567]
print(lst)#結果：[1, 2, 3, [6, 5, 7]]

#操做3.修改第三層數據，原列表也變
lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst1[-1][-1] = "56"
print(lst)#結果：[1, 2, 3, 4, [5, 6, 7, '56']]
print(lst1) #結果：[1, 2, 3, 4, [5, 6, 7, '56']]

#操做4.注意，字典的值整個就算爲第一層數據，裏面的任意都不僅是第一層數據
dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["alex"] = "56"
print(dic)#結果：{'alex': '56'}
print(dic1)#結果：{'alex': [1, 2, 3, [5, 6]]}

dic["alex"][0] = "56"
print(dic)#結果：{'alex': ['56', 2, 3, [5, 6]]}
print(dic1)#結果：{'alex': ['56', 2, 3, [5, 6]]}

淺拷貝總結：

1. 淺拷貝只拷貝第一層元素的內存地址
2. 淺拷貝在修改第一層數據時，原數據不變
3. 淺拷貝在修改非第一層數據時，同時發生改變

3.深拷貝

深拷貝總結：

​ 不管怎樣改變新拷貝的數據，原數據都不會改變。

​ 開闢一個容器空間，不可變數據類型(第一層元素)共用同一內存地址，共用值，可變數據類型(非第一層)在開闢一個新空間(新的內存地址)，可是裏面的值是共用的

import copy
lst = [1,2,3[6,5,7]]
lst1 = copy.deepcopy(lst)
lst1[-1].append(8)
print(lst)
print(lst1)
#修改非第一層數據，原數據不變

lst1[0] = 88
print(lst)
print(lst1)
#修改第一層數據，原數據不變

print(id(lst[0]))#結果：494255688
print(id(lst1[0]))#結果：494255688
#第一層是同一內存地址

print(id(lst[-1]))#結果：43102336
print(id(lst1[-1]))#結果：43321264
#非第一層是不一樣的內存地址，可是非第一層內層的值內存地址相同。
print(id(lst[-1][0]))#結果：503627400
print(id(lst[-1][0]))#結果：503627400

4.集合 -- set

1.簡介：

​ 沒有值的字典，無序 - - 不支持索引，

​ *自然去重

​ 定義:

s = {1,"alex",False,(1,2,3),12,15,1,1,2,12}#列表不能夠做爲元素
#面試題：
list1 = [1,2,1,21,21,2,1,212,1,1]
print(list(set(list1)))

2.方法

1.增：

1. s.add('66'):一次添加一個元素
2. s.update("今天")：迭代添加

s = {1,2,3,4}
s.add("67") #只能添加一個
print(s)

s.update("今天")#迭代添加
print(s)

2.刪：

1. s.pop():隨機刪除
2. s.remove(3):指定元素刪除
3. s.clear():清空

s = {1,2,3,4}
s.pop()#有返回值，隨機刪除
print(s)
print(s.pop)

s.remove(3)#指定元素刪除
print(s)

s.clear()
print(s)#集合 set()

3.改：

先刪再增

4.查：

​ for 循環

s = {1,2,3,4}
for i in s:
    print(i)

菜中菜：各類集合

s1 = {1,2,3,4,5,6,6,7}
s2 = {5,6,7,1,9}
print(s1 & s2) #交集。結果：{1, 5, 6, 7}
print(s1 | s2) #並集，可去重。結果：{1, 2, 3, 4, 5, 6, 7，9}
print(s1 - s2) #差集。結果：{2, 3, 4}
print(s1 ^ s2) #反交集。結果：{2, 3, 4, 9}
print(s1 > s2) #父集(超集)。結果：False
print(s1 < s2) #字跡。結果：False

#凍結集合,很不經常使用，也沒什麼用，使此集合不可更改
print(frozenset(s1))#結果：frozenset({1, 2, 3, 4, 5, 6, 7})
dic = {frozenset(s1):1}
print(dic)#結果：{frozenset({1, 2, 3, 4, 5, 6, 7}): 1}