Python内存相关

Python内存相关

示例一：

v1 = [1, 2, 3]
v2 = [1, 2 ,3]

v1 = 123
v2 = 123

v1 = "dogfa"
v2 = "dogfa"
# 虽然v1 和v2 的值相同，但是由于v1和v2 在内存中分别开辟了两块不同的空间，所以理论上v1的内存地址不等于v2的内存地址	（在Python中有不同变化，下面会介绍）

示例二：

v1 = [1, 2, 3]
v1 = [4, 5, 6]
# v1最开始指向的内存地址是[1, 2, 3],但是由于对v1进行了重新赋值，所以v1重新指向了内存地址中的[4, 5, 6]，这个时候原来v1 指向的内存地址中的[1, 2, 3]由于没有变量接收，将会被Python中的GC（垃圾回收机制）释放掉。

示例三：

v1 = [1, 2, 3]
v2 = v1
v2.append(4)
print(v1)		# [1, 2, 3, 4]
print(v2)		# [1, 2, 3, 4]
# v1 的内存地址指向了[1, 2, 3],v2 = v1 表示将v1 的内存地址赋值给了v2， 也就意味着v2的内存地址也指向着[1, 2, 3],无论对v1 中的元素还是对v2 中的元素进行改变，都将互相影响。

v1 = [1, 2, 3]
v2 = v1
v1 = 123
print(v1)		# 123
print(v2)		# [1, 2, 3]
# 首先v1 和v2 指向了同一个内存地址，但是后来对v1 进行了重新赋值，v1所指向的内存地址发生了改变，而v2所指向的内存地址并没有发生改变，还是原先v1 所指向的内存地址，所以print(v1)将输出 “123”， print(v2)将输出[1, 2, 3]

v1 = "dogfa"
v2 = v1
v1 = "oldniu"
print(v1)		# oldniu
print(v2)		# dogfa

示例四：

v = [1, 2, 3]
lst = [11, 22, v]
v.append(4)
print(v)		# [1, 2, 3, 4]
print(lst)		# [11, 22, [1, 2, 3, 4]]
# lst 中的v 实际上存放的是指向的内存地址

v = [1, 2, 3]
lst = [11, 22, v]
lst[2].append(4)
print(v)		# [1, 2, 3, 4]
print(lst)		# [11, 22, [1, 2, 3, 4]]

v = [1, 2, 3]
lst = [11, 22, v]
v = 4
print(v)		# 4
print(lst)		# [11, 22, [1, 2, 3]]
# v 的内存地址发生了改变，而lst中的v指向并没有发生改变

v = [1, 2, 3]
lst = [11, 22, v]
lst[2] = 33
print(v)		# [1, 2, 3]
print(lst)		# [11, 22, 33]

结论：当变量属于不可变类型时（str，int，tuple），对其重新赋值，将会开辟新的内存空间。当变量属于可变类型时（list，dict，set），对其内部的元素进行操作时，将不会重新开辟内存空间，对整个变量进行赋值时，将会开辟新的内存空间。

小数据池

v1 = 123
v2 = 123
print("int:", id(v1))
print(id(v2))

v1 = "dogfa"
v2 = "dogfa"
print("str:", id(v1))
print(id(v2))

理论上v1和v2的内存地址是不一样的，但是结果是否真的如此吗？以下是打印输出结果。

从打印结果我们 可以看出内存地址是完全一致的，那么是否意味着我们之前所认为的全都是错误的？其实并不是的。

因为在Python当中有一个小数据池，你可以理解为是一个容器，里面存放了int类型和str类型的数据的存储规则。

1、int类型的规则：它会把 -5 ~ 256 范围内的数进行缓存，当你将这些整数赋值给变量时，它不会再次开辟新的内存空间，而是使用已经创建好的缓存对象。

2、str类型的规则：① 出现特殊字符时，内存地址不相等

​ ② 当字符超过20个以上时，内存地址不会相等

is 和 == 的区别

1. is：对内存地址进行比较

   v1 = 123
   v2 = v1
   print(v1 is v2)		# True
   v1 = 321
   print(v1 is v2)		# False
   

2. ==：对两边的值进行比较

   v1 = 6
   v2 = 6
   print(v1 == v2)	# True