小数据池,深浅拷贝以及集合

一.小数据池

小数据池的验证方法必须脱离代码块才能进行验证

驻留机制--先执行代码块的规则,再执行小数据池的规则

1.小数据池 --缓存机制(驻留机制)

小数据池的支持数据类型和范围:

• 数字
  • -5 ~ 256
• 字符串
  • 在同一个代码块下,只要内容相同就采用相同的内存地址
  • 字符串做乘法的时候总长度不能超过20
  • 中文和特殊符号乘法的时候乘以0
• 布尔值
  • 在同一个代码块下,只要内容相同就采用相同的内存地址

2.代码块

一个文件,一个函数,一个模块,一个类,终端中一行就是一个代码块.

代码块的支持数据类型和范围

• 数字
  • 在同一个代码块下,只要内容相同就采用相同的内存地址(-5以后不是)
  • 数字在做乘法的时候范围 -5 ~ 256
  • 数字在做乘法的时候不能使用浮点数
• 字符串
  • 在同一个代码块下,只要内容相同就采用相同的内存地址
  • 字符串进行乘法的时候总长度不能超过20
  • 中文和特殊符号乘法的时候只能乘以1或0
• 布尔值
  • 在同一个代码块下,只要内容相同就采用相同的内存地址二.

二. == 和 is

• == 判断等号两边的值是否相等
• is 判断两边的值内存地址是否相同

三.深浅拷贝

1.赋值

赋值: 多个变量名指向同一个内存地址,一个变量对其进行操作后,其他变量进行查看时都变动

lst = [1,2,3,[5,6,7]]
lst1 = lst
print(lst)
print(lst1)     #[1,2,3,[5,6,7]]
                #[1,2,3,[5,6,7]]

2.浅拷贝

• 浅拷贝的时候只拷贝第一层元素
• 浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变
• 浅拷贝在替换第一层元素内的(可变数据类型)时候,拷贝出来的新列表进行改变
• 浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变
• lst[:] --是浅拷贝

lst =[1,2,3,[6,7,8]]
lst1= lst
lst[-1].append(9)
print(lst)
print(lst1)      #[1, 2, 3, [6, 7, 8, 9]]
                 #[1, 2, 3, [6, 7, 8, 9]]

浅拷贝

lst = [1,2,3[6,7,8]]
lst1 = lst.copy()
print(lst)
print(lst1)     #[1,2,3,[6,7,8]]
                #[1,2,3,[6,7,8]]

lst = [1,2,3,[6,7,8]]
lst1 = lst.copy()
lst[-1].append(9)
print(lst)
print(lst1)      #[1, 2, 3, [6, 7, 8, 9]]
                 #[1, 2, 3, [6, 7, 8, 9]]

lst = [1,2,3,[6,7,8]]
lst1 = lst.copy()
lst[3] = 9
print(lst)
print(lst1)        #[1, 2, 3, 9]
                   #[1, 2, 3, [6, 7, 8]]
  
lst = [1,2,3,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst.append(10)
print(lst)
print(lst1)       #[1, 2, 3, [5, 6, 7, [8, 9]],10]
                  #[1, 2, 3, [5, 6, 7, [8, 9]]]

    
lst = [[1,2,],90,6,7,[5,6]]
lst1 = lst.copy()
lst[-1] = 8
print(lst)
print(lst1)      #[[1, 2], 90, 6, 7, 8]
                 #[[1, 2], 90, 6, 7, [5,6]]    
        
lst = [1,2,3,4,[5,6,7,[8,9]]] 
lst1 = lst.copy()
lst[-1][-1] = "56"
print(lst)
print(lst1)      #[1, 2, 3, 4, [5, 6, 7, '56']]
                 #[1, 2, 3, 4, [5, 6, 7, '56']]

dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["alex"][-1] = "56"
print(dic)
print(dic1)     #{'alex': [1, 2, 3, '56']}
                #{'alex': [1, 2, 3, '56']}

3.深拷贝

• 不可变的数据类型共用,可变的数据类型重新开辟空间
• 对源数据进行修改,深拷贝的内容不进行修改

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

四.集合(set)

• 没有值的字典
• 无序,不支持索引
• 天然去重

定义集合 s = {1,"alex",False}

增:

s = {"刘嘉玲", '关之琳', "王祖贤"}

#添加 s.add()
s.add("郑裕玲") # 重复的内容不会被添加到set集合中
print(s)


#迭代添加 s.update()
s.update("麻花藤") 
print(s)
s.update(["张曼⽟", "李若彤","李若彤"])
print(s)

删:

s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}

# s.pop()     # 随机弹出⼀个.

#s.remove()    # 直接删除元素

s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错


#s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set()

改:

# set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改.
# 我们可以采⽤先删除后添加的⽅式来完成修改操作
s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
# 把刘嘉玲改成赵本⼭
s.remove("刘嘉玲")
s.add("赵本⼭")
print(s)

查:

# set是⼀个可迭代对象. 所以可以进⾏for循环
for el in s:
 print(el)

常用操作

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}

# 交集($)
# 两个集合中的共有元素
print(s1 & s2) # {'⽪⻓⼭'}
print(s1.intersection(s2)) # {'⽪⻓⼭'}

# 并集(丨)
print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}

# 差集(-)
print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
print(s1.difference(s2)) # {'赵四', '刘能'}

# 反交集(^)
print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪⻓⼭"}

# ⼦集(<)
print(s1 < s2) # set1是set2的⼦集吗? True
print(s1.issubset(s2))

# 超集(>)
print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))


#冻结集合
s = frozenset(["赵本⼭", "刘能", "⽪⻓⼭", "长桂"])
dic = {s:'123'}   # 可以正常使⽤了
print(dic)