📋Fonctions et listes

Une fonction est un petit programme réutilisable. On la définit avec def, on lui donne des paramètres, et elle renvoie un résultat avec return :

def carre(x):
    return x * x

y = carre(6)   # y vaut 36

On appelle la fonction en écrivant son nom suivi des arguments entre parenthèses : carre(6).

1. La ligne def nom(parametres): se termine par :.
2. Le corps de la fonction est indenté.
3. return renvoie une valeur ET arrête la fonction.

return (renvoyer) n'est pas print (afficher) ! Une fonction qui fait print mais pas return renvoie en réalité None.

Les paramètres sont les noms entre parenthèses dans le def ; les arguments sont les valeurs qu'on passe lors de l'appel.

Une variable créée dans une fonction est locale : elle n'existe que le temps de l'appel et n'est pas visible à l'extérieur.

Pour utiliser un résultat ailleurs, il faut le return puis le ranger dans une variable : r = carre(6). Sans return, le calcul est perdu.

Le nom des paramètres est libre : def f(x) et def f(n) marchent pareil. Choisis un nom qui parle.

Une liste range plusieurs valeurs dans un ordre. On l'écrit entre crochets, séparées par des virgules :

notes = [12, 8, 15, 9]

On accède à un élément par son indice, qui commence à 0 :

print(notes[0])   # 12 (le premier)
print(notes[3])   # 9  (le quatrième)
print(notes[-1])  # 9  (le dernier)

len(notes) donne le nombre d'éléments (ici 4).

⭐ Pour les curieux — pourquoi ça marche ? On peut voir l'indice comme « le nombre de cases qu'on saute depuis le début ». Pour atteindre le premier élément, on ne saute rien : son indice est donc $0$ ; pour le deuxième, on saute une case ($1$), et ainsi de suite. Du coup, dans une liste de $4$ éléments, les indices sont $0, 1, 2, 3$ : le dernier vaut bien $4-1 = 3$, c'est-à-dire $\text{len(liste)} - 1$. C'est aussi pour ça que notes[4] plante : il faudrait sauter $4$ cases alors qu'il n'y en a que $4$ en tout, on tomberait juste après la fin.

Le premier élément a l'indice 0, le dernier l'indice len(liste) - 1. L'indice -1 est un raccourci pour le dernier élément.

Accéder à notes[4] dans une liste de 4 éléments provoque une erreur « index out of range » : le dernier indice valide est 3 !

On parcourt une liste avec une boucle for, qui prend chaque élément l'un après l'autre :

notes = [12, 8, 15]
for note in notes:
    print(note)

Pour ajouter un élément à la fin, on utilise .append(...) :

notes.append(20)   # notes vaut maintenant [12, 8, 15, 20]

Pour calculer sur une liste, on prépare souvent un accumulateur avant la boucle (par exemple total = 0), puis on le met à jour à chaque tour.

Pour construire une liste vide puis la remplir : resultat = [] puis resultat.append(...) dans la boucle.

Une liste en compréhension construit une liste en une seule ligne, à partir d'une boucle :

carres = [i * i for i in range(5)]
# [0, 1, 4, 9, 16]

On peut y ajouter une condition if pour filtrer :

pairs = [n for n in range(10) if n % 2 == 0]
# [0, 2, 4, 6, 8]

Lis une compréhension de gauche à droite : « la valeur i*i, pour chaque i dans range(5) ». La partie for se lit comme une boucle.

Une compréhension est juste une boucle for raccourcie : tout ce qu'elle fait, tu peux l'écrire avec une boucle classique et .append.