python切片

py切片

  • 切片使用方法
    • 访问
        • 访问单个元素
        • 访问多个元素
        • 多层访问
    • 插入
    • 修改
            • 另外:
    • 删除
        • 列表赋值空值
        • 直接取列表中的子列表
        • 设置步长

切片使用方法

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

# 包含元素的列表
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)) # 
li = li[1:3] # 结果为[10,9999]
print(type(li)) # 
print(li[1]) # 结果为9999
print(type(li)) # 
# 若对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] = [81122]
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

你可能感兴趣的:(python知识点,python)