python基础知识四 小数据池，深浅拷贝，集合+菜中菜

四、小数据池，深浅拷贝，集合+菜中菜

1小数据池 --缓存机制（驻留机制）

​ '==' 判断两边内容是否相等

​ 'is' 基于内存地址进行判断是否相同

a = 10
b = 10
print(a == b )
#is
print(a is b)

小数据池的数字范围： -5 ~256

a = -5
b = -5
c = -5
print(id(a))
print(id(b))
print(id(c))

#<-5不行
a = -6
b = -6
print(id(a))
print(id(b))

a = 256
b = 256
print(id(a))
print(id(b))
#>256可以，但是不是小数据池，是python的代码块
a = 257
b = 257
print(id(a))
print(id(b))

1.代码块：python自有的属性

1.代码块范围：（3.7以下版本）

​ 支持：一个文件，一个函数，一个类，一个模块，终端的每一行是一个代码块

2.数字：

1. 在同一代码块下，只要内容相同，就采用相同的内存地址，(-5以后就不是)，
2. *数字在做乘法的时候范围-5 ~ 256
3. 数字在做乘法的时候不能用浮点数

a = -2.5 * 1
b = -2.5 * 1
print(id(a))
print(id(b))

3.字符串：

1. 在同一代码块下，只要内容相同，就采用相同的内存地址

2. *做乘法的时候总长度不能超过20(python4.7版本到4096)

3. 乘法的时候中文，特殊符号乘以1或0

   a = "alex你好" *2
   b = "alex你好" *2
   print(id(a))
   print(id(b))
   

4.布尔值：

​ 在同一代码块下，只要内容相同，就采用相同的内存地址

2.小数据池：

1.数字：

​ 范围*-5 ~256

2.字符串：

1. 在同一代码块下，只要内容相同，就采用相同的内存地址
2. 做乘法的时候总长度不能超过20
3. 乘法的时候中文，特殊符号乘以0

3.bool:

​ 在同一代码块下，只要内容相同，就采用相同的内存地址

必会*：

小数据池的验证方法：必须脱离代码块才能验证(在Windows cmd下验证)

python规则：先执行代码块的规则，在执行小数据池的规则 --(驻留机制)

2.深浅拷贝，赋值

面试必问：赋值，浅拷贝，深拷贝

1.浅拷贝  -- 拷贝第一层元素内存地址,修改第一层元素的时候新拷贝的列表不进行改变
 2.深拷贝  -- 不可变的数据类型共用,可变数据类型开辟一个新的空间,新的空间中的元素如果是不可变类型也是共用
3.赋值 -- 多个变量名指向同一个内存地址

import copy
v1 = "alex"
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2)#结果：True
print(v1 is v3)#结果：True

v1 = [1,2,3]
v2 = copy.copy(v1)
v3 = copy.deepcopy(v1)
print(v1 is v2)#结果：False
print(v1 is v3)#结果：False

1.赋值：

​ 多个变量名指向同一个内存地址

#1.赋值
lst = [1,2,3,[5,6,7]]
lst1= list2
print(lst)
print(lst1)
#赋值后，一个操作，两个全变，内存地址相同
lst1[-1].append(8)
print(lst)
print(lst1)
print(id(lst),id(lst1))

2.浅拷贝

​ *浅拷贝的时候,只会开辟一个新的容器列表,其他元素使用的都是源列表中的元素

lst = [1,2,3,[6,5,7]]
lst1 = lst.copy()#新开辟一个空间给lst1
print(lst)
print(lst1)
print(id(lst),id(lst1))#结果：46646536 46647136
#操作1.修改第二层数据，原列表也变
lst1[-1].append(8)
print(lst1)#结果：[1, 2, 3, [6, 5, 7, 8]]
print(lst)#结果：[1, 2, 3, [6, 5, 7, 8]]

#操作2.修改第一层数据，原列表不变
lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst1[3] = 567
print(lst1)#结果：[1, 2, 3, 567]
print(lst)#结果：[1, 2, 3, [6, 5, 7]]

#操作3.修改第三层数据，原列表也变
lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst1[-1][-1] = "56"
print(lst)#结果：[1, 2, 3, 4, [5, 6, 7, '56']]
print(lst1) #结果：[1, 2, 3, 4, [5, 6, 7, '56']]

#操作4.注意，字典的值整个就算为第一层数据，里面的任意都不只是第一层数据
dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["alex"] = "56"
print(dic)#结果：{'alex': '56'}
print(dic1)#结果：{'alex': [1, 2, 3, [5, 6]]}

dic["alex"][0] = "56"
print(dic)#结果：{'alex': ['56', 2, 3, [5, 6]]}
print(dic1)#结果：{'alex': ['56', 2, 3, [5, 6]]}

浅拷贝总结：

1. 浅拷贝只拷贝第一层元素的内存地址
2. 浅拷贝在修改第一层数据时，原数据不变
3. 浅拷贝在修改非第一层数据时，同时发生改变

3.深拷贝

深拷贝总结：

​ 无论怎样改变新拷贝的数据，原数据都不会改变。

​ 开辟一个容器空间，不可变数据类型(第一层元素)共用同一内存地址，共用值，可变数据类型(非第一层)在开辟一个新空间(新的内存地址)，但是里面的值是共用的

import copy
lst = [1,2,3[6,5,7]]
lst1 = copy.deepcopy(lst)
lst1[-1].append(8)
print(lst)
print(lst1)
#修改非第一层数据，原数据不变

lst1[0] = 88
print(lst)
print(lst1)
#修改第一层数据，原数据不变

print(id(lst[0]))#结果：494255688
print(id(lst1[0]))#结果：494255688
#第一层是同一内存地址

print(id(lst[-1]))#结果：43102336
print(id(lst1[-1]))#结果：43321264
#非第一层是不同的内存地址，但是非第一层内层的值内存地址相同。
print(id(lst[-1][0]))#结果：503627400
print(id(lst[-1][0]))#结果：503627400

4.集合 -- set

1.简介：

​ 没有值的字典，无序 - - 不支持索引，

​ *天然去重

​ 定义:

s = {1,"alex",False,(1,2,3),12,15,1,1,2,12}#列表不可以作为元素
#面试题：
list1 = [1,2,1,21,21,2,1,212,1,1]
print(list(set(list1)))

2.方法

1.增：

1. s.add('66'):一次添加一个元素
2. s.update("今天")：迭代添加

s = {1,2,3,4}
s.add("67") #只能添加一个
print(s)

s.update("今天")#迭代添加
print(s)

2.删：

1. s.pop():随机删除
2. s.remove(3):指定元素删除
3. s.clear():清空

s = {1,2,3,4}
s.pop()#有返回值，随机删除
print(s)
print(s.pop)

s.remove(3)#指定元素删除
print(s)

s.clear()
print(s)#集合 set()

3.改：

先删再增

4.查：

​ for 循环

s = {1,2,3,4}
for i in s:
    print(i)

菜中菜：各种集合

s1 = {1,2,3,4,5,6,6,7}
s2 = {5,6,7,1,9}
print(s1 & s2) #交集。结果：{1, 5, 6, 7}
print(s1 | s2) #并集，可去重。结果：{1, 2, 3, 4, 5, 6, 7，9}
print(s1 - s2) #差集。结果：{2, 3, 4}
print(s1 ^ s2) #反交集。结果：{2, 3, 4, 9}
print(s1 > s2) #父集(超集)。结果：False
print(s1 < s2) #字迹。结果：False

#冻结集合,很不常用，也没什么用，使此集合不可更改
print(frozenset(s1))#结果：frozenset({1, 2, 3, 4, 5, 6, 7})
dic = {frozenset(s1):1}
print(dic)#结果：{frozenset({1, 2, 3, 4, 5, 6, 7}): 1}