Langages et programmation

Python n'est qu'un langage parmi des centaines.

Ce chapitre prend du recul : quelles constructions élémentaires tous les langages partagent-ils, et en quoi diffèrent-ils ?

Il montre ensuite comment écrire un programme fiable : spécifier une fonction, la mettre au point avec des jeux de tests, et réutiliser du code grâce aux bibliothèques.

1. Les constructions élémentaires

1.1 Un corpus commun

Tout programme, quel que soit le langage, est bâti avec un petit nombre de constructions.

Les six constructions sont toutes présentes dans ce petit programme. Repère-les, puis exécute-le.

def somme_pairs(n):
    s = 0
    for i in range(n + 1):
        if i % 2 == 0:
            s = s + i
    return s

print(somme_pairs(10))

# boucle non bornée : on ne sait pas à l'avance combien de tours il faudra
n = 1
while somme_pairs(n) < 1000:
    n = n + 1
print("On dépasse 1000 à partir de n =", n)

1.2 Unité et diversité

Le même algorithme s'écrit de façon voisine dans des langages différents.

Voici la somme des entiers pairs de $0$ à $n$, dans trois langages.

def somme_pairs(n):
    s = 0
    for i in range(n + 1):
        if i % 2 == 0:
            s = s + i
    return s

function sommePairs(n) {
  let s = 0;
  for (let i = 0; i <= n; i++) {
    if (i % 2 === 0) {
      s = s + i;
    }
  }
  return s;
}

int somme_pairs(int n) {
    int s = 0;
    for (int i = 0; i <= n; i++) {
        if (i % 2 == 0) {
            s = s + i;
        }
    }
    return s;
}

def somme_multiples_3(n):
    s = 0
    # à toi
    return s

1.3 Les styles de programmation

Les langages se distinguent aussi par leur style, qu'on appelle un paradigme.

Python est multi-paradigme : il permet plusieurs styles dans le même programme.

notes = [12, 7, 15, 9]

# style impératif : on modifie une variable pas à pas
total = 0
for x in notes:
    total = total + x
print(total)

# style fonctionnel : on compose des fonctions, sans variable modifiée
print(sum([x for x in notes]))

# style objet : on appelle une méthode de l'objet
notes.append(18)
print(notes)

2. Spécifier une fonction

2.1 Prototype et documentation

Avant d'écrire le corps d'une fonction, on écrit son prototype : son nom, ses paramètres avec leur type attendu, et le type du résultat.

On écrit ensuite sa documentation (la docstring) : ce que la fonction calcule, en une phrase précise.

def racine_entiere(n):
    """Renvoie le plus grand entier r tel que r * r <= n.
    n : entier positif ou nul (précondition).
    Résultat : entier r vérifiant r*r <= n < (r+1)*(r+1) (postcondition)."""

2.2 Préconditions et postconditions

La spécification est un contrat entre celui qui écrit la fonction et ceux qui l'utilisent.

Grâce à elle, on peut programmer et tester chaque fonction indépendamment des autres.

2.3 Les assertions

On s'en sert pour garantir les préconditions et les postconditions.

def racine_entiere(n):
    assert type(n) == int and n >= 0, "n doit être un entier positif ou nul"
    r = 0
    while (r + 1) * (r + 1) <= n:
        r = r + 1
    assert r * r <= n < (r + 1) * (r + 1)
    return r

print(racine_entiere(17))
print(racine_entiere(16))

Ajoute une dernière ligne print(racine_entiere(-4)) et relance : la précondition est violée, l'assertion arrête le programme et affiche son message.

3. Mettre au point avec des jeux de tests

3.1 Le jeu de tests

def racine_entiere(n):
    r = 0
    while (r + 1) * (r + 1) <= n:
        r = r + 1
    return r

def test_racine_entiere():
    assert racine_entiere(0) == 0
    assert racine_entiere(1) == 1
    assert racine_entiere(15) == 3
    assert racine_entiere(16) == 4
    assert racine_entiere(17) == 4
    assert racine_entiere(10**6) == 1000
    print("Tous les tests passent.")

test_racine_entiere()

Remplace <= par < dans la boucle while, puis relance : quel test échoue en premier, et pourquoi ?

3.2 Le succès des tests ne prouve pas la correction

Voici une fonction maximum et trois tests. Exécute le programme.

def maximum(t):
    m = 0
    for x in t:
        if x > m:
            m = x
    return m

assert maximum([3, 8, 1]) == 8
assert maximum([5]) == 5
assert maximum([2, 9, 9]) == 9
print("Tous les tests passent.")

print(maximum([-3, -8, -1]))

Les trois tests passent, et pourtant le dernier affichage est faux : on obtient $0$ au lieu de $-1$.

Aucun des tests ne contenait de nombres négatifs.

def maximum(t):
    m = 0
    for x in t:
        if x > m:
            m = x
    return m

3.3 Méthode de mise au point

Entraîne-toi : ce programme s'arrête sur une erreur. Lis le message, trouve la ligne, corrige.

def dernier(t):
    return t[len(t)]

print(dernier([4, 8, 15]))

4. Utiliser des bibliothèques

4.1 Réutiliser

Python en fournit des centaines (math, random, csv, time, turtle), et des milliers d'autres sont disponibles : matplotlib pour tracer, pygame pour les jeux, requests pour le Web.

On importe une bibliothèque avant de l'utiliser.

import math
print(math.sqrt(2))

from random import randint
print(randint(1, 6))

Relance plusieurs fois : randint(1, 6) renvoie un entier au hasard entre $1$ et $6$ inclus, comme un dé.

Modulariser son propre code (une fonction par tâche, un fichier par thème) permet de le réutiliser de la même façon : from outils import moyenne.

4.2 Lire une documentation

On ne retient pas une bibliothèque par cœur : on consulte sa documentation.

Elle donne pour chaque fonction son prototype, ses paramètres (obligatoires, ou optionnels avec une valeur par défaut), sa valeur de retour et des exemples.

Dans l'interpréteur, help(f) affiche la docstring d'une fonction, et dir(module) liste le contenu d'un module.

from random import randint
help(randint)

5. Exemple résolu pas à pas

def moyenne(t):
    """Renvoie la moyenne des éléments de t (t : tableau non vide de nombres)."""
    assert len(t) > 0, "le tableau ne doit pas être vide"
    total = 0
    for x in t:
        total = total + x
    return total / len(t)

À toi de réparer le code du camarade.

def moyenne(t):
    total = 0
    for i in range(1, len(t)):
        total = total + t[i]
    return total / len(t)

À retenir