Collections

Pour importer le module : import collections.

Classe namedtuple : permet de créer des classes de tuples dont les champs sont nommés :

• on peut accéder à un champ par son nom plutôt qu'avec un index.
• il n'y a pas de surcoût par rapport à un tuple normal.
• exemple : Person = collections.namedtuple('Person', ['name', 'age']) construit une classe Person pour faire des tuples nommés avec les deux champs name et age. La valeur renvoyée est en fait le constructeur de la classe (fortement recommandé de l'appeler avec le même nom que la classe, d'où l'utilisation 2 fois de Person).
• on peut aussi utiliser un chaîne plutôt qu'une liste : Person = collections.namedtuple('Person', 'name age').
• une fois la classe construite, on fait : pers = Person(name = 'Jean', age = 4) et pers contiendra Person(name='Jean', age=4).
• on peut aussi donner une liste (ou un tuple !) pour construire le namedtuple : l = ['Jean', 4]; pers = Person(*l)
• on peut aussi utiliser un dictionnaire pour construire le namedtuple : d = {'name': 'Jean', 'age': 4}; pers = Person(**d)
• pers.name : accès au champ name.
• attention : comme pour tout tuple, on ne peut pas modifier un champ, pers.name = 'Pierre' est interdit !
• Accès à un champ du namedtuple dont le nom est dans une variable : myVar = 'age'; getattr(pers, myVar)
• pers._fields : donne le tuple des champs, ici ('name', 'age').
• on peut aussi faire Person._fields pour donner ici ('name', 'age')
• _asdict : renvoie un OrderedDict (cf ci-dessous) à partir d'un named tuple : pers._asdict() va donner OrderedDict([('name', 'Jean'), ('age', 4)]).
• On peut associer une fonction str à un namedtuple pour l'afficher d'une autre façon que le défaut : Person.__str__ = lambda x: x[0] + '/' + str(x[1] (pareil avec __repr__)

Attention : si le namedtuple n'est pas défini en dehors de toute fonction, ou s'il n'est pas défini avec un nom identique à gauche du = et à droite (par exemple, si défini par Person2 = collections.namedtuple('Person', ['name', 'age'])), on ne pourra pas le sérialiser avec Pickle !

Classe Counter, sous classe de dict qui permet de compter le nombre d'éléments de chaque type (la clef est l'élément et la valeur le nombre) :

• import collections; c = collections.Counter() : définition d'un compteur.
• c = collections.Counter({'pomme': 1, 'orange': 3}) : on peut aussi l'initialiser avec des clefs.
• on peut aussi l'initialiser avec une liste, et chaque élément aura alors un compte de 1 si les éléments ne sont pas répétés : c = collections.Counter(['pomme', 'orange']) (donne Counter({'orange': 1, 'pomme': 1})).
• on peut aussi l'initialiser avec une liste ayant des éléments répétés qui seront alors comptés : c = collections.Counter(['pomme', 'poire', 'pomme']) donne Counter({'pomme': 2, 'poire': 1})
• c['banane'] : renvoie 0 si la clef n'existe pas.
• c['banane'] += 1 : rajout de 1, même si la clef n'existait pas encore.
• attention, en stockant des valeurs numériques, car Counter ne le vérifie pas !
• comme pour un dictionnaire, on peut savoir si la clef existe par 'banane' in c et détruire une clef par del c['banane'].
• pour avoir les clefs : myCounter.keys()
• c.elements() : renvoie un itérateur qui fournit chaque élément autant de fois qu'il est compté. Par exemple, c = collections.Counter({'pomme': 1, 'orange': 3}); list(c.elements()) peut renvoyer ['orange', 'orange', 'orange', 'pomme'] (ordre est quelconque).
• conversion en d'autres types : list(c), set(c), dict(c)
• c.items() : renvoie quelque chose comme [('orange', 3), ('pomme', 1)].
• c.clear() : supprime toutes les clefs.
• sum(c.values()) : somme de tous les comptes (ici, 4).
• c.most_common(2) : renvoie les 2 éléments avec les comptes les plus grands. Si c = collections.Counter({'orange': 3, 'pomme': 2, 'banane': 1}), alors c.most_common(2) donne [('orange', 3), ('pomme', 2)].
• c.most_common() : renvoie la liste de toutes les paires (clef, valeur) triés dans l'ordre décroissant des comptes.

Mises à jour des valeurs pour la classe Counter :

• c1.update(c2) : rajoute aux comptes de c1 les comptes de c2. Par exemple, c1 = collections.Counter({'pomme': 1, 'orange': 3}); c2 = collections.Counter({'pomme': 2, 'banane': 1}); c1.update(c2) donnera pour c1 : Counter({'orange': 3, 'pomme': 3, 'banane': 1}).
• c1.subtract(c2) : soustrait des comptes de c1 les comptes de c2. Par exemple, c1 = collections.Counter({'pomme': 1, 'orange': 3}); c2 = collections.Counter({'pomme': 2, 'banane': 1}); c1.subtract(c2) donnera pour c1 : Counter({'orange': 3, 'banane': -1, 'pomme': -1}).
• c1 + c2 : addition des comptes (donne ici Counter({'orange': 3, 'pomme': 3, 'banane': 1})).
• c1 - c2 : soustraction des comptes, mais en ne gardant que les comptes strictement positifs (donne ici Counter({'orange': 3})).
• c1 & c2 : intersection des comptes, c'est à dire le minimum (donne ici Counter({'pomme': 1})).
• c1 | c2 : union des comptes, c'est à dire le maximum (donnc ici Counter({'orange': 3, 'pomme': 2, 'banane': 1})).

Classe OrderedDict : dictionnaire qui se souvient de l'ordre dans lequel les clefs ont été insérées :

• d = collections.OrderedDict(); d['a'] = 2; d['b'] = 4; d['c'] = 2; d['d'] = 1; d.keys() : renvoie les clefs dans l'ordre d'insertion, donc donne ['a', 'b', 'c', 'd'].
• on peut aussi initialiser directement le dictionnaire : collections.OrderedDict([('a', 2), ('b', 4), ('c', 2), ('d', 1)]).
• d.items() : renvoie les paires clef-valeur dans l'ordre d'insertion : [('a', 2), ('b', 4), ('c', 2), ('d', 1)].
• d.popitem() : renvoie la dernière paire insérée, donc ici ('d', 1) et la retire du dictionnaire.
• d.popitem(last = False) : renvoie la première paire insérée et la retire du dictionnaire.

Classe defaultdict : dictionnaire pour lequel on indique la valeur par défaut à utiliser quand une clef n'existe pas. En fait, lors de la construction du defaultdict, il faut donner une fonction sans argument qui doit renvoyer la valeur par défaut :

• d = collections.defaultdict(lambda: 0) : dictionnaire dont la valeur par défaut est 0. Si la clef 'a' n'existe pas, on peut faire d['a'] += 1, on aura alors la valeur 1 associée à la clef 'a'.
• d = collections.defaultdict(list) : dictionnaire dont la valeur par défaut est une liste vide. On peut alors faire : d['a'].apppend(3) même si la clef 'a' n'existe pas encore (la liste vide sera créée et 3 rajouté).
• d = collections.defaultdict(dict) : pareil avec un dictionnaire créé.
• attention : la simple lecture crée l'entrée : d['a'] crée la clef (alors que d.get('a') ne la crée pas).

Classe deque : implémente un deque qui permet à la fois les opérations de type pile (stack) et de type queue (en termes de performance, rajout et retraits d'éléments en début et fin en temps constant) :

• d = collections.deque() : initialise un deque vide.
• d = collections.deque(['a', 'b']) : initialise un deque avec les valeurs indiquées (on peut aussi donner un tuple).
• d = collections.deque('ab') : donne aussi deque(['a', 'b']) (une chaîne est une séquence).
• d.append('c') : rajoute l'élément à la fin (donne ici deque(['a', 'b', 'c'])).
• d.appendleft('c') : rajoute l'élément au début (donne ici deque(['c', 'a', 'b'])).
• d.extend(['c', 'd']) : rajoute les éléments à la fin (donne ici deque(['a', 'b', 'c', 'd'])).
• d.extendleft(['c', 'd']) : rajoute les éléments au début un par un, donne ici deque(['d', 'c', 'a', 'b'])).
• d.pop() : renvoie le dernier élément et le retire du deque.
• d.popleft() : renvoie le premier élément et le retire du deque.
• d.count('a') : compte le nombre d'éléments égaux à celui donné (ici 1)
• d.clear() : efface tous les éléments.
• d.reverse() : renverse l'ordre en place (d modifié).
• d.rotate(n) :
  • d.rotate(2) : fait une rotation vers la droite de 2 positions, par exemple d = collections.deque('abcdef'); d.rotate(2) donne comme valeur de d deque(['e', 'f', 'a', 'b', 'c', 'd']).
  • d.rotate(-2) : fait une rotation vers la gauche de 2 positions.
  • d.remove('a') : enlève le premier élément a (de gauche à droie), par exemple d = collections.deque('bacdae'); d.remove('a') donne deque(['b', 'c', 'd', 'a', 'e']).