今日進度(數據類型)

  1. 集合
  2. 內存相關
  3. 深淺拷貝

1.集合表示

1.無序
2.不重復
3.hash查找
#問題：v={}表示？
set:
v1=set()#空集合
v1={1,2,3,4,5}

dict:
v2=dict()
v2={}  #dict空字典表示

str:
v3=str()
v3=""

bool:
v4=bool()--->False
v4=True/False

int:
v5=int()--->0
v5=999

list:
v6=list()
v6=[]

tuple:
v7=tuple()
v7=()

3.獨有方法

1.add
se={1,2,3}
se.add("Gao")
print(se)
2.discard: 不存在不報錯
se.discard("Gao")
print(se)
**3.update: 批量添加 **
se.update({11,22,33})
print(se)
#{1，2，3，11，22，33}
4.集合運算：可與（列表 /集合 /元組）參與 集合運算,都會形成新的集合，不會對原的集合進行修改
4.intersection()：交集
#集合和集合
se={11,22,33,44}
result=se.intersection({"Gao","B",11,22})
print(result)
#{11,22}

#和列表對比
result=se.intersection(["Gao","B",11,22])
print(result)
#{11,22}

#集合和元組
#都會形成新的集合，不會對原的集合進行修改
5.union():并集
se={11,22,33,44}
result=se.union({"Gao","B",11,22})
print(result)
#{33, 'B', 11, 44, 'Gao', 22}
6.difference():差集
se1={11,22,33,44}
se2={"Gao","B",11,22}
result1=se1.difference(se2)#在se1集合里面找se2集合沒有的元素
print(result1)
#{33，44}
result2=se2.difference(se1)#在se2集合里面找se1集合沒有的元素
print(result2)
#{'B', 'Gao'}
7.symmetric_difference()：對稱差集
se1={11,22,33,44}
se2={"Gao","B",11,22}
result1=se1.symmetric_difference(se2)#兩個集合里面沒有的元素都天劍
print(result1)
#{33, 'Gao', 44, 'B'}

result2=se2.symmetric_difference(se1)
print(result)
#{33, 'Gao', 44, 'B'}

4.公共

1.len
2.for循環

5.集合嵌套

1.列表/字典/集合 (可以改變的) ->不能放在（集合，字典的鍵）中
info = {1, 2, 3, 4, True, "國風", None, (1, 2, 3)}
print(info)
#{1, 2, 3, 4, None, (1, 2, 3), '國風'}
#True被忽略掉  True被轉換成1  因為集合中元素不能重復所以被過濾掉

#加入列表后報錯
info = {1, 2, 3, 4, True, "國風", None, (1, 2, 3),["a","b","c"]}
print(info)
#TypeError: unhashable type: 'list'

#加入集合后報錯
info = {1, 2, 3, 4, True, "國風", None, (1, 2, 3),{33,44,55}}
print(info)
#TypeError: unhashable type: 'set'

#加入字典后報錯
info = {1, 2, 3, 4, True, "國風", None, (1, 2, 3),{"name":'Gao',"age":12}}
print(info)
#TypeError: unhashable type: 'dict'
2.hash算法
  • hash算法 ：內存中將值進行hash算法得到一個數值存儲在內存中，查找也會按照算法進行查找，使用hash算法 執行效率高相對于list的索引查找
  • （字典，集合）：使用的是hash查找，因為只有（不可變的數據類型）才能被hash，而列表/字典/集合 (可以改變的) ==>不能放在（集合，字典的鍵）中
3.可變數據類型 / 不可變數據類型
dict/list/set  是可變數據類型  可變的數據類型不能被hash
int/str/tuple/bool 不可變數據類型

2. 內存相關

  • 示例一

    v1=[11,22,33]
v2=[11,22,33]
#值相等 內存地址不等

v1=11
v2=11
#按理說內存地址應該不等，但是python為了優化使其內存地址相等

v1="dd"
v2="dd"
#按理說內存地址應該不等，但是python為了優化使其內存地址相等

  • 示例二

    v1=[11,22,33]
v1=[11,22]#第一個值將會被銷毀,另外再開辟內存地址

  • 示例三

    v1=[11,22,33]
v2=v1# v2指向v1指向的地址

#練習1
v1=[11,22,33]
v2=v1#v2指向v1指向的地址
v1.append(666)#在v1指向的內存地址中修改內容
print(v2)#v2還是指向v1指向的地址
#[11,22,33,666]

#2
v1=[11,22,33]
v2=v1#v2指向v1指向的地址
v1=[1,2,3,4]#v1重新開辟一塊內存空間
print(v2)#v2還是指向原來v1指向的地址  address([11,22,33])
#[11,22,33]

#3.
v1="mari"
v2=v1#v2指向v1指向的地址
v1="old"
print(v2)
#mari

  • 示例四

    v=[1,2,3]
values=[11,2,v] #values[2]指向v指向的內存地址
#1.內部修改
v.append(9)
print(values)#[11,2,[1,2,3,9]]

#2.內部修改
values[2].append(999)# values[2]==v 修改v內存地址的內容
print(v)#
[1,2,3,999]

#3.賦值
values[2]=666
#將values[2]不再指向v 而是新賦值666  重新開辟內存空間 所以對v沒有影響
print(v)
#[1,2,3]

  • 示例五

    v1 = [1,2]
v2 = [2,3]
v3 = [11,22,v1,v2,v1]

  • 示例6

    #20.看代碼寫結果并解釋原因

# info = [1,2,3]
# userinfo = [info,info,info,info,info]
#
# info[0] = '不僅多，還特么難呢'
# print(info,userinfo)
#['不僅多，還特么難呢', 2, 3]  （列表修改后  自身改變 可變數據類型）
#[['不僅多，還特么難呢', 2, 3], ['不僅多，還特么難呢', 2, 3], ['不僅多，還特么難呢', 2, 3], ['不僅多，還特么難呢', 2, 3], ['不僅多，還特么難呢', 2, 3]]
#(userinfo指向info指向的地址，info只是修改了內存地址中的一個元素，并沒有改變地址，info的地址中內容改變，userinfo的內容也會跟著內存地址中內容變化而變化)


#24.看代碼寫結果并解釋原因

# data_list = []
# data = {}
# for i in range(10):
#     data['user'] = i
#     data_list.append(data)
# print(data_list)

#[{'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}]
#data的內存地址中的值最后都被9覆蓋
#data_list里面保存的是十個相同的data內存地址

#25.看代碼寫結果并解釋原因

# data_list = []
# for i in range(10):
#     data = {}
#     data['user'] = i
#     data_list.append(data)
# print(data_list)
#[{'user': 0}, {'user': 1}, {'user': 2}, {'user': 3}, {'user': 4}, {'user': 5}, {'user': 6}, {'user': 7}, {'user': 8}, {'user': 9}]
#data字典創建了10次-->10個不同的內存地址-->每創建一次地址就賦一個i值(i每次都會自加一次）然后將十個不同內存地址添加到列表data_list中
# 所以i不會被覆蓋 
#所以打印的就是10個內存地址中的值


#列表中存放的是很多個地址的，每個地址指向存放該元素的另一個內存地址
data=[1,2,3,4]
nums=[]
for i in data:
  nums.append(i)#將data列表的地址存放到num列表中
 print(id(data[0]),id(num[0]))#所以每個列表中子元素的地址都相等，但是nums和data的地址不等
#地址相同

data=[1,2,3,4]
nums=[]
for i in data:
  nums.append(str(i))#存放的是一個字符串，因為字符串得到的是一個新值
 print(id(data[0]),id(data[0]))
#地址不同

#
data=["a","b","c"]
nums=[]
for i in data:
  nums.append(i)
 print(id(data[0]),id(data[0]))
#相同

#
v1=[
  [1,2,3],[2,3,4]
]
v2=[]
for item in v1:
  v2.append(item)
print(id(v1),id(v2))#不同
print(id(v1[0]),id(v2[0]))#相同

  • 示例7：(字符串和集合運算)的修改后，不會影響原來的值 而是開辟新空間存儲

    v1="Gao"
v2=v1
v1.upper()#新開辟一塊空間
print(v1,v2)
"Gao"
"Gao"

v1={1,2,3}
v2=v1
v1.intersection({2,3})#生成新的集合  開辟新的空間 對原來的集合沒沒有影響

  • 查看內存地址: id()

    v1=[1,2,3]
v2=v1
#v2=[1,2,3]
print(id(v1),id(v2))#

  • python小數據池緩存機制:

    • 優化功能 某些條件的相同值不會被重新開辟內存空間
    • 1.int -5<=num<=256:內存地址相同
    • "Gao"/"ddjdj" ——>相同地址/"f_"*3類型除外
    #1.int -5<=num<=256:內存地址相同
v1=1
v2=1
id(v1)==id(v2)#True

2.v1=257
 v2=257
 print(id(v1),id(v2))#False

2.字符串："Gao"/"ddjdj" ---->/"f_"*3類型除外
str1="Gao"
str2="Gao"
id(str1)==id(str2)#True

  1. 易考點

    == 和 is 的區別

    == 和 is 的區別
1.==是 值比較
is 是地址比較
(注意考慮小數據池緩存機制)

v1=[1,2,3]
v2=[1,2,3]
print(v1==v2) #True
print(v1 is v2)#False

v1=[1,2,3]
v2=v1
print(v1==v2) #True
print(v1 is v2)#True

v1=[1,2,3]
v2=[1,2,3,4]
print(v1==v2) #False
print(v1 is v2)#False

#小數據池緩存機制
v1=10
v2=10
print(v1==v2) #True
print(v1 is v2)#True

#2.num>256
v1=1000
v2=1000
print(v1==v2) #True
print(v1 is v2)#False

總結

4.set：無序 唯一

  • 獨有

    • add
    • discard
    • update:批量添加
    • intersection
    • union
    • difference
    • Symmetric_difference

  • 公共

    • len
    • Index/切片/步長:無 集合是無序的
    • for

  • In 敏感字符判斷

  • 內存

    • 內存地址
    • id()
    • hash算法
    • python小數據緩存機制
    • 賦值
    • 內部修改

  • 數據類型分類

    • 可變數據類型：list、set ,dict
    • 不可變數據類型：int 、str , tuple

  • set嵌套

    • 可變數據類型不可嵌套

  • None空類型

  • == / is