第六天

id

id 相同 值一定相同----字符串 不可变 就是(可哈希)

值相同,id不一定相同----列表

代码块

• 我们所有的代码都需要依赖代码块执行
• 一个文件就是一个代码块
• 交互式命令下一行就是一个代码块

2. 两个机制:统一代码块下,有一个机制.不同的代码块下,遵循另一个机制.
3. 同一个代码块下的缓存机制
   • 前提条件:同一个代码块内
   • 机制内容:pass
   • 适用的对象: int bool str
   • 具体细则:所有的数字,bool,几乎所有的字符串
   • 优点:提升性能,节省内存
4. 不同代码块下的缓存机制:小数据池
5. • 前提条件:同一个代码块内
   • 机制内容:pass
   • 适用的对象: int bool str
   • 具体细则:-₅256,bool,满足规则的字符串
   • 优点:提升性能,节省内存
6. 总结
   1. 面试题考
   2. 回答的时候一定要分清楚:同一个代码块下适用于一个缓存机制.不同代码块下适用于另一个缓存机制(小数据池)
   3. 小数据池:数字范围是-5~256
   4. 优点:提升性能,节省内存

集合set

容器型的数据类型.他要求里面的元素必须是不可变的数据,但是它本身是可变的数据类型. 集合是无序的.

{}

1. 放的键值对 是字典
2. 不是键值对 是集合

作用

• 列表的去重
• 关系测试:交集,并集,差集

创建

1. set1=({1,3,"bhb","太白"})

空集合

print({},type({})) #空字典 dict

2. set1=set() #空集合的创建

增

1. add

   ​ set1.add("xx")

2. upadte 迭代着增加

   ​ setupdate("adasdasd")

   ​ #去重之后填进去

删

1. remove

   set1.remove("alexsb")

   print()

   只有按照元素删除

2. pop()

   ​ 随机删除

   set1.pop()

3. 变相改值

   ​ set1.remove("太白金星")

   ​ set1.add("男神")

   ​ print(set1)

交集

& set1.intersection(set2)

set1={1,2,3,4,5}

set2={4,5,6,7,8}

print(set1 & set2)

{4, 5}

并集

| union

{1, 2, 3, 4, 5, 6, 7, 8}

差集

"-" difference

{1, 2, 3}

反交集

^ symmetric_difference

print(set1 ^set2)

子集

set1<set2

集合一是集合二的子集

超集

与子集相反

">"

列表的去重

列表变成集合 自动去重

l1=[1,1,2,2,3,3,5,5,6,6]
a=set(l1)
l1=list(a)
print(a)

深浅copy

1. 赋值运算

l1与l2指向的是同一个内存地址，所以他们是完全一样的，在举个例子，比如张三李四合租在一起，那么对于客厅来说，他们是公用的，张三可以用，李四也可以用，但是突然有一天张三把客厅的的电视换成投影了，那么李四使用客厅时，想看电视没有了，而是投影了，对吧？l1,l2指向的是同一个列表，任何一个变量对列表进行改变，剩下那个变量在使用列表之后，这个列表就是发生改变之后的列表。

两个列表一模一样 id什么都相同 一个改 另一个一样

2. 浅拷贝

   ​

对于浅copy来说，只是在内存中重新创建了开辟了一个空间存放一个新列表，但是新列表中的元素与原列表中的元素是公用的。浅拷贝copy。

#同一代码块下：
l1 = [1, '太白', True, (1,2,3), [22, 33]]
l2 = l1.copy()
print(id(l1), id(l2))  # 2713214468360 2713214524680
print(id(l1[-2]), id(l2[-2]))  # 2547618888008 2547618888008
print(id(l1[-1]),id(l2[-1]))  # 2547620322952 2547620322952

# 不同代码块下：
>>> l1 = [1, '太白', True, (1, 2, 3), [22, 33]]
>>> l2 = l1.copy()
>>> print(id(l1), id(l2))
1477183162120 1477183162696
>>> print(id(l1[-2]), id(l2[-2]))
1477181814032 1477181814032
>>> print(id(l1[-1]), id(l2[-1]))
1477183162504 1477183162504

创建之后 L1 L2 id不同

全部元素------------ 共用

3. 拷贝deepcopy

# 同一代码块下
import copy
l1 = [1, 'alex', True, (1,2,3), [22, 33]]
l2 = copy.deepcopy(l1)
print(id(l1), id(l2))  # 2788324482440 2788324483016
print(id(l1[0]),id(l2[0]))  # 1470562768 1470562768
print(id(l1[-2]),id(l2[-2]))  # 2788323047752 2788323047752   #元组不可变

print(id(l1[-1]),id(l2[-1]))  # 2788324482632 2788324482696


# 不同代码块下
>>> import copy
>>> l1 = [1, '太白', True, (1, 2, 3), [22, 33]]
>>> l2 = copy.deepcopy(l1)
>>> print(id(l1), id(l2))
1477183162632
>>> print(id(0), id(0))
1470562736
>>> print(id(-2), id(-2))
1470562672
>>> print(id(l1[-1]), id(l2[-1]))
1477183162312

对于深copy来说，列表是在内存中重新创建的，列表中可变的数据类型是重新创建的，列表中的不可变的数据类型是公用的。

创建之后 L1 L2 id不同

不可变元素------------ 共用 str int tuple bool

可变元素-------------- 不共用

2020年3月5日13:50:31

---

新见解:

深拷贝 就是完全跟以前就没有任何关系了，原来的对象怎么改都不会影响当前对象

浅拷贝，原对象的list元素改变的话会改变当前对象，如果当前对象中list元素改变了，也同样会影响原对象。

浅拷贝就是藕断丝连

深拷贝就是离婚了

import copy
a=[1,2,3,4,5,['a','b']]
b=a#赋值，传对象的引用
c=copy.copy(a)#对象拷贝，浅拷贝
d=copy.deepcopy(a)

a.append(6)#修改对象a

a[5].append('c')

a=[1,2,3,4,5,['a','b','c'],6]
b=[1,2,3,4,5,['a','b','c'],6]
c=[1,2,3,4,5,['a','b','c']]
d=[1,2,3,4,5,['a','b',]]

修改浅层次不影响
a中修改list  影响 浅copy 中的 list

不影响身copy