标签: python-itertools

首先，为我对问题的描述不佳而道歉。我找不到更好的了。

我发现将列表应用于 itertools.groupby 结果会破坏结果。见代码：

import itertools
import operator

log = '''\
hello world
hello there
hi guys
hi girls'''.split('\n')

data = [line.split() for line in log]

grouped = list(itertools.groupby(data, operator.itemgetter(0)))

for key, group in grouped:
    print key, group, list(group)

print '-'*80

grouped = itertools.groupby(data, operator.itemgetter(0))

for key, group in grouped:
    print key, group, list(group)

结果是：

hello <itertools._grouper object at 0x01A86050> []
hi <itertools._grouper object at 0x01A86070> [['hi', 'girls']]
--------------------------------------------------------------------------------
<itertools.groupby object at 0x01A824E0>
hello <itertools._grouper object at 0x01A860B0> [['hello', 'world'], …

我有一个数据集，其结构是：Date Profit

数据集的一个示例是：

   Date     Profit
2013-06-21   14
2013-06-22   19
2013-06-23   11
2013-06-24   13
2013-06-25   6
2013-06-26   22
2013-06-27   22
2013-06-28   3
2013-06-29   5
2013-06-30   10
2013-07-01   17
2013-07-02   14
2013-07-03   9
2013-07-04   7

Sample input 是 ：

data = [('2013-06-21',14),
    ('2013-06-22',19),
    ('2013-06-23',11),
    ('2013-06-24',13),
    ('2013-06-25',6),
    ('2013-06-26',22),
    ('2013-06-27',22),
    ('2013-06-28',3),
    ('2013-06-29',5),
    ('2013-06-30',10),
    ('2013-07-01',17),
    ('2013-07-02',14),
    ('2013-07-03',9),
    ('2013-07-04',7)]

现在我想做一个rolling aggregation并存储聚合。通过滚动聚合，我的意思是说对于第 1 周（2013-06-21 到 2013-06-27），我想添加前一个日期的利润并将其与当前日期一起存储。因此，对于2013-06-21总和将是14唯一的，因为它是一周的第一天，但然后2013-06-22它应该是的总和previous date (2013-06-21)与current date (2013-06-22)这应该与当前的日期一起存储。这将持续到本周末，然后下周它将再次重新开始，新周没有以前的日期。所以第一周sample output应该是这样的：

 Date …

我试图找到np.linspace(0,n,n*10+1) 子区间大于宽度的所有可能的子区间（比如宽度 = 0.5）

所以我通过使用 itertools 尝试了这个

import itertools
ranges=np.linspace(0,n,n*10+1)
#find all combinations
combinations=list(itertools.combinations(ranges,2))
#using for-loops to calculate width of each intervals
#and append to new list if the width is greater than 0.5
save=[]
for i in range(len(combinations)):
    if combinations[i][1]-combinations[i][0]>0.5:
        save.append(combinations[i]) 

但这需要太多次，尤其是当 n 变大时，尤其会消耗大量内存

所以我想知道我是否可以在收集组合时更快地修改函数或设置约束

我有 6 个不同范围的变量。我想用我的代码创建可能性池。在这个例子中，我为每个变量提供了 10 个范围，但我必须给它们大约 200 个范围。但是每当我试图超过 20 个范围（例如 30 个范围）时，Python 都会杀死自己，有时它会冻结计算机。有没有办法让它更快更稳定？

谢谢。

import itertools

a = [x for x in range(400,411)]
b = [x for x in range(400,411)]
c = [x for x in range(400,411)]
d = [x for x in range(400,411)]
e = [x for x in range(400,411)]
f = [x for x in range(400,411)]

fl = lambda x: x

it = filter(fl, itertools.product(a,b,c,d,e,f))

posslist = [x for x in it]

print(len(posslist))

我一直在尝试创建一个脚本，其中将打印列表的每个可能组合[其中 (1,2) 和 (2,1) 将被视为不同的条目]。例如：

c = [1,2]
# do something magical
print(c with magical stuff) 
>>>[(1), (2), (1, 1), (1, 2), (2, 1), (2, 2)]

我试过 itertools.permutations。它显示输出为 >>> () (1,) (​​2,) (1, 2) (2, 1)。但是，它不包括 (1, 1) 和 (2,2)

任何帮助将不胜感激。我是编码新手（我非常流利地打印“Hello World！”虽然：3）

我需要一种惯用的方式来交错这两个向量：

let v1 = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
let v2 = vec![7.0, 8.0, 9.0, 10.0, 11.0, 12.0];

我期望的输出是：

[1.0, 2.0, 3.0,
 7.0, 8.0, 9.0,
 4.0, 5.0, 6.0,
 10.0, 11.0, 12.0];

我使用了 itertoolschunks方法，但我不相信这是最好的实现，因为有两个collect调用。

let output = interleave(&v1.into_iter().chunks(3), &v2.into_iter().chunks(3)).map(|v| {v.into_iter().collect::<Vec<f32>>()}).flatten().collect::<Vec<f32>>();

有没有更好的方法来使用 itertools 编写这个迭代器？

在此文档链接中，我们可以阅读以下内容：

itertools.accumulate(iterable[, func, *, initial=None])

通常，元素输出的数量与输入迭代匹配。但是，如果提供了关键字参数initial，则累积以初始值开始，因此输出的元素比输入的可迭代元素多一个。

但是，我无法弄清楚如何使用该initial参数。

如果我像这样使用它：

accumulate([0, 7, 19, 13], operator.add,1)

我收到错误“TypeError：accumulate() 最多需要 2 个参数（给定 3 个）”。

我正在使用 Python 3.4。

我有以下 2 个列表。

my_values = ['0,78', '0,40', '0,67']

my_list = [
    ['Morocco', 'Meat', '190,00', '0,15'], 
    ['Morocco', 'Meat', '189,90', '0,32'], 
    ['Morocco', 'Meat', '189,38', '0,44'],
    ['Morocco', 'Meat', '188,94', '0,60'],
    ['Morocco', 'Meat', '188,49', '0,78'],
    ['Morocco', 'Meat', '187,99', '0,101'],
    ['Spain', 'Meat', '190,76', '0,10'], 
    ['Spain', 'Meat', '190,16', '0,20'], 
    ['Spain', 'Meat', '189,56', '0,35'],
    ['Spain', 'Meat', '189,01', '0,40'],
    ['Spain', 'Meat', '188,13', '0,75'],
    ['Spain', 'Meat', '187,95', '0,85'],
    ['Italy', 'Meat', '190,20', '0,11'],
    ['Italy', 'Meat', '190,10', '0,31'], 
    ['Italy', 'Meat', '189,32', '0,45'],
    ['Italy', 'Meat', '188,61', '0,67'],
    ['Italy', 'Meat', '188,01', '0,72'],
    ['Italy', …

我有一个列表，如：

['A','B','C']

我想得到的是这三个字母在九个长度列表中的所有组合，它可以是重复的字母。

例如：

combination_1 = ['A','A','A','A','A','A','A','A','A']
combination_2 = ['A','A','A','A','C','A','A','A','A']
combination_3 = ['B','B','B','A','C','A','A','C','C']

我想用 python 来做，但如果有其他语言的解决方案，它也可以工作。

我如何同时迭代两个列表，一个列表大于第二个。所以第二个就完蛋了。我想再次开始较小的列表，直到较大的列表耗尽

_list = [ 19 , 74, 544, 39, 00, 34, 44, 593, 33, 2123, 22]
_list1 = [0, 1, 2, 3, 4]

我尝试过的事情：

我使用了 itertools.zip_longest 但我不知道在填充值中使用什么。

需要的输出：

我想要的输出：(19, 0), (74, 1) ----- (34, 5) (44, 0) (593, 1)直到更大的列表耗尽。