遗憾的是，我不认为使用itertools.groupby()是明智的。要安全使用它太难了，而且只需要几行代码就可以写出一些可以按照预期工作的东西。

def my_group_by(iterable, keyfunc):
    """Because itertools.groupby is tricky to use

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

像这样使用它:

def first_letter(x):
    return x[0]

my_group_by('four score and seven years ago'.split(), first_letter)

得到

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

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

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)

使用itertools的关键是要认识到。Groupby是指只有在可迭代对象中是顺序的项才会被分组在一起。这就是排序工作的原因，因为基本上你在重新排列集合，以便所有满足callback(item)的项现在都按顺序出现在排序的集合中。

也就是说，您不需要对列表进行排序，只需要一个键-值对的集合，其中的值可以根据groupby生成的每个group iterable增长。例如，列表字典。

>>> things = [("vehicle", "bear"), ("animal", "duck"), ("animal", "cactus"), ("vehicle", "speed boat"), ("vehicle", "school bus")]
>>> coll = {}
>>> for k, g in itertools.groupby(things, lambda x: x[0]):
...     coll.setdefault(k, []).extend(i for _, i in g)
...
{'vehicle': ['bear', 'speed boat', 'school bus'], 'animal': ['duck', 'cactus']}

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

您可以使用groupby来对迭代进行分组。你给groupby一个可迭代对象，和一个可选的键函数/可调用对象，用来检查从可迭代对象中取出的项，它返回一个迭代器，给出一个由可调用键的结果和另一个可迭代对象中的实际项组成的二元组。来自帮助:

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

下面是groupby使用协程按计数分组的例子，它使用一个键可调用对象(在本例中是corroutine .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])]

groupby的一个新技巧是在一行中运行长度编码:

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

会给你一个二元组列表，其中第一个元素是char，第二个元素是重复的次数。

编辑:注意这是itertools的区别。来自SQL GROUP BY语义的groupby: itertools不会(通常也不能)提前对迭代器排序，因此具有相同“key”的组不会合并。

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