Quels critères d'évaluation du code en style procédural peuvent être considérés comme bons et quels sont mauvais?

Critères positifs:

• Lisibilité: À quel point il est facile de comprendre ce que fait le code en le lisant de haut en bas.
• Clarté des variables et fonctions: Utilisation de noms descriptifs reflétant leur but et leur logique.
• Découpage: Diviser des tâches complexes en fonctions plus petites et gérables. Chaque fonction doit effectuer une tâche spécifique.
• Absence de variables globales: Minimiser l'utilisation de variables globales pour réduire les dépendances et les effets secondaires.
• Gestion des erreurs: Gestion explicite des erreurs et exceptions possibles.
• Commentaires: Présents là où le code n'est pas évident ou pour expliquer la logique.
• Cohérence du style: Style uniforme de formatage et de nommage dans tout le projet.
• Minimisation de la duplication de code: Éviter de répéter des blocs de code identiques.

# Bon exemple de découpage et noms clairs
def calculate_average(numbers):
    """Calcule la moyenne d'une liste de nombres."""
    if not numbers:
        return 0
    total = sum(numbers)
    return total / len(numbers)

def process_data(data):
    # Supposons que 'data' est une liste de listes de nombres
    averages = []
    for row in data:
        avg = calculate_average(row)
        averages.append(avg)
    return averages

Critères faibles:

• Manque de clarté: Le code est difficile à comprendre en raison d'une logique confuse, de noms peu descriptifs ou d'un manque de structure.
• "Code spaghetti": Beaucoup de transitions et de dépendances rendant la séquence d'exécution difficile à suivre.
• Code "lazo": Fonctions longues et monolithiques effectuant plusieurs tâches non liées.
• Utilisation de "nombres magiques": Constantes numériques non expliquées dans le code.
• Absence de gestion des erreurs: Le programme "s'effondre" face à des situations imprévues.
• Duplication de code: Blocs identiques ou très similaires répétés à différents endroits.
• Style incohérent: Formats et noms différents rendant la lecture difficile.

# Mau exemple de "lazo" et de nombres magiques
def process(d):
    t = 0
    for r in d:
        s = 0
        c = 0
        for n in r:
            s += n
            c += 1
        if c > 0:
            t += s / c
    return t / len(d) if len(d) > 0 else 0

Comparaison:

Bonnes pratiques	Mauvaises pratiques
Lisibilité	Manque de clarté ("spaghetti", "lazo")
Variables et fonctions compréhensibles	Noms illisibles
Découpage	Fonctions monolithiques
Absence de variables globales	Utilisation excessive de variables globales
Gestion explicite des erreurs	Absence de gestion des erreurs
Commentaires là où c'est nécessaire	Absence de commentaires
Style cohérent	Style incohérent
Minimisation de la duplication de code	Duplication de code