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

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

a=10
b=10
print(a==b)
Ture

is 是

a=10
b=10
print(a is b) # is 判断基于内存地址进行判断

#查ID
print(id(a))
print(id(b))

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

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

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

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

支持:

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

小数据池

# 数字:  -5 ~ 256   ****
字符串:
      在同一代码块下 只要内容相同就采用相同的内存地址
    # 乘法的时候总长度不能超过20   ****
      乘法的时候中文,特殊符号乘以0
布尔值:
      在同一代码块下 只要内容相同就采用相同的内存地址
小数据池的验证方法,必须脱离代码块才能进行验证
先执行代码块的规则,在执行小数据的规则 --(驻留机制)

必会:

#重点重点

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

总结

    1.1代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
       1.1.1 数字: -5 ~ 256
       1.1.2 字符串: 乘法时总长度不能超过20
       1.1.3 布尔值: 内容相同内存地址相同
    1.2 小数据池:
       1.2.1 数字: -5 ~ 256
       1.2.2 字符串: 乘法时总长度不能超过20
       1.2.3 布尔值: 内容相同内存地址相同
    1.3 先执行代码块后执行小数据池
    1.4 == is
        1.4.1 == 判断等号两边值是否相等
        1.4.2 is 判断两边的值内存地址是否相等

深浅拷贝--复制

# 面试必问:赋值,浅拷贝,深拷贝

# 浅拷贝=修改第一层元素不改变,其它改变.
# 深拷贝=修改任何位置,另外一个不改变.

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

lst[-1].append(8)
print(lst1)
print(lst)

lst1 = lst.copy()  # 新开辟一个空间给lst1

print(lst[-1])
print(lst1[-1])

print(id(lst1[-1]))
print(id(lst[-1]))

浅拷贝的时候

只会开辟一个新的容器列表,其他元素使用的都是源列表中的元素

# 浅拷贝=修改第一层元素不改变,其它改变.

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

深拷贝

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

# 深拷贝=修改任何位置,另外一个不改变.

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

总结

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

# 深拷贝开辟一个容器空间(列表),不可变数据公用,可变数据数据类型(再次开辟一个新的空间)
# ,空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间

测试代码

#浅拷贝
        s = [1, 2, 3, [4, 5, 6]]
        s1 = s.copy()
        s[-1] = 11111
        print(s)
        print(s1)
#深拷贝
        s=[1,2,3,[4,5,6]]
        import copy
        s1=copy.deepcopy(s)
        s[-1][1]=11111
        print(s)
        print(s1)

集合--set

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

**** 天然去重

定义集合

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

面试题:

lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))

s = {1,2,3,4}

增:
s.add("67")  #只能添加一个
print(s)
s.update("今天")  # 迭代添加
print(s)

删:
print(s.pop())  # pop有返回值
print(s)
s.remove(3)     # 指定元素删除
print(s)
s.clear()         # 清空   -- set() 空集合
print(s)

改:
先删在加

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

其他操作:

s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}
print(s1 & s2)  # 交集
print(s1 | s2)  # 并集
print(s1 - s2)  # 差集
print(s1 ^ s2)  # 反交集
print(s1 > s2)  # 父集(超集)
print(s1 < s2)  # 子集

 print(frozenset(s1))  # 冻结集合 更不常用
 dic = {frozenset(s1):1}
 print(dic)