Python

Normes départementales du langage Python.

Fichiers

Les fichiers du langage Python doivent avoir l'extension .py.

Chaque classe doit être dans un ou des fichiers dont le nom est celui de la classe converti en notation serpent (snake case), à moins que plusieurs classes soient indissociables.

Gabarit d'un fichier

Chaque fichier doit respecter l'ordre suivant :

# Imports

# Constantes

# Fonctions
# Pour chaque fonction respecter l'ordre aussi:
    # Constantes
    # Variables
    # Logique
    # Return ou print

# Variables

# Logique

Langue

Le code peut être en anglais ou en français, mais doit être constant. Tandis que la documentation, les commentaires et les sorties du terminal doivent obligatoirement être en français.

Importations

Limiter les importations à ce qui est nécessaire au code présent dans le fichier :

import numpy as np
#    ^^^^^^^^^^^^^ Ne devrait pas être présent puisqu'inutilisé.

print("Bonjour le monde!")

Identificateurs

Tous les identificateurs doivent être significatifs.

De plus, pour une meilleure intercompatibilité, les règles suivantes devraient être respectées :

• Débuter par une lettre ou un trait de soulignement.
• Contenir que des lettres (sans accent), des chiffres, et des traits de soulignement.
• Ne pas être un terme réservé par les langages de programmation.

Constantes

Pour être plus distinguables des autres identificateurs, ceux des constantes doivent utiliser la notation « serpent criant (screaming snake case) » en contenant que des lettres majuscules et des traits de soulignement pour séparer les termes :

VALEUR_MAXIMALE = 42

Variables

Les identificateurs de données membres, de variables, de méthodes, et de fonctions, doivent utiliser la casse de chameau « camel case », c'est-à-dire commencer par un caractère minuscule, et utiliser un caractère majuscule au début des termes suivants :

identificateurDeVariableBooleenne = True

Fonction

L'identificateur doit comporter un verbe à l'infinitif précisant ce que réalise la fonction.

Une fonction devrait contenir au maximum une trentaine de lignes de code.

Typage

Toutes les variables, constantes, paramètres et types de retour doivent être typés.

Les tableaux numpy doivent être typés avec numpy.typing.

Une fonction qui n'a pas de return aura comme type de retour None.

Netteté

Tout code source doit être le plus concis possible, tout en restant visuellement agréable et facile à lire.

Les remises ne devraient pas contenir de code de débogage.

Commentaires

Outre pour des raisons académiques, seuls les morceaux de code non triviaux doivent être commentés afin d'expliquer leur algorithme.

Toutes les fonctions doivent être commentées à l'aide d'une docstring selon la norme Google; les sections Args et Returns sont retirées lorsqu'elles sont vides :

def sommeEntiers(nombre1: int, nombre2: int) -> int:
    """Additionne deux entiers

    Args:
        nombre1: Premier entier à additionner
        nombre2: Deuxième entier à additionner

    Returns:
        La somme des deux entiers reçus
    """

    somme: int

    somme = nombre1 + nombre2

    return somme

Les remises ne devraient pas contenir de code en commentaire inutilement.

Aération

Comme dans tous textes, les gros morceaux de code doivent être séparés en paragraphes afin d'être plus agréables à lire, mais il ne devrait pas y avoir plus de 2 sauts de lignes consécutifs.

Chaque éléments importants doivent aussi être séparés par une ligne vide. Par exemple: entre les constantes et les variables, entre les variables et les fonctions, et entre chaque fonctions.

Crochets

Les crochets ne doivent pas être précédés ni suivis d'un espace lors d'initialisation d'une liste sur une seule ligne :

# Sur une ligne
tabEntiers = [7, 42, 69, 404, 666]

# Sur plusieurs lignes
tabEntiers = [
    7,
    42,
    69,
    404,
    666
]

Opérateurs

Les opérateurs unaires doivent être adjacents aux identificateurs tandis que les opérateurs binaires doivent être précédés et suivis d'un espace :

variableC = -variableA / variableB * 42

Indentation

Il doit y avoir une indentation à la suite de chaque deux-points, notamment pour les fonctions et méthodes, les if, les else, les while, les for, et les case :

class Classe:
    def methode(self, valeurEntiere):
        match valeurEntiere:
            case _:
                for i in range(666):
                    if valeurEntiere < 42:
                        valeurEntiere += 1
                    else:
                        valeurEntiere -= 1
                    break

L'indentation doit être faite avec des espaces et non des tabulations, conformément à la PEP 8, à raison de 4 espaces par niveau.

Élégance

Le code doit être élégant en étant concis et en évitant les pléonasmes et les redondances.

Pléonasmes

Une proposition est toujours booléenne :

# if estValide == True:
if estValide:

Une valeur autre que 0 est interprétée comme étant vraie sous forme booléenne :

# if compte != 0:
if compte:

Redondances

Les mêmes instructions en début et en fin de if et de else doivent être sorties de ces blocs de code :

# Incorrecte
if estValide:
    instructionA()
    instructionB()
    instructionD()
else:
    instructionA()
    instructionC()
    instructionD()

# Correcte
instructionA()
if estValide:
    instructionB()
else:
    instructionC()
instructionD()

Concision

Affectation d'une valeur booléenne par une proposition plutôt que dans une structure conditionnelle :

# Incorrecte
if estValide:
    enMarche = True
else:
    enMarche = False

# Correcte
enMarche = estValide

Sans bloc de code vide :

# Incorrecte
if estValide:
    pass
else:
    instruction()

# Correcte
if not estValide:
    instruction()

Restrictions

Pour le cours 420-1C7 (Programmation 1), les restrictions suivantes s'appliquent :

• Maximum un seul return par fonction, toujours en fin de fonction (la dernière ligne de la fonction)
• Les mots-clés break, continue et raise sont interdits
• Toute fonction de terminaison prématurée du programme (exit(), quit(), sys.exit(), os._exit()) est interdite.
• En résumé: interdit de contourner la condition d'une boucle, de sortir d'une fonction avant sa fin, ou de terminer le programme prématurément.