Librairie standard et administration

Commande Pip¶

pip est un gestionnaire de paquets pour Python. Il permet d’installer, de mettre à jour et de supprimer des bibliothèques Python. pip est utilisé pour gérer les dépendances de projets Python et est essentiel pour le développement Python.

Exemple d’utilisation de pip

Pour installer un paquet, par exemple requests, vous pouvez utiliser la commande suivante :

pip install requests

Cela installera la bibliothèque requests et ses dépendances.

Pour desintaller un paquet, par exemple requests, vous pouvez utiliser la commande suivante :

pip uninstall requests

Pour connaitre la liste des bibliothèques installées, vous pouvez utiliser la commande suivante :

pip freeze

On peut ainsi sauvegarder la liste dans un fichier.

pip freeze > requirements.txt

La liste sauvegardée peut être rechargée à volonté

pip install -r requirements.txt

Infos sur le système¶

Python fournit plusieurs moyens d’obtenir des informations sur le système sur lequel il s’exécute. Cela peut être utile pour diagnostiquer des problèmes, adapter le comportement d’un script à l’environnement, ou simplement pour des raisons de documentation.

Utilisation du module platform¶

Le module platform permet d’accéder à des informations sur le système d’exploitation, la version de Python, l’architecture, etc.

import platform

print(platform.system())         # Nom du système d'exploitation (ex: 'Windows', 'Linux', 'Darwin')
print(platform.release())        # Version du système
print(platform.machine())        # Architecture (ex: 'x86_64')
print(platform.python_version()) # Version de Python

Utilisation du module sys¶

Le module sys fournit des informations sur l’interpréteur Python lui-même et sur l’environnement d’exécution.

import sys

print(sys.version)      # Version complète de Python
print(sys.executable)   # Chemin vers l'exécutable Python
print(sys.platform)     # Plateforme (ex: 'win32', 'linux', 'darwin')
print(sys.path)         # Liste des chemins de recherche des modules

Ces outils sont particulièrement utiles pour le débogage, la configuration de scripts multiplateformes, ou encore pour générer des rapports d’environnement.

Utilisation du module os¶

Le module os permet d’interagir avec le système d’exploitation, notamment pour manipuler les fichiers, les répertoires, et les variables d’environnement.

import os

print(os.name)                     # Nom du système (ex: 'posix', 'nt')
print(os.getcwd())                 # Répertoire de travail actuel
print(os.listdir())                # Liste des fichiers dans le répertoire courant
print(os.environ.get('PATH'))      # Valeur d'une variable d'environnement

Ce module est très utile pour automatiser des tâches système, créer ou supprimer des fichiers, ou encore naviguer dans l’arborescence des dossiers.

Gérer la ligne de commande¶

Python permet d’interagir avec la ligne de commande grâce à plusieurs modules de la bibliothèque standard. Cela permet de créer des scripts plus flexibles, capables de recevoir des arguments ou d’exécuter des commandes système.

Utilisation du module argparse¶

Le module argparse permet de gérer les arguments passés à un script Python via la ligne de commande. C’est l’outil recommandé pour créer des interfaces en ligne de commande robustes.

import argparse

parser = argparse.ArgumentParser(description="Un exemple de script avec des arguments.")
parser.add_argument("nom", help="Nom de l'utilisateur")
parser.add_argument("--age", type=int, help="Âge de l'utilisateur", default=0)

args = parser.parse_args()

print(f"Bonjour {args.nom}, vous avez {args.age} ans.")

Interception des signaux¶

Python permet d’intercepter et de gérer les signaux du système d’exploitation, comme les interruptions clavier (Ctrl+C) ou les demandes de terminaison. Cela permet de rendre les programmes plus robustes et de gérer proprement l’arrêt ou la suspension d’un processus.

Utilisation du module signal¶

Le module signal permet de définir des gestionnaires personnalisés pour différents signaux système.

import signal
import time

def gerer_interruption(signum, frame):
    print("\nInterruption détectée (Ctrl+C). Nettoyage en cours...")
    exit(0)

# Associer le signal SIGINT (Ctrl+C) à la fonction de gestion
signal.signal(signal.SIGINT, gerer_interruption)

print("Appuyez sur Ctrl+C pour interrompre.")
while True:
    time.sleep(1)
    print("Programme en cours d'exécution...")

Signaux courants¶

• signal.SIGINT : Interruption clavier (Ctrl+C)

• signal.SIGTERM : Demande de terminaison (souvent utilisée par les systèmes pour arrêter un processus)

• signal.SIGHUP : Déconnexion du terminal (sur Unix)

• signal.SIGALRM : Minuterie expirée

Exemple avec SIGTERM¶

def gerer_termination(signum, frame):
    print("Signal de terminaison reçu. Fermeture propre du programme.")
    exit(0)

signal.signal(signal.SIGTERM, gerer_termination)

Ce mécanisme est particulièrement utile pour les scripts longs, les serveurs, ou les programmes qui doivent libérer des ressources (fichiers, connexions réseau, etc.) avant de se fermer.

Fichiers temporaires¶

Le module tempfile permet de créer des fichiers et des répertoires temporaires de manière sécurisée. Ces fichiers sont souvent utilisés pour stocker des données intermédiaires ou temporaires sans polluer le système de fichiers.

Exemple de création d’un fichier temporaire¶

import tempfile

with tempfile.NamedTemporaryFile(mode='w+', delete=True) as tmp:
    tmp.write("Données temporaires")
    tmp.seek(0)
    print(tmp.read())  # Affiche le contenu du fichier temporaire

• delete=True : le fichier est supprimé automatiquement à la fermeture.

• NamedTemporaryFile : crée un fichier avec un nom accessible via tmp.name.

Exemple de répertoire temporaire¶

with tempfile.TemporaryDirectory() as tmpdir:
    print(f"Répertoire temporaire créé : {tmpdir}")

Gestion des processus¶

Le module subprocess permet de lancer et de contrôler des processus externes. Il est utile pour exécuter des commandes système ou interagir avec d’autres programmes.

Exemple simple¶

import subprocess

result = subprocess.run(["echo", "Bonjour"], capture_output=True, text=True)
print(result.stdout)  # Affiche "Bonjour"

Exécution avec gestion des erreurs¶

try:
    subprocess.run(["ls", "/chemin/inexistant"], check=True)
except subprocess.CalledProcessError as e:
    print("Erreur lors de l'exécution :", e)

Expressions régulières¶

Le module re permet de manipuler des chaînes de caractères à l’aide d’expressions régulières. C’est un outil puissant pour la recherche, la validation ou la transformation de texte.

Exemple de recherche¶

import re

texte = "Mon email est exemple@test.com"
match = re.search(r"\b[\w.-]+@[\w.-]+\.\w+\b", texte)
if match:
    print("Email trouvé :", match.group())

Exemple de remplacement¶

texte = "Le prix est de 100 euros"
nouveau_texte = re.sub(r"\d+", "XXX", texte)
print(nouveau_texte)  # "Le prix est de XXX euros"

Logging¶

Le module logging permet de générer des messages de journalisation (logs) pour suivre l’exécution d’un programme, détecter des erreurs ou enregistrer des événements.

Exemple de configuration de base¶

import logging

logging.basicConfig(level=logging.INFO)
logging.info("Démarrage du programme")
logging.warning("Ceci est un avertissement")
logging.error("Une erreur est survenue")

Journalisation dans un fichier¶

logging.basicConfig(filename='app.log', level=logging.DEBUG,
                    format='%(asctime)s - %(levelname)s - %(message)s')

logging.debug("Message de debug")
logging.info("Information")
logging.error("Erreur critique")

Le module logging est préférable à print() pour les applications complexes, car il permet de mieux contrôler le niveau, le format et la destination des messages.

L’accès aux bases de données¶

Python propose plusieurs bibliothèques pour interagir avec des bases de données relationnelles comme SQLite, MySQL ou PostgreSQL. La bibliothèque standard inclut le module sqlite3 pour travailler avec des bases SQLite.

Exemple avec sqlite3¶

import sqlite3

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

# Création d'une table
cursor.execute("CREATE TABLE IF NOT EXISTS utilisateurs (id INTEGER PRIMARY KEY, nom TEXT)")

# Insertion de données
cursor.execute("INSERT INTO utilisateurs (nom) VALUES (?)", ("Alice",))
conn.commit()

# Lecture des données
cursor.execute("SELECT * FROM utilisateurs")
for row in cursor.fetchall():
    print(row)

conn.close()

Pour d’autres bases de données, on peut utiliser des bibliothèques comme mysql-connector-python, psycopg2, ou des ORM comme SQLAlchemy.

Réseaux¶

Python permet de créer des applications réseau grâce à des modules comme socket pour les connexions bas niveau, ou http.client pour les requêtes HTTP.

Exemple avec socket (serveur simple)¶

import socket

serveur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serveur.bind(("localhost", 12345))
serveur.listen(1)
print("Serveur en attente de connexion...")

conn, addr = serveur.accept()
print("Connecté par", addr)
conn.sendall(b"Bonjour client !")
conn.close()

Exemple avec socket (client)¶

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("localhost", 12345))
data = client.recv(1024)
print("Reçu :", data.decode())
client.close()

Pour des communications plus haut niveau, on peut utiliser requests, http.server, ou des frameworks comme Flask ou FastAPI.

Python et Web¶

Python est largement utilisé pour le développement web, que ce soit côté serveur avec des frameworks ou pour interagir avec des APIs web.

Création d’un serveur web simple avec http.server¶

# Partie serveur
from http.server import SimpleHTTPRequestHandler, HTTPServer

serveur = HTTPServer(("localhost", 8000), SimpleHTTPRequestHandler)
print("Serveur en cours d'exécution sur http://localhost:8000")
serveur.serve_forever()


# Partie client
import http.client

# Définir le nom de domaine et le chemin de la ressource
domain = "localhost"
path = "/"

# Créer une connexion HTTP
conn = http.client.HTTPConnection(domain)

# Envoyer une requête GET
conn.request("GET", path)

# Obtenir la réponse
response = conn.getresponse()

# Lire et afficher le contenu de la réponse
content = response.read()
print(content.decode('utf-8'))

# Fermer la connexion
conn.close()