Exemple code Python : 25 scripts essentiels pour maîtriser le langage

Vous cherchez des exemples de code Python pratiques pour progresser ? En 2026, les développeurs débutants comme confirmés s’appuient sur des scripts concrets pour apprendre et résoudre leurs problématiques quotidiennes. Les statistiques de Stack Overflow montrent que 87% des questions Python concernent l’implémentation pratique plutôt que la théorie pure.

Cet article compile les exemples de code Python les plus utiles, organisés par niveau et cas d’usage, pour vous permettre de maîtriser les concepts par la pratique.

1. Fondamentaux Python : variables et structures de base
2. Manipulation de données et fichiers
3. Scripts d’automatisation et utilitaires
4. Projets intermédiaires pour se perfectionner
5. Bonnes pratiques et optimisation du code

Fondamentaux Python : variables et structures de base

La maîtrise des structures de données constitue le socle de tout développement Python efficace.

Variables et types de données

L’échange de valeurs entre variables illustre parfaitement la syntaxe Python simplifiée :

« `python
# Échange de variables sans variable temporaire
a, b = 10, 20
a, b = b, a
print(f »a = {a}, b = {b} ») # Résultat : a = 20, b = 10
« `

Structures conditionnelles et boucles

La vérification de parité démontre l’usage des conditions :

« `python
def est_pair(nombre):
if nombre % 2 == 0:
return True
else:
return False

# Version concise
def est_pair_concis(nombre):
return nombre % 2 == 0
« `

Les boucles permettent de parcourir collections et séquences :

« `python
# Parcours de liste avec énumération
fruits = [‘pomme’, ‘banane’, ‘orange’]
for index, fruit in enumerate(fruits):
print(f »{index + 1}. {fruit} »)
« `

Gestion des chaînes de caractères

La manipulation de strings représente un usage quotidien en Python :

« `python
# Division d’une chaîne
texte = « Python est un langage polyvalent »
mots = texte.split()
print(f »Nombre de mots : {len(mots)} »)

# Formatage moderne avec f-strings
nom = « Marie »
age = 25
message = f »Bonjour {nom}, vous avez {age} ans »
« `

Manipulation de données et fichiers

Après avoir assimilé les bases, l’étape suivante consiste à manipuler données et fichiers externes.

Lecture et écriture de fichiers

La gestion des fichiers texte constitue un pilier des scripts Python utilitaires :

« `python
# Lecture complète d’un fichier
def lire_fichier(nom_fichier):
try:
with open(nom_fichier, ‘r’, encoding=’utf-8′) as fichier:
contenu = fichier.read()
return contenu
except FileNotFoundError:
return « Fichier introuvable »

# Écriture dans un fichier
def ecrire_fichier(nom_fichier, contenu):
with open(nom_fichier, ‘w’, encoding=’utf-8′) as fichier:
fichier.write(contenu)
« `

Traitement de données CSV

L’analyse de fichiers CSV simplifie l’importation de données tabulaires :

« `python
import csv

def analyser_csv(nom_fichier):
donnees = []
try:
with open(nom_fichier, ‘r’, encoding=’utf-8′) as fichier:
lecteur = csv.DictReader(fichier)
for ligne in lecteur:
donnees.append(ligne)
except FileNotFoundError:
print(« Fichier CSV introuvable »)

return donnees

# Écriture CSV
def creer_csv(nom_fichier, donnees, colonnes):
with open(nom_fichier, ‘w’, newline= », encoding=’utf-8′) as fichier:
writer = csv.DictWriter(fichier, fieldnames=colonnes)
writer.writeheader()
writer.writerows(donnees)
« `

Manipulation de listes et dictionnaires

Les compréhensions de listes offrent une syntaxe concise pour transformer les données :

« `python
# Filtrage et transformation
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pairs_carres = [x2 for x in nombres if x % 2 == 0]
print(pairs_carres) # [4, 16, 36, 64, 100]

# Dictionnaire par compréhension
mots = [‘python’, ‘java’, ‘javascript’, ‘go’]
longueurs = {mot: len(mot) for mot in mots}
print(longueurs) # {‘python’: 6, ‘java’: 4, ‘javascript’: 10, ‘go’: 2}
« `

Scripts d’automatisation et utilitaires

Les exemples précédents posent les bases pour développer des scripts d’automatisation concrets.

Générateur de mots de passe sécurisé

La sécurité informatique nécessite des mots de passe robustes générés aléatoirement :

« `python
import random
import string

def generer_mot_de_passe(longueur=12, inclure_symboles=True):
caracteres = string.ascii_letters + string.digits
if inclure_symboles:
caracteres += « !@#$%^&* »

mot_de_passe =  ».join(random.choice(caracteres) for _ in range(longueur))
return mot_de_passe

# Génération de plusieurs mots de passe
def generer_plusieurs_mots_de_passe(nombre=5, longueur=12):
mots_de_passe = []
for i in range(nombre):
mdp = generer_mot_de_passe(longueur)
mots_de_passe.append(mdp)
return mots_de_passe
« `

Sécurité cryptographique

Pour des applications critiques, préférez le module `secrets` au module `random`. Le module `secrets` utilise des générateurs cryptographiquement sécurisés.

Calculatrice en ligne de commande

Une calculatrice interactive démontre la gestion des entrées utilisateur :

« `python
import operator

def calculatrice():
operations = {
‘+’: operator.add,
‘-‘: operator.sub,
‘*’: operator.mul,
‘/’: operator.truediv,
‘‘: operator.pow
}

print(« Calculatrice Python – Tapez ‘quit’ pour sortir »)

while True:
try:
expression = input(« Entrez votre calcul : « )
if expression.lower() == ‘quit’:
break

# Évaluation sécurisée (attention aux risques en production)
resultat = eval(expression)
print(f »Résultat : {resultat} »)

except Exception as e:
print(f »Erreur : {e} »)

# Version plus sécurisée avec parsing manuel
def calculatrice_securisee():
while True:
try:
a = float(input(« Premier nombre : « ))
op = input(« Opération (+, -, *, /) : « )
b = float(input(« Second nombre : « ))

if op == ‘+’:
resultat = a + b
elif op == ‘-‘:
resultat = a – b
elif op == ‘*’:
resultat = a * b
elif op == ‘/’:
resultat = a / b if b != 0 else « Division par zéro »
else:
resultat = « Opération inconnue »

print(f »Résultat : {resultat} »)

except ValueError:
print(« Veuillez entrer des nombres valides »)
« `

Surveillance de fichiers système

La surveillance de l’espace disque permet d’automatiser la maintenance système :

« `python
import os
import shutil

def verifier_espace_disque(chemin= »/ »):
«  » »Vérifie l’espace disque disponible » » »
total, utilise, libre = shutil.disk_usage(chemin)

# Conversion en GB
total_gb = total // (10243)
utilise_gb = utilise // (10243)
libre_gb = libre // (10243)

pourcentage_utilise = (utilise / total) * 100

return {
‘total’: total_gb,
‘utilise’: utilise_gb,
‘libre’: libre_gb,
‘pourcentage’: round(pourcentage_utilise, 2)
}

def surveiller_repertoire(chemin):
«  » »Liste les fichiers volumineux d’un répertoire » » »
fichiers_volumineux = []

for racine, dossiers, fichiers in os.walk(chemin):
for fichier in fichiers:
chemin_complet = os.path.join(racine, fichier)
try:
taille = os.path.getsize(chemin_complet)
if taille > 100 * 1024 * 1024: # > 100 MB
fichiers_volumineux.append({
‘fichier’: chemin_complet,
‘taille_mb’: taille // (10242)
})
except OSError:
continue

return sorted(fichiers_volumineux, key=lambda x: x[‘taille_mb’], reverse=True)
« `

Projets intermédiaires pour se perfectionner

Une fois les scripts utilitaires maîtrisés, des projets plus ambitieux permettent d’approfondir les concepts.

Gestionnaire de tâches simple

Un gestionnaire de tâches en ligne de commande combine plusieurs concepts Python :

« `python
import json
import datetime

class GestionnaireTaches:
def __init__(self, fichier=’taches.json’):
self.fichier = fichier
self.taches = self.charger_taches()

def charger_taches(self):
try:
with open(self.fichier, ‘r’, encoding=’utf-8′) as f:
return json.load(f)
except FileNotFoundError:
return []

def sauvegarder_taches(self):
with open(self.fichier, ‘w’, encoding=’utf-8′) as f:
json.dump(self.taches, f, ensure_ascii=False, indent=2)

def ajouter_tache(self, description, priorite=’normale’):
tache = {
‘id’: len(self.taches) + 1,
‘description’: description,
‘priorite’: priorite,
‘terminee’: False,
‘date_creation’: datetime.datetime.now().isoformat()
}
self.taches.append(tache)
self.sauvegarder_taches()
return tache[‘id’]

def marquer_terminee(self, id_tache):
for tache in self.taches:
if tache[‘id’] == id_tache:
tache[‘terminee’] = True
tache[‘date_fin’] = datetime.datetime.now().isoformat()
self.sauvegarder_taches()
return True
return False

def lister_taches(self, inclure_terminees=False):
taches_affichees = self.taches
if not inclure_terminees:
taches_affichees = [t for t in self.taches if not t[‘terminee’]]

for tache in taches_affichees:
statut = « ✓ » if tache[‘terminee’] else « ○ »
print(f »{statut} [{tache[‘id’]}] {tache[‘description’]} ({tache[‘priorite’]}) »)
« `

Analyseur de logs web

L’analyse de fichiers de logs nécessite des expressions régulières et des statistiques :

« `python
import re
import collections
from datetime import datetime

class AnalyseurLogs:
def __init__(self, fichier_log):
self.fichier_log = fichier_log
self.pattern_apache = re.compile(
r'(\S+) \S+ \S+ \[([^\]]+)\] « (\S+) (\S+) (\S+) » (\d+) (\d+)’
)

def parser_ligne(self, ligne):
match = self.pattern_apache.match(ligne)
if match:
return {
‘ip’: match.group(1),
‘timestamp’: match.group(2),
‘methode’: match.group(3),
‘url’: match.group(4),
‘protocole’: match.group(5),
‘statut’: int(match.group(6)),
‘taille’: int(match.group(7))
}
return None

def analyser_fichier(self):
statistiques = {
‘total_requetes’: 0,
‘ips_uniques’: set(),
‘codes_statut’: collections.Counter(),
‘urls_populaires’: collections.Counter(),
‘erreurs_404’: []
}

try:
with open(self.fichier_log, ‘r’, encoding=’utf-8′) as f:
for ligne in f:
entree = self.parser_ligne(ligne.strip())
if entree:
statistiques[‘total_requetes’] += 1
statistiques[‘ips_uniques’].add(entree[‘ip’])
statistiques[‘codes_statut’][entree[‘statut’]] += 1
statistiques[‘urls_populaires’][entree[‘url’]] += 1

if entree[‘statut’] == 404:
statistiques[‘erreurs_404’].append(entree[‘url’])

except FileNotFoundError:
print(f »Fichier {self.fichier_log} introuvable »)
return None

# Conversion du set en nombre
statistiques[‘ips_uniques’] = len(statistiques[‘ips_uniques’])

return statistiques

def generer_rapport(self):
stats = self.analyser_fichier()
if not stats:
return

print(f »=== Rapport d’analyse – {self.fichier_log} === »)
print(f »Total des requêtes : {stats[‘total_requetes’]} »)
print(f »IPs uniques : {stats[‘ips_uniques’]} »)
print(f »\nCodes de statut les plus fréquents : »)
for code, count in stats[‘codes_statut’].most_common(5):
print(f » {code} : {count} requêtes »)

print(f »\nURLs les plus visitées : »)
for url, count in stats[‘urls_populaires’].most_common(10):
print(f » {url} : {count} visites »)
« `

Web scraper simple

L’extraction de données web utilise la bibliothèque requests et BeautifulSoup :

« `python
import requests
from bs4 import BeautifulSoup
import csv
import time

class WebScraper:
def __init__(self, delai=1):
self.session = requests.Session()
self.session.headers.update({
‘User-Agent’: ‘Mozilla/5.0 (compatible; Python-Scraper/1.0)’
})
self.delai = delai

def extraire_titres_actualites(self, url_base):
«  » »Extrait les titres d’actualités d’un site » » »
try:
response = self.session.get(url_base, timeout=10)
response.raise_for_status()

soup = BeautifulSoup(response.content, ‘html.parser’)

# Sélecteurs génériques pour les titres
titres = []
selectors = [‘h1’, ‘h2’, ‘h3’, ‘.titre’, ‘.title’, ‘.headline’]

for selector in selectors:
elements = soup.select(selector)
for element in elements[:10]: # Limite à 10 résultats
texte = element.get_text().strip()
if len(texte) > 10: # Filtrer les titres trop courts
titres.append({
‘titre’: texte,
‘url’: url_base,
‘timestamp’: time.strftime(‘%Y-%m-%d %H:%M:%S’)
})

return titres[:10] # Retourne les 10 premiers

except requests.RequestException as e:
print(f »Erreur lors de la requête : {e} »)
return []

def sauvegarder_csv(self, donnees, nom_fichier):
«  » »Sauvegarde les données extraites en CSV » » »
if not donnees:
return

with open(nom_fichier, ‘w’, newline= », encoding=’utf-8′) as f:
writer = csv.DictWriter(f, fieldnames=donnees[0].keys())
writer.writeheader()
writer.writerows(donnees)

print(f »Données sauvegardées dans {nom_fichier} »)

def scraper_multiple_sites(self, urls, nom_fichier=’actualites.csv’):
«  » »Scrape plusieurs sites et compile les résultats » » »
tous_titres = []

for url in urls:
print(f »Extraction de {url}… »)
titres = self.extraire_titres_actualites(url)
tous_titres.extend(titres)

# Respect du délai entre requêtes
time.sleep(self.delai)

self.sauvegarder_csv(tous_titres, nom_fichier)
return tous_titres
« `

Bonnes pratiques et optimisation du code

Ces exemples pratiques s’accompagnent de règles de développement pour produire du code maintenable.

Gestion d’erreurs robuste

La gestion d’exceptions prévient les plantages et améliore l’expérience utilisateur :

« `python
import logging

# Configuration du logging
logging.basicConfig(
level=logging.INFO,
format=’%(asctime)s – %(levelname)s – %(message)s’,
handlers=[
logging.FileHandler(‘app.log’),
logging.StreamHandler()
]
)

def division_securisee(a, b):
«  » »Division avec gestion complète des erreurs » » »
try:
# Validation des types
if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
raise TypeError(« Les arguments doivent être des nombres »)

# Validation des valeurs
if b == 0:
raise ValueError(« Division par zéro impossible »)

resultat = a / b
logging.info(f »Division réussie : {a} / {b} = {resultat} »)
return resultat

except TypeError as e:
logging.error(f »Erreur de type : {e} »)
raise
except ValueError as e:
logging.error(f »Erreur de valeur : {e} »)
raise
except Exception as e:
logging.error(f »Erreur inattendue : {e} »)
raise

def traitement_fichier_robuste(nom_fichier):
«  » »Traitement de fichier avec gestion d’erreurs » » »
try:
with open(nom_fichier, ‘r’, encoding=’utf-8′) as f:
contenu = f.read()

# Traitement du contenu
lignes = contenu.split(‘\n’)
lignes_non_vides = [ligne.strip() for ligne in lignes if ligne.strip()]

return {
‘succes’: True,
‘nombre_lignes’: len(lignes_non_vides),
‘donnees’: lignes_non_vides
}

except FileNotFoundError:
logging.warning(f »Fichier non trouvé : {nom_fichier} »)
return {‘succes’: False, ‘erreur’: ‘Fichier introuvable’}
except PermissionError:
logging.error(f »Permissions insuffisantes pour : {nom_fichier} »)
return {‘succes’: False, ‘erreur’: ‘Accès refusé’}
except UnicodeDecodeError:
logging.error(f »Problème d’encodage dans : {nom_fichier} »)
return {‘succes’: False, ‘erreur’: ‘Encodage invalide’}
« `

Optimisation et performance

Les techniques d’optimisation améliorent les performances des scripts Python :

« `python
import time
import functools
from collections import defaultdict

# Décorateur de mesure de performance
def mesurer_temps(func):
@functools.wraps(func)
def wrapper(*args, kwargs):
debut = time.time()
resultat = func(*args, kwargs)
fin = time.time()
print(f »{func.__name__} exécutée en {fin – debut:.4f} secondes »)
return resultat
return wrapper

# Cache LRU pour éviter les recalculs
@functools.lru_cache(maxsize=128)
def fibonacci_optimise(n):
«  » »Version optimisée avec cache » » »
if n < 2: return n return fibonacci_optimise(n-1) + fibonacci_optimise(n-2) @mesurer_temps def traiter_donnees_optimise(donnees): """Traitement optimisé avec structures adaptées""" # Utilisation de defaultdict pour éviter les vérifications statistiques = defaultdict(int) categories = defaultdict(list) for item in donnees: statistiques[item['type']] += 1 categories[item['categorie']].append(item['valeur']) # Compréhension de liste pour les calculs moyennes = { cat: sum(valeurs) / len(valeurs) for cat, valeurs in categories.items() if valeurs } return { 'statistiques': dict(statistiques), 'moyennes': moyennes } # Générateur pour économiser la mémoire def lire_gros_fichier(nom_fichier): """Lecture ligne par ligne pour les gros fichiers""" try: with open(nom_fichier, 'r', encoding='utf-8') as f: for ligne in f: ligne = ligne.strip() if ligne: # Ignorer les lignes vides yield ligne except FileNotFoundError: print(f"Fichier {nom_fichier} introuvable") return def traiter_gros_volume(): """Traitement mémoire-efficace avec générateur""" compteur = 0 for ligne in lire_gros_fichier('donnees_massives.txt'): # Traitement ligne par ligne compteur += 1 if compteur % 10000 == 0: print(f"Traité {compteur} lignes...") return compteur ```

Tests et validation

Les tests unitaires garantissent la fiabilité du code en production :

« `python
import unittest
import tempfile
import os

class TestGestionFichiers(unittest.TestCase):

def setUp(self):
«  » »Préparation avant chaque test » » »
self.fichier_temp = tempfile.NamedTemporaryFile(delete=False, mode=’w’, encoding=’utf-8′)
self.fichier_temp.write(« Ligne 1\nLigne 2\nLigne 3 »)
self.fichier_temp.close()

def tearDown(self):
«  » »Nettoyage après chaque test » » »
if os.path.exists(self.fichier_temp.name):
os.unlink(self.fichier_temp.name)

def test_lecture_fichier(self):
«  » »Test de lecture de fichier » » »
resultat = traitement_fichier_robuste(self.fichier_temp.name)

self.assertTrue(resultat[‘succes’])
self.assertEqual(resultat[‘nombre_lignes’], 3)
self.assertIn(‘Ligne 1’, resultat[‘donnees’])

def test_fichier_inexistant(self):
«  » »Test avec fichier inexistant » » »
resultat = traitement_fichier_robuste(‘fichier_inexistant.txt’)

self.assertFalse(resultat[‘succes’])
self.assertEqual(resultat[‘erreur’], ‘Fichier introuvable’)

def test_division_securisee(self):
«  » »Test de la division avec gestion d’erreurs » » »
# Test normal
self.assertEqual(division_securisee(10, 2), 5.0)

# Test division par zéro
with self.assertRaises(ValueError):
division_securisee(10, 0)

# Test type incorrect
with self.assertRaises(TypeError):
division_securisee(« 10 », 2)

if __name__ == ‘__main__’:
# Lancement des tests
unittest.main(verbosity=2)
« `

Ces exemples de code Python couvrent les aspects essentiels du développement, depuis les concepts fondamentaux jusqu’aux bonnes pratiques professionnelles. La pratique régulière de ces scripts, adaptés à vos projets spécifiques, accélérera votre maîtrise du langage.

Commencez par implémenter les scripts qui correspondent à votre niveau actuel, puis progressez vers des projets plus complexes en intégrant systématiquement la gestion d’erreurs et les tests unitaires dans votre workflow de développement.