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

深藏阁楼爱情的钟 2021-11-10 02:12 167阅读 0赞

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

### 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.浅拷贝 #####

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

![1712363-20190712213350840-1448609170.png][]

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}

##  ##

转载于:https://www.cnblogs.com/Onlywang/p/11178538.html

[1712363-20190712213350840-1448609170.png]: /images/20211109/9e4b2f41c04243c395581e8d77528961.png