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

StackOverflow https://stackoverflow.com/questions/773

  •  08-06-2019
  •  | 
  •  

题

我还没有找到关于如何实际使用Python的可以理解的解释 itertools.groupby() 功能。我想做的是：

  • 拿一个列表 - 在这种情况下，是一个对象化的孩子 lxml 元素
  • 根据某些标准将其分为几组
  • 然后分别迭代每个组。

我已经评论过 文档, ， 和 例子, ，但我在尝试将它们应用到简单的数字列表之外时遇到了麻烦。

那么，我该如何使用 itertools.groupby()？我应该使用另一种技术吗？指向良好的“先决条件”阅读的指示也将不胜感激。

有帮助吗？

解决方案

重要的提示： 你必须 对您的数据进行排序 第一的。

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

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 + "."

这将为您提供输出：

动物：熊和鸭子。
植物：仙人掌。
汽车：快艇和校车。

其他提示

您能向我们展示您的代码吗？

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 方法实际上只是遍历一个列表，每当键更改时它就会创建一个新组。

groupby 的一个巧妙技巧是在一行中进行运行长度编码：

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

将为您提供一个 2 元组列表，其中第一个元素是 char，第二个元素是重复次数。

编辑：请注意，这是分开的 itertools.groupby 从 SQL GROUP BY 语义：itertools 不会（并且通常不能）提前对迭代器进行排序，因此具有相同“键”的组不会被合并。

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, key=None):
...    for k, g in it.groupby(iterable, key):
...        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
>>> key = lambda x: x.islower()
>>> print_groupby(sorted("bCAaCacAADBbB"), key)
key: 'False'--> group: ['A', 'A', 'A', 'B', 'B', 'C', 'C', 'D']
key: 'True'--> group: ['a', 'a', 'b', 'b', 'c']

用途

笔记：后面的几个例子来自 Víctor Terrón 的 PyCon （讲话） （西班牙语）, 、“Itertools 的黎明功夫”。另请参阅 groupby源代码 用C写的。

回复

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

另一个例子：

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 中的值分组。在这种情况下，首先输出一组零，然后输出一组零，最后输出一组零。

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]

警告：

语法 list(groupby(...)) 不会按您预期的方式工作。它似乎破坏了内部迭代器对象，所以使用

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

将产生：

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

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

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

并访问 groupby 功能，同时避免那些讨厌的（对于小数据）迭代器。

我想举另一个例子，其中没有排序的 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.

有两组有车辆，但预计只有一组

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

正如您所看到的，有两个 o 和两个 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 函数 不管用!

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

您可以使用 groupby 对要迭代的内容进行分组。你给groupby一个可迭代的和一个可选的 钥匙 函数/可调用函数，用于检查可迭代对象中出现的项目，并返回一个迭代器，该迭代器给出键可调用结果和另一个可迭代对象中实际项目的二元组。来自帮助：

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

排序和分组依据

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'}

我遇到的一个有用的例子可能会有所帮助：

from itertools import groupby

#user input

myinput = input()

#creating empty list to store output

myoutput = []

for k,g in groupby(myinput):

    myoutput.append((len(list(g)),int(k)))

print(*myoutput)

输入示例：14445221

示例输出：(1,1) (3,4) (1,5) (2,2) (1,1)

您可以编写自己的 groupby 函数：

           def groupby(data):
                kv = {}
                for k,v in data:
                    if k not in kv:
                         kv[k]=[v]
                    else:
                        kv[k].append(v)
           return kv

     Run on ipython:
       In [10]: data = [('a', 1), ('b',2),('a',2)]

        In [11]: groupby(data)
        Out[11]: {'a': [1, 2], 'b': [2]}
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top