将列表环绕为切片操作

发布于 2024-10-09 06:50:00 字数 264 浏览 4 评论 0原文

考虑下面的简单 python 代码

>>> L = range(3)
>>> L
[0, 1, 2]

我们可以按如下方式对该数组进行切片:

>>> L[1:3]
[1, 2]

向左移动来环绕上面的数组?

[1, 2, 0]

有没有办法通过简单地使用切片操作

Consider the following simple python code

>>> L = range(3)
>>> L
[0, 1, 2]

We can take slices of this array as follows:

>>> L[1:3]
[1, 2]

Is there any way to wrap around the above array by shifting to the left

[1, 2, 0]

by simply using slice operations?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

甲如呢乙后呢 2024-10-16 06:50:00

向左旋转 n 个元素(或向右旋转负 n):

L = L[n:] + L[:n]

请注意 collections.deque 支持轮换 。使用它而不是列表可能会更好。

Rotate left n elements (or right for negative n):

L = L[n:] + L[:n]

Note that collections.deque has support for rotations. It might be better to use that instead of lists.

陌伤ぢ 2024-10-16 06:50:00

左:

L[:1], L[1:] = L[-1:], L[:-1]

右:

L[-1:], L[:-1] = L[:1], L[1:]

Left:

L[:1], L[1:] = L[-1:], L[:-1]

Right:

L[-1:], L[:-1] = L[:1], L[1:]
森林散布 2024-10-16 06:50:00

在我看来,没有办法,除非您同意如上所示剪切和连接列表。
要进行您所描述的包装,您需要更改起始索引和结束索引。

  • 正的起始指数会削减一些初始项目。
  • 负的起始索引会给你一些尾部项目,再次削减初始项目。
  • 积极的整理指数消除了一些尾部项目。
  • 负的整理指数会给你一些初始项目,再次削减尾部项目。

这些的组合都不能提供尾项后面跟着初始项的包装点。所以无法创建整个事物。

存在许多解决方法。如果您需要顺序访问(例如在循环中),请参阅上面的答案,另请参阅 itertools.islice.chain 以了解无复制顺序方法。

To my mind, there's no way, unless you agree to cut and concatenate lists as shown above.
To make the wrapping you describe you need to alter both starting and finishing index.

  • A positive starting index cuts away some of initial items.
  • A negative starting index gives you some of the tail items, cutting initial items again.
  • A positive finishing index cuts away some of the tail items.
  • A negative finishing index gives you some of the initial items, cutting tail items again.

No combination of these can provide the wrapping point where tail items are followed by initial items. So the entire thing can't be created.

Numerous workarounds exist. See answers above, see also itertools.islice and .chain for a no-copy sequential approach if sequential access is what you need (e.g. in a loop).

情魔剑神 2024-10-16 06:50:00

如果您不太执着于精确的切片语法,则可以编写一个函数来生成所需的输出(包括包装行为)。

例如,如下所示:

def wrapping_slice(lst, *args):
    return [lst[i%len(lst)] for i in range(*args)]

示例输出:

>>> L = range(3)
>>> wrapping_slice(L, 1, 4)
[1, 2, 0]
>>> wrapping_slice(L, -1, 4)
[2, 0, 1, 2, 0]
>>> wrapping_slice(L, -1, 4, 2)
[2, 1, 0]

警告:您不能在切片分配的左侧使用此内容

If you are not overly attached to the exact slicing syntax, you can write a function that produces the desired output including the wrapping behavior.

E.g., like this:

def wrapping_slice(lst, *args):
    return [lst[i%len(lst)] for i in range(*args)]

Example output:

>>> L = range(3)
>>> wrapping_slice(L, 1, 4)
[1, 2, 0]
>>> wrapping_slice(L, -1, 4)
[2, 0, 1, 2, 0]
>>> wrapping_slice(L, -1, 4, 2)
[2, 1, 0]

Caveat: You can't use this on the left-hand side of a slice assignment.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文