六.切片操作

1.list 列表切片

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

10.tuple 元组切片

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

11.字符串切片

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

12.反向切片

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

2.倒序输出

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sub_list = my_list[5::-1]  # 从索引5到索引0（不包括0），步长为-1
print(sub_list)

[5, 4, 3, 2, 1, 0]

3.不包含 0

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sub_list = my_list[5:0:-1]  # 从索引5到索引0（不包括0），步长为-1
print(sub_list)

[5, 4, 3, 2, 1]

4.正序输出

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sub_list = my_list[:5]  # 从索引5到索引0（不包括0），步长为-1
print(sub_list)

[0, 1, 2, 3, 4]

5.减一位输出

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sub_list = my_list[5-1::-1]  # 从索引5到索引0（不包括0），步长为-1
print(sub_list)

[4, 3, 2, 1, 0]

6.reversed 函数

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sub_list = reversed(my_list[:5])  # 从索引5到索引0（不包括0），步长为-1
print(sub_list)
print(type(sub_list))
for sub in sub_list:
    print(sub)

<list_reverseiterator object at 0x108485d50> <class 'list_reverseiterator'> 4 3 2 1 0

一.基本介绍

1.切片基础

在 Python 中，切片是指从序列类型（如列表、字符串、元组等）中提取子序列的过程。切片的基本语法如下：

sequence[start:stop:step]

• start：切片开始的位置（包含该位置）。如果省略，切片从序列的开始位置开始。
• stop：切片结束的位置（不包含该位置）。如果省略，切片一直取到序列的末尾。
• step：步长，即选取元素的间隔。如果省略，默认为 1，即依次选取每个元素。

2. 获取子列表

切片可以用来快速获取列表的一部分。例如，要从列表中获取前三个元素，可以使用以下切片：

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[:3]
print(sub_list)  # 输出: [1, 2, 3]

3. 反转列表

切片也可以用于反转列表。通过设置步长为 -1，可以从列表的末尾开始向前选取元素：

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

4. 跳过元素

通过设置步长 step，你可以跳过列表中的某些元素。例如，获取列表中的偶数位置元素：

my_list = [1, 2, 3, 4, 5]
even_index_elements = my_list[::2]
print(even_index_elements)  # 输出: [1, 3, 5]

5. 从中间开始切片

如果你只想从列表的中间开始获取元素，可以设置 start 参数：

my_list = [1, 2, 3, 4, 5]
middle_elements = my_list[2:]
print(middle_elements)  # 输出: [3, 4, 5]

6. 动态切片

切片的参数可以是变量，这使得切片更加灵活和动态：

start = 1
end = 4
step = 2
my_list = [1, 2, 3, 4, 5]
dynamic_slice = my_list[start:end:step]
print(dynamic_slice)  # 输出: [2, 4]

7. 切片与循环结合

切片可以与循环结合使用，对列表的子序列进行迭代处理：

my_list = [1, 2, 3, 4, 5]
for item in my_list[::2]:
    print(item)  # 依次打印 1, 3, 5

8. 切片与列表推导式

切片可以与列表推导式结合，创建新的列表：

my_list = [1, 2, 3, 4, 5]
filtered_list = [x for x in my_list if x % 2 == 0]
print(filtered_list)  # 输出: [2, 4]

二.切片的注意事项

1. 索引越界

当 start 或 stop 参数超出列表的范围时，Python 会优雅地处理这种情况，不会抛出错误：

my_list = [1, 2, 3, 4, 5]
print(my_list[10:])  # 输出: []

2. 负索引

Python 支持负索引，其中 -1 表示列表的最后一个元素：

my_list = [1, 2, 3, 4, 5]
print(my_list[-1])  # 输出: 5

3. 步长为零

步长不能为零，否则 Python 会抛出 ValueError：

my_list = [1, 2, 3, 4, 5]
try:
    print(my_list[0:5:0])
except ValueError as e:
    print(e)  # 输出: slice step cannot be zero

三.代码实践

1.将第一个元素移到最后

# 假设列表名为 my_list
my_list = [1, 2, 3, 4, 5]

# 将第1个元素移动到末尾
my_list = my_list[1:] + my_list[:1]

print(my_list)

[2, 3, 4, 5, 1]

2.将第二个元素移到最后

# 假设列表名为 my_list
my_list = [1, 2, 3, 4, 5]

# 弹出第二个元素并添加到列表末尾
second_element = my_list.pop(1)
my_list.append(second_element)
print(my_list)

[1, 3, 4, 5, 2]

3.将第二个元素移到最后

# 假设列表名为 my_list
my_list = [1, 2, 3, 4, 5]

# 将第二个元素插入到列表末尾
my_list.insert(len(my_list), my_list.pop(1))
print(my_list)

[1, 3, 4, 5, 2]

4.将第二个元素移到最后

# 假设列表名为 my_list
my_list = [1, 2, 3, 4, 5]

# 使用列表推导式重新构建列表
my_list = [x for i, x in enumerate(my_list) if i != 1] + [my_list[1]]
print(my_list)

[1, 3, 4, 5, 2]