0%
Bibliothèques standard en Python

Bibliothèques standard

Exploitez toute la puissance des modules intégrés

10-15 min

Bibliothèques standard en Python

L’une des grandes forces de Python est sa riche bibliothèque standard, qui offre une collection de modules prêts à l’emploi couvrant un large éventail de fonctionnalités. Ces modules sont disponibles dans toute installation Python sans nécessiter de téléchargements supplémentaires, ce qui fait de Python un langage “batteries included” (batteries incluses).

Dans ce tutoriel, nous explorerons certains des modules les plus utiles de la bibliothèque standard Python et comment les utiliser pour résoudre divers problèmes courants.

Exploration des modules essentiels

datetime - Manipulation de dates et heures

Le module datetime fournit des classes pour manipuler les dates et les heures.

from datetime import datetime, timedelta, date

# Date et heure actuelles
maintenant = datetime.now()
print(f"Date et heure actuelles : {maintenant}")

# Formater une date
date_formatee = maintenant.strftime("%d/%m/%Y %H:%M:%S")
print(f"Date formatée : {date_formatee}")

# Créer une date spécifique
date_specifique = datetime(2023, 12, 31, 23, 59, 59)
print(f"Réveillon du Nouvel An : {date_specifique}")

# Calculer la différence entre deux dates
difference = date_specifique - maintenant
print(f"Jours jusqu'au Nouvel An : {difference.days}")

# Ajouter un délai à une date
dans_une_semaine = maintenant + timedelta(days=7)
print(f"Dans une semaine : {dans_une_semaine}")

random - Génération de nombres aléatoires

Le module random est utile pour générer des nombres aléatoires et faire des sélections aléatoires.

import random

# Nombre aléatoire entre 0 et 1
nombre_aleatoire = random.random()
print(f"Nombre aléatoire entre 0 et 1 : {nombre_aleatoire}")

# Nombre entier aléatoire dans une plage
entier_aleatoire = random.randint(1, 100)
print(f"Entier aléatoire entre 1 et 100 : {entier_aleatoire}")

# Choix aléatoire dans une liste
fruits = ["pomme", "banane", "orange", "fraise", "kiwi"]
fruit_aleatoire = random.choice(fruits)
print(f"Fruit aléatoire : {fruit_aleatoire}")

# Mélanger une liste
random.shuffle(fruits)
print(f"Liste mélangée : {fruits}")

# Sélectionner k éléments uniques aléatoires
selection = random.sample(range(1, 51), 6)  # 6 numéros pour un tirage de loto
print(f"Tirage du loto : {selection}")

math - Fonctions mathématiques

Le module math fournit des fonctions mathématiques avancées.

import math

# Constantes mathématiques
print(f"Pi : {math.pi}")
print(f"e : {math.e}")

# Fonctions trigonométriques (en radians)
print(f"sin(π/2) : {math.sin(math.pi/2)}")
print(f"cos(π) : {math.cos(math.pi)}")

# Logarithmes
print(f"log(10) (base e) : {math.log(10)}")
print(f"log10(100) : {math.log10(100)}")

# Racine carrée et puissance
print(f"Racine carrée de 16 : {math.sqrt(16)}")
print(f"2 puissance 10 : {math.pow(2, 10)}")

# Arrondi
print(f"Arrondi inférieur de 3.7 : {math.floor(3.7)}")
print(f"Arrondi supérieur de 3.7 : {math.ceil(3.7)}")

collections - Structures de données spécialisées

Le module collections fournit des alternatives aux structures de données intégrées.

from collections import Counter, defaultdict, namedtuple, deque

# Counter - Compter les occurrences
texte = "Mississippi"
compteur = Counter(texte)
print(f"Occurrences des lettres : {compteur}")
print(f"Lettres les plus fréquentes : {compteur.most_common(2)}")

# defaultdict - Dictionnaire avec valeur par défaut
dd = defaultdict(list)  # La valeur par défaut est une liste vide
dd["fruits"].append("pomme")
dd["fruits"].append("banane")
dd["legumes"].append("carotte")
print(f"defaultdict : {dict(dd)}")

# namedtuple - Tuples avec des champs nommés
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(f"Point : {p}, Coordonnées : x={p.x}, y={p.y}")

# deque - Double-ended queue (file double terminaison)
d = deque(["a", "b", "c"])
d.append("d")         # Ajouter à droite
d.appendleft("z")     # Ajouter à gauche
print(f"deque : {d}")

re - Expressions régulières

Le module re permet de travailler avec des expressions régulières pour la recherche et la manipulation de texte.

import re

texte = "Contactez-moi à john.doe@example.com ou jane_smith@company.org"

# Rechercher une correspondance
if re.search(r"@example\.com", texte):
    print("Adresse e-mail example.com trouvée!")

# Trouver toutes les adresses e-mail
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(pattern, texte)
print(f"Adresses e-mail trouvées : {emails}")

# Remplacer du texte
texte_anonymise = re.sub(pattern, "[EMAIL REMOVED]", texte)
print(f"Texte anonymisé : {texte_anonymise}")

# Séparation d'une chaîne
date = "2023-11-24"
annee, mois, jour = re.split(r"-", date)
print(f"Année : {annee}, Mois : {mois}, Jour : {jour}")

os - Interface avec le système d’exploitation

Le module os fournit des fonctions pour interagir avec le système d’exploitation.

import os

# Informations sur le système
print(f"Nom du système d'exploitation : {os.name}")
print(f"Répertoire de travail actuel : {os.getcwd()}")
print(f"Contenu du répertoire : {os.listdir('.')}")

# Variables d'environnement
print(f"Variable PATH : {os.environ.get('PATH')}")

# Manipulation de chemins (voir aussi le module os.path)
chemin = os.path.join("dossier", "sous_dossier", "fichier.txt")
print(f"Chemin joint : {chemin}")
print(f"Nom de base : {os.path.basename(chemin)}")
print(f"Répertoire : {os.path.dirname(chemin)}")

sys - Configuration spécifique au système

Le module sys fournit des fonctions et variables spécifiques au système Python.

import sys

# Informations sur l'interpréteur Python
print(f"Version de Python : {sys.version}")
print(f"Plateforme : {sys.platform}")

# Arguments de ligne de commande
print(f"Arguments : {sys.argv}")

# Chemins de recherche de modules
print(f"Chemins de recherche : {sys.path}")

# Entrée/sortie standard
sys.stdout.write("Ceci est écrit sur la sortie standard\n")
sys.stderr.write("Ceci est un message d'erreur\n")

json - Manipulation de données JSON

Le module json permet de travailler avec des données au format JSON.

import json

# Dictionnaire Python
donnees = {
    "nom": "Alice",
    "age": 30,
    "langages": ["Python", "JavaScript", "Go"],
    "adresse": {
        "rue": "123 Rue Principale",
        "ville": "Paris",
        "code_postal": "75001"
    }
}

# Conversion Python -> JSON (sérialisation)
json_str = json.dumps(donnees, indent=4)
print(f"JSON formaté :\n{json_str}")

# Conversion JSON -> Python (désérialisation)
obj = json.loads(json_str)
print(f"Prénom : {obj['nom']}, Âge : {obj['age']}")

# Écrire dans un fichier JSON
with open("donnees.json", "w") as f:
    json.dump(donnees, f, indent=4)

# Lire depuis un fichier JSON
with open("donnees.json", "r") as f:
    donnees_lues = json.load(f)
    print(f"Données lues du fichier : {donnees_lues['nom']}")

time - Fonctions liées au temps

Le module time fournit des fonctions pour travailler avec le temps.

import time

# Timestamp actuel (secondes depuis l'époque Unix)
timestamp = time.time()
print(f"Timestamp actuel : {timestamp}")

# Convertir timestamp en temps local
temps_local = time.localtime(timestamp)
print(f"Année : {temps_local.tm_year}, Mois : {temps_local.tm_mon}, Jour : {temps_local.tm_mday}")

# Formater le temps
temps_formate = time.strftime("%Y-%m-%d %H:%M:%S", temps_local)
print(f"Temps formaté : {temps_formate}")

# Mesurer le temps d'exécution
debut = time.time()
# Simuler une opération longue
time.sleep(1)
fin = time.time()
print(f"Temps d'exécution : {fin - debut} secondes")

argparse - Analyse des arguments de ligne de commande

Le module argparse facilite l’écriture d’interfaces en ligne de commande conviviales.

import argparse

def main():
    # Créer un parser d'arguments
    parser = argparse.ArgumentParser(description='Un exemple de programme en ligne de commande')
    
    # Ajouter des arguments
    parser.add_argument('fichier', help='fichier à traiter')
    parser.add_argument('-v', '--verbose', action='store_true', help='activer la verbosité')
    parser.add_argument('-o', '--output', help='fichier de sortie')
    parser.add_argument('-n', '--number', type=int, default=1, help='nombre d\'itérations')
    
    # Parser les arguments
    args = parser.parse_args()
    
    # Utiliser les arguments
    print(f"Fichier à traiter : {args.fichier}")
    if args.verbose:
        print("Mode verbeux activé")
    if args.output:
        print(f"Fichier de sortie : {args.output}")
    print(f"Nombre d'itérations : {args.number}")

if __name__ == "__main__":
    main()

itertools - Fonctions pour itérateurs efficaces

Le module itertools fournit des fonctions qui créent des itérateurs pour des boucles efficaces.

import itertools

# Générer des combinaisons
nombres = [1, 2, 3]
for combo in itertools.combinations(nombres, 2):
    print(f"Combinaison : {combo}")

# Générer des permutations
for perm in itertools.permutations([1, 2, 3], 2):
    print(f"Permutation : {perm}")

# Produit cartésien
for prod in itertools.product("AB", "12"):
    print(f"Produit : {''.join(prod)}")

# Cycles infinis
cycleur = itertools.cycle(["rouge", "vert", "bleu"])
for _ in range(6):
    print(f"Couleur : {next(cycleur)}")

# Regrouper des éléments
donnees = [("A", 1), ("A", 2), ("B", 1), ("B", 2)]
for cle, groupe in itertools.groupby(donnees, lambda x: x[0]):
    print(f"Groupe {cle} : {list(groupe)}")

logging - Journalisation

Le module logging fournit un système de journalisation flexible.

import logging

# Configuration de base
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='app.log'
)

# Différents niveaux de log
logging.debug("Ce message est au niveau DEBUG")
logging.info("Ce message est au niveau INFO")
logging.warning("Ce message est au niveau WARNING")
logging.error("Ce message est au niveau ERROR")
logging.critical("Ce message est au niveau CRITICAL")

# Utiliser un logger spécifique
logger = logging.getLogger('mon_application')
logger.info("Information de mon_application")

# Exception logging
try:
    1 / 0
except Exception as e:
    logging.exception("Une erreur s'est produite")

urllib - URL handling modules

Le module urllib permet de travailler avec des URLs et de faire des requêtes HTTP.

import urllib.request
import urllib.parse
import json

# Effectuer une requête GET simple
with urllib.request.urlopen('https://httpbin.org/get') as response:
    data = json.loads(response.read().decode())
    print(f"URL : {data['url']}")

# Effectuer une requête POST
params = urllib.parse.urlencode({'name': 'John', 'age': 30}).encode()
req = urllib.request.Request('https://httpbin.org/post', data=params, method='POST')
with urllib.request.urlopen(req) as response:
    data = json.loads(response.read().decode())
    print(f"Données envoyées : {data['form']}")

# Analyser une URL
url = "https://www.example.com/path?param1=value1&param2=value2"
parsed_url = urllib.parse.urlparse(url)
print(f"Schéma : {parsed_url.scheme}, Domaine : {parsed_url.netloc}, Chemin : {parsed_url.path}")
print(f"Paramètres : {urllib.parse.parse_qs(parsed_url.query)}")

functools - Fonctions d’ordre supérieur et opérations sur fonctions

Le module functools fournit des outils pour travailler avec des fonctions et des callables.

import functools

# Décorateur pour mettre en cache les résultats d'une fonction
@functools.lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(f"Fibonacci de 30 : {fibonacci(30)}")
print(f"Statistiques du cache : {fibonacci.cache_info()}")

# Fonction partielle (fixe certains arguments)
def multiplier(x, y):
    return x * y

doubler = functools.partial(multiplier, 2)
tripler = functools.partial(multiplier, 3)

print(f"Doubler 5 : {doubler(5)}")
print(f"Tripler 5 : {tripler(5)}")

# reduce - Appliquer une fonction cumulativement
nombres = [1, 2, 3, 4, 5]
somme = functools.reduce(lambda x, y: x + y, nombres)
print(f"Somme : {somme}")

Modules pour des cas d’utilisation spécifiques

statistics - Fonctions statistiques

Le module statistics fournit des fonctions pour calculer des statistiques de base.

import statistics

donnees = [2, 4, 4, 4, 5, 5, 7, 9]

print(f"Moyenne : {statistics.mean(donnees)}")
print(f"Médiane : {statistics.median(donnees)}")
print(f"Mode : {statistics.mode(donnees)}")
print(f"Écart-type : {statistics.stdev(donnees)}")
print(f"Variance : {statistics.variance(donnees)}")

sqlite3 - Interface pour SQLite

Le module sqlite3 fournit une interface pour utiliser la base de données SQLite.

import sqlite3

# Connexion à une base de données (sera créée si elle n'existe pas)
conn = sqlite3.connect('exemple.db')
cursor = conn.cursor()

# Créer une table
cursor.execute('''
CREATE TABLE IF NOT EXISTS utilisateurs (
    id INTEGER PRIMARY KEY,
    nom TEXT NOT NULL,
    email TEXT UNIQUE,
    age INTEGER
)
''')

# Insérer des données
cursor.execute("INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)",
                ("Alice", "alice@example.com", 30))
cursor.execute("INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)",
                ("Bob", "bob@example.com", 25))

# Valider les changements
conn.commit()

# Requête SELECT
cursor.execute("SELECT * FROM utilisateurs")
for row in cursor.fetchall():
    print(f"Utilisateur : {row}")

# Fermer la connexion
conn.close()

uuid - Génération d’identifiants universellement uniques

Le module uuid permet de générer des identifiants universellement uniques.

import uuid

# Générer différents types d'UUID
print(f"UUID1 (basé sur l'horloge) : {uuid.uuid1()}")
print(f"UUID4 (aléatoire) : {uuid.uuid4()}")

# Créer un UUID à partir d'un nom
namespace = uuid.NAMESPACE_DNS
nom = "example.com"
uuid5 = uuid.uuid5(namespace, nom)
print(f"UUID5 (basé sur un nom) : {uuid5}")

hashlib - Fonctions de hachage cryptographique

Le module hashlib implémente diverses fonctions de hachage cryptographique.

import hashlib

# Hacher une chaîne avec différents algorithmes
texte = "Bonjour, monde!"
print(f"MD5 : {hashlib.md5(texte.encode()).hexdigest()}")
print(f"SHA-1 : {hashlib.sha1(texte.encode()).hexdigest()}")
print(f"SHA-256 : {hashlib.sha256(texte.encode()).hexdigest()}")
print(f"SHA-512 : {hashlib.sha512(texte.encode()).hexdigest()}")

# Hachage incrémental
h = hashlib.sha256()
h.update(b"Partie 1 du message")
h.update(b"Partie 2 du message")
print(f"Hachage incrémental : {h.hexdigest()}")

concurrent.futures - Exécution parallèle de tâches

Le module concurrent.futures fournit des interfaces pour l’exécution asynchrone de tâches.

import concurrent.futures
import time

def tache_longue(n):
    """Simule une tâche qui prend du temps"""
    time.sleep(n)
    return f"Tâche {n} terminée après {n} secondes"

# Exécution en parallèle avec ThreadPoolExecutor
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    taches = [1, 2, 3, 4, 5]
    futurs = {executor.submit(tache_longue, t): t for t in taches}
    
    for futur in concurrent.futures.as_completed(futurs):
        tache = futurs[futur]
        try:
            resultat = futur.result()
            print(f"Résultat de la tâche {tache}: {resultat}")
        except Exception as e:
            print(f"Tâche {tache} a généré une exception: {e}")

shutil - Opérations de haut niveau sur les fichiers

Le module shutil fournit des opérations de haut niveau sur les fichiers et les collections de fichiers.

import shutil
import os

# Créer un répertoire pour les tests
os.makedirs("test_dossier", exist_ok=True)
with open("test_dossier/test.txt", "w") as f:
    f.write("Contenu de test")

# Copier un fichier
shutil.copy("test_dossier/test.txt", "test_dossier/test_copie.txt")

# Copier un répertoire entier
shutil.copytree("test_dossier", "test_dossier_copie")

# Déplacer un fichier
shutil.move("test_dossier/test_copie.txt", "test_dossier/test_deplace.txt")

# Supprimer un répertoire et son contenu
shutil.rmtree("test_dossier_copie")

# Archiver un répertoire
shutil.make_archive("archive_test", "zip", "test_dossier")

Conclusion

La bibliothèque standard de Python est vaste et couvre une multitude de fonctionnalités. Ce tutoriel n’a effleuré que la surface de ce qui est disponible. En vous familiarisant avec ces modules, vous pouvez résoudre de nombreux problèmes courants sans avoir à installer de packages tiers.

Voici quelques conseils pour tirer le meilleur parti de la bibliothèque standard :

  1. Consultez la documentation officielle : La documentation Python contient des informations détaillées sur tous les modules de la bibliothèque standard.

  2. Préférez les solutions standard : Avant d’installer un package externe, vérifiez si la bibliothèque standard offre déjà une solution.

  3. Explorez les nouveautés : À chaque nouvelle version de Python, de nouveaux modules ou fonctionnalités sont ajoutés à la bibliothèque standard.

Dans le prochain et dernier tutoriel de cette série, nous mettrons en pratique tout ce que nous avons appris en créant un projet Python complet qui utilisera plusieurs des concepts et modules que nous avons explorés jusqu’à présent.

Commentaires

Les commentaires sont alimentés par GitHub Discussions

Connectez-vous avec GitHub pour participer à la discussion

Lien copié !