Python Language
par groupe()
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']]}