掌握 Python 切片：高效提取与操作序列数据的终极技巧！！

于 2025-02-06 21:27:19 发布
阅读量882 收藏 16
点赞数 24
文章标签： python 数据库 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44705554/article/details/145482264
版权

1. Python 切片基础

1.1 Python 切片是什么？

Python 中的切片（Slicing）是指从一个序列（如列表、元组、字符串等）中提取出一部分子序列的操作。通过切片，我们可以在不修改原序列的情况下，提取其某一部分，并返回一个新的子序列。

切片操作是 Python 中处理序列的一个非常强大且常用的工具，它可以让你轻松地从大数据结构中获取一个子集。

举个例子，假设有一个列表：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

如果你想获取从索引 2 到索引 5 的元素，可以使用切片：

subset = numbers[2:6]
print(subset)  # 输出 [2, 3, 4, 5]

这里，[2:6] 表示从索引 2 到索引 5（不包括索引 6）的所有元素。

1.2 Python 切片特点

  1. 不改变原始序列：切片操作不会修改原始的序列，而是返回一个新的子序列。

  2. 支持负索引：Python 切片支持负索引，允许从序列的末尾开始索引。例如，-1 代表最后一个元素，-2 代表倒数第二个元素，依此类推。

  3. 步长支持：切片不仅可以指定起始和结束位置，还支持步长（即提取序列中的某些元素），步长默认是 1，但你可以更改它。

  4. 支持列表、元组和字符串：切片不仅适用于列表，也适用于元组、字符串等其他序列类型。

1.3 Python 切片语法

Python 切片的基本语法如下：

sequence[start:end:step]
  • start：切片的起始位置，包含在切片内。默认为 0。
  • end：切片的结束位置，不包含在切片内。默认为序列的长度。
  • step：步长，表示每次提取元素的间隔。默认为 1。

示例：

# 示例序列
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取从索引 2 到索引 5 的元素
subset1 = numbers[2:6]  # [2, 3, 4, 5]

# 获取从索引 1 到索引 7，每隔 2 个元素的子列表
subset2 = numbers[1:8:2]  # [1, 3, 5, 7]

# 获取整个列表的副本
subset3 = numbers[:]  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用负索引获取最后 3 个元素
subset4 = numbers[-3:]  # [7, 8, 9]

1.4 Python 切片具体使用

1. 切片获取子列表

切片可以方便地提取列表中的一部分。例如，获取列表中的前几个元素，或者提取中间的一部分：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取前 3 个元素
subset = numbers[:3]  # [0, 1, 2]

# 获取最后 2 个元素
subset = numbers[-2:]  # [8, 9]

# 获取从索引 3 到索引 6 的元素
subset = numbers[3:7]  # [3, 4, 5, 6]

2. 使用步长提取元素

切片的步长参数允许你以特定的间隔从序列中提取元素。例如，提取奇数索引的元素：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 提取索引为偶数的元素
subset = numbers[::2]  # [0, 2, 4, 6, 8]

# 提取索引为奇数的元素
subset = numbers[1::2]  # [1, 3, 5, 7, 9]

3. 字符串切片

切片不仅适用于列表，还可以应用于字符串。字符串的切片可以提取某个子字符串：

text = "Hello, World!"

# 提取从索引 0 到索引 4 的子字符串
substring = text[:5]  # "Hello"

# 提取从索引 7 到索引 12 的子字符串
substring = text[7:13]  # "World"

# 提取倒数第三个到最后的字符
substring = text[-3:]  # "ld!"

4. 切片修改列表

虽然切片返回的是一个新的子序列，但你也可以使用切片来修改原始列表的部分内容：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 修改列表中的一部分元素
numbers[2:5] = [10, 11, 12]
print(numbers)  # [0, 1, 10, 11, 12, 5, 6, 7, 8, 9]

5. 切片的高级用法：翻转列表

通过步长参数，可以实现序列的翻转。将步长设置为 -1，就可以反向获取序列中的元素：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 翻转列表
reversed_numbers = numbers[::-1]
print(reversed_numbers)  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

总结

  • 切片是 Python 中强大而常用的功能，可以帮助你从序列（如列表、元组、字符串等）中提取子序列。
  • 切片的基本语法是 start:end:step，其中 start 和 end 定义了切片的范围，step 定义了步长。
  • 切片支持负索引，能够从序列的末尾开始索引。
  • 使用步长参数可以方便地提取间隔元素或实现反转操作。
  • 切片不仅适用于列表，还可以用于元组、字符串等其他序列类型。

通过理解和灵活应用切片，你可以更高效地操作 Python 中的序列数据。

2. Python 切片 使用

2.1 Python 切片使用思路和技巧

Python 切片是一个非常强大的工具，可以帮助你高效地处理序列数据。以下是一些常用的切片使用思路和技巧：

1. 利用切片简化代码

切片可以让你在没有循环的情况下快速提取序列的一部分，避免使用传统的迭代方法。例如：

numbers = [1, 2, 3, 4, 5, 6]

# 使用切片提取前 3 个元素
subset = numbers[:3]  # [1, 2, 3]

# 使用切片提取从索引 2 到索引 4 的元素
subset = numbers[2:5]  # [3, 4, 5]

这样可以避免使用 for 循环逐一提取元素，使代码更加简洁。

2. 切片与步长结合

切片不仅可以指定起始和结束索引，还可以指定步长。通过步长，你可以提取序列中的每隔几个元素。例如：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 提取索引为偶数的元素
subset = numbers[::2]  # [0, 2, 4, 6, 8]

# 提取索引为奇数的元素
subset = numbers[1::2]  # [1, 3, 5, 7, 9]

这种方法非常适合提取每隔几个元素的场景。

3. 使用负索引进行反向切片

负索引允许你从序列的末尾开始进行索引。切片中的负索引非常适合获取从尾部开始的子序列，避免了从头开始计算索引的麻烦。

numbers = [10, 20, 30, 40, 50, 60]

# 获取最后 3 个元素
subset = numbers[-3:]  # [40, 50, 60]

# 获取倒数第二个到倒数第四个元素
subset = numbers[-4:-1]  # [30, 40, 50]

4. 使用切片修改序列

切片不仅用于获取子序列，也可以用来修改列表中的一部分元素。

numbers = [1, 2, 3, 4, 5]

# 使用切片替换列表中的部分元素
numbers[1:4] = [10, 11, 12]
print(numbers)  # [1, 10, 11, 12, 5]

这种操作方式简洁且直观，用来替换列表的某一部分非常方便。

5. 切片翻转序列

通过设置步长为 -1，你可以方便地反转列表或字符串。

numbers = [1, 2, 3, 4, 5]
reversed_numbers = numbers[::-1]  # [5, 4, 3, 2, 1]

这种方法非常简洁，而且非常高效。

2.2 Python 切片使用场景

Python 切片适用于很多常见的场景，以下是几个常见的使用场景：

1. 提取列表的子序列

切片最常见的用途之一就是从列表中提取子序列。例如，从一个大的数据集或列表中获取前几项，或者从中间获取部分数据：

data = [10, 20, 30, 40, 50, 60, 70]
subset = data[2:5]  # [30, 40, 50]

2. 批量修改列表内容

你可以使用切片修改列表中的多个元素。例如，你可以一次性替换一部分元素，而不需要逐个赋值：

colors = ["red", "green", "blue", "yellow"]
colors[1:3] = ["purple", "orange"]
print(colors)  # ['red', 'purple', 'orange', 'yellow']

3. 翻转序列

切片非常适合用来翻转序列（例如，列表、字符串等）。通过设置步长为 -1，你可以简单地翻转序列：

word = "Python"
reversed_word = word[::-1]
print(reversed_word)  # "nohtyP"

4. 获取特定位置的元素

切片可以用来根据步长获取序列中的特定元素，尤其是你只关心间隔的元素时。例如，提取奇数或偶数位置的元素：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
odd_numbers = numbers[::2]  # [1, 3, 5, 7, 9]
even_numbers = numbers[1::2]  # [2, 4, 6, 8]

5. 提取字符串中的子串

切片对于提取字符串中的子串非常有用。例如，提取字符串的前半部分，或获取最后几个字符：

text = "Hello, world!"
substring = text[:5]  # "Hello"

2.3 Python 切片使用注意事项以及常见的 Bug

切片是一个强大的工具，但也有一些需要注意的事项和潜在的 Bug。

1. 起始和结束索引不包括结束位置

切片的结束位置是排除的。例如，numbers[2:5] 会包含索引为 2、3、4 的元素，但不会包含索引为 5 的元素：

numbers = [1, 2, 3, 4, 5]
subset = numbers[2:5]  # [3, 4, 5]

如果你意外地认为结束位置会被包含在切片内，可能会导致一些困惑或错误。

2. 步长为零时的错误

步长不能为零，因为这会导致无限循环或除零错误。确保步长大于零或小于零，而不是零：

numbers = [1, 2, 3, 4, 5]

# 步长为零会引发错误
# subset = numbers[::0]  # ValueError: slice step cannot be zero

3. 负步长时的起始和结束位置需要正确理解

当使用负步长时，start 必须大于 end，否则你将得到一个空序列。例如：

numbers = [10, 20, 30, 40, 50]
subset = numbers[4:0:-1]  # [50, 40, 30, 20]

如果 start 小于 end，在负步长的情况下将无法得到任何结果：

# 错误示范
subset = numbers[0:4:-1]  # []

4. 不要修改切片后的对象

切片返回的是原序列的一个副本，修改这个副本不会影响原序列。但是，如果你修改切片后的对象（如列表），可能会影响原序列，尤其在进行深拷贝或修改嵌套对象时：

numbers = [1, 2, 3, 4, 5]

# 这不会影响原始列表
subset = numbers[:3]
subset[0] = 10
print(numbers)  # [1, 2, 3, 4, 5]

# 但是，如果修改了切片中的对象（嵌套对象），则会影响原始列表

5. 超出范围的索引

切片操作不会抛出“索引超出范围”的错误。即使切片的 start 或 end 超出范围，Python 也会自动调整范围而不抛出异常。例如：

numbers = [1, 2, 3, 4, 5]
subset = numbers[10:15]  # 返回空列表 []

在这种情况下，切片会返回一个空列表，而不是引发异常。

总结

  • Python 切片是一个强大的工具，用于提取、修改和处理序列数据。
  • 切片非常适用于提取子序列、翻转序列、获取特定位置的元素等常见任务。
  • 使用切片时要注意起始和结束索引不包含结束位置，以及步长为零等潜在的错误。
  • 切片为你提供了非常灵活的方式来高效处理序列数据，是 Python 中处理序列数据的重要工具。

理解和掌握切片的用法，可以大大提升你在 Python 编程中的效率和代码简洁度。

3. Python 切片实战

背景：

假设我们正在开发一个推荐系统，系统根据用户购买历史向他们推荐商品。我们有一个包含商品信息的列表，每个商品都有一个名称、价格和类别。用户会根据类别、价格区间等筛选商品，系统需要根据这些筛选条件快速返回符合条件的商品列表。

为了提高代码的简洁性和效率，我们决定使用 Python 的切片功能来处理这些数据的提取、筛选和排序等操作。切片将帮助我们快速获取商品列表中的子集，同时避免了复杂的循环和条件判断。

1. 为什么选用 Python 切片

选择使用 Python 切片主要是因为以下几个原因：

  1. 简洁高效：切片能够以简洁的语法快速从列表或字符串中提取数据，避免了手动编写循环的冗长代码。

  2. 性能优势：切片是由 Python 内部优化过的操作，比逐个元素提取数据要高效得多。

  3. 灵活性：切片不仅支持起始和结束位置，还支持步长（可以提取每隔几个元素的数据），使得数据筛选非常灵活。

  4. 适应不同数据结构：切片不仅适用于列表，也适用于元组、字符串等其他序列类型，非常通用。

2. 涉及的 Python 切片知识点

在这个实战中，我们将使用到以下几个切片的知识点：

  1. 基本切片语法：

    sequence[start:end:step]

  2. 负索引： 使用负索引可以从序列的末尾开始访问元素。

  3. 步长（Step）： 步长参数允许你提取序列中每隔几个元素的子序列。

  4. 切片返回的是新对象： 切片操作不会改变原始序列，而是返回一个新的子序列。

  5. 列表的切片修改： 切片可以用来修改列表中的一部分元素。

  6. 切片与排序结合： 使用切片配合排序操作可以快速筛选和获取特定的子序列。

3. 如何使用 Python 切片的思路和技巧

1. 使用切片提取子列表

在我们的推荐系统中，我们需要从商品列表中根据不同的条件提取部分商品。例如，根据商品价格筛选出低于一定金额的商品：

# 假设商品列表如下
products = [
    {"name": "Product 1", "price": 10, "category": "A"},
    {"name": "Product 2", "price": 15, "category": "B"},
    {"name": "Product 3", "price": 5, "category": "A"},
    {"name": "Product 4", "price": 30, "category": "C"},
    {"name": "Product 5", "price": 25, "category": "B"}
]

# 使用切片获取前 3 个商品
top_products = products[:3]
print(top_products)

2. 使用负索引和步长进行数据筛选

假设我们想筛选出列表中倒数第 3 到第 5 的商品，并且只取每隔一个商品（步长为 2）。我们可以使用负索引和步长结合：

# 获取倒数第 3 到倒数第 5 个商品，每隔一个商品
subset = products[-5:-2:2]
print(subset)

3. 切片与排序结合

为了按照价格对商品进行排序，并且只获取最便宜的前 3 个商品，我们可以结合排序和切片操作：

# 按价格排序商品列表
sorted_products = sorted(products, key=lambda x: x["price"])

# 获取最便宜的 3 个商品
cheapest_products = sorted_products[:3]
print(cheapest_products)

4. 使用切片批量更新数据

如果我们需要更新商品列表中的多个商品（例如，打折后的商品价格），我们可以通过切片来一次性替换多个商品的价格：

# 假设我们给价格大于 20 的商品打折 10%
for product in products:
    if product["price"] > 20:
        product["price"] = product["price"] * 0.9

print(products)

5. 切片反转序列

假设我们想反向查看商品列表，可以使用切片来翻转列表：

# 翻转商品列表
reversed_products = products[::-1]
print(reversed_products)

4. 使用 Python 切片的注意事项

1. 起始和结束索引不包括结束位置

切片操作时，end 索引是不包括的。如果你想获取从索引 2 到索引 5 的元素，应该使用 numbers[2:6]，而不是 numbers[2:5]。

numbers = [0, 1, 2, 3, 4, 5, 6, 7]
subset = numbers[2:5]  # [2, 3, 4]

2. 步长为零时会引发错误

当步长为零时，切片会抛出 ValueError，因为这会导致无限循环。因此，确保步长不为零。

# 步长不能为零
# subset = numbers[::0]  # ValueError: slice step cannot be zero

3. 步长的负值

步长为负值时，切片会反转序列的顺序，start 必须大于 end，否则会得到空序列。例如，numbers[5:2:-1] 会返回 [5, 4, 3]，但 numbers[2:5:-1] 会返回空列表。

numbers = [1, 2, 3, 4, 5]
subset = numbers[4:1:-1]  # [5, 4, 3]
empty_subset = numbers[1:4:-1]  # []

4. 切片不会修改原序列

切片返回的是原序列的副本，而不是原序列本身。因此，切片操作不会修改原序列的内容。

numbers = [1, 2, 3, 4, 5]
subset = numbers[1:4]
subset[0] = 10
print(numbers)  # [1, 2, 3, 4, 5]  原序列没有被修改

5. 切片时的性能问题

虽然切片在大多数情况下非常高效，但在处理非常大的数据集时，尤其是使用深度复制（例如深拷贝的切片）时，性能可能会受到影响。如果处理非常大的数据集，考虑优化数据结构或分批处理数据。

5. 完整使用过程

场景：

我们正在为一个电商平台设计一个商品管理系统。该系统支持对商品进行筛选、排序、批量修改等操作。我们将使用 Python 切片来提取商品数据并进行批量处理。

步骤：

  1. 商品数据初始化：我们创建一个包含商品信息的列表，每个商品有 name、price 和 category。
  2. 数据筛选：我们使用切片和步长来筛选符合条件的商品。
  3. 排序操作：我们按价格对商品进行排序，并提取最便宜的前 5 个商品。
  4. 批量更新价格：我们通过切片批量修改商品价格。
  5. 反转商品列表：我们使用切片反转商品列表，以便展示最后的商品。
import copy

# 商品列表
products = [
    {"name": "Product 1", "price": 10, "category": "A"},
    {"name": "Product 2", "price": 15, "category": "B"},
    {"name": "Product 3", "price": 5, "category": "A"},
    {"name": "Product 4", "price": 30, "category": "C"},
    {"name": "Product 5", "price": 25, "category": "B"}
]

# 使用切片提取前 3 个商品
top_products = products[:3]
print("Top 3 Products:", top_products)

# 按价格排序并提取最便宜的前 3 个商品
sorted_products = sorted(products, key=lambda x: x["price"])
cheapest_products = sorted_products[:3]
print("Cheapest Products:", cheapest_products)

# 使用切片修改价格
for product in products[:3]:
    product["price"] = product["price"] * 0.9  # 打九折
print("Updated Products:", products)

# 翻转商品列表
reversed_products = products[::-1]
print("Reversed Products:", reversed_products)

输出：

Top 3 Products: [{'name': 'Product 1', 'price': 10, 'category': 'A'}, {'name': 'Product 2', 'price': 15, 'category': 'B'}, {'name': 'Product 3', 'price': 5, 'category': 'A'}]
Cheapest Products: [{'name': 'Product 3', 'price': 5, 'category': 'A'}, {'name': 'Product 1', 'price': 10, 'category': 'A'}, {'name': 'Product 2', 'price': 15, 'category': 'B'}]
Updated Products: [{'name': 'Product 1', 'price': 9.0, 'category': 'A'}, {'name': 'Product 2', 'price': 13.5, 'category': 'B'}, {'name': 'Product 3', 'price': 4.5, 'category': 'A'}, {'name': 'Product 4', 'price': 30, 'category': 'C'}, {'name': 'Product 5', 'price': 25, 'category': 'B'}]
Reversed Products: [{'name': 'Product 5', 'price': 25, 'category': 'B'}, {'name': 'Product 4', 'price': 30, 'category': 'C'}, {'name': 'Product 3', 'price': 4.5, 'category': 'A'}, {'name': 'Product 2', 'price': 13.5, 'category': 'B'}, {'name': 'Product 1', 'price': 9.0, 'category': 'A'}]

总结

  • Python 切片在处理序列数据时非常高效且简洁。
  • 切片支持负索引、步长、修改序列部分内容等功能，灵活性很高。
  • 切片适用于各种数据提取、修改和批量操作的场景，尤其是当数据量较大时，切片能显著简化代码。
  • 使用切片时，要注意起始和结束索引、步长为零等潜在的问题，确保操作的正确性。

4. Python切片 答疑解惑

4.1. [:]代表什么？

在Python中，[:]表示对列表进行切片操作。它表示从列表的开始到结束的所有元素的副本。这个切片操作创建了原列表的一个新副本，而不是直接引用原列表。具体来说，x[:]会生成一个新列表，其中包含原列表x中的所有元素。

示例：

假设有一个列表 x = [1, 2, 3, 4, 5]，通过切片操作 x[:]，你会得到原列表的一个副本。

x = [1, 2, 3, 4, 5]
y = x[:]  # y 是 x 的副本

print(x)  # 输出: [1, 2, 3, 4, 5]
print(y)  # 输出: [1, 2, 3, 4, 5]

# 修改 y 不会影响 x
y[0] = 10
print(x)  # 输出: [1, 2, 3, 4, 5]
print(y)  # 输出: [10, 2, 3, 4, 5]

为什么要使用 x[:]？

当你想要避免在修改列表时影响到原列表的内容时，可以使用切片操作。特别是在遍历列表的副本时，修改原始列表（例如删除元素或添加元素）不会影响到循环的迭代。

例如，在你的例子中，x[:] 让你能够遍历列表的副本，同时删除原列表的元素而不会干扰正在执行的循环。

4.2. 切边为什么会创建一个新的数组

在 Python 中，切片操作会创建一个新的列表，原因与 Python 序列的内存管理和不可变数据结构的特性有关。以下是详细的解释：

1. 切片操作会返回一个新的对象

当你使用切片操作时，Python 会创建一个新的对象（如列表、元组或字符串）。这一行为的核心在于，Python 切片操作会复制数据的部分内容，而不是直接修改原有序列，因此它会返回一个新的对象。例如：

numbers = [1, 2, 3, 4, 5]
sliced_numbers = numbers[1:4]  # 切片操作
print(sliced_numbers)  # 输出 [2, 3, 4]
print(numbers)  # 输出 [1, 2, 3, 4, 5]

为什么会这样？

  • 切片操作是通过复制原始序列中的一部分来创建新的列表。这是为了避免对原始序列造成影响，保证不修改原始数据。
  • 这使得切片结果可以独立于原始对象进行修改。

2. 列表是可变对象

Python 中的列表是可变的（mutable），这意味着你可以修改列表中的元素。如果切片只是直接引用原始列表的一部分，而不是复制数据，那么修改切片时，原始列表也会被修改，导致不期望的副作用。为了避免这种情况，Python 会在进行切片时创建一个新列表，这样修改切片就不会影响原始列表。

numbers = [1, 2, 3, 4, 5]
sliced_numbers = numbers[1:4]  # 创建了一个新列表
sliced_numbers[0] = 10  # 修改切片
print(sliced_numbers)  # 输出 [10, 3, 4]
print(numbers)  # 输出 [1, 2, 3, 4, 5]

这里的 sliced_numbers 是 numbers 列表的一个副本，修改 sliced_numbers 中的元素不会影响 numbers 中的元素。

3. 切片不改变原序列

切片操作的目的是从原始序列中获取一个子序列，而不影响原序列的内容。如果切片操作只是引用原始对象的部分内容（即共享内存），那么修改切片可能会导致原始数据被改变。为了避免这种情况，Python 会在进行切片时生成新的列表对象，而不是直接修改原始列表。

4. 内存管理和性能考虑

Python 为了确保数据不被无意修改，采取了这种做法。在内存管理上，切片会复制数据，但这并不意味着深拷贝。对于不可变类型（如元组、字符串等），切片只是简单地引用相同的数据，而对于可变类型（如列表、字典等），切片操作会创建一个新的对象，复制原始对象的数据。

总结

切片操作创建一个新的列表，是为了确保原始序列不被修改，避免副作用。对于可变对象，切片操作通过复制原始数据的部分内容来创建新的对象，而不会直接引用原始对象的部分内容。这样，修改新列表（切片）不会影响到原始数据。

4.3. [::2] 和 [:2] 区别

[::2] 和 [:2] 都是Python中的切片操作，但它们的含义和作用不同。

1. [::2] 的含义：

这是一个切片操作，其中的 ::2 表示从列表的开始到结束，以步长为 2 进行切片。

  • : 之前为空，表示从列表的第一个元素开始。
  • : 之后为空，表示切片到列表的最后一个元素。
  • 2 表示步长为 2，也就是说，它会每隔一个元素取一个元素。
示例：
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result = x[::2]
print(result)  # 输出: [0, 2, 4, 6, 8]

在这个例子中，x[::2] 会从列表 x 中取出每隔一个元素的元素（即步长为 2），结果是 [0, 2, 4, 6, 8]。

2. [:2] 的含义：

这个切片操作表示从列表的第一个元素开始，到索引 2（不包括索引 2）之间的所有元素。

  • : 之前为空，表示从列表的第一个元素开始。
  • 2 表示切片的结束位置，但不包括索引为 2 的元素。
示例：
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result = x[:2]
print(result)  # 输出: [0, 1]

在这个例子中，x[:2] 会取出列表 x 中索引为 0 和 1 的元素（即，前两个元素）。结果是 [0, 1]。

总结：

  • [::2] 会从列表的开始到结束，按照步长为 2 取出元素，返回每隔一个元素的结果。
  • [:2] 只会取列表的前两个元素（索引 0 和 1）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI Agent首席体验官

您的打赏是我继续创作的动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值