python切片

切片使用方法

对象名称【开始索引：结束索引：步长】
举个栗子：

# 包含元素的列表
li = [1,2,33,555,9999,10,77]
# 使用切片后打印
print(li[1:6:2])
# 输出结果为 [2，555，10]

我们可以分开看

# 当我们打印li[1:6]时：
print(li[1:6]) # 结果是[2,33,555,9999,10]
# 对应的索引是		   1,2,   3,   4,5
# 因此不难看出 用数学来解释就是 [1,6) 左闭右开

# li[1:6]就相当于li[1:6:1],省略的步长默认是1
# 当设定步长为2时
print(li[1:6:2]) # 结果是[2,555,10]
# 对应的索引是			 1, 3, 5
# 因此步长就代表间隔

使用切片可以对列表进行访问，插入，修改以及删除操作。

访问

访问可以访问列表内单个元素或多个元素，切片在访问多个元素时使用。

访问单个元素

访问列表单个元素时，直接使用： 对象名称【索引】
拿之前的列表来举例

li = [1,2,33,555,9999,10,77]
print(li[1]) # 返回第一个元素 2，其中li为对象名称，1为索引
print(li[-2]) # 返回最后一个元素 10
# 相当于 [1, 2, 33, 555, 9999, 10, 77]
# 正索引  0, 1,  2,   3,    4,  5,  6
# 负索引 -7,-6, -5,  -4,   -3, -2, -1
print(li[1] == li[-6]) # True
	 #li[2] == li[-5]  # True
	 #.				   # True
	 #.				   # True
	 #.				   # True
	 #li[6] == li[-1]  # True
# 正索引和负索引的区别是: 
# 	正索引从前往后从0开始递增，负索引从后往前从-1开始递减

因此，如果我们要访问列表首位元素我们可以用

print(li[0]) # 返回 1

而访问列表尾部则是：

print(li[-1]) # 返回 77

访问单个元素不能超吃列表长度，超出长度会报错，例如：

li = [2]
print(li[-2]) # 列表只有一个元素，索引超出范围
print(li[1]) # 列表只有一个元素，索引超出范围

访问多个元素

进行多个元素的访问

li = [1,2,33,555,9999,10,77]
# 打印从第一个索引开始，到列表结束
print(li[1:]) # 结果为 [2,33,555,9999,10,77]
# 列表中最后一个索引之前的所有元素, 其中-1的索引元素不包含在内
print(li[:-1])	# [1,2,33,555,9999,10]

以上使用切片是根据第一个冒号左右两个值进行操作的，当左边为空或者右边为空时，都代表到底为止，同理：

# 如果第一个冒号左右都为空时
print(li[:]) # 打印出的就是原列表
print(li[::] # 同理
# 如果第一个冒号左右都有值，就相当于进行了切片步长为1的操作
print(li[1:6]) # 与li[1:6:1]相同，之前提到过

所以，当没有冒号，就是单个元素的访问。
如果有一个冒号，就是堆列表中片段的访问。
如果有两个冒号，第一个冒号左右分别代表开始索引和结束索引（左闭右开原则）。第二个冒号后面的就是步长，可以间隔取值。
步长值为空时默认为1。所以类似于：

li[1:6] == li[1:6:] == li[1:6:1]

除此之外，还可能会遇到这种情况：

# 第一个冒号左右都为空，步长为-1
li = [1,2,33,555,9999,10,77]
print(li[::-1]) # 结果为[77,10,9999,555,33,2,1],就是把原列表进行了倒装

# 还可以尝试下
print(li[::-2]) # 结果为[77,9999,33,1]
print(li[::-3]) # 结果为[77,555,1]
# 相当于默认起始索引为最后一个值，间隔为从后向前步长

与单个元素访问不同，即便开始索引和结束索引超出了列表的长度，列表也会返回一个列表。

# 索引超过列表大小，返回空
print(li[10:]) # 结果为[]
print(li[:-10]) # 结果为[]

# 索引相擦而过，返回空
print(li[5:5]) # 结果为[]
print(li[4:-7]) # 结果为[]

# 步长迈太大，所以只能访问到起步的位置
print(li[::-18]) # 结果为 [77]
print(li[::18]) # 结果为 [1]

所以当切片的索引超出列表长度，或者开始索引大于结束索引等其他第一个冒号左右数值的问题时，他都返回空集，而步长再怎么大，他都会返回开始位置。

多层访问

所谓多层访问，就是多次切片。切片的前提是，进行切片的对象是列表，所以如果对象是 int 这类单个元素时，是无法切片的。当然字符串是和列表一样的。
例：

li = [1,2,33,555,9999,10,77]
print(li[::-1][1:3][1])	# 结果为 9999
# 相当于：
li = li[::-1] # 结果为[77,10,9999,555,33,2,1]
print(type(li)) # <class 'list'>
li = li[1:3] # 结果为[10,9999]
print(type(li)) # <class 'list'>
print(li[1]) # 结果为9999
print(type(li)) # <class 'int'>
# 若对int使用切片，就会报错
# 或者单个元素访问时，访问的索引超出列表长度时也会报错。

插入

对列表进行插入操作是指在列表中插入一个列表：

li = [1,2,33,555,9999,10,77]
li[2:2] = [8]
# 在第二位插入了8
print(li) # 结果为 [1,2,8,33,555,9999,10,77]
#相当于
l1 = li[:2]
l2 = li[2:]
li = l1 + [8] + l2
print(li) # 结果为 [1,2,8,33,555,9999,10,77]

# 由于是插入一个列表，所以列表可以包含任意多的元素
li = [1,2,33,555,9999,10,77]
li[2:2] = [8，11，22]
print(li) # 结果为 [1,2,8,11,22,33,555,9999,10,77]

在插入时，插入的内容必须是列表形式，如果是整数，就会报错。同理，如果插入的位置超出了列表的索引，那么也会报错。

修改

修改和插入不同之处在于以下：

# 插入
li = [1,2,33,555,9999,10,77]
li[2:2] = [8] # 结果为 [1,2,8,33,555,9999,10,77]

# 修改
li = [1,2,33,555,9999,10,77]
li[2:3] = [8] # 结果为[1,2,8,555,9999,10,77]

我们可以看出，插入时索引位置是【2：2】意思是在开始索引为2的位置上插入列表到结束索引为2的位置之前。
而修改的内容是，在索引2的位置更换列表内容。

在省略开始索引或结束索引的情况下：

li = [1,2,33,555,9999,10,77]
li[:-1] = [7]
print(li) # 结果为 [7,77]
# 它把 li[:-1] == [1,2,33,555,9999,10] 替换为了[7]

#同理
li = [1,2,33,555,9999,10,77]
li[2:] = [11,111]
print(li) # 结果为 [1,2,11,111]
# 把 li[2:] == [33,555,9999,10,77] 替换为了[11,111]

当开始索引和结束索引都省略时，列表替换原列表：

li = [1,2,33,555,9999,10,77]
li[:] = [1]
print(li) # 结果为 [1]

而开始索引和结束索引相交时，以开始索引为基准，结束索引默认为开始索引的值，相当于插入操作：

li = [1,2,33,555,9999,10,77]
li[3:2] = [1]
print(li) # 结果为 [1,2,33,1,555,9999,10,77] 与 li[3:3]相同
# li[3:-5]又对标 li[3:2]
li = [1,2,33,555,9999,10,77]
li[3:-5] = [1]
print(li) # 所以结果也是 [1,2,33,1,555,9999,10,77]

当开始索引超出列表范围：

li = [1,2,33,555,9999,10,77]
li[10:2] = [0]
# 修改的列表会添加在列表最后
print(li) # 结果为 [1,2,33,555,9999,10,77,0]

结束所以就算超出也会按照开始索引来插入：

li = [1,2,33,555,9999,10,77]
li[2:-10] = [0]
# 修改的列表会添加在列表最后
print(li) # 结果为 [1,2,0,33,555,9999,10,77]

另外：

如果加入步长，是无法替换的。除非步长超过列表长度，那么就会根据步长是正数还是负数，分别替换列表第一个值和列表最后一个值。

删除

删除操作可以通过将指定列表段等于空，或者直接取列表中的子列表，又或者设置步长来实现。

列表赋值空值

li = [1,2,33,555,9999,10,77]
li[:] = [] # 删除整个列表，或者说是把列表替换成了空列表
li[3:] = [] # 结果为[1,2,33], 删除索引为3和3之后的元素
			# 与li[:3] 的值相同
li[:-3] = [] # 结果为[9999,10,77], 删除索引为-3之前的元素
			 # 与li[4:]和li[-3:]的值相同

直接取列表中的子列表

li = [1,2,33,555,9999,10,77]
print(li[:3]) # 结果为[1,2,33], 相当于删除索引为3和3之后的元素
			# 与li[3:] 的值相同
print(li[-3:]) # 结果为[9999,10,77], 相当于删除索引为-3之前的元素

设置步长

li = [1,2,33,555,9999,10,77]
print(li[::2]) # 从开始索引默认为0 开始，间隔2取值
			   # 结果为 [1,33,9999,77]
			   # 相当于 删除了 [2],[555],[10]

对列表的操作，可以直接切片访问，也可以进行切片的赋值操作后打印操作后的列表。除了切片的基操外，还有很多其他方式修改列表用以返回所需内容。到此先就这样0.0