day06 内存地址 小数据池缓存机制

1. 内存相关

• 示例一

  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个内存地址中的值
  
  #1.列表中存放的是很多个地址的，每个地址指向存放该元素的另一个内存地址
  data=[1,2,3,4]
  nums=[]
  for i in data:
    nums.append(i)#将data列表的地址存放到num列表中
   print(id(data[0]),id(nums[0]))#所以每个列表中子元素的地址都相等，但是nums和data的地址不等
  #地址相同
  
  #2,
  data=[1,2,3,4]
  nums=[]
  for i in data:
    nums.append(str(i))#存放的是一个字符串，因为字符串得到的是一个新值
   print(id(data[0]),id(nums[0]))
  #地址不同
  
  #3.
  data=["a","b","c"]
  nums=[]
  for i in data:
    nums.append(i)
   print(id(data[0]),id(data[0]))
  #相同
  
  #4.
  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})#生成新的集合  开辟新的空间 对原来的集合没没有影响
  
  

2.查看内存地址: id()

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

3.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

4.易考点 == / is

== 和 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