Cours
1. Variables, types et affectation
Une variable mémorise une valeur. L’instruction
a = 5 affecte la valeur 5 à la variable a : le signe
= ne représente donc pas ici une égalité mathématique.
nombre = 5 # entier : int
mesure = 2.5 # flottant : float
message = "Bonjour" # chaîne de caractères : str
test = nombre > 0 # booléen : bool
nombre = nombre + 1
print(nombre)
Après la dernière affectation, nombre vaut 6. Python exécute
les instructions dans l’ordre où elles sont écrites.
2. Entrées, sorties et calculs
input() lit une réponse sous forme de texte. On utilise
int() ou float() lorsqu’un calcul numérique est attendu.
prix = float(input("Prix en euros : "))
taux = 20
prix_final = prix * (1 + taux / 100)
print("Prix final :", prix_final)
Les opérateurs usuels sont +, -, *,
/ et ** pour une puissance.
3. Conditions et booléens
Une condition est une expression qui vaut True ou
False. Les comparaisons s’écrivent notamment <,
<=, >, >=, == et !=.
x = float(input("x = "))
if x > 0:
print("x est positif")
elif x == 0:
print("x est nul")
else:
print("x est négatif")
L’indentation délimite les instructions exécutées dans chaque cas.
On peut combiner des conditions avec and, or et
not.
4. Boucle bornée for
Une boucle bornée est utilisée lorsque le nombre de répétitions est connu.
for i in range(1, 6):
print(i, i ** 2)
Ce programme affiche les carrés des entiers de 1 à 5. La borne finale de
range(1, 6) n’est pas incluse.
5. Boucle non bornée while
Une boucle non bornée répète des instructions tant qu’une condition est vraie. Il faut veiller à modifier une variable pour que la condition devienne fausse.
n = 1
while n ** 2 < 50:
n = n + 1
print(n)
Le programme affiche 8 : c’est le plus petit entier positif dont le carré est supérieur ou égal à 50.
6. Fonctions à un ou plusieurs arguments
Une fonction reçoit des arguments et renvoie un résultat avec
return. Il ne faut pas confondre renvoyer une valeur et l’afficher.
def image_affine(x, a, b):
return a * x + b
y = image_affine(3, 2, 1)
print(y)
L’appel image_affine(3, 2, 1) renvoie 7.
7. Lire, vérifier et modifier un programme
Avant d’exécuter le programme suivant, prévoir la valeur affichée.
def mystere(n):
resultat = 0
for i in range(1, n + 1):
resultat = resultat + i
return resultat
print(mystere(4))
On obtient 10, car le programme calcule 1 + 2 + 3 + 4.
Pour contrôler un programme, on peut suivre pas à pas les valeurs des variables,
tester des cas simples et vérifier la vraisemblance du résultat.
Exercices d’entraînement
Exercice 1 — Types et affectations
Donner le type et la valeur finale de chaque variable après l’exécution :
a = 4, b = 2.5, a = a + 3,
test = a > b.
Afficher la correction
Les instructions sont exécutées dans l’ordre : a reçoit 4, b reçoit 2.5, puis a est remplacé par 4 + 3 = 7. La comparaison a > b devient donc 7 > 2.5.
Les valeurs finales sont a = 7, de type int ; b = 2.5, de type float ; test = True, de type bool. test mémorise le résultat de la comparaison, pas les nombres comparés.
Exercice 2 — Condition
Écrire un programme qui demande un nombre et indique s’il appartient à l’intervalle [−2 ; 5].
Afficher la correction
L’intervalle est fermé : les deux bornes doivent être incluses. On traduit donc l’appartenance par -2 <= x <= 5, équivalent à x >= -2 and x <= 5.
x = float(input("Nombre : "))
if -2 <= x <= 5:
print("Le nombre appartient a [-2 ; 5].")
else:
print("Le nombre n'appartient pas a [-2 ; 5].")Les entrées −2 et 5 sont acceptées, de même que 0. Les entrées −2,1 et 5,1 sont refusées. Lors de la saisie Python, on utilise un point pour les décimaux, par exemple 5.1.
Exercice 3 — Boucle bornée
Écrire une boucle qui affiche les dix premiers multiples de 7.
Afficher la correction
On choisit ici les dix premiers multiples strictement positifs de 7. La variable i prend les valeurs de 1 à 10 : la borne finale de range(1, 11) est exclue.
for i in range(1, 11):
print(7 * i)Le programme affiche 7, 14, 21, 28, 35, 42, 49, 56, 63 et 70, un nombre par ligne. Si l’on inclut 0 parmi les premiers multiples naturels, on utilise range(10) et on obtient 0, 7, …, 63. L’énoncé ne précisait pas cette convention.
Exercice 4 — Boucle non bornée
Compléter un programme qui cherche le plus petit entier n tel que n3 soit supérieur ou égal à 1 000.
Afficher la correction
On part de 0 et on augmente n tant que son cube est strictement inférieur à 1 000. Le test d’arrêt doit autoriser l’égalité.
n = 0
while n ** 3 < 1000:
n = n + 1
print(n)Le programme affiche 10. Vérification : 9³ = 729 < 1 000 et 10³ = 1 000. La fonction cube étant strictement croissante, 10 est bien le plus petit entier qui convient. Un test <= 1000 ferait une itération de trop.
Exercice 5 — Fonction
Écrire une fonction aire_rectangle(longueur, largeur) qui renvoie
l’aire d’un rectangle, puis l’appeler avec 8 et 3,5.
Afficher la correction
L’aire est le produit de la longueur par la largeur. La fonction reçoit deux dimensions positives et return renvoie le résultat.
def aire_rectangle(longueur, largeur):
return longueur * largeur
print(aire_rectangle(8, 3.5))L’appel renvoie 28.0, car 8 × 3,5 = 28. Si les dimensions sont en centimètres, l’aire est de 28 cm². print affiche la valeur renvoyée ; la fonction, elle, ne fait que la calculer.
Exercice 6 — Comprendre et modifier
Expliquer ce que renvoie la fonction mystere du cours. La modifier
pour qu’elle calcule la somme des carrés des entiers de 1 à n.
Afficher la correction
Pour un entier n positif ou nul, mystere(n) renvoie la somme 1 + 2 + … + n ; pour n = 0, la boucle ne s’exécute pas et la somme vaut 0. Pour additionner les carrés, on remplace i par i ** 2 dans l’accumulation.
def somme_carres(n):
resultat = 0
for i in range(1, n + 1):
resultat = resultat + i ** 2
return resultat
print(somme_carres(4))Pour n = 4, le programme affiche 30, car 1² + 2² + 3² + 4² = 1 + 4 + 9 + 16 = 30. Le return reste en dehors de la boucle pour renvoyer la somme après toutes les additions. Pour n = 0, la fonction renvoie 0.
Vidéo
Vidéo explicative sur les bases de Python :
À retenir
En Python, l’indentation est essentielle : elle indique quelles instructions appartiennent à une condition, une boucle ou une fonction.
Pour passer d’un algorithme en langage naturel à Python, identifier les données, les variables, les étapes du calcul, les conditions, les répétitions et le résultat attendu.