python 06 深浅拷贝

目录

?1. 小数据池 ?1.1 代码块
?1.2 小数据池
?1.3 执行顺序 （代码块--小数据池）
?1.4 "=="和 “is”

?2. 深浅拷贝 ?2.1 赋值
?2.2 浅拷贝： copy() ?2.2.1 本质
?2.2.2 特征

?2.3 深拷贝：copy.deepcopy（） ?2.3.1 格式
?2.3.2 特征

?3.集合——set ?3.1 定义
?3.2 操作 ?3.2.1增
?3.2.2 删
?3.2.3 改
?3.2.4 查
?3.2.5 其他操作

?3.3 集合面试题 ?1. 用一行代码将列表去重：

1. 小数据池

? 小数据池——缓存机制(驻留机制)

? 数字的范围为：-5~256（在此范围内的数字，内存地址相同）

1.1 代码块

? 一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块。

支持的数据类型：

1.数字类型：

在同一代码块下 只要内容相同就采用相同的内存地址(-5 ~ 正无穷大)；

数字在做乘法的时候范围 -5 ~ 256；

? 数字在做乘法的时候不能使用浮点数，否则地址不同。
1.字符串类型：

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

? 乘法的时候总长度不能超过20，内存地址相同；

? 乘法的时候中文,特殊符号乘以1或0，内存地址相同。
1.布尔值：

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

1.2 小数据池

支持的数据类型：

1.数字类型：

数字范围 -5 ~ 256；

2.字符串类型：

? 纯字母、数字任意长度，只要内容相同就采用相同的内存地址；

? 只有乘法的时候总长度不能超过20，内存地址相同；

? 乘法的时候中文,特殊符号乘以0，内存地址相同。
1.布尔值：

? 只要内容相同就采用相同的内存地址。

1.3 执行顺序 （代码块--小数据池）

? 小数据池的验证方法，必须脱离代码块才能进行验证。否则会先执行代码块的规则，再执行小数据池的验证规则。

1.4 "=="和 “is”
"== 判断等号两边值是否相等
"is" 判断两边的值内存地址是否相等

1. 深浅拷贝

2.1 赋值

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

? 一个变量对其进行操作,其他变量查看时都变动
lst = [1,2,3,[4,5,6]]
lst1 = lst
print(lst1)
print(lst)
lst[-1].append(8)
print(lst1) # lst、lst1都改变
print(lst)

2.2 浅拷贝： copy()

2.2.1 本质

? 浅拷贝的时候,只会开辟一个新的容器列表(内存空间),使用的都是源列表中的元素。
lst1 = lst.copy()
print(lst[-1]) # [4,5,6]
print(lst1[-1]) # [4,5,6]
print(id(lst[-1])) # id 内存地址也一样
print(id(lst1[-1]))

2.2.2 特征

? lst[ : ] -- 也是浅拷贝；

? 浅拷贝只拷贝第一层元素；

? 修改第一层元素时,新开辟了内存空间，则不会进行改变；修改第二层及以上元素时，会改变。
lst = [1,2,3,[4,5,6]]
lst1 = lst.copy() #浅拷贝
lst[0]=10
print(lst) # 会变[10, 2, 3, [4, 5, 6]]
print(lst1) # 不会变[1, 2, 3, [4, 5, 6]]

总结：当改变第一层元素（不可变数据类型）时，拷贝出来的新列表不会改变

lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()
lst[-1]=4
print(lst) # 会变 [1, 2, 3, 4]
print(lst1) # 不会变[1, 2, 3, [4, 5, 6]]

总结：当改变第一层元素（可变数据类型）时，拷贝出来的新列表不会改变

lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()
lst[-1][-1]=10
print(lst) # 会变[1, 2, 3, [4, 5, 10]]
print(lst1) # 会变[1, 2, 3, [4, 5, 10]]

总结：当修改（增删改）第一层元素中可变数据类型（第二层元素）时，拷贝出来的新列表会改变，两个列表相同

dic = {"alex":[1,2,3,[4,5,6]]}
dic1 = dic.copy()
dic["alex"].append (0)
print(dic) #{‘alex‘: [1, 2, 3, [4, 5, 6], 0]}
print(dic1) #{‘alex‘: [1, 2, 3, [4, 5, 6], 0]}

总结：字典存在的值就是第二层元素

dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["wusir"]=[7,8] #增加新的键值对

dic["alex"]=[7,8] #替换键值对的整体值

print(dic) # {‘alex‘: [1, 2, 3, [5, 6]], ‘wusir‘: [7, 8]}
print(dic1) # {‘alex‘: [1, 2, 3, [5, 6]]}

总结：如果是新增/减键值对或者是替换键值对的整体值，那就是在改第一层元素，不会改变

2.3 深拷贝：copy.deepcopy（）

2.3.1 格式
import copy #导入
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst) # 深拷贝
print(lst)
print(lst1)

2.3.2 特征

? 不可变的数据类型共用,可变的数据类型重新开辟一个空间对源数据进行修改; 深拷贝的内容都不会改变。
import copy
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst)
lst[-1][-1] = 10
print(lst) #会变[1, 2, 3, [4, 5, 10]]
print(lst1) #不变[1, 2, 3, [4, 5, 6]]

import copy
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst)
lst[-1].append(7)
print(lst) #会变[1, 2, 3, [4, 5, 6, 7]]
print(lst1) #不变[1, 2, 3, [4, 5, 6]]

总结：深拷贝对第二层元素改变时，拷贝出来的新列表不会改变

import copy
lst = [1,2,3,[4,5,6]]
lst1 = copy.deepcopy(lst)
lst[-1] = 10
print(lst) #会变[1, 2, 3, 10]
print(lst1) #不变[1, 2, 3, [4, 5, 6]]

总结：深拷贝对第一层元素改变时，拷贝出来的新列表也不会改变

3.集合——set

? 集合是没用值得字典 { }，集合是无序,可变的，集合可以天然去重（唯一），元素时不可变的数据类型。

3.1 定义
s = {1,"alex",False,(1,2,3),12,4,6,32,2}

3.2 操作

3.2.1增
s.add(67) #只能添加一个
s.update("迭代的内容") # 迭代添加

3.2.2 删
s.pop() #随机删
s.remove(1) #指定元素删除
s.clear() # 清空 -- set() 空集合

3.2.3 改
先删再加

3.2.4 查
for i in {1,2,3}:
print(i)

3.2.5 其他操作
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}

print(s1 & s2) # 交集 {1, 5, 6, 7}
print(s1 | s2) # 并集 {1, 2, 3, 4, 5, 6, 7}
print(s1 - s2) # 差集 {2, 3, 4} 差集是减去相同的元素，打印s1中其他剩下的元素
print(s1 ^ s2) # 反交集 {2, 3, 4} 去两个集合的重
print(s1 > s2) # 父集(超集) True
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}

3.3 集合面试题

1. 用一行代码将列表去重：
   lst = [1,2,1,2,4,2,45,3,2,45,2345,]
   print(list(set(lst))) # [1, 2, 3, 4, 2345, 45]

python深浅拷贝

原文：https://www.cnblogs.com/liwenhu/p/11401246.html