Algorithmique et Python – Cours 2nde

Sommaire

1. Notion d’algorithme 2. Variables et types 3. Affectation et séquence 4. Instruction conditionnelle 5. Boucle bornée (for) 6. Boucle non bornée (while) 7. Fonctions Python 8. Listes (tableaux) Bilan — L’essentiel Pièges et contre-exemples

Un convertisseur de température

On souhaite écrire un programme qui convertit une température de degrés Celsius en degrés Fahrenheit. La formule est : \(F = 1{,}8 \times C + 32\).

Comment écrire un programme Python qui demande une température en Celsius et affiche le résultat en Fahrenheit ?
→ On construira ce programme pas à pas dans le cours.

→ Solution complète en fin de chapitre

Al-Khwarizmi, père de l’algorithme

Muhammad ibn Musa al-Khwarizmi (vers 780–850), mathématicien perse, est considéré comme le père de l’algèbre et de l’algorithmique. Le mot algorithme vient de la latinisation de son nom : Algoritmi.

Dans son ouvrage sur le calcul indien, il décrit des procédures de calcul systématiques — les ancêtres de nos algorithmes modernes. Ses méthodes, étape par étape, pour résoudre des équations sont exactement ce qu’on appelle aujourd’hui un algorithme : une suite finie d’instructions précises.

📜 Lire l’article — Euclide et Thābit : le plus vieil algorithme →

Deviner un nombre en minimum d’essais

L’ordinateur choisit un nombre secret entre 1 et 100. À chaque essai, il répond « trop grand » ou « trop petit ». Quel est le nombre minimum d’essais pour être sûr de trouver ?

Indice : à chaque essai bien choisi, on peut éliminer la moitié des possibilités.

→ Solution complète en fin de chapitre

1. Notion d’algorithme

Définition — Algorithme

Un algorithme est une suite finie d’instructions précises et non ambiguës qui, à partir de données initiales, permet d’obtenir un résultat en un nombre fini d’étapes.

Exemple — Recette de cuisine

Une recette de cuisine est un algorithme : les ingredients sont les données, les étapes de préparation sont les instructions, le plat final est le résultat.

Algorithme vs programme

Un algorithme est écrit en langage naturel ou en pseudo-code (indépendant du langage).
Un programme est la traduction d’un algorithme dans un langage de programmation (ici Python).

Exemple — Algorithme en langage naturel

Problème : Convertir une température de Celsius en Fahrenheit.

Algorithme :

Demander la température en degrés Celsius (notée \(C\))
Calculer \(F \leftarrow 1{,}8 \times C + 32\)
Afficher \(F\)

💡 À toi de jouer — Traduire l'algorithme en Python

Voici la traduction Python de l'algorithme ci-dessus, avec la ligne de calcul à compléter.

🎯 Exercice — Complète la ligne F = ... pour convertir °C en Fahrenheit.
Formule : \(F = 1{,}8 \times C + 32\).

2. Variables et types

Définition — Variable informatique

Une variable est un espace mémoire auquel on donne un nom et qui contient une valeur. On peut la voir comme une « boîte étiquetée » dans laquelle on range une donnée.

Propriété — Les quatre types de base en Python

Type	Nom Python	Exemples
Entier	`int`	`3`, `-7`, `0`
Flottant (décimal)	`float`	`3.14`, `-0.5`, `1.0`
Booleen	`bool`	`True`, `False`
Chaîne de caractères	`str`	`"Bonjour"`, `'Python'`

💡 La fonction print()

La fonction print() affiche à l’écran le contenu passé entre parenthèses. On l’utilise pour visualiser une valeur, un résultat de calcul ou un message :

print("Bonjour") → affiche Bonjour
print(2 + 3) → affiche 5
print("Âge :", age) → affiche par exemple Âge : 16

On peut passer plusieurs arguments séparés par des virgules ; ils sont affichés côte à côte avec un espace.

Exemple — Vérifier le type d’une variable

age = 16            # int
taille = 1.72       # float
réussi = True       # bool
nom = "Alice"       # str

print(type(age))    # <class 'int'>
print(type(taille)) # <class 'float'>

Attention

5 est un entier (int), mais 5.0 est un flottant (float).
"5" est une chaîne de caractères (str), pas un nombre !
Les booléens True et False commencent par une majuscule en Python.

Opérateurs arithmétiques

Propriété — Les opérateurs Python

Opérateur	Rôle	Exemple	Résultat
`+`	Addition	`7 + 3`	`10`
`-`	Soustraction	`7 - 3`	`4`
`*`	Multiplication	`7 * 3`	`21`
`/`	Division flottante (résultat `float`)	`7 / 3`	`2.333...`
`//`	Division entière (quotient)	`7 // 3`	`2`
`%`	Modulo (reste de la division entière)	`7 % 3`	`1`
`**`	Puissance	`2 ** 5`	`32`

Exemple — Lien avec la division euclidienne

Pour tout entier \(a\) et tout entier \(b > 0\), la division euclidienne donne \(a = b \times q + r\) avec \(0 \leqslant r < b\) :

a = 47
b = 6
q = a // b           # quotient = 7
r = a % b            # reste = 5
print(q, r)          # 7 5
print(a == b * q + r) # True

💡 Pair / impair, divisible

Tester si \(n\) est pair : n % 2 == 0
Tester si \(a\) est divisible par \(b\) : a % b == 0
Récupérer le chiffre des unités de \(n\) : n % 10

3. Affectation et séquence

Définition — Affectation

L'affectation consiste à stocker une valeur dans une variable. En Python, on utilise le signe =. En langage naturel, on écrit \(\leftarrow\).

Exemple — Affectations successives

x = 5          # x contient 5
x = x + 3     # x contient maintenant 8
y = 2 * x     # y contient 16
print(x, y)   # Affiche : 8 16

Attention — Le = en Python n’est pas le = mathématique

En mathématiques, \(x = x + 3\) est une équation sans solution. En Python, x = x + 3 signifie : « calculer x + 3 et stocker le résultat dans x ».

Définition — Séquence d’instructions

Une séquence est une suite d’instructions exécutées l’une après l’autre, dans l’ordre où elles sont écrites.

⚠️ Attention — input() retourne toujours du texte

La fonction input() renvoie une chaîne de caractères (str), même si l’utilisateur tape un nombre. Pour faire des calculs, il faut convertir :

int(input("...")) → entier
float(input("...")) → nombre à virgule

Sans conversion, input() + 1 déclenche une erreur TypeError, et input() * 3 répète le texte 3 fois au lieu de multipliér.

Exemple — Convertisseur Celsius → Fahrenheit

celsius = float(input("Temperature en Celsius : "))  # float() pour convertir
fahrenheit = 1.8 * celsius + 32
print("En Fahrenheit :", fahrenheit)

Méthode — Échanger deux variables

Pour echanger les valeurs de à et b, on utilise une variable temporaire ou l’affectation simultanée :

# Méthode 1 : variable temporaire
temp = a
a = b
b = temp

# Méthode 2 : affectation simultanée (Python)
a, b = b, a

4. Instruction conditionnelle

Définition — Instruction conditionnelle

Une instruction conditionnelle permet d’exécuter des instructions différentes selon qu’une condition est vraie ou fausse.

Syntaxe — if / elif / else

if condition:
    instructions si vrai
elif autre_condition:
    instructions si autre condition vraie
else:
    instructions sinon

⚠️ Attention — L’indentation est obligatoire en Python

Contrairement à d’autres langages, Python utilise l’indentation (décalage à droite par 4 espaces) pour délimiter les blocs d’instructions. Tout le bloc exécuté dans un if, else, for ou while doit être indenté exactement de la même manière.

Pas d’indentation du tout → IndentationError.
Indentations incohérentes (mélange espaces/tab ou nombres différents) → erreur.
Astuce : toujours utiliser 4 espaces (la touche Tab des éditeurs Python fait ça automatiquement).

Exemple — Majorite

age = int(input("Quel age as-tu ? "))
if age >= 18:
    print("Tu es majeur.")
else:
    print("Tu es mineur.")

Exemple — Signe d’un nombre

n = float(input("Entre un nombre : "))
if n > 0:
    print("Positif")
elif n < 0:
    print("Negatif")
else:
    print("Nul")

Opérateurs de comparaison

Opérateur	Signification
`==`	égal à
`!=`	différent dé
`<`, `>`	strictement inférieur, supérieur
`<=`, `>=`	inférieur ou égal, supérieur ou égal

On peut combiner des conditions avec and, or, not.

5. Boucle bornée (for)

Définition — Boucle for

Une boucle for (boucle bornée) répète un bloc d’instructions un nombre déterminé de fois.

Syntaxe — for … in range(…)

for i in range(n):
    instructions

La variable i prend successivement les valeurs \(0, 1, 2, \ldots, n-1\). Le bloc est exécuté \(n\) fois.

Exemple — Table de multiplication

n = int(input("Quelle table ? "))
for i in range(1, 11):
    print(n, "x", i, "=", n * i)

Exemple — Somme des entiers de 1 à n

n = 100
s = 0
for i in range(1, n + 1):
    s = s + i
print("Somme =", s)  # Affiche 5050

Variantes de range

range(n) : de 0 à \(n-1\)
range(a, b) : de \(a\) à \(b-1\)
range(a, b, p) : de \(a\) à \(b-1\) avec un pas de \(p\)

6. Boucle non bornée (while)

Définition — Boucle while

Une boucle while (boucle non bornée) répète un bloc d’instructions tant qu’une condition est vraie. Le nombre de répétitions n’est pas connu à l’avance.

Syntaxe — while

while condition:
    instructions

Tant que la condition est True, le bloc est exécuté. Des que la condition devient False, on sort de la boucle.

Exemple — Première puissance de 2 dépassant 1000

p = 1
n = 0
while p <= 1000:
    p = p * 2
    n = n + 1
print("2 ^", n, "=", p)  # Affiche : 2 ^ 10 = 1024

Exemple — Jeu du nombre secret

from random import randint
secret = randint(1, 100)
essai = 0
while essai != secret:
    essai = int(input("Ton essai : "))
    if essai < secret:
        print("Trop petit !")
    elif essai > secret:
        print("Trop grand !")
print("Bravo, c'n’est", secret, "!")

Attention — Boucle infinie

Si la condition ne devient jamais False, la boucle ne s’arrête jamais. Il faut toujours s’assurer que la condition finira par devenir fausse.

7. Fonctions Python

Définition — Fonction

Une fonction est un bloc d’instructions réutilisable, qui peut recevoir des données en entrée (les arguments ou paramètres) et renvoyer un résultat grâce à l’instruction return.

Syntaxe — def

def nom_fonction(paramètre1, paramètre2):
    instructions
    return resultat

Exemple — Convertisseur en fonction

def celsius_vers_fahrenheit(c):
    """Convertit des Celsius en Fahrenheit."""
    return 1.8 * c + 32

print(celsius_vers_fahrenheit(0))    # 32.0
print(celsius_vers_fahrenheit(100))  # 212.0
print(celsius_vers_fahrenheit(37))   # 98.6

Exemple — Fonction à plusieurs paramètres

def aire_rectangle(longueur, largeur):
    return longueur * largeur

print(aire_rectangle(5, 3))  # 15

Exemple — Fonction avec random

from random import randint

def lancer_dé():
    """Simule un lancer de dé à 6 faces."""
    return randint(1, 6)

# Simuler 10 lancers
for i in range(10):
    print(lancer_dé(), end=" ")

Exemple — Fonction définie par intervalles

On veut coder la fonction \(f\) définie par : \(f(x) = 1 + \sqrt{x}\) si \(x \geqslant 0\), et \(f(x) = (x-1)^2\) si \(x < 0\).

from math import sqrt

def f(x):
    if x >= 0:
        y = 1 + sqrt(x)
    else:
        y = (x - 1) ** 2
    return y

print(f(2))    # 2.4142135623730951
print(f(-3))   # 16.0

La condition if/else choisit la bonne formule selon le signe de x avant de returnner le résultat : une fonction Python peut très bien contenir une instruction conditionnelle.

Différence entre print et return

print affiche une valeur à l’écran mais ne renvoie rien.
return renvoie une valeur qu’on peut stocker dans une variable ou utiliser dans un calcul.

Modules Python utiles — math et random

Python propose des modules : des bibliothèques de fonctions prêtes à l’emploi. Au programme de Seconde :

from math import sqrt, cos, sin, pi — racine carrée, trigonométrie, constante \(\pi\)
from random import randint, random — entier aléatoire, nombre réel dans \([0\,;\,1[\)

from math import sqrt, pi
print(sqrt(2))        # 1.4142135...
print(pi)             # 3.141592...

8. Listes (tableaux)

Définition — Liste Python

Une liste est une suite ordonnée de valeurs, notée entre crochets et séparées par des virgules. Une liste peut contenir des nombres, des chaînes, ou même d’autres listes.

Exemple — Création et accès

notes = [12, 15, 9, 17, 13]   # liste de 5 entiers
prénoms = ["Anna", "Bob", "Inès"]

print(notes[0])               # 12 (premier élément, indice 0)
print(notes[2])               # 9
print(notes[-1])              # 13 (dernier élément)
print(len(notes))             # 5 (longueur de la liste)

⚠️ Indices : on commence à 0 !

Le premier élément à l’indice 0.
Le dernier élément à l’indice len(L) - 1 (ou -1).
L[len(L)] provoque une erreur (IndexError) — l’indice est hors limite.

Propriété — Opérations courantes sur les listes

Opération	Syntaxe	Résultat
Longueur	`len(L)`	nombre d’éléments
Accès	`L[i]`	élément d’indice `i`
Modification	`L[i] = v`	remplace l’élément d’indice `i`
Ajout en fin	`L.append(x)`	ajoute `x` à la fin
Test d’appartenance	`x in L`	`True` ou `False`
Liste vidé	`L = []`	aucune valeur

Exemple — Parcours d’une liste avec for

notes = [12, 15, 9, 17, 13]

# Parcourir les valeurs
total = 0
for n in notes:
    total = total + n
print("Somme :", total)        # Somme : 66
print("Moyenne :", total / len(notes))  # Moyenne : 13.2

# Parcourir les indices (utile pour modifier)
for i in range(len(notes)):
    notes[i] = notes[i] + 1     # bonus de +1 sur chaque note
print(notes)                    # [13, 16, 10, 18, 14]

Exemple — Construction d’une liste avec append

# Liste des carrés des entiers de 1 à 5
carrés = []
for n in range(1, 6):
    carrés.append(n * n)
print(carrés)                   # [1, 4, 9, 16, 25]

💡 Listes vs chaînes

Une chaîne "Bonjour" se manipule presque comme une liste de caractères : "Bonjour"[0] donne "B", len("Bonjour") vaut 7, etc. La grande différence : une chaîne est immuable (on ne peut pas faire s[0] = "X"), alors qu’une liste est modifiable.

Exemple — Compter les occurrences d’un caractère

On veut compter combien de fois un caractère donné apparaît dans une phrase, en parcourant chaque position avec une boucle for.

def nb_occurrences(phrase, car):
    l = len(phrase)
    n = 0
    for k in range(l):
        if phrase[k] == car:
            n = n + 1
    return n

print(nb_occurrences("Je programme en Python", "e"))  # 3

La variable n compte le nombre de fois où phrase[k] vaut car, en testant tour à tour chaque indice k de 0 à len(phrase) - 1.

Bilan — L’essentiel

Notion	Python
Affectation	`x = valeur`
Saisie utilisateur	`input("message")`
Affichage	`print(valeur)`
Conditionnelle	`if / elif / else`
Boucle bornée	`for i in range(n):`
Boucle non bornée	`while condition:`
Fonction	`def f(x): return ...`
Nombre aléatoire	`from random import randint`
Liste (tableau)	`L = [...]`, `L[i]`, `len(L)`, `L.append(x)`

Retenir :

Un algorithme est une suite finie d’instructions précises
Les quatre types de base : int, float, bool, str
for quand on connait le nombre de répétitions, while sinon
Une fonction prend des paramètres et renvoie un résultat avec return

⚠️ Pièges et contre-exemples

Algorithmique et Python : teste d’abord ton intuition, puis lis l’explication.

Score : 0 / 5 pièges identifiés

1 Un algorithme donne toujours le résultat le plus rapide

« Un algorithme donne toujours le résultat le plus rapide. »

Cette affirmation n’est-elle vraie ?

📖 Explication

FAUX. Un algorithme donne un résultat correct, mais pas forcément le plus rapide. Il existe souvent plusieurs algorithmes pour un même problème, avec des vitesses très différentes.

💡 Mémo : Un algorithme = une méthode qui termine et donne un résultat correct. La rapidité est une question d’optimisation, pas de correction.

Mini-test : un algorithme doit obligatoirement être le plus rapide possible ?

🔗 Travaille dans les exercices sur l’algorithmique

2 Une boucle while s’exécute toujours un nombre fini de fois

« Une boucle while s’exécute toujours un nombre fini de fois. »

Cette affirmation n’est-elle vraie ?

📖 Explication

FAUX. Si la condition du while ne devient jamais fausse, la boucle tourne indéfiniment : c’est une boucle infinie.

💡 Mémo : Toujours vérifier que la condition du while finira par devenir fausse. Exemple de boucle infinie : while True: pass.

Mini-test : que fait while True: print('ok') ?

🔗 Travaille dans les exercices sur les boucles

3 if et elif sont interchangeables

« if et elif sont interchangeables. »

Cette affirmation n’est-elle vraie ?

📖 Explication

FAUX. elif est évalué que si le if précédent (et les elif précédents) sont faux. Deux if successifs sont évalués indépendamment.

💡 Mémo : Utilise elif pour des cas mutuellement exclusifs, et plusieurs if pour des conditions indépendantes.

Mini-test : si x = 5, combien de branches sont exécutées avec if x>3: ... elif x>4: ... ?

🔗 Travaille dans les exercices sur les conditions

4 Une fonction sans return renvoie une erreur

« Une fonction sans return renvoie une erreur. »

Cette affirmation n’est-elle vraie ?

📖 Explication

FAUX. Une fonction sans return renvoie None par défaut, sans erreur. Elle peut très bien effectuer des actions (afficher, modifier une liste) sans rien renvoyer.

💡 Mémo : Pas de return = la fonction renvoie None. Ce n’est pas une erreur.

Mini-test : que renvoie def f(): print('bonjour') quand on fait x = f() ?

🔗 Travaille dans les exercices sur les fonctions

5 range(5) donne les entiers de 0 à 4

« range(5) donne les entiers de 0 à 4. »

Cette affirmation n’est-elle vraie ou fausse ?

📖 Explication

C’est VRAI ! range(5) produit les entiers 0, 1, 2, 3, 4 — soit 5 valeurs commençant à 0.

💡 Mémo : range(n) donne n valeurs de 0 à n-1. C’est un intrus parmi les pièges !

Mini-test : combien de valeurs produit range(10) ?

🔗 Voir la section sur les boucles

Chapitre 0 — Algorithmique et Python

Un convertisseur de température

Al-Khwarizmi, père de l’algorithme

Deviner un nombre en minimum d’essais

1. Notion d’algorithme

2. Variables et types

Opérateurs arithmétiques

3. Affectation et séquence

4. Instruction conditionnelle

5. Boucle bornée (for)

6. Boucle non bornée (while)

7. Fonctions Python

8. Listes (tableaux)

Bilan — L’essentiel

⚠️ Pièges et contre-exemples