id+is+深浅co'p'y

day06

一、id、is

关键字：id #唯一的，如果id相同，说明2个变量指向同一个地址，就是变量一==变量二
注意：id相同值一定相同，值相同但是id不一定相同（不同代码块的值相同，他们就像太阳和月亮毫无关系）
用法：查看内存地址
例子:
    i = 10
	o = 10
	print(i == o) #ture 判断是否相同
	print(id(i))  #140718777659952
	print(id(o))  #140718777659952

关键字：is
用法：判断2个变量的内存地址是否相同
例子:
	i = 10
	o = 10
	print(i is o)

二、代码块

2.1、什么是代码块？

答：一个模块、一个函数、一个类、一个文件等都是一个代码块。作为交互式的的输入命令都是一个代码块：例如windows中的cmd上面敲的python命令！

2.2、两个机制：

同一个代码块，有一个机制。不同的代码块，遵循另一个机制。

2.2.1、同一代码块下的缓存机制（代码块的缓存机制）：

​ Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将 其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值 存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使 用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两 个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。

三、小数据池（另一个机制）可理解为：有范围的缓存机制

	Python自动将-5~256的整数进行了**缓存**，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。

​ python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。

​ 其实，无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。

四、集合

集合的特点：

​ 1、容器型的数据类型

​ 2、要求里面的元素是不可变的数据

​ 3、但是他本身是可变的数据类型

​ 4、集合是无序的（没有重复值，重复算一个）

集合的用处：

​ 1、列表的去重

​ 2、关系测试：交集、并集、差集

集合从创建：

set1 = {1,3,4,5,'aa','vv'}
print(set1)  #输出是无序的
#空集合
set1 = set()

集合增删查改：

jh = {'a','b','c'}
#增
jh.add('xx')
#迭代增加，每个元素都增加进去了
jh.update('plord')
print(jh)

#删元素
#remove 按照元素删除，无序不能按照索引删除
jh.remove('b')

#pop 随机删除
jh.pop()
print(jh)

#clear 清空
jh.clear()
#del 删除集合
del jh

#改不能直接改，可以变相改！！！也就是先删除，再新增一个！！！
jh.remove('b')
jh.add('xx')

#查 for循环便利
for i in jh:
    print(i)

交集|并集|差集|反交集|子集|超集：

jh1 = {1,2,3,4,8,9}
jh2 = {2,3,4,5,6,7}
#交集 &
print(jh1 & jh2)
#并集 | 或者 union
print(jh1 | jh2)
#差集 - （jh1有的jh2没有）
print(jh1 - jh2)
#jh3有的jh1没有
print(jh2 - jh1)
#反交集
print(jh2 ^ jh1)

#####
jh3 = {1,2,3,}
jh4 = {1,2,3,4,5,6,7}
print(jh3<jh4)  #子集 返回true或者false
print(jh3>jh4)	#超集 返回true或者false

五、深浅copy（列表、字典都有）

​ 深copy其实就是完全复制一份，浅copy部分复制一份的意思！

​ 浅copy：就是copy一个外壳，原来内容的地址都一样

​ 深copy：

5.1、赋值运算

l2 = l1 所以同一块内存，然后l1新增，l2也会改变

l1 = [1,2,3,['barry','alex']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['barry', 'alex']]
print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'
print(l1)  # [111, 2, 3, ['wusir', 'alex']]
print(l2)  # [111, 2, 3, ['wusir', 'alex']]

5.2、浅copy（同一代码块）

#同一代码块下：
l1 = [1, 'll', True, (1,2,3), [22, 33]]
l2 = l1.copy()
#先看看是不是在同一块内存（显然不是啊）但是里面的都一样
print(id(l1), id(l2))          #1953402082312 1953402647368

print(id(l1[1]),id(l2[1]))     #1940390867056 1940390867056

#小列表
print(id(l1[-2]), id(l2[-2]))  #1959984831768 1959984831768

#小列表的是同一块内存，改其中一个两个都会被改
print(id(l1[-1]),id(l2[-1]))   #1959955223048 1959955223048

5.3、浅copy：(不同代码块)

# 不同代码块下：
>>> l1 = [1, 'll', True, (1, 2, 3), [22, 33]]
>>> l2 = l1.copy()
>>> print(id(l1), id(l2))
1477183162120 1477183162696
>>> print(id(l1[-2]), id(l2[-2]))
1477181814032 1477181814032
>>> print(id(l1[-1]), id(l2[-1]))
1477183162504 1477183162504

5.4、深拷贝deepcopy

# 同一代码块下
import copy

l3 = [1, 'aaa', [22, 33]]
l4 = copy.deepcopy(l3)
print(l3,l4)            #内容是一样滴 都是[1, 'aaa', [22, 33]]
print(id(l3),id(l4))    #内存不一样  3153608047880 3153608048136

#增加一个再打印看看效果
l3.append('b')
print(l3,l4) #只有l3有新增的，l4没有
#增加一个再打印看看效果
l3[-1].append('b')
print(l3,l4) #只有l3有新增的，l4没有

# 不同代码块下
>>> import copy
>>> l1 = [1, 'xxx', True, (1, 2, 3), [22, 33]]
>>> l2 = copy.deepcopy(l1)
>>> print(id(l1), id(l2))
1477183162824 1477183162632
>>> print(id(0), id(0))
1470562736 1470562736
>>> print(id(-2), id(-2))
1470562672 1470562672
>>> print(id(l1[-1]), id(l2[-1]))
1477183162120 1477183162312

图解：