驻留机制

驻留机制

• is:判断is两边是否相同

  • is 是通过内存地址判断的

• ==：判断等号两边是否相同

  a = 1 b = 2 print(a is b) #判断a是不是b

• 小数据池(终端测试)

  1. 数字地址相同的范围：-5~256地址相同
  2. 字符串：除去特殊符号，中文，内容相同，地址就相同
  3. python3.6 字符串进行乘法时，总长度不超过20
  4. python 3.7 字符串进行乘法时，总长度不超过4096

• 代码块(pycharm环境)

  • 定义：一个py文件、一个函数、一个模块、一个类、交互模式下的每一行代码
  • 先执行代码块，小数据池
  1. 数字地址相同的范围：-5~正无穷
  2. 字符串：定义时，长度不限，内容相同就驻留(地址相同)
  3. 字符串进行乘法时，除去中文，特殊符号总长度不超过20

深浅拷贝

赋值

• 定义：多个变量名指向同一个内存地址

  a = 2
  b = a
  #a,b都指向2的内存地址
  

  a = 2           #不可变数据类型
  b = a           
  a = 11          #开辟空间，指向新的内存地址
  print(a,b)
  

  

  lst = [1,2,3,4]         #可变数据类型
  lst1 = lst              #lst和lst1指向同一个地址列表
  lst = [5,6,7,8]         #lst开辟新的空间，指向新的地址
  print(lst,lst1)
  

  dic = {"key2":[1,2,3]}   #可变数据类型
  dic1 = dic               #两个变量指向同一个字典的地址
  dic1["key2"].append(5)   #对字典地址的只改变
  print(dic,dic1)          #结果都改变
  

  

• 总结：

  1. 当多个变量名指向同一个地址时，如果这个变量的数据是

     1. 修改时，不可变数据类型，新开辟空间变量名指向新的地址空间(数字，字符串)
     2. 修改时，可变数据类型，在原地址修改(字典，列表)

浅拷贝

lst = [1,2,3,4]
lst1 = lst.copy()
print(lst,lst1)                   #两者一样,浅拷贝是新开辟空间，lst1指向新的开辟空间
lst1.append(5)                    #在新的空间数据进行操作
print(lst)                        #结果为：[1,2,3,4]

• 浅拷贝的另一种方法

  lst = [1,2,[3,4]]
  lst1 = lst[:]  # 浅拷贝
  lst1[-1].append(5)
  print(lst,lst1)
  

  lst = [1,2,3,4]
  lst1 = lst                      #lst和lst1指向同一个列表内存地址
  lst2 = lst[:]                   #lst2新开辟地址空间，其中元素是与lst共用的，因此元素的地址相同
  lst.append(5)                   #是在lst内部新开辟空间指向5
  print(lst,lst1,lst2)            #结果是：[1,2,3,4,5][1,2,3,4,5][1,2,3,4]
  

  

深拷贝

使用深拷贝时，必须使用improt copy引入copy模块才能使用深拷贝

improt copy
lst = [1,2,[3,4],5]
lst1 = copy.deepcopy(lst)
print(id(lst),id(lst1))             #地址不同，开辟新的空间
print(id(lst[0]),id(lst1[0]))       #拷贝元素中，不可变数据类型共用，因此地址相同
print(id(lst[2]),id(lst1[2]))       #拷贝元素中，可变数据类型开辟新的空间，因此地址不同

• 总结：

  1. 浅拷贝，只拷贝数据第一层的内存地址，咱们能看到是因为，根据内存地址去查找对应的值
  2. 深拷贝，开辟新的空间后，可变数据类型开辟新的空间，不可变数据类型共用

集合

关键字 set

空集合 set()

集合的定义

s = set()

集合：集合就是一个没有值得字典

面试题：集合可以天然去重，元素都是唯一的，且可哈希

lst = [1,2,3,4,1,1,12,33,3,421,21,12,3]
print(list(set(lst)))                 #转换成集合可以去重

集合：是无序的，不支持索引，可变，可迭代

集合的增

set.update()

s = {1,2,3,4}
s.update(5)             #迭代添加,整型是不可迭代，所以不能用update添加整型
print(s)          

set.add()

s = {1,2,3,4}
s.add(5)
print(s)

集合的删

set.pop() 随机删除

s = {1,2,3,4}
s.pop()               #随机删除，默认删除最小的，自动根据大小排序
print(s)

set.clear() 清空集合

s = {1,2,3,4}
s.clear()               #清空集合所有的元素
print(s)                #结果为set()

s.remove(元素) 根据指定元素删除

s = {1,2,3,4}
s.remove(4)           #删除元素4
print(s)               #查看

集合的改

删完在加

集合的查

集合可迭代，for循环可查

集合的关系

交集: &

并集：|

补集(反差集)：^

差集：-

子集：<

父集(超集)：>