10 fonctions Python cachées que tout développeur devrait connaître

En tant que développeurs, nous nous en tenons souvent à nos fonctions Python intégrées préférées et écrivons parfois même des solutions personnalisées pour des problèmes qui ont déjà des solutions intégrées efficaces. Cependant, la bibliothèque standard de Python regorge de joyaux cachés qui peuvent simplifier notre code et améliorer les performances.

Dans cet article, nous allons explorer certaines fonctions Python moins connues mais incroyablement utiles qui méritent plus d’attention.

1. bisect – Opérations efficaces de liste triée

Le module bisect permet de maintenir des listes triées et de trouver efficacement des points d’insertion, ce qui est particulièrement utile lorsque vous avez besoin de recherches rapides ou de séquences triées dynamiques.

Exemple : Système de suivi des notes

Mettons en œuvre un système qui gère les notes triées, trouve les points d’insertion et détermine les notes alphabétiques de manière dynamique.

from bisect import bisect_left, bisect_right, insort

grades = [60, 70, 75, 85, 90, 95]

Find the correct position to insert a new grade
new_grade = 82
position = bisect_left(grades, new_grade)
print(f"Insert 82 at position: {position}")

Insert while keeping the list sorted
insort(grades, new_grade)
print(f"Grades after insertion: {grades}")

Assign letter grades based on score
def grade_to_letter(score):
    breakpoints = [60, 70, 80, 90]  # F, D, C, B, A
    grades = 'FDCBA'
    position = bisect_right(breakpoints, score)
    return grades[position]

print(f"Score 82 gets grade: {grade_to_letter(82)}")
print(f"Score 75 gets grade: {grade_to_letter(75)}")

2. itertools.pairwise - Traitez facilement les paires consécutives

La fonction par paires génère des paires consécutives dans une séquence, ce qui la rend idéale pour l’analyse des tendances, le calcul des différences et le lissage des données.

Exemple : Analyse des changements de température

Lors de l’analyse des données de température, nous avons souvent besoin de calculer les différences entre des lectures consécutives, de trouver des tendances ou de calculer des moyennes mobiles. Au lieu d’itérer manuellement avec une logique basée sur un index, la fonction par paires d’itertools nous permet de traiter des paires consécutives sans effort.

from itertools import pairwise

temperatures = [20, 23, 24, 25, 23, 22, 20]

Compute temperature differences
changes = [curr - prev for prev, curr in pairwise(temperatures)]
print("Temperature changes:", changes)

Compute moving averages
moving_averages = [(t1 + t2) / 2 for t1, t2 in pairwise(temperatures)]
print("Moving averages:", moving_averages)

Find the largest temperature jump
max_jump = max(abs(b - a) for a, b in pairwise(temperatures))
print(f"Largest temperature change: {max_jump} degrees")

3. statistics.fmean – Moyenne en virgule flottante rapide et précise

La fonction fmean calcule la moyenne plus rapidement et avec une plus grande précision par rapport à mean(), ce qui la rend idéale pour les grands ensembles de données.

Exemple : Comparaison de vitesse entre mean() et fmean()

L’exemple illustre une comparaison des performances entre deux fonctions du module de statistiques de Python : mean() et fmean().

from statistics import mean, fmean
import time

temperatures = [21.5, 22.1, 23.4, 22.8, 21.8] * 100000  

Regular mean
start_time = time.perf_counter()
regular_mean = mean(temperatures)
regular_time = time.perf_counter() - start_time

fmean
start_time = time.perf_counter()
fast_mean = fmean(temperatures)
fast_time = time.perf_counter() - start_time

print(f"Regular mean: {regular_mean:.10f} (took {regular_time:.4f} seconds)")
print(f"fmean: {fast_mean:.10f} (took {fast_time:.4f} seconds)")

fmean est nettement plus rapide, en particulier pour les grands ensembles de données.

4. itertools.takewhile - Traiter jusqu’à ce qu’une condition échoue

La fonction takewhile permet de traiter les séquences jusqu’à ce qu’une condition ne soit plus remplie, offrant ainsi un moyen plus propre de rompre les boucles.

Exemple : Traitement des journaux jusqu’à ce qu’une erreur se produise

Cet exemple montre comment traiter efficacement les entrées de journal jusqu’à ce qu’une erreur soit rencontrée à l’aide de la fonction itertools.takewhile de Python. L’objectif est d’extraire et d’afficher toutes les entrées de journal qui se produisent avant la première entrée d’erreur dans une liste de journaux.

from itertools import takewhile

log_entries = [
    "INFO: System started",
    "INFO: Loading data",
    "INFO: Processing users",
    "ERROR: Database connection failed",
    "INFO: Retrying connection",
]

Retrieve logs until the first error
normal_operation = list(takewhile(lambda x: not x.startswith("ERROR"), log_entries))
print("Logs before first error:")
print("\n".join(normal_operation))

5. operator.attrgetter - Récupérer efficacement les attributs d’objet

La fonction attrgetter simplifie l’extraction d’attributs à partir d’objets, en particulier pour le tri et les attributs imbriqués.

Exemple : Tri des articles de blog par auteur et vues

Ce code montre comment trier une liste d’articles de blog en fonction de plusieurs critères à l’aide de la fonction sorted() de Python avec l’utilitaire attrgetter du module opérateur.

Le tri s’effectue d’abord par le nom de l’auteur (par ordre alphabétique) puis par le nombre de vues (numériquement). Cette approche est utile lorsque vous souhaitez organiser les données de manière hiérarchique, par exemple en regroupant les articles par auteur et en les classant par popularité.

from operator import attrgetter
from datetime import datetime

class Article:
    def __init__(self, title, author, views, date):
        self.title = title
        self.author = author
        self.stats = type('Stats', (), {'views': views})  
        self.date = date

    def __repr__(self):
        return f"{self.title} by {self.author}"

articles = [
    Article("Python Tips", "Alice", 1500, datetime(2025, 1, 15)),
    Article("Data Science", "Bob", 2500, datetime(2025, 1, 20)),
    Article("Web Dev", "Alice", 1800, datetime(2025, 1, 10))
]

Sort by author and then by views
sorted_articles = sorted(articles, key=attrgetter('author', 'stats.views'))
for article in sorted_articles:
    print(f"{article.author}: {article.title} ({article.stats.views} views)")

6. itertools.chain.from_iterable – Aplatir efficacement les listes imbriquées

La fonction itertools.chain.from_iterable est un outil puissant dans le module itertools de Python qui vous permet d’aplatir des structures itérables imbriquées (par exemple, des listes de listes, des tuples de tuples, etc.) en un seul itérable de manière économe en mémoire.

Contrairement à d’autres méthodes d’aplatissement, telles que les compréhensions de listes ou les boucles imbriquées, chain.from_iterable évite de créer des listes intermédiaires, ce qui le rend particulièrement utile pour gérer de grands ensembles de données.

Exemple : Aplatissement des données de vente

Cet exemple montre comment aplatir efficacement une structure de liste imbriquée à l’aide du fichier itertools.chain de Python. Le scénario implique des données de vente représentées sous la forme d’une liste de sous-listes, où chaque sous-liste contient des tuples représentant des chiffres de vente mensuels.

L’objectif est d'« aplatir » cette structure imbriquée en une seule liste de tuples pour faciliter le traitement ou l’analyse.

from itertools import chain

sales_data = [
    [('Jan', 100), ('Feb', 150)],
    [('Mar', 200), ('Apr', 180)],
    [('May', 210), ('Jun', 190)]
]

Flatten data efficiently
flat_sales = list(chain.from_iterable(sales_data))
print("Flattened sales data:", flat_sales)

7. functools.cache - Mise en cache automatique des fonctions

Le décorateur de cache (introduit dans Python 3.9) stocke les résultats des fonctions pour accélérer les calculs répétés, idéal pour les calculs récursifs ou coûteux.

Exemple : Optimisation de la séquence de Fibonacci

Cet exemple montre comment 'functools.cache' améliore considérablement les performances en stockant les résultats précédemment calculés. Au lieu de recalculer les valeurs de chaque appel récursif, il récupère les résultats mis en cache, ce qui accélère exponentiellement des fonctions telles que les calculs de Fibonacci.

from functools import cache

@cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(30))  # Much faster than an uncached version

Sortie :

832040

8. contextlib.suppress - Gestion des exceptions plus propre

La fonction suppress est une alternative plus propre à essayer, sauf lorsque vous souhaitez ignorer des exceptions spécifiques sans code standard inutile.

Exemple : suppression des erreurs de fichier introuvable

Cet exemple tente d’ouvrir un fichier qui n’existe peut-être pas. Au lieu de lever une FileNotFoundError, la fonction suppress() la gère silencieusement, ce qui permet au programme de continuer sans interruption.

from contextlib import suppress

with suppress(FileNotFoundError):
    with open("non_existent_file.txt", "r") as file:
        data = file.read()

print("No crash, program continues!")

Sortie :

No crash, program continues!

9. Pathlib. Path.glob – Recherche intuitive de fichiers

La méthode glob() de pathlib. Path vous permet de rechercher des fichiers qui correspondent à un modèle spécifique dans un répertoire. L’utilisation de rglob() permet la recherche récursive, ce qui signifie qu’il parcourt également tous les sous-répertoires, ce qui est utile pour des tâches telles que trouver tous les scripts Python dans un dossier de projet sans vérifier manuellement chaque répertoire.

Exemple : Recherche récursive de tous les fichiers Python

Cet exemple utilise Path.rglob(« *.py ») pour rechercher de manière récursive tous les fichiers Python (.py) dans le répertoire courant et ses sous-répertoires. Le résultat est une liste de chemins d’accès aux fichiers, ce qui facilite la gestion ou le traitement de plusieurs scripts Python à la fois.

from pathlib import Path

python_files = list(Path(".").rglob("*.py"))
print("Found Python files:", python_files)

10. dataclasses.asdict - Convertissez facilement des objets en dictionnaires

La fonction asdict() de dataclasses simplifie la conversion d’objets en dictionnaires, ce qui les rend sérialisables JSON ou faciles à manipuler.

Exemple : Conversion d’un objet utilisateur en JSON

Transforme un objet dataclass en dictionnaire, ce qui facilite la sérialisation au format JSON.

from dataclasses import dataclass, asdict
import json

@dataclass
class User:
    name: str
    age: int
    email: str

user = User("Alice", 30, "[email ")
user_dict = asdict(user)

print(json.dumps(user_dict, indent=4))  # Easily convert to JSON

Conclusion

Ces fonctions Python moins connues simplifient les opérations complexes tout en améliorant la lisibilité et l’efficacité. Essayez de les intégrer dans vos projets, et vous serez surpris de voir à quel point votre code devient plus propre et plus rapide !