1re techno · Du modèle à l’autonomie

Algorithmique, Python et tableur : pas à pas

Observe un exemple expliqué, entraîne-toi avec des indices, puis résous une autre situation sur papier. Compare les étapes avant de faire le point.

Mon objectif

Retrouver mes révisions

Variables, affectations et fonctions

1. Observer

Exemple · Exemple commenté

Objectif : calculer le coût de n pièces sans recopier la formule à chaque fois.

def cout(n):
    return 15 + 3*n

prix = cout(4)
print(prix)

def cout(n): définit une recette nommée cout. Cette ligne ne commande pas encore une fabrication et ne calcule pas le coût de quatre pièces.
L'appel cout(4) donne la valeur 4 au paramètre n. La multiplication est prioritaire : $3\times4=12$ .
L'addition donne $$15+12=27$$ . return transmet ce nombre à l'endroit où la fonction a été appelée.
L'affectation prix = cout(4) range donc 27 dans prix. Enfin, print(prix) affiche 27.

Contrôle indépendant. Quatre pièces à 3 euros coûtent 12 euros ; avec les 15 euros fixes, le total est bien 27 euros. Pour zéro pièce, la formule renvoie 15 : cela correspond aux frais fixes du modèle. Si aucun frais n'est réellement facturé en l'absence de commande, il faut modifier le modèle, pas accuser Python.

Pourquoi distinguer afficher et renvoyer ? On peut écrire cout(4) + 5 pour ajouter des frais, car cout(4) fournit un nombre. Une fonction qui se contente de l'afficher ne fournit pas automatiquement ce nombre au calcul suivant.

2. S’entraîner avec aide

En Python, le carré de x s’écrit…

x**2
x^2
2x

Comparer avec l’explication

La bonne réponse est x**2. Pour x égal à 3, elle donne $$3^2=9$$ . 2*x donnerait 6, tandis que 2x n’est pas une syntaxe valide. Le symbole ^ ne désigne pas une puissance en Python.

3. Résoudre seul

Après x = 4, y = x + 3, puis x = 10, quelles sont les valeurs finales ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Il faut suivre trois instructions successives. On cherche l’état final des deux variables, et non une relation valable pour toutes leurs futures valeurs.

Construire la réponse.

Après x = 4, la valeur de x est 4. La variable y n’a pas encore reçu de valeur.
Pour y = x + 3, on calcule d’abord le membre droit avec la valeur actuelle de x : $$4+3=7$$ . On mémorise donc 7 dans y.
La dernière ligne x = 10 remplace uniquement la valeur de x. Aucune instruction ne redonne une valeur à y : elle reste à 7.

Vérifier. La table de trace contient les états $(4;\text{non définie})$ , $$(4;7)$$ puis $$(10;7)$$ . Obtenir $$y=13$$ supposerait d’exécuter une seconde fois y = x + 3, ce que l’énoncé ne demande pas.

Conclure. Les valeurs finales sont x = 10 et y = 7.

Écris une fonction Python qui renvoie $$2x^2-5x+1$$ , puis donne sa valeur en 3.

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. On doit traduire $$2x^2-5x+1$$ en une fonction qui renvoie un nombre, puis tester cette fonction en 3.

Construire la réponse.

Le carré de x se traduit par x**2. Les multiplications implicites de l’écriture mathématique doivent devenir explicites : 2*x**2 et 5*x.
On écrit :
```
def f(x):
    return 2*x**2 - 5*x + 1
```
La ligne indentée appartient à la fonction. return fournit le résultat à l’appelant.
Lors de f(3), Python utilise $$x=3$$ . Le carré vaut $$3^2=9$$ , puis $2\times9=18$ et $5\times3=15$ . Enfin $$18-15+1=3+1=4$$ .

Vérifier. Le calcul manuel doit retrouver la sortie 4. Une écriture comme 2x n’est pas une multiplication reconnue par Python ; x*2 calcule le double et non le carré.

Conclure. La fonction ci-dessus renvoie 4 pour l’entrée 3.

4. Aller plus loin

Une fonction contient seulement print(2*x). Pourquoi ne peut-on pas utiliser directement son résultat comme un nombre dans un autre calcul ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. On cherche pourquoi une valeur visible à l’écran ne peut pas forcément être utilisée dans une autre opération.

Construire la réponse.

print(2*x) calcule le double de x puis l’affiche. Son rôle est d’écrire à l’écran, pas de transmettre le résultat comme sortie de la fonction.
Une fonction qui termine sans return explicite renvoie la valeur spéciale None. Par exemple, pour x égal à 3, on voit 6, mais la sortie récupérée par l’appelant est None.
Si l’appelant tente d’ajouter 1 à cette sortie, il tente de calculer None + 1. Cette opération n’est pas définie comme une addition de nombres.
La correction consiste à écrire return 2*x dans la fonction. L’appelant peut ensuite mémoriser cette sortie, l’ajouter à une autre valeur, ou l’afficher avec print.

Vérifier. Avec le retour corrigé, l’entrée 3 donne le nombre 6 ; lui ajouter 1 donne 7. Ce test distingue la donnée transmise du texte affiché.

Conclure. Pour réutiliser le double dans un calcul, la fonction doit le renvoyer avec return.

Choisir avec une condition

1. Observer

Exemple · Exemple commenté

Traduire la règle de livraison.

def livraison(total):
    if total >= 50:
        return 0
    else:
        return 5

Pour livraison(49), le test $49\ge50$ est faux : Python va dans else, puis renvoie 5. Pour livraison(50), $50\ge50$ est vrai : il renvoie 0. Pour 51, la même première branche fournit 0. Les trois essais contrôlent les deux côtés et la frontière.

Pourquoi l'indentation compte. Les deux instructions return appartiennent à des branches différentes. Leur décalage indique leur rôle. Aligner return 5 à l'intérieur de la première branche rendrait le programme différent ; copier un code sans ses espaces peut donc modifier ou empêcher son exécution.

Ajouter une troisième tranche. Supposons 8 euros de frais sous 20 euros, 5 euros entre 20 euros inclus et 50 euros exclus, puis zéro. On teste d'abord total < 20, ensuite total < 50, enfin else. Dans le deuxième test, on sait déjà que le total n'est pas inférieur à 20 : l'échec du premier test apporte cette information. Pour vérifier cette variante, essaie 19, 20, 49 et 50.

2. S’entraîner avec aide

Pour tester une égalité en Python, on utilise…

=
:=
==

Comparer avec l’explication

Le test d’égalité s’écrit ==. Ainsi x == 5 produit vrai ou faux selon la valeur actuelle de x. x = 5 change cette valeur ; il ne pose pas une question. L’opérateur := concerne une affectation dans une expression et ne remplace pas ce test.

3. Résoudre seul

Quel test Python traduit $3\le x<8$ ?

Comparer avec l’explication

Un code renvoie « accepté » si x > 10, sinon « refusé ». Que renvoie-t-il pour 10 et comment inclure 10 ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. On doit d’abord exécuter la règle existante pour la valeur 10, puis modifier la frontière acceptée.

Construire la réponse.

Le test est x > 10. En remplaçant x par 10, on obtient $$10>10$$ , ce qui est faux : un nombre n’est pas strictement supérieur à lui-même.
La branche de réussite n’est donc pas exécutée. Le programme suit le cas « sinon » et renvoie « refusé ».
Pour inclure la valeur 10, on veut « supérieur ou égal ». On remplace > par >=, sans changer les messages ni les autres branches.

Vérifier. Avec le test corrigé, 9 reste refusé, 10 devient accepté et 11 reste accepté. Le seul changement à la frontière correspond bien à la demande.

Conclure. Le code initial refuse 10. Le test x >= 10 permet de l’accepter.

4. Aller plus loin

Un code teste d’abord note >= 10 puis, dans elif, note >= 16. Pourquoi la seconde branche ne s’exécute-t-elle jamais ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Il faut contrôler l’ordre des branches : une note peut satisfaire plusieurs tests, mais seule la première branche vraie d’une chaîne est exécutée.

Construire la réponse.

Pour une note de 18, le test note >= 10 est déjà vrai. La première branche est donc choisie immédiatement.
Python ne poursuit pas la recherche dans le elif note >= 16, même si $18\ge16$ est vrai. Toute note qui atteint 16 atteint nécessairement 10 ; aucune valeur ne peut donc arriver dans la seconde branche.
On place d’abord if note >= 16, puis elif note >= 10, et enfin le cas restant. Après l’échec du premier test, le deuxième ne concerne plus que $10\le\texttt{note}<16$ .

Vérifier. Essaie 18 : première branche ; 12 : deuxième branche ; 8 : cas restant. Les notes frontières 16 et 10 sont incluses dans les branches correspondantes grâce au signe >=.

Conclure. Le test le plus restrictif doit précéder celui qui englobe ses valeurs.

Répéter un nombre connu de fois

1. Observer

Exemple · Exemple commenté

Additionner les entiers de 1 à 5.

s = 0
for k in range(1, 6):
    s = s + k
print(s)

Avant le premier passage, s vaut 0. Pour k égal à 1, le membre droit vaut $$0+1=1$$ , donc s devient 1. Pour k égal à 2, on utilise cette nouvelle valeur : $$1+2=3$$ . Pour k égal à 3, on calcule $$3+3=6$$ . Les deux derniers passages donnent $$6+4=10$$ , puis $$10+5=15$$ .

k	1	2	3	4	5
s après l'ajout	1	3	6	10	15

Le print n'est pas indenté dans la boucle : il affiche seulement le résultat final 15. S'il était dans le bloc, les cinq sommes intermédiaires seraient affichées. Ce changement ne modifierait pas les calculs de s, seulement les affichages.

Contrôle. Le calcul direct $$1+2+3+4+5=15$$ retrouve le résultat. Pour sommer de 1 à n, la borne finale devient n+1. Le cas n égal à zéro donne une suite vide de valeurs et conserve la somme initiale zéro.

2. S’entraîner avec aide

range(5) parcourt…

0, 1, 2, 3, 4, 5
1, 2, 3, 4, 5
0, 1, 2, 3, 4

Comparer avec l’explication

range(5) fournit 0, 1, 2, 3 et 4 : cinq valeurs au total. La liste 1 à 5 correspondrait à range(1, 6). Inclure à la fois 0 et 5 donnerait six valeurs, ce qui ne correspond pas à la commande.

3. Résoudre seul

Quels entiers parcourt range(2, 6) ? Combien y en a-t-il ?

Comparer avec l’explication

On initialise s = 0 puis on ajoute 2*k pour k dans range(1, 4). Quelle valeur finale obtient-on ?

Comparer avec l’explication

4. Aller plus loin

Un programme veut calculer $1\times2\times3\times4$ mais commence par p = 0. Explique l’erreur et corrige-la.

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Le programme doit accumuler un produit. Il faut choisir une valeur initiale qui ne fausse pas la multiplication.

Construire la réponse.

En partant de zéro, le premier calcul vaut $0\times1=0$ . Le suivant vaut encore $0\times2=0$ , puis $0\times3=0$ et $0\times4=0$ . Tous les facteurs sont absorbés par zéro.
La valeur initiale correcte est 1, car multiplier par 1 conserve une valeur. On écrit donc p = 1 avant la boucle.
Les états après multiplication sont $1\times1=1$ , $1\times2=2$ , $2\times3=6$ , puis $6\times4=24$ .
Le parcours doit être range(1, 5) pour inclure le facteur 4 et exclure 5.

Vérifier. Le calcul direct $1\times2\times3\times4=24$ confirme la sortie. Avec une somme on choisirait zéro, mais le choix doit dépendre de l’opération répétée.

Conclure. Initialiser p à 1 permet d’obtenir le produit attendu, 24.

Répéter jusqu’à un objectif

1. Observer

Exemple · Exemple commenté

Trouver le premier entier naturel dont le carré dépasse 50.

n = 0
while n*n <= 50:
    n = n + 1
print(n)

Au départ, $0^2\le50$ est vrai : on remplace n par 1. Le nouveau test porte sur $$1^2$$ , pas sur l'ancien zéro. Le processus continue ainsi jusqu'à n égal à 7. À cet instant $7^2=49\le50$ est encore vrai ; un passage supplémentaire donne n égal à 8. Le test $8^2=64\le50$ est faux et la boucle s'arrête.

Justifier le mot « premier ». Le dernier entier refusé comme réponse est 7 : son carré ne dépasse pas 50. L'entier 8 convient. Comme les carrés des entiers naturels augmentent, aucun entier naturel plus petit que 8 ne convient. Vérifier seulement $$8^2>50$$ prouverait que 8 convient, sans prouver à lui seul qu'il est le premier.

Changer l'objectif. Pour rechercher un carré supérieur ou égal à 49, la continuation serait n*n < 49. Le résultat serait 7. Pour rechercher un carré strictement supérieur à 49, on conserverait <= 49 et le résultat serait 8. L'égalité au seuil doit donc être traitée avant d'écrire le code.

2. S’entraîner avec aide

La condition d’une boucle while est testée…

Avant chaque passage
Seulement après le premier passage
Une seule fois au début

Comparer avec l’explication

La condition est testée avant chaque passage. Une boucle dont le test initial est faux fait zéro passage. Si le test est vrai, le bloc s’exécute puis un nouveau test décide du passage suivant.

3. Résoudre seul

On initialise x = 12, puis exécute while x < 10: x = x + 1. Quelle est la valeur finale ?

Comparer avec l’explication

On part de $$x=3$$ et on ajoute 4 tant que $$x<15$$ . Combien de passages ont lieu et quelle est la valeur finale ?

Comparer avec l’explication

4. Aller plus loin

Un code commence avec $$x=5$$ et répète $$x=x-1$$ tant que $$x<10$$ . Pourquoi est-il incorrect pour atteindre 10 ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Le programme doit atteindre 10 depuis 5, mais sa mise à jour fait diminuer la valeur. Il faut déterminer si le test pourra devenir faux.

Construire la réponse.

Au départ, $$5<10$$ est vrai. Le premier passage donne $$5-1=4$$ , qui reste inférieur à 10.
Les passages suivants donnent 3, 2, 1, puis des valeurs de plus en plus petites. Après n passages, $$x=5-n$$ .
Pour tout entier $n\ge0$ , $5-n\le5<10$ . La condition est donc toujours vraie : la boucle ne s’arrête pas dans ce modèle entier.
Pour atteindre 10 en augmentant depuis 5, on remplace la mise à jour par x = x + 1. Les états deviennent 5, 6, 7, 8, 9, 10.

Vérifier. À 9, le test reste vrai ; à 10, il devient faux. La boucle corrigée fait cinq passages, ce que confirme $$5+5=10$$ .

Conclure. La mise à jour initiale provoque une boucle infinie ; ajouter 1 au lieu de le retrancher résout le problème posé.

Listes, données et contrôles numériques

1. Observer

Exemple · Exemple commenté

Construire la liste des carrés de 0 à 4.

carres = []
for k in range(5):
    carres.append(k*k)

[] crée une liste vide. append ajoute une nouvelle valeur à la fin sans effacer les précédentes. Les valeurs de k sont 0, 1, 2, 3 et 4.

Pour k égal à 0, le carré vaut 0. La liste devient [0].
Pour k égal à 1, le carré vaut 1. Elle devient [0, 1].
Pour k égal à 2, on ajoute 4 : [0, 1, 4].
Les passages suivants ajoutent 9 et 16 : la liste finale est [0, 1, 4, 9, 16].

On contrôle la longueur : cinq valeurs de k ont été parcourues et un élément a été ajouté à chaque tour, donc len(carres) vaut 5. L'élément d'indice 2 vaut 4 ; celui d'indice 4 vaut 16.

Calculer une moyenne. La somme de cette liste vaut $$0+1+4+9+16=30$$ ; son effectif est 5. Sa moyenne est donc $$30/5=6$$ . En Python, sum(carres)/len(carres) traduit exactement cette formule. La liste doit être non vide : sinon son effectif est nul et le quotient n'est pas défini.

2. S’entraîner avec aide

Dans [3, 8, 11], l’élément d’indice 1 vaut…

Comparer avec l’explication

Dans [3, 8, 11], l’indice 0 désigne 3, l’indice 1 désigne 8 et l’indice 2 désigne 11. La réponse est donc 8. Le nombre 1 est une position ; ce n’est ni le nombre d’éléments, ni une valeur à chercher dans la liste.

3. Résoudre seul

Pour L = [12, 8, 15, 10], que valent L[2] et len(L) ?

Comparer avec l’explication

Calcule le résultat de sum(L)/len(L) pour L = [6, 10, 14].

Comparer avec l’explication

4. Aller plus loin

On a les abscisses [1, 2, 3] et les ordonnées associées [30, 10, 20]. Pourquoi trier seulement les ordonnées est-il une erreur ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Chaque abscisse et l’ordonnée de même position décrivent une observation. On doit conserver ces couples pour ne pas modifier les données.

Construire la réponse.

Les couples initiaux sont $$(1;30)$$ , $$(2;10)$$ et $$(3;20)$$ . Le premier peut représenter une mesure 30 à l’instant 1.
Trier seulement les ordonnées donne [10, 20, 30], tandis que les abscisses restent [1, 2, 3]. Les couples deviennent $$(1;10)$$ , $$(2;20)$$ et $$(3;30)$$ .
Le premier couple n’a plus la même mesure, et aucun des trois couples nouveaux ne correspond au couple initial de même abscisse. On a créé artificiellement une tendance croissante.
Pour réordonner les observations, on trie des couples complets, en déplaçant toujours ensemble les deux coordonnées. Par exemple, trier selon l’ordonnée donnerait $$(2;10)$$ , $$(3;20)$$ , $$(1;30)$$ .

Vérifier. Après le tri correct, les trois couples d’origine sont toujours présents, seul leur ordre a changé. C’est ce contrôle qu’un tri d’une seule colonne ne satisfait pas.

Conclure. Il faut conserver les couples associés ; trier une seule colonne falsifie la relation étudiée.

Construire et recopier une formule de tableur

1. Observer

Exemple · Exemple commenté

Préparer une petite facture avec un taux commun. A2 contient 4, B2 contient 12 et D2 contient 20 %. En C2, on calcule le montant HT par =A2*B2, soit $4\times12=48$ euros. En E2, on écrit =C2*(1+$D$2), soit $48\times1{,}20=57{,}60$ euros TTC.

Pour un second article, A3 contient 3 et B3 contient 10. La recopie de C2 en C3 donne =A3*B3, soit 30 euros HT. La recopie de E2 en E3 donne =C3*(1+$D$2), soit 36 euros TTC. Le prix change de ligne, le taux reste en D2.

Contrôler le total de deux façons. =SOMME(E2:E3) donne $$57{,}60+36=93{,}60$$ euros. Comme les deux lignes utilisent le même taux, on peut aussi calculer le total HT $$48+30=78$$ euros, puis $78\times1{,}20=93{,}60$ . L'accord valide ici la construction des références.

Une formule de décision. Pour afficher « à contrôler » lorsque le montant d'une ligne dépasse 50 euros, on peut écrire =SI(E2>50;"à contrôler";"valide"). Avec 57,60, le test est vrai ; avec 36, il est faux. Pour 50 exactement, il serait faux car le signe est strict.

2. S’entraîner avec aide

Une formule de tableur commence par…

Le mot calcul
Le signe égal
Un point

Comparer avec l’explication

Une formule commence par le signe =. Ainsi =2+3 calcule 5. Pour qu’elle s’adapte aux données, on utilise des références, par exemple =A2+B2.

3. Résoudre seul

A2 contient une quantité de 4 et B2 un prix unitaire de 12 euros. Quelle formule écrire en C2 pour calculer le montant ? Que devient ce montant si A2 passe à 5 ?

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Le montant correspond au nombre de pièces multiplié par le prix d’une pièce. La formule doit utiliser les données des cellules pour suivre une modification.

Construire la réponse.

La quantité se trouve en A2 et le prix unitaire en B2. On écrit donc en C2 =A2*B2. Le signe égal annonce une formule et l’astérisque la multiplication.
Avec les données initiales, le tableur calcule $4\times12=48$ . La cellule C2 affiche donc un montant de 48 euros.
Quand A2 passe à 5, la formule n’est pas changée mais elle lit la nouvelle valeur. Elle calcule $5\times12=60$ euros.

Vérifier. La quantité augmente d’une pièce, donc le montant doit augmenter de 12 euros : $$60-48=12$$ . Écrire directement 48 dans C2 aurait empêché cette mise à jour automatique.

Conclure. La formule est =A2*B2. Le montant passe de 48 à 60 euros.

B2 contient 80 euros et D2 contient un taux de TVA de 20 %. On veut recopier vers le bas une formule en C2 calculant le montant TTC. Écris la formule et sa version après recopie en C3.

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Le prix HT varie selon la ligne tandis que le taux commun doit toujours être lu en D2.

Construire la réponse.

Un taux de 20 % vaut $$0{,}20$$ . Le prix TTC est le prix HT plus sa TVA : $$HT+0{,}20HT=HT(1+0{,}20)$$ .
Le prix est en B2 et le taux en D2. On écrit =B2*(1+$D$2) dans C2. Les dollars empêchent la colonne D et la ligne 2 de changer lors d’une recopie.
En recopiant une ligne plus bas, B2 devient B3 car sa référence est relative. La formule en C3 est donc =B3*(1+$D$2).
Pour la première ligne, on obtient
$\begin{aligned}80\times(1+0{,}20) &= 80\times1{,}20\\[.35em] &= 96\end{aligned}$
euros.

Vérifier. La TVA seule vaut $80\times0{,}20=16$ euros ; $$80+16=96$$ confirme le TTC. Sans blocage, D2 deviendrait D3 et la formule pourrait lire une cellule vide ou un autre taux.

Conclure. La formule initiale calcule 96 euros TTC et conserve le taux fixe pendant la recopie.

4. Aller plus loin

C2:C5 contient les montants 12, 18, 25 et 15 euros. Calcule le total avec une formule. Une cellule F2 doit afficher « gratuit » si ce total est au moins égal à 70, sinon « payant ». Propose la formule et contrôle le cas frontière.

Comparer avec l’explication

Démonstration · Solution expliquée

Comprendre la question. Il faut additionner quatre montants puis appliquer une condition qui inclut exactement le seuil 70.

Construire la réponse.

La plage C2:C5 comprend C2, C3, C4 et C5. La formule =SOMME(C2:C5) donne $$12+18+25+15=30+40=70$$ euros.
« Au moins 70 » se traduit par >=70. Un test strict >70 refuserait à tort l’égalité.
On peut écrire en F2 =SI(SOMME(C2:C5)>=70;"gratuit";"payant"). Le premier argument est le test, le deuxième le texte si le test est vrai et le troisième le texte sinon.
Avec le total actuel, $70\ge70$ est vrai. La cellule doit donc afficher « gratuit ».

Vérifier. Pour un total de 69, le résultat serait « payant » ; pour 70 et 71, il serait « gratuit ». Ces trois essais vérifient les deux branches et la frontière.

Conclure. Le total est 70 euros et la condition de gratuité est satisfaite.

La recherche et les corrigés restent accessibles ici. JavaScript permet de mémoriser ton autoévaluation.