Algorithmique et programmation en 1ère
Cours complet, points clés à retenir et exercices d'entraînement de algorithmique et programmation pour les élèves de 1ère. Conforme au programme officiel.
Réviser notion par notion
- Séquences d'instructions et instructions conditionnelles
- Boucles bornées et non bornées
- Types de variables et affectation
- Fonctions en Python : arguments et valeurs renvoyées
- Décomposer un problème en sous-problèmes
- Listes : générer, manipuler, parcourir
- Itérer des instructions sur les éléments d'une liste
- Modifier, compléter ou concevoir un programme simple
Ce que tu vas réviser
- Séquences d'instructions et instructions conditionnelles
- Boucles bornées (for) et non bornées (while)
- Types de variables (entiers, flottants, chaînes de caractères, booléens) et affectation
- Fonctions en Python : arguments et valeur(s) renvoyée(s)
- Décomposer un problème en sous-problèmes (programmation modulaire)
- Listes : générer (en extension, en compréhension), manipuler, parcourir
- Itérer des instructions sur les éléments d'une liste
- Modifier, compléter ou concevoir un programme simple en Python
Séquences d'instructions et instructions conditionnelles
Un programme est une suite d'instructions exécutées dans l'ordre, de haut en bas : c'est une séquence. Une instruction conditionnelle permet de faire un choix : si une condition est vraie, on exécute un bloc d'instructions ; sinon, on peut en exécuter un autre. En Python, on écrit `if`, éventuellement `elif` (sinon si) et `else` (sinon), suivis de deux-points ; les instructions du bloc sont décalées (indentées).
Exemple
Une application météo affiche un message selon la température : ```python temperature = 3 if temperature < 0: print("Risque de verglas") elif temperature < 5: print("Il fait froid") else: print("Conditions normales") ``` Avec `temperature = 3`, le programme affiche « Il fait froid ».
À retenir : Les deux-points et l'indentation sont obligatoires ; une seule branche d'un `if … elif … else` est exécutée.
Boucles bornées et non bornées
Une boucle répète un bloc d'instructions. La boucle bornée `for` s'utilise quand le nombre de répétitions est connu à l'avance : `for i in range(n):` répète $n$ fois, avec `i` prenant les valeurs 0, 1, …, $n - 1$. La boucle non bornée `while` répète tant qu'une condition est vraie ; on ne sait pas d'avance combien de fois. Il faut que la condition finisse par devenir fausse, sinon la boucle ne s'arrête jamais.
Exemple
Boucle bornée : afficher les carrés de 1 à 5. ```python for i in range(1, 6): print(i ** 2) ``` Boucle non bornée : un capital de 1 000 euros augmente de 5 % par an ; on compte les années jusqu'à ce qu'il dépasse 1 500 euros. ```python capital = 1000 annees = 0 while capital <= 1500: capital = capital * 1.05 annees = annees + 1 print(annees) ``` Le programme affiche 9 : au bout de 8 ans, le capital vaut environ 1 477,46 euros ; au bout de 9 ans, environ 1 551,33 euros.
À retenir : `for` : nombre de répétitions connu. `while` : on répète tant que la condition est vraie.
Types de variables et affectation
Une variable a un nom et contient une valeur. L'affectation donne une valeur à une variable : en Python, `x = 5` (en langage naturel, on note $x \leftarrow 5$). Types de base : entier (`int`, par exemple `12`), flottant (`float`, nombre à virgule écrit avec un point, par exemple `3.5`), chaîne de caractères (`str`, entre guillemets, par exemple `"bonjour"`), booléen (`bool`, `True` ou `False`). La fonction `type()` donne le type d'une valeur.
Exemple
```python score = 1250 # int prix = 19.99 # float nom = "Lina" # str admis = score > 1000 # bool, vaut True score = score + 50 # la nouvelle valeur de score est 1300 ``` Attention : `input()` renvoie toujours une chaîne ; pour faire des calculs, on la convertit avec `int()` ou `float()`.
À retenir : `=` affecte une valeur (à droite) à une variable (à gauche) ; `==` teste une égalité. Les nombres à virgule s'écrivent avec un point en Python.
Fonctions en Python : arguments et valeurs renvoyées
Une fonction est un bloc d'instructions nommé, que l'on peut appeler plusieurs fois. Elle se définit avec `def`, reçoit des arguments (entre parenthèses) et renvoie un résultat avec `return`. Une fonction peut renvoyer plusieurs valeurs, séparées par des virgules.
Exemple
```python def prix_ttc(prix_ht, taux): return prix_ht * (1 + taux / 100) def perimetre_aire(longueur, largeur): return 2 * (longueur + largeur), longueur * largeur print(prix_ttc(50, 20)) # affiche 60.0 p, a = perimetre_aire(8, 5) # p vaut 26 et a vaut 40 ```
À retenir : `def nom(arguments):` puis `return` pour renvoyer le résultat ; on appelle la fonction avec des valeurs précises.
Décomposer un problème en sous-problèmes
Pour un problème complexe, on le découpe en tâches plus simples, chacune confiée à une fonction : c'est la programmation modulaire. Chaque fonction peut être testée séparément, puis réutilisée ; le programme principal appelle les fonctions dans l'ordre.
Exemple
Calcul d'une facture : une fonction calcule le montant hors taxe d'une ligne, une autre applique la TVA, le programme principal les combine. ```python def montant_ligne(quantite, prix_unitaire): return quantite * prix_unitaire def appliquer_tva(montant_ht, taux): return montant_ht * (1 + taux / 100) total_ht = montant_ligne(3, 12) + montant_ligne(2, 7) # 36 + 14 = 50 print(appliquer_tva(total_ht, 20)) # affiche 60.0 ```
À retenir : Une fonction = une tâche ; on teste chaque fonction avant de les assembler.
Listes : générer, manipuler, parcourir
Une liste est une suite ordonnée de valeurs, écrite entre crochets. On peut la générer en extension (on écrit tous ses éléments) ou en compréhension (à partir d'une règle). Les éléments sont numérotés à partir de 0 : `L[0]` est le premier élément. `len(L)` donne le nombre d'éléments, `L.append(x)` ajoute `x` à la fin, `L[i] = x` remplace l'élément d'indice `i`.
Exemple
```python notes = [12, 15, 9, 18] # en extension carres = [k ** 2 for k in range(1, 6)] # en compréhension : [1, 4, 9, 16, 25] print(notes[0]) # affiche 12 print(len(notes)) # affiche 4 notes.append(14) # notes vaut [12, 15, 9, 18, 14] notes[2] = 10 # notes vaut [12, 15, 10, 18, 14] ```
À retenir : Le premier élément a l'indice 0 et le dernier l'indice `len(L) - 1`.
Itérer des instructions sur les éléments d'une liste
Pour appliquer une même instruction à chaque élément d'une liste, on la parcourt avec une boucle `for` : soit directement sur les éléments (`for x in L:`), soit sur les indices (`for i in range(len(L)):`). On peut ainsi calculer une somme, une moyenne, compter les éléments qui vérifient une condition ou construire une nouvelle liste.
Exemple
```python temperatures = [12.5, 15.0, 9.5, 18.0, 14.0] somme = 0 nb_chaud = 0 for t in temperatures: somme = somme + t if t > 14: nb_chaud = nb_chaud + 1 print(somme / len(temperatures)) # moyenne : 13.8 print(nb_chaud) # 2 relevés dépassent 14 degrés ```
À retenir : `for x in L:` parcourt les éléments ; `for i in range(len(L)):` parcourt les indices.
Modifier, compléter ou concevoir un programme simple
On doit savoir lire un programme existant pour prévoir ce qu'il affiche, le compléter (ligne manquante), le modifier (autre valeur, autre condition) ou en écrire un nouveau. Il faut ensuite le tester sur plusieurs exemples, dont des cas limites, et corriger les erreurs.
Exemple
Pour modifier le programme des températures afin de compter les relevés inférieurs à 10 degrés, on remplace la condition `t > 14` par `t < 10` ; avec la même liste, le résultat est 1 (seul 9,5 convient). On teste ensuite avec une liste vide : `len(temperatures)` vaut 0 et la division par zéro provoque une erreur, qu'il faut prévoir.
À retenir : Lire, prévoir, tester sur plusieurs cas (dont les cas limites), puis corriger.
Les points clés
- Séquence, conditionnelle (`if` / `elif` / `else`) et boucles (`for`, `while`) sont les briques de base d'un programme
- Types de base : `int`, `float`, `str`, `bool` ; `=` affecte, `==` compare
- Une fonction se définit avec `def`, reçoit des arguments et renvoie un résultat avec `return`
- Découper un problème en fonctions simples facilite l'écriture et les tests
- Une liste se génère en extension ou en compréhension, ses indices commencent à 0, et on la parcourt avec `for`
- Toujours tester un programme sur plusieurs valeurs, y compris les cas limites
L'essentiel
Programmer en Python, c'est combiner des variables typées, des choix, des boucles, des fonctions et des listes pour résoudre un problème découpé en étapes simples, puis tester soigneusement le résultat.
Exercices d'entraînement
Entraîne-toi sur ces exercices, puis fais-toi corriger pas à pas par le tuteur.
Exercice 1
Écris une fonction Python `prix_solde(prix, remise)` qui renvoie le prix après une remise de `remise` %. Utilise-la pour afficher le prix d'un article à 80 euros soldé à 25 %, puis vérifie le résultat à la main.
Corrige cet exercice avec le tuteur →Exercice 2
On donne la liste des ventes d'une semaine : `ventes = [120, 95, 140, 80, 150]`. a) Écris un programme qui calcule le total des ventes avec une boucle `for`, puis la moyenne. b) Complète-le pour construire, en compréhension, la liste des ventes supérieures à 100.
Corrige cet exercice avec le tuteur →