Fiche récapitulative générée pour impression / export PDF.
Licence 1 · Informatique L1 — Introduction à Python pour les mathématiques
Fonctions et listes
Fonctions et listes
### 1. Définir une fonction
Une fonction se définit avec le mot-clé def, suivi du nom, des paramètres entre parenthèses, et de : :
> def carre(x):
> return x ** 2
Le mot-clé return renvoie une valeur et termine immédiatement l'exécution de la fonction. Une fonction sans return explicite renvoie None.
Appel de la fonction : carre(5) renvoie . Les paramètres peuvent avoir des valeurs par défaut :
> def puissance(x, n=2):
> return x ** n
puissance(3) donne (utilise par défaut), puissance(3, 3) donne .
### 2. Portée des variables
Une variable définie à l'intérieur d'une fonction (variable locale) n'est pas accessible à l'extérieur. Une fonction peut lire une variable globale (définie hors de toute fonction), mais pour la modifier, il faut le mot-clé global (rarement recommandé en pratique — on préfère retourner une valeur).
### 3. Listes : création et indexation
Une liste Python est une séquence ordonnée et modifiable d'éléments, créée avec des crochets :
> L = [3, 7, 1, 9, 4]
L'indexation commence à : L[0] vaut , L[1] vaut . Les indices négatifs comptent depuis la fin : L[-1] vaut (dernier élément), L[-2] vaut .
Le découpage (slicing) L[a:b] extrait les éléments d'indices à : L[1:3] donne [7, 1].
La fonction len(L) renvoie le nombre d'éléments de la liste (ici ).
### 4. Parcourir une liste
> for x in L:
> print(x)
parcourt chaque élément de L directement (sans passer par les indices). Si l'on a besoin de l'indice et de la valeur, on utilise enumerate :
> for i, x in enumerate(L):
> print(i, x)
### 5. Méthodes courantes sur les listes
| Méthode / fonction | Effet |
|---|---|
| L.append(x) | ajoute x à la fin de L |
| L.pop() | retire et renvoie le dernier élément |
| L.sort() | trie L en place (ordre croissant) |
| sum(L) | somme des éléments |
| max(L), min(L) | valeur maximale, minimale |
| x in L | renvoie True si x appartient à L |
Exemple résolu : écrire une fonction qui renvoie la moyenne des éléments d'une liste.
> def moyenne(L):
> return sum(L) / len(L)
moyenne([2, 4, 6, 8]) renvoie .
### 6. Construire une liste avec une boucle
Pour construire une nouvelle liste à partir d'un calcul répété, on initialise une liste vide et on utilise append :
> carres = []
> for i in range(5):
> carres.append(i ** 2)
Donne carres = [0, 1, 4, 9, 16]. (Il existe une syntaxe plus compacte, la liste en compréhension [i**2 for i in range(5)], équivalente mais non indispensable au niveau L1.)
### 7. Résumé méthodologique
| Concept | Syntaxe clé |
|---|---|
| Définir une fonction | def nom(params): ... return ... |
| Indexer une liste | L[i] (depuis ), L[-1] (dernier élément) |
| Découper une liste | L[a:b] (de inclus à exclu) |
| Ajouter un élément | L.append(x) |
Exercices de la leçon
Exercice 1
Que renvoie l'appel carre(4) pour la fonction def carre(x): return x ** 2 ?
Corrigé
La fonction calcule x**2, soit .
Exercice 2
Soit L = [10, 20, 30, 40]. Que vaut L[1] ?
Corrigé
L'indexation Python commence à : L[0]=10, L[1]=20.
Exercice 3
Vrai ou faux : une fonction Python sans instruction return renvoie automatiquement None.
Corrigé
Vrai. En l'absence de return explicite, Python renvoie la valeur spéciale None à la fin de l'exécution de la fonction.
Exercice 4
Que vaut len([5, 8, 2, 9, 1]) ?
Corrigé
len renvoie le nombre d'éléments de la liste, ici éléments.
Exercice 5
Quelle méthode ajoute un élément à la fin d'une liste L ?
Corrigé
append est la méthode standard pour ajouter un élément à la fin d'une liste Python.
Exercice 6
Soit L = [3, 7, 1, 9, 4]. Que vaut L[-1] ?
Corrigé
L'indice désigne le dernier élément de la liste, ici .
Exercice 7
Que vaut L[1:3] pour L = [3, 7, 1, 9, 4] ?
Corrigé
L[1:3] extrait les éléments d'indices et (la borne est exclue) : [7, 1].
Exercice 8
Que renvoie puissance(2, 5) pour def puissance(x, n=2): return x ** n ?
Corrigé
Les deux arguments sont fournis explicitement, x=2 et n=5 (la valeur par défaut n'est utilisée que si n n'est pas précisé). .
Exercice 9
Vrai ou faux : une variable définie à l'intérieur d'une fonction est accessible depuis l'extérieur de cette fonction.
Corrigé
Faux. Une variable définie dans une fonction est locale : elle n'existe que pendant l'exécution de la fonction et n'est pas visible à l'extérieur.
Exercice 10
Écrire une fonction Python somme_carres(L) qui renvoie la somme des carrés des éléments d'une liste L.
Corrigé
Une solution possible :
def somme_carres(L):
s = 0
for x in L:
s = s + x ** 2
return s
On initialise un accumulateur s à , on parcourt chaque élément x de la liste, on ajoute son carré à s, puis on renvoie le résultat final.
Exercice 11
Quelle est la sortie de ce code ?
def f(x):
x = x + 1
return x
y = 5
z = f(y)
print(y, z)
Corrigé
À l'intérieur de f, le paramètre x est une copie locale : le modifier (x = x + 1) ne change pas la variable y du programme principal. y reste , et z reçoit la valeur renvoyée .
Exercice 12
Écrire une fonction maximum(L) qui renvoie le plus grand élément d'une liste L non vide, sans utiliser la fonction native max.
Corrigé
Une solution possible :
def maximum(L):
m = L[0]
for x in L:
if x > m:
m = x
return m
On initialise m avec le premier élément (hypothèse de liste non vide essentielle), puis on parcourt la liste en mettant à jour m chaque fois qu'on trouve un élément strictement plus grand.
Exercice 13
Que vaut L après l'exécution de ce code ?
L = [1, 2, 3]
L.append(4)
L.pop()
L.append(10)
Corrigé
Après append(4) : . Après pop() (retire le dernier élément, ) : . Après append(10) : .
Exercice 14
Vrai ou faux : enumerate(L) permet d'obtenir à la fois l'indice et la valeur de chaque élément lors d'un parcours de liste.
Corrigé
Vrai. for i, x in enumerate(L): donne à chaque itération l'indice i et la valeur correspondante x = L[i], évitant d'avoir à écrire L[i] manuellement.
Exercice 15
Écrire une fonction compte_occurrences(L, valeur) qui renvoie le nombre de fois que valeur apparaît dans la liste L, en justifiant pourquoi on ne peut pas simplement utiliser L.index(valeur) pour ce besoin.
Corrigé
Une solution possible :
def compte_occurrences(L, valeur):
n = 0
for x in L:
if x == valeur:
n = n + 1
return n
L.index(valeur) renvoie uniquement l'indice de la première occurrence de valeur dans L (et lève une erreur si valeur est absente) — elle ne compte pas les occurrences. Pour compter, il faut parcourir explicitement toute la liste et incrémenter un compteur à chaque correspondance (la méthode native L.count(valeur) fait exactement cela, mais l'exercice demande de la réimplémenter).
AlphaMath Académie · Fonctions et listes · Informatique L1 — Introduction à Python pour les mathématiques