day 6

day06
列表的 in / not in 运算符
in 判断一个对象是否存在于容器内，如果存在返回True,否则返回False
用法同字符串的 in 相同

语法:
数据对象 in 容器

示例：
L = [1, ‘Two’, 3.3, ‘四’]
1 in L # True
2 in L # False
3.3 in L # True
‘4’ not in L # True

列表的索引：
语法:
列表[整数表达式]
用法:
取值时，等同于字符串的索引操作
索引分为正向索引和反向索引，规则与字符串索引规则完全相同

列表的索引赋值
列表是可变的序列，可以通过索引赋值改变列表中的元素
示例:
L = [1,2,3,4]
L[2] = 3.3 # 将第三个元素改为 3.3

列表的切片
语法:
列表[:]
列表[::]
列表的切片取值时，返回一个列表，规则等同于字符串切片规则

列表的切片赋值:
作用：
可以改变原列表的排序，可以插入和修改数据
可以用切片改变列表的对应元素的值
语法:
列表[切片] = 可迭代对象
注: 赋值运算符的右侧必须是一个可迭代对象
示例:
L = [2, 3, 4]
L[0:1] = [1.1, 2.2] # L = [1.1,2.2,3,4]
L = [2, 3, 4]
L[1:] = [3.3, 4.4, 5.5]#L=[2,3.3,4.4,5.5]
L = [2, 3, 4]
L[:] = [0, 1] # L = [0, 1]
L = [2, 4] # 实现中间插入 [3.1, 3.2]
L[1:1] = [3.1, 3.2] # L = [2,3.1,3.2,4]
L = [2,3,4] # 实现在前面插入[0,1]
L[0:0] = [0, 1]
L = [2,3,4] # 实现在后面插入[5,6]
L[-1:-1] = [5, 6]
L = [1,4] # 用range函数生成的可迭代对象赋值
L[1:1] = range(2,4)
L = [1,2,3,4]
L[1:2] = “ABCD” # "ABCD"也是可迭代对象
切片赋值注意事项:
对于步长不等于1的切片赋值，赋值运算符右侧的可迭代对象提供的元素个数一定要等于切片切出的段数
例:
L = [1,2,3,4,5,6]
L[::2] = “ABC” # 对的
# 以下切出三段，但给出5个元素填充是错的
L[::2] = “ABCDE”

del 语句 用于删除列表中的元素
语法
del 序列[整数表达式]
del 序列[切片]
示例:
L = [1,2,3,4,5,6]
del L[-1] # 删除最后一个 6
del L[0] # 删除第1个 1
del L[::2] # 删除 2,4

python3常用于序列的函数:
len(seq) 返回容器的元素个数
max(x) 返回序列的最大值元素
min(x) 返回序列的最小值元素
sum(x) 返回序列中所有元素的和(元素必须是数值类型)
any(x) 真值测试, 如果容器内其中一个值为True则返回True,否则返回False
all(x) 真值测试, 容器内所有元素的布尔值为True才返回True

python3 中常用的列表方法(method)
详见:
>>> help(list)
或：
/python_base_docs_html/list_xxxxx.html

浅拷贝 shallow copy 和 深拷贝 deep copy
浅拷贝:
是指复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
示例:
L = [3.1, 3.2]
L1 = [1, 2, L] #[1, 2, [3.1, 3.2]]
L2 = L1.copy() #[1, 2, [3.1, 3.2]]浅拷贝
L[0] = 3.14
L1 # [1, 2, [3.14, 3.2]]
L2 # [1, 2, [3.14, 3.2]] 为什么变为3.14？
# L1[2] 和 L2[2] 共同拥有 L绑定的对象
深拷贝:
示例:
import copy # 导放copy模块
L = [3.1, 3.2]
L1 = [1, 2, L] #[1, 2, [3.1, 3.2]]
L2 = copy.deepcopy(L1) # 深拷贝
L[0] = 3.14
L1 # [1, 2, [3.14, 3.2]]
L2 # [1, 2, [3.1, 3.2]] 此列表不受影响

注：
深拷贝通常只对可变对象进行深层复制，不可变对象通常不会被复制

理解:
import copy # 导入复制模块
L1 = [1, 2, [3.1, 3.2]]
L2 = L1 # 会发生什么?
L3 = L1.copy() # 会发生什么
L4 = copy.deepcopy(L1) # 会发生什么？
问题:
如何把L1 里的3.1 改为3.14
L1[2][0] = 3.14

列表与字符串比较:

1. 列表和字符串都是序列，元素之间有先后关系
2. 字符串是不可变的序列，而列表是可变的序列
3. 字符串中每个元素只能存储字符，而列表可以存储任意类型的元素
4. 列表和字符串都是可迭代对象

字符串文本解析方法 split 和 join
S.split(sep=None) 将字符串使用sep作为分隔符分割S字符串，返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔符分割
S.join(iterable) 用可迭代对象中的字符串，返回一个中间用S进行分隔的字符串

示例：
s = ‘Beijing is capital’
L = s.split(’ ') # L = [‘Beijing’, ‘is’, ‘capital’]

L = ["C:", "Programe files", "Python3"]
s = '\\'.join(L)
# s = "C:\\Programe files\\Python3"

列表推导式 list comprehension
列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式

作用：
用简易方法生成列表
语法:
[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]