01 内容大纲
- is == id 用法
- 代码块
- 同一代码块下的缓存机制
- 不同代码块下的缓存机制（小数据池）
- 总结
- 集合（了解）
- 深浅copy
02 具体内容
1.id is ==
- id是内存地址。 你只要创建一个数据（对象）那么都会在内存中开辟一个空间，将这个数据临时加在到内存中，那么这个空间是有一个唯一标识的，就好比是身份证号，标识这个空间的叫做内存地址，也就是这个数据（对象）的id。可以利用id（）去获取这个数据的内存地址。
- == 是比较的两边的数值是否相等。
- is 是比较的两边的内存地址是否相等。 如果内存地址相等，那么这两边其实是指向同一个内存地址。
- 如果内存地址id相同，那么值肯定相同，但是如果值相同，内存地址id不一定相同。
- id is == 三个方法要会用，知道是做什么的。
# id 相当于身份证号
i = 100
print(id(i))#1366718576
s = 'alex'
print(id(s))#2321428227272
# == 比较的是两边的值是否相等
l1 = [1,2,3]
print(id(l1))#2773818942472
l2 = [1,2,3]
print(id(l2))#2773819744136
print(l1 == l2)# True 如果值相同，内存地址id不一定相同
s1 = 'alex'
print(id(s1))#2147747407048
s2 = 'alex '
print(id(s2))#2147777344096
print(s1 == s2)#False
# is 判断的是内存地址是否相同
l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(id(l1))#1693709444104 同一代码块下，list不适用同一个代码块下的缓存机制
print(id(l2))#1693710245768
print(l1 is l2)#False 值相同，内存地址id不一定相同
s1 = 'alex'
s2 = 'alex'
print(id(s1))#2941129958600
print(id(s2))#2941129958600
print(s1 is s2)#True
print(s1 == s2)#True # 内存地址id 相同，值一定相同
2.代码块
- 代码块：我们所有的代码都需要依赖代码块执行。Python程序是由代码块构造的。块是一个python程序的文本，他是作为一个单元执行的。
- 代码块：一个模块，一个函数，一个类，一个文件等都是一个代码块。
- 交互式方式下一行就是一个代码块。（作为交互方式输入的每个命令都是一个代码块。）
- 两个机制： 同一个代码块下，有一个机制。不同的代码块下，遵循另一个机制。
3.同一个代码块下的缓存机制。
- 前提条件：在同一个代码块内。
- 机制内容：Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。
- 适用的对象： int bool str
- 具体细则：所有的数字，bool，几乎所有的字符串。
- int(float): 任何数字在同一代码块下都会复用。
- bool: True和False在字典中会以1，0方式存在，并且复用。
- str：几乎所有的字符串都会符合缓存机制，满足缓存机制则他们在内存中只存在一个，即：id相同。
- 优点：提升性能，节省内存。
i1 = 1000 i2 = 1000 i3 = 1000 print(id(i1))#1328495379536 print(id(i2))#1328495379536 print(id(i3))#1328495379536 i = 800 ##int i1 = 800 print(i is i1) #True s1 = '[email protected]!#fkdjlsafjdskl;fjds中国' ##str s2 = '[email protected]!#fkdjlsafjdskl;fjds中国' print(s1 is s2) #True
4.不同代码块下的缓存机制--- 小数据池。
- 小数据池，不同代码块的缓存机制，也称为小整数缓存机制，或者称为驻留机制。
- 前提条件：在不同代码块内。
- 机制内容：Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。
- 适用的对象： int bool str
- 具体细则：-5~256数字【记】，bool，满足规则的字符串。（小数据池下的数字和字符串的范围比同一代码块缓存机制时缩小了。）
- int:对于整数来说，小数据池的范围是-5~256 ，如果多个变量都是指向同一个（在这个范围内的）数字，他们在内存中指向的都是一个内存地址。
#交互式环境下，属于不同代码块，满足小数据池的数字范围是：-5~256 >>> i = 100 #在-5~256内 >>> i1 = 100 >>> print(id(i)) 1366718576 >>> print(id(i1)) 1366718576 >>> print(i is i1) True >>> i2 = 1000 #不在范围内 >>> i3 = 1000 >>> print(id(i2)) 1928403259184 >>> print(id(i3)) 1928403508080 >>> print(i2 is i3) False - bool:bool值就是True，False，无论你创建多少个变量指向True，False，那么他在内存中只存在一个。
- str:
- int:对于整数来说，小数据池的范围是-5~256 ，如果多个变量都是指向同一个（在这个范围内的）数字，他们在内存中指向的都是一个内存地址。
- 优点：提升性能，节省内存。
5.总结:
- 面试题考。
- 回答的时候一定要分清楚：如果在同一代码块下，则采用同一代码块下的换缓存机制。如果是不同代码块，则采用小数据池的驻留机制。
- 小数据池：数字的范围是-5~256.
- 缓存机制的优点：提升性能，节省内存。
6.集合set
- 集合 set，容器型的数据类型，它要求它里面的元素是不可变的数据类型（int，str，bool，tuple），但是它本身是可变的数据类型。集合是无序的，不能按索引删除。{}。
- 不可变的数据类型：int，str，bool，tuple 容器型的数据类型：list, tuple, dict, set
- 集合的作用：
- 列表的去重:不能保留列表原来的顺序
- 关系测试： 交集，并集，差集，.....（数据之间的关系）
# 集合的创建：
set1 = set({1,3,'barry',False})
print(set1)#{False, 1, 'barry', 3}
set1 = {1,3,'太白金星',4,'alex',False,'武大'}
print(set1)#{False, 1, '武大', 3, 4, '太白金星', 'alex'}
# 空集合：
dic = {} # 创建空字典
print({}, type({})) #{} <class 'dict'>
set1 = set() # 创建空集合
print(set1) #set()
# 集合的有效性测试：要求它里面的元素是不可变的数据类型
set1 = {[1,2,3], 3, {'name':'alex'}}
print(set1) #TypeError: unhashable type: 'list' 'dict'
set1 = {'太白金星', '景女神', '武大', '三粗', 'alexsb', '吴老师'}
# 集合的增：
# add
set1.add('xx')
print(set1)#{'景女神', 'xx', '三粗', '太白金星', 'alexsb', '吴老师', '武大'}
set1.add('haha')
print(set1)#{'景女神', 'xx', '三粗', 'haha', '太白金星', 'alexsb', '吴老师', '武大'}
# update迭代着增加---->集合自动去重
set1 = {'太白金星', '景女神', '武大', '三粗', 'alexsb', '吴老师'}
set1.update('derdfetg')
print(set1)#{'g', 'alexsb', '三粗', 'e', '景女神', 'r', '吴老师', '太白金星', 'f', 'd', 't', '武大'}
# 集合的删
因为集合是无序的，所以不能按索引删除
# remove ：按照元素删除
set1 = {'太白金星', '景女神', '武大', '三粗', 'alexsb', '吴老师'}
set1.remove('武大')
print(set1)#{'alexsb', '吴老师', '三粗', '太白金星', '景女神'}
# pop 随机删除一个元素
set1 = {'太白金星', '景女神', '武大', '三粗', 'alexsb', '吴老师'}
set1.pop()
print(set1)#{'武大', '太白金星', '吴老师', '三粗', 'alexsb'}
#clear
set1.clear() # 清空集合
print(set1)#set()
#del
del set1 # 删除集合
print(set1)#NameError: name 'set1' is not defined
# 变相改值:先删除，在增加
set1 = {'太白金星', '景女神', '武大', '三粗', 'alexsb', '吴老师'}
set1.remove('太白金星')
set1.add('男神')
print(set1)#{'三粗', 'alexsb', '吴老师', '武大', '景女神', '男神'}
#关系测试：***【重点】
# 交集（& 或者 intersection）
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)#{4, 5}
print(set1.intersection(set2))#{4, 5}
# 并集：（| 或者 union）
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2)#{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))#{1, 2, 3, 4, 5, 6, 7, 8}
# 差集：（- 或者 difference）
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 - set2)#{1, 2, 3} #求set1独有的
print(set1.difference(set2))#{1, 2, 3}
print(set2 - set1)#{8, 6, 7}
# 反交集：（^ 或者 symmetric_difference）
print(set1 ^ set2)#{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))#{1, 2, 3, 6, 7, 8}
# 子集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)#True 说明set1是set2子集。
print(set1.issubset(set2))#True
# 超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set2 > set1)#True 说明set2是set1超集。
print(set2.issuperset(set1))#True
应用：列表的去重 ***【重点】 不能保留列表原来的顺序
l1 = [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
set1 = set(l1)
l1 = list(set1)
print(l1)#[1, 2, 3, 4, 5, 6, '太白']
7.深浅copy（面试会考,按代码的形式考）
- 深浅copy其实就是完全复制一份，和部分复制一份的意思。
# 赋值运算【面试题】
对于赋值运算来说，l1与l2指向的是同一个内存地址id，所以他们是完全一样的。l1,l2指向的是同一个列表，任何一个变量对列表进行改变，剩下那个变量在使用列表之后，这个列表就是发生改变之后的列表。
l1 = [1, 2, 3, [22, 33]]
print(id(l1))#2999106822024
l2 = l1 #赋值运算
print(id(l2))#2999106822024
l1.append(666)
print(l1)#[1, 2, 3, [22, 33], 666]
print(l2)#[1, 2, 3, [22, 33], 666]
####注意区分：（重新建了一个列表）
l1 = [1, 2, 3, [22, 33]]
l2 = [1, 2, 3, [22, 33]]
print(id(l1))#2115308511112
print(id(l2))#2115308545608
l1.append(666)
print(l1)#[1, 2, 3, [22, 33], 666]
print(l2)#[1, 2, 3, [22, 33]]
# 浅copy:
对于浅copy来说，只是在内存中重新创建了开辟了一个空间存放一个新列表，但是新列表中的元素与原列表中的元素是公用的。
#1:
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1.append(666)
print(l1,id(l1))#[1, 2, 3, [22, 33], 666] 2632840208264
print(l2,id(l2))#[1, 2, 3, [22, 33]] 2632840243464
#2: 浅copy只是copy了一个外壳，里面所有内容指向原来的。所以l1和l2的id不同，但是里面内容的id相同。
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1[-1].append(666)
print(id(l1))#1717681938312 列表id不同
print(id(l2))#1717681973512
print(id(l1[-1]))#1717681136648 内容id相同
print(id(l2[-1]))#1717681136648
print(id(l1[0]))#1366715408 内容id相同相同
print(id(l2[0]))#1366715408
print(id(l1[1]))#1366715440 内容id相同
print(id(l2[1]))#1366715440
print(l1) #[1, 2, 3, [22, 33, 666]]
print(l2) #[1, 2, 3, [22, 33, 666]]
#3.同一代码块下：
l1 = [1, 2, 3, [22, 33],(1,2,3)]
l2 = l1.copy()
print(l1,id(l1))#[1, 2, 3, [22, 33], (1, 2, 3)] 1808473481096
print(l2,id(l2))#[1, 2, 3, [22, 33], (1, 2, 3)] 1808473516296
print(id(l1[-1]),id(l2[-1]))#1808473473672 1808473473672
print(id(l1[-2]),id(l2[-2]))#1808472679432 1808472679432
#4.
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1[0] = 90
print(l1)#[90, 2, 3, [22, 33]]
print(l2)#[1, 2, 3, [22, 33]]
# 深copy
对于深copy来说，列表是在内存中重新创建的，列表中可变的数据类型是重新创建的，列表中的不可变的数据类型是公用的。
python对深copy做了优化，将不可变的数据类型沿用同一个。
import copy
l1 = [1, 2, 3, [22, 33]]
l2 = copy.deepcopy(l1)
print(id(l1))#2336066990856
print(id(l2))#2336066992136
l1[-1].append(666)
print(l1)#[1, 2, 3, [22, 33,666]]
print(l2)#[1, 2, 3, [22, 33]]
# 相关面试题；
【注意】***list切片是浅copy***
l1 = [1, 2, 3, [22, 33]]
l2 = l1[:]
l1[-1].append(666)
print(l1)#[1, 2, 3, [22, 33,666]]
print(l2)#[1, 2, 3, [22, 33,666]]
区分：看是否共用一个嵌套的可变数据类型list，dict
浅copy：嵌套的可变的数据类型(list dict)是同一个。
深copy：嵌套的可变的数据类型(list dict)不是同一个 。8.enumerate：枚举
对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
# enumerate(iterable[, start])
l1 = ['a', 'b', 'c']
for i in enumerate(l1): # [(0, 'a'),(1, 'b'),(2, 'c')]
print(i)
# (0, 'a')
# (1, 'b')
# (2, 'c')
for i in enumerate(l1,start=100): #起始位置默认是0，可更改
print(i)
# (100, 'a')
# (101, 'b')
# (102, 'c')
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
# (0, 'alex')
# (1, '银角')
# (2, '女神')
# (3, 'egon')
# (4, '太白')
for index,name in enumerate(li,1):
print(index,name)
# 1 alex
# 2 银角
# 3 女神
# 4 egon
# 5 太白
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
# 100 alex
# # 101 银角
# # 102 女神
# # 103 egon
# # 104 太白
原文地址：https://www.cnblogs.com/xiaomage666/p/10822732.html
时间： 2024-10-29 06:22:02