关于语法：订阅序列时python中的::(双冒号)是什么？


What is :: (double colon) in Python when subscripting sequences?

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

相关讨论

它的意思是"第一个论点没什么，第二个论点没什么，跳三步"。它将序列的每三个项目切片。扩展片就是你想要的。python 2.3中的新功能

相关讨论

python序列切片地址可以写为[start:end:step]并且可以删除start、stop或end中的任何一个。a[::3]是序列的每三个元素。

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

例子：

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

语法是：

1
seq[start:end:step]

所以你可以这样做：

1
2
>>> range(100)[5:18:2]
[5, 7, 9, 11, 13, 15, 17]
相关讨论

解释

根据文件，s[i:j:k]是"从i到j的S切片，步骤k"。当缺少i和j时，假定整个序列，因此s[::k]表示"每个k项"。

实例

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

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

让我们从s中取第三项：

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

让我们从s[2:]中取第三项：

1
2
3
4
>>> 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]

让我们从s[5:12]中取第三项：

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

让我们从s[:10]中取第三项：

1
2
3
4
>>> s[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> s[:10:3]
[0, 3, 6, 9]
相关讨论

DR

这个可视化示例将向您展示如何以一种非常有趣的方式(我保证)整齐地选择numpy矩阵(二维数组)中的元素。下面的步骤2说明了"双冒号"::的用法。

(注意：这是一个特定于numpy数组的示例，旨在说明"双冒号"::用于在多个轴中跳跃元素的用例。这个例子不包括本地的python数据结构，比如List。

一个具体的例子来统治他们…

假设我们有一个像这样的麻木矩阵：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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]])

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

enter image description here

"但是怎么办？？？"…继续阅读！(我们可以用两步的方法做到这一点)

步骤1-获取子集

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

enter image description here

在代码中：

1
2
3
4
5
6
7
8
9
10
11
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-选择元素(使用"跳转步骤"参数)

我们现在可以在行方向和列方向上指定"跳转步骤"(以"跳转"方式选择元素)，如下所示：

enter image description here

在代码中(注意双冒号)：

1
2
3
4
5
6
7
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组合成一个合并的步骤-为了紧凑：

1
2
3
4
5
6
7
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]])

完成！

相关讨论

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

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

1
2
>>> '123123123'[::3]
'111'

第三个参数是步骤。所以[：：3]将返回列表/字符串的每三个元素。

python使用：：分隔结束、开始和步骤值。

相关讨论

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

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
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

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

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

这在numpy中被显著地用于在任何方向上切片多维数组。

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