Recherche…


Introduction

Dans Python, la méthode itertools.groupby() permet aux développeurs de regrouper les valeurs d'une classe itérable en fonction d'une propriété spécifiée dans un autre ensemble de valeurs itérables.

Syntaxe

  • itertools.groupby (itérable, clé = aucune ou une fonction)

Paramètres

Paramètre Détails
itérable Tout python itérable
clé Fonction (critères) sur laquelle regrouper les itérables

Remarques

groupby () est délicat mais une règle générale à garder à l'esprit lors de son utilisation est la suivante:

Toujours trier les éléments que vous souhaitez regrouper avec la même clé que vous souhaitez utiliser pour le regroupement

Il est recommandé au lecteur de consulter la documentation ici et de voir comment cela est expliqué en utilisant une définition de classe.

Exemple 1

Dis que tu as la ficelle

s = 'AAAABBBCCDAABBB'

et vous voudriez le diviser pour que tous les A soient dans une liste et donc avec tous les B et C, etc. Vous pourriez faire quelque chose comme ça

s = 'AAAABBBCCDAABBB'
s_dict = {}
for i in s:
    if i not in s_dict.keys():
        s_dict[i] = [i]
    else:
        s_dict[i].append(i)
s_dict

Résulte en

{'A': ['A', 'A', 'A', 'A', 'A', 'A'],
 'B': ['B', 'B', 'B', 'B', 'B', 'B'],
 'C': ['C', 'C'],
 'D': ['D']}

Mais pour un grand ensemble de données, vous créeriez ces éléments en mémoire. C'est à ce moment que groupby () entre

Nous pourrions obtenir le même résultat de manière plus efficace en procédant comme suit

# note that we get a {key : value} pair for iterating over the items just like in python dictionary
from itertools import groupby
s = 'AAAABBBCCDAABBB'
c = groupby(s)

dic = {} 
for k, v in c:
    dic[k] = list(v)
dic

Résulte en

{'A': ['A', 'A'], 'B': ['B', 'B', 'B'], 'C': ['C', 'C'], 'D': ['D']}

Notez que le nombre de «A» dans le résultat lorsque nous avons utilisé le groupe par est inférieur au nombre réel de «A» dans la chaîne d'origine. Nous pouvons éviter cette perte d'information en triant les éléments dans s avant de les transmettre à c comme indiqué ci-dessous.

c = groupby(sorted(s))

dic = {} 
for k, v in c:
    dic[k] = list(v)
dic

Résulte en

{'A': ['A', 'A', 'A', 'A', 'A', 'A'], 'B': ['B', 'B', 'B', 'B', 'B', 'B'], 'C': ['C', 'C'], 'D': ['D']}

Maintenant, nous avons tous nos A.

Exemple 2

Cet exemple illustre comment la clé par défaut est choisie si nous ne spécifions aucun

c = groupby(['goat', 'dog', 'cow', 1, 1, 2, 3, 11, 10, ('persons', 'man', 'woman')])
dic = {}
for k, v in c:
    dic[k] = list(v)
dic

Résulte en

{1: [1, 1],
 2: [2],
 3: [3],
 ('persons', 'man', 'woman'): [('persons', 'man', 'woman')],
 'cow': ['cow'],
 'dog': ['dog'],
 10: [10],
 11: [11],
 'goat': ['goat']}

Notez ici que le tuple dans son ensemble compte comme une clé dans cette liste

Exemple 3

Remarquez dans cet exemple que mulato et camel n'apparaissent pas dans notre résultat. Seul le dernier élément avec la clé spécifiée apparaît. Le dernier résultat pour c efface en fait deux résultats précédents. Mais regardez la nouvelle version où les données sont triées en premier sur la même clé.

list_things = ['goat', 'dog', 'donkey', 'mulato', 'cow', 'cat', ('persons', 'man', 'woman'), \
               'wombat', 'mongoose', 'malloo', 'camel']
c = groupby(list_things, key=lambda x: x[0])
dic = {}
for k, v in c:
    dic[k] = list(v)
dic

Résulte en

{'c': ['camel'],
 'd': ['dog', 'donkey'],
 'g': ['goat'],
 'm': ['mongoose', 'malloo'],
 'persons': [('persons', 'man', 'woman')],
 'w': ['wombat']}

Version triée

list_things = ['goat', 'dog', 'donkey', 'mulato', 'cow', 'cat', ('persons', 'man', 'woman'), \
               'wombat', 'mongoose', 'malloo', 'camel']
sorted_list = sorted(list_things, key = lambda x: x[0])
print(sorted_list)
print()
c = groupby(sorted_list, key=lambda x: x[0])
dic = {}
for k, v in c:
    dic[k] = list(v)
dic

Résulte en

['cow', 'cat', 'camel', 'dog', 'donkey', 'goat', 'mulato', 'mongoose', 'malloo', ('persons', 'man', 'woman'), 'wombat']

{'c': ['cow', 'cat', 'camel'],
 'd': ['dog', 'donkey'],
 'g': ['goat'],
 'm': ['mulato', 'mongoose', 'malloo'],
 'persons': [('persons', 'man', 'woman')],
 'w': ['wombat']}

Exemple 4

Dans cet exemple, nous voyons ce qui se passe lorsque nous utilisons différents types d’itération.

things = [("animal", "bear"), ("animal", "duck"), ("plant", "cactus"), ("vehicle", "harley"), \
          ("vehicle", "speed boat"), ("vehicle", "school bus")]
dic = {}
f = lambda x: x[0]
for key, group in groupby(sorted(things, key=f), f):
    dic[key] = list(group)
dic

Résulte en

{'animal': [('animal', 'bear'), ('animal', 'duck')],
 'plant': [('plant', 'cactus')],
 'vehicle': [('vehicle', 'harley'),
  ('vehicle', 'speed boat'),
  ('vehicle', 'school bus')]}

Cet exemple ci-dessous est essentiellement le même que celui ci-dessus. La seule différence est que j'ai changé tous les tuples en listes.

things = [["animal", "bear"], ["animal", "duck"], ["vehicle", "harley"], ["plant", "cactus"], \
          ["vehicle", "speed boat"], ["vehicle", "school bus"]]
dic = {}
f = lambda x: x[0]
for key, group in groupby(sorted(things, key=f), f):
    dic[key] = list(group)
dic

Résultats

{'animal': [['animal', 'bear'], ['animal', 'duck']],
 'plant': [['plant', 'cactus']],
 'vehicle': [['vehicle', 'harley'],
  ['vehicle', 'speed boat'],
  ['vehicle', 'school bus']]}


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow