我如何使用Python的itertools.groupby()？

Question

我无法找到关于如何实际使用Python itertools.groupby()函数的可理解的解释.我想要做的是这样的:

• 列出一个列表 - 在这种情况下,是一个客观化lxml元素的孩子
• 根据某些标准将其划分为不同的组
• 然后分别迭代这些组中的每一个.

我已经阅读了文档和示例,但是我在尝试将它们应用到简单的数字列表之外时遇到了麻烦.

那么,我该如何使用itertools.groupby()？我应该使用另一种技术吗？指向良好的"先决条件"阅读的指针也将受到赞赏.

Answer 1

重要说明:您必须先对数据进行排序.

我没有得到的部分是在示例构造中

groups = []
uniquekeys = []
for k, g in groupby(data, keyfunc):
   groups.append(list(g))    # Store group iterator as a list
   uniquekeys.append(k)

k是当前分组键,g是一个迭代器,可用于迭代由该分组键定义的组.换句话说,groupby迭代器本身返回迭代器.

这是一个例子,使用更清晰的变量名称:

from itertools import groupby

things = [("animal", "bear"), ("animal", "duck"), ("plant", "cactus"), ("vehicle", "speed boat"), ("vehicle", "school bus")]

for key, group in groupby(things, lambda x: x[0]):
    for thing in group:
        print "A %s is a %s." % (thing[1], key)
    print " "

这将为您提供输出:

熊是动物.
鸭子是动物.

仙人掌是一种植物.

快艇是一种车辆.
校车是一种车辆.

在此示例中,things是元组列表,其中每个元组中的第一个项目是第二个项目所属的组.

该groupby()函数有两个参数:(1)要分组的数据和(2)将其分组的函数.

这里,lambda x: x[0]告诉groupby()我们使用每个元组中的第一项作为分组键.

在上面的for语句中,groupby返回三个(键,组迭代器)对 - 每个唯一键一次.您可以使用返回的迭代器迭代该组中的每个项目.

这是使用列表理解的相同数据的略有不同的示例:

for key, group in groupby(things, lambda x: x[0]):
    listOfThings = " and ".join([thing[1] for thing in group])
    print key + "s:  " + listOfThings + "."

这将为您提供输出:

动物:熊和鸭.
植物:仙人掌.
车辆:快艇和校车.

Answer 2

你能告诉我们你的代码吗？

Python文档中的示例非常简单:

groups = []
uniquekeys = []
for k, g in groupby(data, keyfunc):
    groups.append(list(g))      # Store group iterator as a list
    uniquekeys.append(k)

因此,在您的情况下,数据是节点列表,keyfunc是条件函数的逻辑所在的位置,然后groupby()对数据进行分组.

在调用之前,您必须小心按标准对数据进行排序,groupby否则它将无法正常工作.groupby方法实际上只是迭代一个列表,每当密钥更改它创建一个新组.

Answer 3

itertools.groupby 是一个分组项目的工具.

从文档中,我们进一步收集了它可能做的事情:

# [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B

# [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D

groupby 对象产生关键组对,其中组是生成器.

特征

• A.将连续项目组合在一起
• B.给定一个已排序的可迭代项,对所有项目的出现进行分组
• C.指定如何使用键功能对项目进行分组

比较

# Define a printer for comparing outputs
>>> def print_groupby(iterable, keyfunc=None):
...    for k, g in it.groupby(iterable, keyfunc):
...        print("key: '{}'--> group: {}".format(k, list(g)))

# Feature A: group consecutive occurrences
>>> print_groupby("BCAACACAADBBB")
key: 'B'--> group: ['B']
key: 'C'--> group: ['C']
key: 'A'--> group: ['A', 'A']
key: 'C'--> group: ['C']
key: 'A'--> group: ['A']
key: 'C'--> group: ['C']
key: 'A'--> group: ['A', 'A']
key: 'D'--> group: ['D']
key: 'B'--> group: ['B', 'B', 'B']

# Feature B: group all occurrences
>>> print_groupby(sorted("BCAACACAADBBB"))
key: 'A'--> group: ['A', 'A', 'A', 'A', 'A']
key: 'B'--> group: ['B', 'B', 'B', 'B']
key: 'C'--> group: ['C', 'C', 'C']
key: 'D'--> group: ['D']

# Feature C: group by a key function
>>> # keyfunc = lambda s: s.islower()                      # equivalent
>>> def keyfunc(s):
...     """Return a True if a string is lowercase, else False."""   
...     return s.islower()
>>> print_groupby(sorted("bCAaCacAADBbB"), keyfunc)
key: 'False'--> group: ['A', 'A', 'A', 'B', 'B', 'C', 'C', 'D']
key: 'True'--> group: ['a', 'a', 'b', 'b', 'c']

用途

• 字谜(见笔记本)
• 分档
• 组奇数和偶数
• 按值对列表进行分组
• 删除重复元素
• 查找数组中重复元素的索引
• 将数组拆分为n个大小的块
• 在两个列表之间查找相应的元素
• 压缩算法(见笔记本)/ 运行长度编码
• 按长度分组字母,按键功能(见笔记本)
• 超过阈值的连续值(请参阅笔记本)
• 查找列表或连续项目中的数字范围(请参阅文档)
• 找到所有相关的最长序列
• 采取符合条件的连续序列(参见相关文章)

注:后面的几个例子来自VíctorTerrón的PyCon (谈话) (西班牙语),"Dawn with Itertools的功夫".另请参阅用C编写的groupby源代码.

响应

# OP: Yes, you can use `groupby`, e.g. 
[do_something(list(g)) for _, g in groupby(lxml_elements, criteria_func)]

Answer 4

使用groupby的neato技巧是在一行中运行长度编码:

[(c,len(list(cgen))) for c,cgen in groupby(some_string)]

将给出一个2元组的列表,其中第一个元素是char,第二个元素是重复的数量.

编辑:请注意,这itertools.groupby与SQL GROUP BY语义分开:itertools不会(通常不能)提前对迭代器进行排序,因此不会合并具有相同"键"的组.

Answer 5

另一个例子:

for key, igroup in itertools.groupby(xrange(12), lambda x: x // 5):
    print key, list(igroup)

结果是

0 [0, 1, 2, 3, 4]
1 [5, 6, 7, 8, 9]
2 [10, 11]

请注意,igroup是一个迭代器(文档调用它的子迭代器).

这对于分块生成器很有用:

def chunker(items, chunk_size):
    '''Group items in chunks of chunk_size'''
    for _key, group in itertools.groupby(enumerate(items), lambda x: x[0] // chunk_size):
        yield (g[1] for g in group)

with open('file.txt') as fobj:
    for chunk in chunker(fobj):
        process(chunk)

groupby的另一个例子 - 当键没有排序时.在以下示例中,xx中的项目按yy中的值进行分组.在这种情况下,首先输出一组零,然后输出一组1,然后再输出一组零.

xx = range(10)
yy = [0, 0, 0, 1, 1, 1, 0, 0, 0, 0]
for group in itertools.groupby(iter(xx), lambda x: yy[x]):
    print group[0], list(group[1])

生产:

0 [0, 1, 2]
1 [3, 4, 5]
0 [6, 7, 8, 9]

Answer 6

警告:

语法列表(groupby(...))将无法按您的意图运行.它似乎破坏了内部迭代器对象,所以使用

for x in list(groupby(range(10))):
    print(list(x[1]))

将产生:

[]
[]
[]
[]
[]
[]
[]
[]
[]
[9]

相反,列表(groupby(...)),尝试[(k,list(g))为k,g in groupby(...)],或者如果经常使用该语法,

def groupbylist(*args, **kwargs):
    return [(k, list(g)) for k, g in groupby(*args, **kwargs)]

并且可以访问groupby功能,同时避免那些讨厌的(对于小数据)迭代器.

Answer 7

遗憾的是，我不认为 \xe2\x80\x99s 建议使用itertools.groupby(). 它\xe2\x80\x99s 太难安全使用，而且它\xe2\x80\x99s 只需几行就可以编写按预期工作的东西。

\n

def my_group_by(iterable, keyfunc):\n    """Because itertools.groupby is tricky to use\n\n    The stdlib method requires sorting in advance, and returns iterators not\n    lists, and those iterators get consumed as you try to use them, throwing\n    everything off if you try to look at something more than once.\n    """\n    ret = defaultdict(list)\n    for k in iterable:\n        ret[keyfunc(k)].append(k)\n    return dict(ret)\n

\n

像这样使用它：

\n

def first_letter(x):\n    return x[0]\n\nmy_group_by('four score and seven years ago'.split(), first_letter)\n

\n

要得到

\n

{'f': ['four'], 's': ['score', 'seven'], 'a': ['and', 'ago'], 'y': ['years']}\n

\n

Answer 8

我想举一个例子,其中没有排序的groupby不起作用.改编自James Sulak的例子

from itertools import groupby

things = [("vehicle", "bear"), ("animal", "duck"), ("animal", "cactus"), ("vehicle", "speed boat"), ("vehicle", "school bus")]

for key, group in groupby(things, lambda x: x[0]):
    for thing in group:
        print "A %s is a %s." % (thing[1], key)
    print " "

输出是

A bear is a vehicle.

A duck is a animal.
A cactus is a animal.

A speed boat is a vehicle.
A school bus is a vehicle.

有两个车辆组,而一个人只能期待一组

Answer 9

这个基本实现帮助我理解了这个函数。希望它也能帮助其他人：

arr = [(1, "A"), (1, "B"), (1, "C"), (2, "D"), (2, "E"), (3, "F")]

for k,g in groupby(arr, lambda x: x[0]):
    print("--", k, "--")
    for tup in g:
        print(tup[1])  # tup[0] == k

-- 1 --
A
B
C
-- 2 --
D
E
-- 3 --
F

Answer 10

@CaptSolo,我试过你的例子,但它没有用.

from itertools import groupby 
[(c,len(list(cs))) for c,cs in groupby('Pedro Manoel')]

输出:

[('P', 1), ('e', 1), ('d', 1), ('r', 1), ('o', 1), (' ', 1), ('M', 1), ('a', 1), ('n', 1), ('o', 1), ('e', 1), ('l', 1)]

正如你所看到的,有两个和两个e,但它们分成了不同的组.那时我意识到你需要对传递给groupby函数的列表进行排序.所以,正确的用法是:

name = list('Pedro Manoel')
name.sort()
[(c,len(list(cs))) for c,cs in groupby(name)]

输出:

[(' ', 1), ('M', 1), ('P', 1), ('a', 1), ('d', 1), ('e', 2), ('l', 1), ('n', 1), ('o', 2), ('r', 1)]

只记得,如果列表没有排序,groupby函数将无法正常工作!

Answer 11

排序和分组

from itertools import groupby

val = [{'name': 'satyajit', 'address': 'btm', 'pin': 560076}, 
       {'name': 'Mukul', 'address': 'Silk board', 'pin': 560078},
       {'name': 'Preetam', 'address': 'btm', 'pin': 560076}]


for pin, list_data in groupby(sorted(val, key=lambda k: k['pin']),lambda x: x['pin']):
...     print pin
...     for rec in list_data:
...             print rec
... 
o/p:

560076
{'name': 'satyajit', 'pin': 560076, 'address': 'btm'}
{'name': 'Preetam', 'pin': 560076, 'address': 'btm'}
560078
{'name': 'Mukul', 'pin': 560078, 'address': 'Silk board'}

Answer 12

我如何使用Python的itertools.groupby()？

您可以使用groupby将事物分组以进行迭代.你给groupby一个可迭代的,一个可选的key函数/ callable来检查它们从iterable出来时的项目,然后它返回一个迭代器,它给出了一个可以调用键的结果和实际项目的二元组.另一个可迭代的.从帮助:

groupby(iterable[, keyfunc]) -> create an iterator which returns
(key, sub-iterator) grouped by each value of key(value).

下面是groupby使用协程按计数分组的示例,它使用一个密钥可调用(在这种情况下coroutine.send),只是吐出多次迭代的计数和元素的分组子迭代器:

import itertools


def grouper(iterable, n):
    def coroutine(n):
        yield # queue up coroutine
        for i in itertools.count():
            for j in range(n):
                yield i
    groups = coroutine(n)
    next(groups) # queue up coroutine

    for c, objs in itertools.groupby(iterable, groups.send):
        yield c, list(objs)
    # or instead of materializing a list of objs, just:
    # return itertools.groupby(iterable, groups.send)

list(grouper(range(10), 3))

版画

[(0, [0, 1, 2]), (1, [3, 4, 5]), (2, [6, 7, 8]), (3, [9])]

Answer 13

from random import randint
from itertools import groupby

 l = [randint(1, 3) for _ in range(20)]

 d = {}
 for k, g in groupby(l, lambda x: x):
     if not d.get(k, None):
         d[k] = list(g)
     else:
         d[k] = d[k] + list(g)

上面的代码显示了如何使用 groupby 根据提供的 lambda 函数/键对列表进行分组。唯一的问题是输出没有合并，这可以使用字典轻松解决。

例子：

l = [2, 1, 2, 3, 1, 3, 2, 1, 3, 3, 1, 3, 2, 3, 1, 2, 1, 3, 2, 3]

应用 groupby 后结果将是：

for k, g in groupby(l, lambda x:x):
    print(k, list(g))

2 [2]
1 [1]
2 [2]
3 [3]
1 [1]
3 [3]
2 [2]
1 [1]
3 [3, 3]
1 [1]
3 [3]
2 [2]
3 [3]
1 [1]
2 [2]
1 [1]
3 [3]
2 [2]
3 [3]

一旦使用了如上所示的字典，就会得出以下结果，可以轻松迭代：

{2: [2, 2, 2, 2, 2, 2], 1: [1, 1, 1, 1, 1, 1], 3: [3, 3, 3, 3, 3, 3, 3, 3]}