présentation du code

dans cette partie on voit des conventions de codage; on peut ne pas les suivre, et le code fonctionne tout de même ! mais il est fortement recommandé de les appliquer - sinon c’est un peu comme si on parlait avec un fort accent :)
en particulier tout le code de la librairie standard obéit à ces règles de présentation (sauf certains modules très anciens)

PEP-008¶

ces règles de présentation sont explicitées dans la note dite PEP-008
les points les plus importants qu’on vous demande de retenir et d’appliquer :

on va voir tout ça un peu plus en détail

les espaces¶

les espaces (2/3)¶

les espaces (3/3)¶

les noms de variables¶

largeur de la page¶

• dans sa version orthodoxe, la largeur de la page est limitée à 80 caractères
  en pratique aujourd’hui on peut être un peu plus souple,
  mais jamais > 100 caractères de large

• l’idée est de pouvoir juxtaposer plusieurs codes (3 voire 4 )
  dans la largeur d’un écran moderne

• on a parfois besoin de recourir à des astuces pour y arriver

longueur des lignes¶

plusieurs astuces pour respecter une largeur fixe :

# 1. utiliser les parenthèses

def foo():
    if expression(args):
        return (le_resultat() and de_l_expression() 
                and est_susceptible() and de_prendre()
                and beaucoup_de_place())

longueur des lignes et parenthèses¶

# 2. ça marche aussi avec les {} et [] 

GLOBAL_MAP = [
    {'shortcut': 'ctrl-w', 'function': 'RISE:render-all-cells'},
    {'shortcut': 'ctrl-q', 'function': 'RISE:edit-all-cells'},
]

longueur des lignes et chaines littérales¶

# 3. lorsqu'on a besoin de retourner des chaines de caractères très longues
# on peut utiliser une conjonction de
# * parenthèses
# * concaténation des chaines dans le source

def longue_chaine(nom, prenom):
    return (
        f"<table><thead><tr><th>Nom</th><th>Prénom</th></tr></thead>"
        f"<tbody><tr><td>{nom}</td><td>{prenom}</td></tr></tbody>"
        f"</table>"
    )

le docstring¶

lorsqu’on écrit une fonction (ou une classe, ou un module) on la documente comme ceci

def gcd(a, b):
    """
    returns the greatest common divisor
    of both inputs
    """
    while b:
        a, b = b, a % b
    return a

help(gcd)

Help on function gcd in module __main__:

gcd(a, b)
    returns the greatest common divisor
    of both inputs

• le docstring est une simple chaine, sauf qu’elle apparaît en premier

• cela permet de ranger de la documentation directement dans l’objet fonction

• nécessaire pour les fonctions exposées aux utilisateurs

type hints¶

de manière optionnelle, on peut indiquer les types des arguments et le type de retour

def gcd2(a: int, b: int) -> int:
    """
    returns the greatest common divisor
    of both inputs
    """
    while b:
        a, b = b, a % b
    return a

help(gcd2)

Help on function gcd2 in module __main__:

gcd2(a: int, b: int) -> int
    returns the greatest common divisor
    of both inputs

• annotations de type (type hints) totalement optionnelles et ignorées par l’interpréteur

• mais utiles pour une meilleure documentation

• et aussi pour détecter des erreurs de type par analyse statique i.e. avant l’exécution, avec des outils dédiés comme par exemple mypy

• techniquement, ne fait pas partie de la PEP008, car les type hints sont postérieurs

de nombreux outils¶

• très grand nombre d’outils de vérification de code Python

• du plus simple qui vérifie seulement PEP008 - par exemple flake8

• au plus compliqué - genre pylint - qui peut trouver

  • les erreurs de frappe dans les noms de variable

  • les imports inutiles,

  • ...

command line¶

pour vérifier / réparer, regardez du coté de

• autopep8

• black

• flake8

• pylint (affiche les erreurs pep8, et bien d’autres d’ailleurs)

vs-code¶

et pour naviguer entre les erreurs, via la palette (ctrl-shift p ou cmd-shift-p)