标签: python-itertools

在Python中,如果n是k(IOW,)的倍数,很容易将n长列表分解为k -size块.这是我最喜欢的方法(直接来自文档):n % k == 0

>>> k = 3
>>> n = 5 * k
>>> x = range(k * 5)
>>> zip(*[iter(x)] * k)
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14)]

(诀窍是[iter(x)] * k产生一个对同一个迭代器的k个引用列表,如返回的那样.然后通过调用迭代器的每个k副本一次来生成每个块.之前是必要的因为期望接收它的参数为"单独的" "迭代器,而不是它们的列表."iter(x)zip*[iter(x)] * kzip

我用这个习语看到的主要缺点是,当n不是k的倍数(IOW,n % k > 0 …

早些时候,我试图回答一个问题,我希望尽可能有效地迭代列表切片.

for x in lst[idx1:]:

是不理想的,因为它创建一个副本(通常,这是O(n)).我的下一个想法是使用itertools.islice.但是,如果你看一下文档,它似乎islice会调用,next直到它找到它正在寻找的索引,它将开始产生值.这也是O(n).如果传递给的对象islice是a list或a tuple似乎可以在这里进行优化- 看起来你可以直接迭代"切片"(在C中)而不实际制作副本.我很好奇这个优化是否在源头,但我没有找到任何东西.我对C和python源代码树并不是很熟悉,所以我完全有可能错过了它.

我的问题是:

有没有办法迭代列表"切片"而不制作列表切片的副本,而不烧掉一堆不需要的元素(在优化的C实现中)？

我很清楚我可以为此编写自己的生成器(非常天真,不考虑许多参数应该是可选的,等等):

def myslice(obj,start,stop,stride):
    for i in xrange(start,stop,stride):
        yield obj[i]

但这肯定不会超过优化的C实现.

如果你想知道为什么我需要这个直接在一个切片上循环,请考虑以下两者之间的区别:

takewhile(lambda x: x == 5, lst[idx:])  #copy's the tail of the list unnecessarily

和

takewhile(lambda x: x == 5, islice(lst,idx,None)) #inspects the head of the list unnecessarily 

最后:

takewhile(lambda x: x == 5, magic_slice(lst,idx,None)) #How to create magic_slice???

Python的succint语法通过其电池允许详细的代码行以可读的一行表示.请考虑以下示例

====================================================|
for a in range(3):                                  |
    for b in range(3):                              |
        for c in range(3):                          |
            print (a,b,c),                          |
-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -|
for e in product(range(3), repeat=3):               |
    print e,                                        |
====================================================|
for a in range(3):                                  |
    for b in range(a , 3):                          |
        for c in range(b , 3):                      |
            print (a,b,c),                          |
-  -  -  -  -  -  -  -  -  - …

考虑一些给定的序列和窗口长度,比如说 list

a = [13 * i + 1 for i in range(24)]

(以便

In [61]: a
Out[61]: 
[1,
 14,
 27,
 40,
 ...,
 287,
 300]

)

和窗口长度3.

我想把这个序列的滑动窗口总和,但是周期性地; 即,计算长度-24 list:

[sum([1, 14, 27]),
 sum([14, 27, 40]),
 ...,
 sum([287, 300, 1]),
 sum([300, 1, 14])]

我能想到的最好的,使用collections.deque和愚蠢的Lambda技巧,是

d = collections.deque(range(24))
d.rotate(1)
map(lambda _: d.rotate(-1) or sum(a[i] for i in list(d)[: 3]), range(24))

有什么不那么可怕的东西吗？

我有一个这样的df:

Count
1
0
1
1
0
0
1
1
1
0

我想返回1一个新列,如果有两个或多个连续出现1在Count和0如果没有.因此,在新列中,每行将1根据列中满足的此条件获得Count.那么我想要的输出是:

Count  New_Value
1      0 
0      0
1      1
1      1
0      0
0      0
1      1
1      1 
1      1
0      0

我想我可能需要使用,itertools但我一直在阅读它,并没有遇到我需要的东西.我希望能够使用此方法计算任意数量的连续出现次数,而不仅仅是2次.例如,有时我需要连续计算10次,我在这里只使用2.

我在python中有一些元组.例如,容量限制为5.我想将子元素拆分为由元素总和限制的子元素:

例如:

input: (3, 1, 4, 2, 2, 1, 1, 2) and capacity = 5
output: (3, 1) (4) (2, 2, 1) (1, 2) #each subtuple is less than 5, order safe.

我正在寻找这个任务的一个很好的表达解决方案,最好是在编程的功能风格(itertools.dropwhile例如使用或类似的东西)

在这个问题的评论中讨论的上下文中提到,虽然连接一串字符串只是简单地''.join([str1, str2, ...])连接,但连接一系列列表就像是list(itertools.chain(lst1, lst2, ...)),尽管你也可以使用列表理解[x for y in [lst1, lst2, ...] for x in y].让我感到惊讶的是,第一种方法始终比第二种方法更快:

import random
import itertools

random.seed(100)
lsts = [[1] * random.randint(100, 1000) for i in range(1000)]

%timeit [x for y in lsts for x in y]
# 39.3 ms ± 436 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit list(itertools.chain.from_iterable(lsts))
# 30.6 ms ± 866 µs per loop (mean ± std. dev. …

我知道我可以使用itertools.permutation来获得大小为r的所有排列.但是,对于itertools.permutation([1,2,3,4],3)它将返回(1,2,3)以及(1,3,2).

1. 我想过滤那些重复(即获得组合)

2. 是否有一种简单的方法来获得所有排列(所有长度)？

3. 如何将itertools.permutation()结果转换为常规列表？

我是Python的新手.我想从itertools导入izip_longest.但我无法在Python解释器的首选项中找到导入"itertools".我使用的是Python 3.5.2.它给我以下错误 -

from itertools import izip_longest
ImportError: cannot import name 'izip_longest'

请让我知道什么是正确的行动方案.我也尝试过Python 2.7并且遇到了同样的问题.我是否需要使用较低版本的Python.

我正在使用NumPy创建几个多维数组,并根据索引对它们进行初始化,如下所示:

pos_data = []
# Some typical values
d = 2  # Could also be 3
vol_ext = (1000, 500)  # If d = 3, this will have another entry
ratio = [5.0, 8.0]  # Again, if d = 3, it will have another entry

for i in range(d):
    pos_data.append(np.zeros(vol_ext))

if d == 2:
    for y in range(vol_ext[1]):
        for x in range(vol_ext[0]):
            pos_data[0][x, y] = (x - 1.0) * ratio[0]
            pos_data[1][x, y] = (y - 1.0) * ratio[1]
elif d …