Python基础学习笔记（06）代码块、集合、深浅copy

Python基础学习（06）

一、今日内容大纲

id 内存地址
代码块及其缓存机制
set 集合（了解）
深浅copy
enumerate 枚举

二、id 内存地址

id()可以返回目标变量的地址，而is可以用来判断两者的id是否相同，若相同则返回True。

i1 = 100
j1 = 100
i2 = '100'
j2 = '100'
i3 = [100]
i4 = [100]
print(i1 is j1)
print(i2 is j2)
print(i3 is j3)			#==仅仅是判断两者的值是否相同，同is的使用略有不同，这里==会返回True

程序运行结果为：

True
True
False

三、代码块

这篇博客写的比较清楚：https://www.cnblogs.com/zx125/p/11745864.html

什么是代码块

我们所有的代码都需要依赖代码块执行，一个函数、一个文件就是一个代码块，在交互式命令下，每一行都是一个代码块。同一个代码块下，有一个缓存机制；不同的代码块下，遵循不同的缓存机制。
同一代码块的缓存机制
- 机制内容：Python在执行统一代码块的初始化对象的命令时，会检查是否其值已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，它会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中之前的这个值。
- 适用对象：int（float）、str、bool
- 具体细则：所有的数字、布尔值及几乎所有的字符串
- 优点：提升性能、节省内存
不同代码块的缓存机制（小数据池）
- 机制内容：Python自动将-5~256的整数进行了缓存，当你将这些证书赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。Python会将一定规则的字符串在字符串驻留池中创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象，而是使用在字符串驻留池中创建好的对象。
- 适用对象：-5~256整数、str、一定规则的字符串

四、set 集合（了解）

集合

容器型的数据类型，它要求它里面的元素是不可变（可hash）的数据（int、bool、str），但是它本身是可变的数据类型，集合是无序的，相同元素只允许存在一个，用大括号括起表示。
集合的作用
- 列表的去重
- 关系测试：交集、并集、差集等

集合的基本操作

集合的创建

set1 = set({1,3,'barry',False})
set1 = {1,3,'barry',False}        # 一般使用这种方式

空集合的表示

print({},type({}))
set1 = set()
print(set1,type(set1))

# result:
# {} <class 'dict'>
# set() <class 'set'>

集合的有效性

set1 = {[1,2,3],3,{'name':'alex'}}
print(set1)

# result: TypeError: unhashable type: 'list'

add 函数：添加元素

set1 = {1,2,3,'Raigor'}
set1.add('xx')
print(set1)

# result: {1, 2, 3, 'Raigor', 'xx'}

update 函数：迭代添加

set1 = {1,2,3,'Raigor'}
set1.update('sad')
print(set1)

# result: {1, 2, 3, 's', 'Raigor', 'a', 'd'}

remove函数：按照元素删除

set1 = {1,2,3,'Raigor'}
set1.remove('Raigor')
print(set1)

# result: {1, 2, 3}

pop函数：随即删除

set1 = {1,2,3,'Raigor'}
set1.pop()
print(set1)

# result: {1,2,3}

修改操作：先删除在增加

set1 = {1,2,3,'Raigor'}
set1.remove('Raigor')
set1.add(4)
print(set1)

# result: {1, 2, 3, 4}

查找操作：常在列表中使用的in函数也可用于集合的查找操作

集合的操作

有以下两个集合：
```
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
```

交集
```
print(set1 & set2)
  
# result: {4, 5}
```

并集：| 或者 union

print(set1 | set2)

# result: {1, 2, 3, 4, 5, 6, 7, 8}

差集：- 或者 difference

print(set1 - set2)
   
# result: {1, 2, 3}

反交集：^ 或者 symmetric_difference

print(set1 ^ set2)

# result: {1, 2, 3, 6, 7, 8}

子集：< 或者 issubset
```
print(set1 < set2)

# result: False
```
超集：> 或者 issuperset
```
print(set1 > set2)

# result: False
```

应用：列表的去重

l1 = [1,1,2,2,3,3,4,5,6]		# 利用集合去重不会保持原先顺序
set1 = set(l1)
l1 = list(set1)
print(l1)

# result: [1, 2, 3, 4, 5, 6]

五、深浅copy

赋值运算

l1 = [1, 2, 3, [22, 33]]
l2 = l1
l1[1] = 999
l1.append(666)			# 对于列表等容器型数据类型而言，容器内部其他数据的改变不影响容器本身的地址
print(l1)		
print(l2)

# result:
# [1, 999, 3, [22, 33]]
# [1, 999, 3, [22, 33]]

浅拷贝 copy（切片属于浅copy）

l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()          # l1,l2此时的id已经不是一个地址了
l1.append(666)
print(l1)
print(l2)

# result:
# [1, 2, 3, [22, 33], 666]
# [1, 2, 3, [22, 33]]

另一种情况：

l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1[-1].append(666)          # l1[-1],l2[-1]的id仍然相同
print(l1)
print(l2)

# result:
# [1, 2, 3, [22, 33, 666]]
# [1, 2, 3, [22, 33, 666]]

深拷贝 deepcopy

python对深copy进行了优化，将可变的重新创建了一份，不可变的数据类型沿用之前的，节省了空间。

import copy
l1 = [1 ,2 ,3 , [22, 33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1)
print(l2)

# result:
# [1, 2, 3, [22, 33, 666]]
# [1, 2, 3, [22, 33]]

六、enumerate 枚举

是一种可迭代对象遍历方法，会返回多组一个数字和对象值的元组类型，使用方法如下：

l1 = ['a', 'b', 'c']
for i in enumerate(l1):
    print(i)
for i in enumerate(l1,start = 100):		# 可以设置开始数字
    print(i)

程序运行结果为：

(0, 'a')
(1, 'b')
(2, 'c')
(100, 'a')
(101, 'b')
(102, 'c')