day05 集合

时间：2023-03-09 19:08:57
day05 集合

今日进度(数据类型)

  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

相关文章