在Python中进行切片时，第三个参数是step。正如其他人提到的，请参阅长片来获得一个很好的概述。

有了这些知识，[::3]只是意味着你没有为你的片指定任何开始或结束索引。因为你已经指定了一个步骤，3，这将从第一个索引开始，每第三个something项。例如:

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

Python序列片地址可以被写成a[start:end:step], start、stop或end中的任何一个都可以被删除。a[::3]是该序列的每三个元素。

它的意思是“第一个参数什么都没有，第二个参数什么都没有，跳转到3”。它对序列中的每三项进行切片。 长片是你想要的。Python 2.3新增功能

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

例子:

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

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

解释

s[i:j:k]是，根据文档，“s从i到j的切片，步骤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]

让我们从s中取每一个3^{理查德·道金斯}项:

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

让我们从s[2:]中取每一个3^{理查德·道金斯}项:

>>> 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]中取每一个3^{理查德·道金斯}项:

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

让我们从s[:10]中取每一个3^{理查德·道金斯}项:

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

Python使用::分隔结束、开始和步骤值。

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

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将在:省略对象做什么?中进一步介绍

博士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]])

我们刚刚选择了所有需要的元素!：）

巩固第一步(开始和结束)和第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]])

完成了!

我错过了还是没有人提到用[::-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)

记住，基础是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