Chapitre 13 : Bonnes pratiques

# MAUVAIS - Criard, désordonné, suspect.
def Traiter_Cible (Cible,Parametre):
    R=None
    if (Parametre>0):
        R = Cible*Parametre
    return R

# BON - Lisible, discret, professionnel.
def traiter_cible(cible, parametre):
    """Applique un paramètre à une cible et retourne le résultat."""
    resultat = None
    if parametre > 0:
        resultat = cible * parametre
    return resultat

# OBSCUR - Code "astucieux" et dangereux.
x=[n for n in l if n%2 and n>10 and func(n)];m=sum(x)/len(x) if x else 0

# CLAIR - On comprend l'intention en une lecture.
def calculer_moyenne_filtree(liste_nombres):
    """
    Calcule la moyenne des nombres impairs > 10 qui passent un test.
    """
    nombres_filtres = [
        n for n in liste_nombres 
        if n % 2 != 0 and n > 10 and test_special(n)
    ]
    
    if not nombres_filtres:
        return 0
    
    moyenne = sum(nombres_filtres) / len(nombres_filtres)
    return moyenne

operation_phantome/          # Racine du projet
├── README.md                # Présentation, instructions
├── requirements.txt         # Dépendances (pip install -r requirements.txt)
├── .gitignore              # Ce qu'il faut ignorer (logs, fichiers sensibles)
├── setup.py                # Installation en tant que package (optionnel)
│
├── src/                    # Le code source
│   └── operation/
│       ├── __init__.py     # Rend le dossier importable
│       ├── infiltration.py # Module d'infiltration
│       ├── exfiltration.py
│       └── communication.py
│
├── tests/                  # Les tests (aussi importants que le code)
│   ├── __init__.py
│   ├── test_infiltration.py
│   └── test_communication.py
│
├── data/                   # Données, configurations
│   ├── config.json
│   └── cibles.csv
│
├── docs/                   # Documentation détaillée
│   └── protocoles.md
│
└── logs/                   # Fichiers de log (NE PAS versionner !)
    └── operation_20231027.log

# operation/calculs_secrets.py
def chiffrement_simple(message, decalage):
    """Chiffre un message par décalage de lettres (César)."""
    if not isinstance(message, str):
        raise TypeError("Le message doit être une chaîne")
    resultat = ""
    for lettre in message:
        if lettre.isalpha():
            base = ord('A') if lettre.isupper() else ord('a')
            nouvelle_lettre = chr((ord(lettre) - base + decalage) % 26 + base)
            resultat += nouvelle_lettre
        else:
            resultat += lettre
    return resultat

# tests/test_calculs_secrets.py
import unittest
from operation.calculs_secrets import chiffrement_simple

class TestChiffrementSimple(unittest.TestCase):
    """Tests pour le module de chiffrement."""
    
    def test_chiffrement_basique(self):
        """Test de chiffrement d'un message simple."""
        resultat = chiffrement_simple("ALLO", 3)
        self.assertEqual(resultat, "DOOR")
    
    def test_dechiffrement(self):
        """Test que le chiffrement est réversible."""
        message_original = "SECRET"
        decalage = 5
        chiffre = chiffrement_simple(message_original, decalage)
        dechiffre = chiffrement_simple(chiffre, -decalage)
        self.assertEqual(dechiffre, message_original)
    
    def test_gestion_erreurs(self):
        """Test que des entrées invalides lèvent des erreurs."""
        with self.assertRaises(TypeError):
            chiffrement_simple(123, 3)  # Nombre au lieu de chaîne
    
    def test_conservation_non_alpha(self):
        """Test que les caractères non alphabétiques sont conservés."""
        resultat = chiffrement_simple("A1B!", 2)
        self.assertEqual(resultat, "C1D!")

# Pour exécuter les tests depuis la ligne de commande :
# python -m unittest discover tests/