Python : modules utiles

Sommaire :
• bisect
• collections
• Counter
• defaultdict
• deque
• OrderedDict
• heapq
• itertools
• groupby
• pairwise
• product
• Loguru
• re: expressions rationnelles
• re.findall
• re.finditer

bisect

Implémente l'algorithme de recherche dichotomique dans une liste triée.
Notamment, bisect_left() permet de trouver le point d'insertion d'un élément (i.e. la position du premier élément ≥).

collections

Counter

Équivalent du multi-set : dictionnaire comptant les occurrences d'éléments.

number_per_item = Counter(items_list)
reverse_cardinals = sorted(list(number_per_item.values()), reverse=True)

defaultdict

Dictionnaire avec un initialiseur appelé pour tout premier accès à un élément.

items_list = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
numbers_per_colour = defaultdict(list)
for key, value in items_list:
    numbers_per_colour[key].append(value)
→ [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

deque

Une “deque” est une “double-ended queue” qui permet d'ajouter et d'enlever des éléments des deux côtés de la queue en temps constant.

OrderedDict

Dictionnaire ordonné, avec une méthode pour déplacer un item à la fin.

heapq

Les fonctions de ce module permettent d'implémenter une queue priorisée (“heap queue” ou “priority queue”).
Une heap (« tas ») est un arbre binaire dans lequel chaque parent contient une valeur inférieure ou égale à celles de tous ses enfants.
La structure de données de la heap est une liste d'éléments (par exemples des paires dont le premier élément est la priorité).

propagation_heap = [(0, "toto")]
while propagation_heap:
    priority, element = heappop(propagation_heap)
    …
    heappush(propagation_heap, (next_priority, next_element))

itertools

groupby

groupby regroupe les valeurs consécutives :

(key, list(group)) for key, group in groupby('aaabbcaa')
→ ('a', ['a', 'a', 'a']), ('b', ['b', 'b']), ('c', ['c']), ('a', ['a', 'a'])

list(group) for key, group in groupby('abc de fgh', lambda item: item == " ") if not key
→ ['a', 'b', 'c'], ['d', 'e'], ['f', 'g', 'h']

pairwise

Renvoie les paires successives d'un itérable.

pairwise("abcd")
→ ('a', 'b') ('b', 'c') ('c', 'd')

product

Produit cartésien d'itérables.

product(A, B)
↔ ((x, y) for x in A for y in B)

Pour obtenir le produit d'un itérable avec lui-même, on peut utiliser repeat :

product(range(2), repeat=3)
→ 000 001 010 011 100 101 110 111

Loguru

Loguru est une bibliothèque de logging, facile à configurer, avec des options par défaut.

Loguru n'a qu'un seul logger, déjà préconfiguré (qui envoie les logs sur stderr) :

from loguru import logger
logger.info("Info message")  # levels: trace, debug, info, success, warning, error, critical

Configuration du logger :

logger.remove()  # remove the default logger before adding a new one
logger.add(sys.stderr, level="TRACE")  # enable TRACE level messages (which are disabled in the default logger)

Formattage des logs, via des paramètres optionnels de logger.add() :

• - format="{time:YYYY-MM-DD HH:mm:ss} {level} {name}:{line} | {message}"
• - json : serialize=True

Ajout d'information contextuelles :

logger.add(sys.stderr, format="{message} | {extra}")
logger.info("Foo", user_id=42)  # Foo | {'user_id': 42}

Écriture dans un fichier avec rotation automatique et période de rétention :

logger.add("app.log", rotation="1 MB", retention="1 week")

Via un décorateur, écriture automatique de log en cas d'exception dans une fonction :

@logger.catch(message="Foo")
def my_function():…

re: expressions rationnelles

re.findall

Trouve toutes les correspondances successives (qui ne se chevauchent pas), et renvoie une liste de strings ou de tuples.

re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
→ ('width', '20'), ('height', '10')

re.finditer

Comme findall mais renvoie un itérateur.

La dernière mise à jour de cette page date de mai 2026.

Le contenu de ce site est, en tant qu'œuvre originale de l'esprit, protégé par le droit d'auteur.
Pour tout commentaire, vous pouvez m'écrire à xavier.lamorlette@gmail.com.