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" 判断两边的值内存地址是否相等

2. 深浅拷贝

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]