354

我知道我可以使用类似的东西string[3:4]在 Python 中获取子字符串，但是 3 中的含义是somesequence[::3]什么？

4

11 回答 11

332

它的意思是“第一个参数没有，第二个参数没有，跳三”。它对序列的每第三个项目进行切片。 扩展切片是您想要的。Python 2.3 中的新功能

于 2010-08-10T20:24:20.663 回答
214

Python 序列切片地址可以写成，a[start:end:step]并且可以删除任何开始、停止或结束。 a[::3]是序列的每三个元素。

于 2010-08-10T20:24:08.883 回答
112

seq[::n]是n整个序列中每一项的序列。

例子：

>>> range(10)[::2]
[0, 2, 4, 6, 8]

语法是：

seq[start:end:step]

所以你可以这样做（在 Python 2 中）：

>>> range(100)[5:18:2]
[5, 7, 9, 11, 13, 15, 17]
于 2010-08-10T20:24:22.570 回答
74

解释

s[i:j:k]是，根据文档，“从 i 到 j 的 s 切片，步骤为 k”。当i和j不存在时，假定整个序列，因此s[::k]意味着“每第 k 个项目”。

例子

首先，让我们初始化一个列表：

>>> s = range(20)
>>> s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

让我们从以下每 3 个项目中获取s：

>>> s[::3]
[0, 3, 6, 9, 12, 15, 18]

让我们从以下每 3 个项目中获取s[2:]：

>>> s[2:]
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> s[2::3]
[2, 5, 8, 11, 14, 17]

让我们从以下每 3 个项目中获取s[5:12]：

>>> s[5:12]
[5, 6, 7, 8, 9, 10, 11]
>>> s[5:12:3]
[5, 8, 11]

让我们从以下每 3 个项目中获取s[:10]：

>>> s[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> s[:10:3]
[0, 3, 6, 9]
于 2010-08-10T20:33:02.683 回答
39

TL;博士

这个视觉示例将向您展示如何以一种非常有趣的方式（我保证）巧妙地选择 NumPy 矩阵（二维数组）中的元素。下面的第 2 步说明了有问题的“双冒号”的用法::。

（注意：这是一个特定于 NumPy 数组的示例，旨在说明“双冒号”::用于在多个轴上跳转元素的用例。此示例不包括原生 Python 数据结构，例如List）。

一个统治他们的具体例子......

假设我们有一个如下所示的 NumPy 矩阵：

In [1]: import numpy as np

In [2]: X = np.arange(100).reshape(10,10)

In [3]: X
Out[3]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

假设出于某种原因，您的老板希望您选择以下元素：

在此处输入图像描述

“但是如何？？？”...继续阅读！（我们可以分两步进行）

第 1 步 - 获取子集

在行方向和列方向上指定“开始索引”和“结束索引”。

在此处输入图像描述

在代码中：

In [5]: X2 = X[2:9,3:8]

In [6]: X2
Out[6]:
array([[23, 24, 25, 26, 27],
       [33, 34, 35, 36, 37],
       [43, 44, 45, 46, 47],
       [53, 54, 55, 56, 57],
       [63, 64, 65, 66, 67],
       [73, 74, 75, 76, 77],
       [83, 84, 85, 86, 87]])

请注意，现在我们刚刚使用简单的开始和结束索引技术获得了我们的子集。接下来，如何做到“跳跃”……（继续阅读！）

第 2 步 - 选择元素（使用“跳转步骤”参数）

我们现在可以在行方向和列方向上指定“跳跃步骤”（以“跳跃”方式选择元素），如下所示：

在此处输入图像描述

在代码中（注意双冒号）：

In [7]: X3 = X2[::3, ::2]

In [8]: X3
Out[8]:
array([[23, 25, 27],
       [53, 55, 57],
       [83, 85, 87]])

我们刚刚根据需要选择了所有元素！:)

 合并第 1 步（开始和结束）和第 2 步（“跳跃”）

现在我们知道了这个概念，我们可以轻松地将第 1 步和第 2 步合并为一个统一的步骤 - 为了紧凑：

In [9]: X4 = X[2:9,3:8][::3,::2]

    In [10]: X4
    Out[10]:
    array([[23, 25, 27],
           [53, 55, 57],
           [83, 85, 87]])

完毕！

于 2017-05-18T14:44:57.253 回答
21

在 Python 中切片时，第三个参数是步骤。正如其他人提到的，请参阅扩展切片以获得很好的概述。

有了这些知识，[::3]就意味着您没有为切片指定任何开始或结束索引。由于您已经指定了一个步骤，这将需要从第一个索引开始的3每第三个条目。something例如：

>>> '123123123'[::3]
'111'
于 2010-08-10T20:24:08.030 回答
7

你也可以在你自己的自定义类中使用这个符号来让它做你想做的任何事情

class C(object):
    def __getitem__(self, k):
        return k

# Single argument is passed directly.
assert C()[0] == 0

# Multiple indices generate a tuple.
assert C()[0, 1] == (0, 1)

# Slice notation generates a slice object.
assert C()[1:2:3] == slice(1, 2, 3)

# If you omit any part of the slice notation, it becomes None.
assert C()[:] == slice(None, None, None)
assert C()[::] == slice(None, None, None)
assert C()[1::] == slice(1, None, None)
assert C()[:2:] == slice(None, 2, None)
assert C()[::3] == slice(None, None, 3)

# Tuple with a slice object:
assert C()[:, 1] == (slice(None, None, None), 1)

# Ellipsis class object.
assert C()[...] == Ellipsis

然后我们可以打开切片对象：

s = slice(1, 2, 3)
assert s.start == 1
assert s.stop == 2
assert s.step == 3

这在 Numpy 中特别用于在任何方向上对多维数组进行切片。

当然，任何健全的 API 都应该使用::3通常的“每 3”语义。

相关Ellipsis内容在以下位置进一步介绍：Ellipsis 对象做什么？

于 2015-10-12T17:20:28.850 回答
6

第三个参数是步长。因此 [::3] 将返回列表/字符串的每个第三个元素。

于 2010-08-10T20:24:28.477 回答
4

Python 使用 :: 分隔 End、Start 和 Step 值。

于 2012-03-28T21:46:09.180 回答
3

我错过了还是没有人提到在[::-1]这里倒车？

# Operating System List
systems = ['Windows', 'macOS', 'Linux']
print('Original List:', systems)

# Reversing a list  
#Syntax: reversed_list = systems[start:stop:step] 
reversed_list = systems[::-1]

# updated list
print('Updated List:', reversed_list)

来源： https ://www.programiz.com/python-programming/methods/list/reverse

于 2020-08-31T15:53:06.320 回答
1

请记住，基础是什么a[start:end:step]意思。从那里您a[1::2]可以获得每个奇数索引，a[::2]每个偶数，a[2::2]从 2 开始的a[2:4:2]每个偶数，从 2 开始到 4 结束的每个偶数。灵感来自https://stackoverflow.com/a/3453102/1601580

于 2021-07-22T21:39:48.077 回答