Fiche de révision — Algorithmique — Listes (1ère spé)
Cette fiche de révision de maths en 1ère Spécialité résume le chapitre Algorithmique — Listes. Elle aide à mémoriser les définitions, les formules, les méthodes et les points de vigilance avant un contrôle.
Cours
Cours de mathématiques en 1ère Spécialité : Algorithmique — Listes
Fiches
Fiche de révision maths 1ère Spécialité : Algorithmique — Listes
Exercices
Exercices corrigés de mathématiques en 1ère Spécialité : Algorithmique — Listes
Quiz
Quiz de maths 1ère Spécialité : Algorithmique — Listes
1ère Spé
Chapitres
Fiche ultra-synthèse — Algorithmique : Listes (1ère Spé)
Générer • indexer • parcourir • modifier • comprendre • calculer • rechercher • programmer avec des fonctions.
Objectif : choisir rapidement le bon schéma algorithmique et l’écrire sans erreur.
Essentiel (à savoir par cœur)
1 Liste et affectation
Une liste est une collection ordonnée de valeurs. En Python, elle s’écrit entre crochets.
Le symbole = réalise une affectation : il stocke une valeur dans une variable.
x = 5
L = [4, 7, 12, 5]
Ne pas confondre = (affecter) et == (tester une égalité).
2 Générer une liste : 3 méthodes
| Méthode | Exemple |
|---|---|
| En extension | [2, 4, 6, 8] |
| Ajouts successifs | L.append(x) |
| Compréhension | [n**2 for n in range(5)] |
La compréhension est compacte ; les ajouts successifs sont souvent plus faciles à détailler dans un raisonnement.
3 Éléments, indices et taille
L = [10, 4, 9, 7]
L[0] # 10
L[2] # 9
L[-1] # 7
len(L) # 4
Une liste de taille \(n\) possède les indices \(0,1,\ldots,n-1\). Le premier indice est 0.
4 Parcourir / itérer
Itérer signifie répéter des instructions. Sur une liste, on parcourt soit les valeurs, soit les indices.
# Parcours des valeurs
for x in L:
print(x)
# Parcours des indices
for i in range(len(L)):
print(i, L[i])
5 Modifier une liste
L = [4, 7, 12]
L[1] = 20 # remplacer
L.append(9) # ajouter à la fin
L.pop(1) # supprimer l'élément d'indice 1
L.remove(12) # supprimer la première valeur 12
pop(i) travaille avec un indice ;
remove(x) travaille avec une valeur.
6 Liste en compréhension
Forme générale : [expression for variable in iterable if condition].
carres = [n**2 for n in range(1, 6)]
pairs = [n for n in range(1, 11) if n % 2 == 0]
On obtient [1, 4, 9, 16, 25] puis [2, 4, 6, 8, 10].
7 Accumulateurs : somme, produit, moyenne
| Objectif | Initialisation | Mise à jour |
|---|---|---|
| Somme | s = 0 | s = s + x |
| Produit | p = 1 | p = p*x |
| Compteur | c = 0 | c = c + 1 |
Pour une liste non vide, la moyenne est \(\dfrac{s}{len(L)}\).
8 Maximum et minimum
maxi = L[0]
for x in L:
if x > maxi:
maxi = x
On initialise avec L[0] uniquement si la liste est non vide.
Pour un minimum, remplacer > par <.
9 Rechercher, compter, filtrer
# présence
trouve = False
for x in L:
if x == 7:
trouve = True
# comptage
c = 0
for x in L:
if x > 10:
c = c + 1
# filtrage
R = [x for x in L if x > 0]
10 Fonctions et programmation modulaire
Une fonction reçoit des paramètres, effectue un traitement et peut renvoyer un résultat avec return.
def moyenne(L):
s = 0
for x in L:
s = s + x
return s / len(L)
print affiche ; return renvoie une valeur réutilisable.
11 Listes et suites
# u0 = 1 et u(n+1) = 2*u(n) + 3
u = 1
U = [u]
for k in range(4):
u = 2*u + 3
U.append(u)
On obtient [1, 5, 13, 29, 61].
12 Boucle while et seuil
On utilise while lorsque le nombre d’itérations n’est pas connu à l’avance.
u = 5
n = 0
while u <= 1000:
u = 1.5*u + 2
n = n + 1
À la sortie, \(n\) est le premier rang pour lequel \(u_n>1000\).
Compléments Python utiles : les sous-listes L[a:b] et le tri
sorted(L) / L.sort() restent utiles, mais ils ne remplacent pas les schémas algorithmiques fondamentaux ci-dessus.
Méthodes (procédures rapides 20/20)
A Calculer une somme ou une moyenne
- Initialiser la somme à \(0\).
- Parcourir les valeurs.
- Ajouter chaque valeur à la somme courante.
- Pour la moyenne, diviser par la taille de la liste non vide.
s = 0
for x in L:
s = s + x
moy = s / len(L)
B Construire ou filtrer par compréhension
- Repérer la variable de parcours.
- Écrire l’expression à placer dans la nouvelle liste.
- Ajouter une condition seulement si un filtrage est demandé.
carres = [x**2 for x in L]
grands = [x for x in L if x >= 10]
C Trouver un maximum / minimum
- Vérifier que la liste est non vide.
- Initialiser avec le premier élément.
- Comparer chaque nouvelle valeur avec la valeur courante.
- Mettre à jour seulement si nécessaire.
maxi = L[0]
for x in L:
if x > maxi:
maxi = x
D Trouver le premier indice d’une valeur
Si on veut la première occurrence, il faut empêcher les occurrences suivantes d’écraser la réponse.
pos = -1
i = 0
while i < len(L) and pos == -1:
if L[i] == x:
pos = i
i = i + 1
E Transformer un algorithme en fonction
- Identifier les données d’entrée : ce sont les paramètres.
- Écrire le traitement dans le corps de la fonction.
- Renvoyer le résultat avec return.
def compte_superieurs(L, a):
c = 0
for x in L:
if x > a:
c = c + 1
return c
F Générer les termes d’une suite
- Initialiser le terme courant.
- Créer la liste avec le premier terme.
- Calculer le terme suivant dans une boucle.
- Ajouter chaque nouveau terme avec append.
u = u0
U = [u]
for k in range(n):
u = expression_du_terme_suivant
U.append(u)
G Chercher un premier rang de dépassement
- Initialiser le terme et son rang.
- Continuer tant que le seuil n’est pas dépassé.
- Mettre à jour à la fois le terme et le rang.
- À la sortie, interpréter le rang obtenu.
u = u0
n = 0
while u <= seuil:
u = expression_du_terme_suivant
n = n + 1
H Deux listes associées : moyenne pondérée
s = 0
c = 0
for i in range(len(notes)):
s = s + notes[i]*coef[i]
c = c + coef[i]
m = s / c
Les deux listes doivent correspondre position par position et avoir la même longueur.
Pièges classiques (à éviter)
1 Indices
Le premier élément a l’indice 0. Une liste de taille \(n\) s’arrête à l’indice \(n-1\).
2 = / ==
x = 5 affecte une valeur ; x == 5 teste une égalité.
3 Liste vide
L[0] est impossible si L = []. Cette hypothèse compte pour max, min et moyenne.
4 Valeur / indice
pop(i) supprime à une position ; remove(x) supprime une valeur.
5 Première occurrence
Une boucle qui réaffecte pos à chaque occurrence finit par donner la dernière occurrence.
6 Compréhension
Dans [f(x) for x in L if condition], l’expression produite est placée avant for.
7 return
Une fonction sans return ne renvoie pas le résultat calculé pour le réutiliser ensuite.
8 Boucle while
Si les variables de la condition ne sont pas mises à jour, la boucle peut ne jamais s’arrêter.
9 Deux listes associées
Avec notes et coefficients, il faut utiliser le même indice dans les deux listes.
Réflexe : exécuter mentalement le programme sur une petite liste et noter les valeurs successives des variables.
Mini-tests (30 à 60 secondes) — corrigés
Q1 Génération
Que produit [n**2 for n in range(1,5)] ?
Corrigé : [1, 4, 9, 16].
Q2 Indice
Si L = [6, 11, 4, 9, 2], que vaut L[3] ?
Corrigé : L[3] = 9.
Q3 Modification
Après L=[2,5], L.append(8), que vaut \(L\) ?
Corrigé : [2, 5, 8].
Q4 Accumulateur
Quelle valeur finale obtient-on pour \(s\) en additionnant successivement \(3,8,12,5\) ?
Corrigé : \(s=3+8+12+5=28\).
Q5 Compréhension filtrée
Que produit [n for n in range(1,11) if n % 3 == 0] ?
Corrigé : [3, 6, 9].
Q6 Fonction
Quel mot-clé permet à une fonction Python de renvoyer son résultat ?
Corrigé : return.
Q7 Suite
Pour \(u_0=1\) et \(u_{n+1}=2u_n+3\), quels sont \(u_1\) et \(u_2\) ?
Corrigé : \(u_1=5\), puis \(u_2=13\).
Q8 Seuil
Si \(u_0=1\) et \(u_{n+1}=2u_n+1\), quel est le premier rang tel que \(u_n>50\) ?
Corrigé : \(1,3,7,15,31,63\), donc le premier rang est \(n=5\).
Q9 Premier indice
Dans L = [4, 7, 4, 9], quel est le premier indice de la valeur \(4\) ?
Corrigé : l’indice \(0\).
Q10 Moyenne pondérée
Notes \([12,8,15,5]\), coefficients \([2,1,3,2]\) : calculer la moyenne.
Corrigé : \(\dfrac{12\times2+8\times1+15\times3+5\times2}{2+1+3+2}=\dfrac{87}{8}=10{,}875\).
Q11 Filtrage combiné
Dans \([4,9,12,15,18]\), quelles valeurs sont à la fois \(>10\) et paires ?
Corrigé : \([12,18]\).
Q12 Booléen
Si ok=True devient False dès qu’un élément de \(L\) est négatif, que signifie ok=True à la fin ?
Corrigé : aucun élément de la liste n’est négatif ; tous sont donc positifs ou nuls.
Checklist (avant contrôle)
Je sais faire
- Créer une liste en extension, par ajouts successifs et en compréhension.
- Accéder à un élément et distinguer valeur, indice et taille.
- Parcourir les valeurs ou les indices selon l’objectif.
- Modifier une liste avec affectation, append, pop et remove.
- Calculer somme, produit, moyenne, maximum et minimum.
- Rechercher une valeur, trouver une position et compter des occurrences.
- Filtrer une liste par boucle ou compréhension.
- Écrire une fonction avec paramètres et return.
- Générer les termes d’une suite récurrente.
- Utiliser while pour chercher un seuil.
Réflexes 20/20
1) J’identifie la donnée d’entrée et le résultat attendu.
2) Je choisis : valeurs, indices, for ou while.
3) J’initialise correctement chaque accumulateur.
4) Je vérifie les conditions et les mises à jour.
5) Je teste le programme sur un petit exemple.
2) Je choisis : valeurs, indices, for ou while.
3) J’initialise correctement chaque accumulateur.
4) Je vérifie les conditions et les mises à jour.
5) Je teste le programme sur un petit exemple.
À bannir : oublier l’indice 0, confondre = et ==,
utiliser L[0] sans hypothèse de liste non vide, oublier return,
ou écrire une boucle while sans mise à jour garantissant son arrêt.
Formule mentale : initialiser → parcourir/itérer → tester → mettre à jour → renvoyer/interpréter.
Suivez votre progression
Connectez-vous pour enregistrer votre progression et vos tentatives de quiz.