Bibliotecas estándar en Python

Una de las grandes fortalezas de Python es su amplia biblioteca estándar, que ofrece una colección de módulos listos para usar que cubren un amplio abanico de funcionalidades. Estos módulos están disponibles en cualquier instalación de Python sin necesidad de descargas adicionales, lo que convierte a Python en un lenguaje “batteries included” (baterías incluidas).

En este tutorial exploraremos algunos de los módulos más útiles de la biblioteca estándar de Python y cómo utilizarlos para resolver diversos problemas habituales.

Exploración de los módulos esenciales

datetime - Manipulación de fechas y horas

El módulo datetime proporciona clases para manipular fechas y horas.

from datetime import datetime, timedelta, date

# Fecha y hora actuales
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 - Generación de números aleatorios

El módulo random es útil para generar números aleatorios y hacer selecciones aleatorias.

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 - Funciones matemáticas

El módulo math proporciona funciones matemáticas avanzadas.

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 - Estructuras de datos especializadas

El módulo collections proporciona alternativas a las estructuras de datos integradas.

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 - Expresiones regulares

El módulo re permite trabajar con expresiones regulares para la búsqueda y la manipulación de texto.

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 - Interfaz con el sistema operativo

El módulo os proporciona funciones para interactuar con el sistema operativo.

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 - Configuración específica del sistema

El módulo sys proporciona funciones y variables específicas del sistema 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 - Manipulación de datos JSON

El módulo json permite trabajar con datos en formato 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 - Funciones relacionadas con el tiempo

El módulo time proporciona funciones para trabajar con el tiempo.

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 - Análisis de argumentos de línea de comandos

El módulo argparse facilita la escritura de interfaces de línea de comandos fáciles de usar.

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 - Funciones para iteradores eficientes

El módulo itertools proporciona funciones que crean iteradores para bucles eficientes.

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 - Registro de eventos

El módulo logging proporciona un sistema de registro de eventos 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 - Módulos para el manejo de URL

El módulo urllib permite trabajar con URL y realizar peticiones 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 - Funciones de orden superior y operaciones sobre funciones

El módulo functools proporciona herramientas para trabajar con funciones y objetos invocables (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}")

Módulos para casos de uso específicos

statistics - Funciones estadísticas

El módulo statistics proporciona funciones para calcular estadísticas básicas.

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 - Interfaz para SQLite

El módulo sqlite3 proporciona una interfaz para utilizar la base de datos 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 - Generación de identificadores universalmente únicos

El módulo uuid permite generar identificadores universalmente únicos.

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 - Funciones de hash criptográfico

El módulo hashlib implementa diversas funciones de hash criptográfico.

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 - Ejecución paralela de tareas

El módulo concurrent.futures proporciona interfaces para la ejecución asíncrona de tareas.

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 - Operaciones de alto nivel sobre archivos

El módulo shutil proporciona operaciones de alto nivel sobre archivos y colecciones de archivos.

import shutil
import os

# Crear un directorio para las pruebas
os.makedirs("test_dossier", exist_ok=True)
with open("test_dossier/test.txt", "w") as f:
    f.write("Contenu de test")

# Copiar un archivo
shutil.copy("test_dossier/test.txt", "test_dossier/test_copie.txt")

# Copiar un directorio completo
shutil.copytree("test_dossier", "test_dossier_copie")

# Mover un archivo
shutil.move("test_dossier/test_copie.txt", "test_dossier/test_deplace.txt")

# Eliminar un directorio y su contenido
shutil.rmtree("test_dossier_copie")

# Archivar un directorio
shutil.make_archive("archive_test", "zip", "test_dossier")

Conclusión

La biblioteca estándar de Python es muy extensa y cubre una multitud de funcionalidades. Este tutorial solo ha rozado la superficie de lo que hay disponible. Al familiarizarte con estos módulos, podrás resolver muchos problemas comunes sin tener que instalar paquetes de terceros.

Estos son algunos consejos para sacar el máximo partido a la biblioteca estándar:

1. Consulta la documentación oficial: La documentación de Python contiene información detallada sobre todos los módulos de la biblioteca estándar.

2. Prefiere las soluciones estándar: Antes de instalar un paquete externo, comprueba si la biblioteca estándar ya ofrece una solución.

3. Explora las novedades: En cada nueva versión de Python se añaden nuevos módulos o funcionalidades a la biblioteca estándar.

En el próximo y último tutorial de esta serie, pondremos en práctica todo lo que hemos aprendido creando un proyecto completo en Python que utilizará varios de los conceptos y módulos que hemos explorado hasta ahora.