Une variable est une « boîte » qui porte un nom et contient une valeur. L'instruction x = 5 affecte la valeur \(5\) à la variable x (elle remplace l'ancienne valeur).
x = 5 # x vaut 5
x = x + 2 # on calcule x + 2, puis on range le résultat dans x : x vaut 7
nom = "Alice" # une chaîne de caractères
| Type | Description | Exemple |
|---|---|---|
int |
nombre entier | 42 |
float |
nombre à virgule (flottant) | 3.14 |
str |
chaîne de caractères | "bonjour" |
bool |
booléen | True, False |
+, -, *, / ; a ** b pour \(a^b\) ; a // b pour le quotient et a % b pour le reste de la division euclidienne (\(17 = 5 \times 3 + 2\) : 17 // 5 vaut \(3\) et 17 % 5 vaut \(2\)).
Une fonction reçoit des arguments et renvoie un résultat avec return.
def f(x):
return x**2 - 3*x + 1
print(f(4)) # affiche 5
f(4) calcule l'image de \(4\) par \(f\). Une fonction Python peut aussi avoir plusieurs arguments, ou renvoyer un booléen.
def tarif(age):
if age < 12:
return 5
elif age < 18:
return 7
else:
return 10
== (égal), != (différent), <, <=, >, >=. Opérateurs logiques : and, or, not.
= sert à affecter, == sert à tester une égalité. Et l'indentation (le décalage de 4 espaces) indique ce qui fait partie du if, de la boucle ou de la fonction.
forOn l'utilise quand on connaît le nombre de répétitions. range(n) donne \(0, 1, \ldots, n - 1\) ; range(a, b) donne les entiers de \(a\) à \(b - 1\).
s = 0
for k in range(1, 101): # k prend les valeurs 1, 2, ..., 100
s = s + k
print(s) # 5050
whileOn l'utilise quand on répète tant qu'une condition est vraie, sans savoir à l'avance combien de fois. C'est le cas des algorithmes de seuil.
capital = 1000
annees = 0
while capital <= 2000: # tant que le capital n'a pas doublé
capital = capital * 1.05 # +5 % par an
annees = annees + 1
print(annees) # 15
On fait un tableau avec une colonne par variable, et une ligne par tour de boucle.
Le module random fournit des nombres aléatoires : random.randint(1, 6) donne un entier au hasard entre \(1\) et \(6\) (comme un dé), random.random() un nombre au hasard dans \([0 ; 1[\).
import random
compteur = 0
for i in range(1000):
if random.randint(1, 6) == 6:
compteur = compteur + 1
print(compteur / 1000) # fréquence des 6, proche de 1/6
Contenu facultatif, non exigible.
En 1re, tu utiliseras les listes Python pour stocker plusieurs valeurs (par exemple les termes d'une suite).
L’essentiel du chapitre, à relire avant un contrôle.
| Instruction | Effet |
|---|---|
x = 5 |
affectation |
def f(x): return ... |
définir une fonction |
if / elif / else |
instruction conditionnelle |
for k in range(a, b) |
boucle bornée (\(k\) de \(a\) à \(b - 1\)) |
while condition: |
boucle « tant que » |
a // b, a % b |
quotient, reste |
random.randint(a, b) |
entier aléatoire entre \(a\) et \(b\) |
range(1, 10) s'arrête à \(9\).= (affectation) et == (test d'égalité) sont différents.input() renvoie du texte : il faut le convertir avec int(...) ou float(...).Qu'affiche ce programme ?
a = 7
b = 3
a = a + b
b = a - b
print(a, b)
| Instruction | a |
b |
|---|---|---|
a = 7 |
\(7\) | |
b = 3 |
\(7\) | \(3\) |
a = a + b |
\(10\) | \(3\) |
b = a - b |
\(10\) | \(7\) |
Le programme affiche 10 7.
Écris une fonction cube(x) qui renvoie \(x^3\). Que renvoie cube(-2) ?
def cube(x):
return x**3
cube(-2) renvoie \((-2)^3 = \mathbf{-8}\).
Écris un programme qui demande deux nombres à l'utilisateur et affiche leur moyenne.
a = float(input("Premier nombre : "))
b = float(input("Deuxième nombre : "))
print((a + b) / 2)
Les parenthèses sont indispensables : a + b / 2 calculerait \(a + \dfrac{b}{2}\).
Que valent 17 // 5, 17 % 5 et 2 ** 10 ?
\(17 = 5 \times 3 + 2\) : 17 // 5 vaut \(\mathbf{3}\), 17 % 5 vaut \(\mathbf{2}\). 2 ** 10 vaut \(\mathbf{1024}\).
Écris une fonction signe(x) qui renvoie "positif", "négatif" ou "nul".
def signe(x):
if x > 0:
return "positif"
elif x < 0:
return "négatif"
else:
return "nul"
Qu'affiche ce programme ?
for i in range(2, 11, 3):
print(i)
(range(a, b, p) va de \(a\) à \(b - 1\) avec un pas de \(p\).)
\(i\) part de \(2\) et augmente de \(3\) tant qu'il reste inférieur à \(11\) : le programme affiche \(2\), \(5\), \(8\) (le suivant, \(11\), n'est pas atteint).
a = 5
b = 3
a = a + b
b = a - b
a = a - b
Que valent a et b à la fin ? Que fait ce programme ?
a : \(5 \to 8 \to 8 \to 3\) ; b : \(3 \to 3 \to 5 \to 5\). À la fin \(\mathbf{a = 3}\) et \(\mathbf{b = 5}\) : le programme échange les valeurs.
def f(x):
return 3 * x**2 - 1
Que renvoient f(2) et f(-1) ?
f(2) \(= 3 \times 4 - 1 = \mathbf{11}\) ; f(-1) \(= 3 - 1 = \mathbf{2}\).
for i in range(1, 6):
print(i * i)
Qu'affiche ce programme ?
range(1, 6) donne \(1, 2, 3, 4, 5\) (\(6\) exclu). Affichage : \(\mathbf{1, 4, 9, 16, 25}\).
Que valent 17 // 5 et 17 % 5 ?
\(17 = 5 \times 3 + 2\) : 17 // 5 \(= \mathbf{3}\) (quotient) et 17 % 5 \(= \mathbf{2}\) (reste).
def signe(x):
if x > 0:
return "positif"
elif x < 0:
return "négatif"
else:
return "nul"
Que renvoient signe(-4), signe(0) et signe(2.5) ?
"négatif", "nul", "positif".
Écris une fonction somme_carres(n) qui calcule \(1^2 + 2^2 + \cdots + n^2\). Que renvoie somme_carres(5) ?
def somme_carres(n):
s = 0
for k in range(1, n + 1):
s = s + k**2
return s
somme_carres(5) \(= 1 + 4 + 9 + 16 + 25 = \mathbf{55}\).
Écris une fonction compte_diviseurs(n) qui renvoie le nombre de diviseurs de l'entier \(n \geqslant 1\). Teste avec \(n = 12\).
def compte_diviseurs(n):
c = 0
for d in range(1, n + 1):
if n % d == 0: # d divise n si le reste est nul
c = c + 1
return c
Pour \(12\) : les diviseurs sont \(1, 2, 3, 4, 6, 12\), la fonction renvoie \(\mathbf{6}\).
Soit \(f(x) = x^2 - 3x + 1\). Écris un programme qui affiche les images de \(-2, -1, 0, 1, 2, 3\), puis donne les valeurs affichées.
def f(x):
return x**2 - 3*x + 1
for x in range(-2, 4):
print(x, f(x))
| \(x\) | \(-2\) | \(-1\) | \(0\) | \(1\) | \(2\) | \(3\) |
|---|---|---|---|---|---|---|
| \(f(x)\) | \(11\) | \(5\) | \(1\) | \(-1\) | \(-1\) | \(1\) |
On place \(1\,000\) € à \(5\,\%\) par an (intérêts composés).
a) Écris un programme qui détermine au bout de combien d'années le capital dépasse \(2\,000\) €.
b) Quel nombre affiche-t-il ?
a)
capital = 1000
n = 0
while capital <= 2000:
capital = capital * 1.05
n = n + 1
print(n)
b) Il affiche \(15\) : \(1{,}05^{14} \approx 1{,}98\) (pas encore doublé) et \(1{,}05^{15} \approx 2{,}08\).
Écris une fonction est_pair(n) qui renvoie True si l'entier \(n\) est pair et False sinon.
def est_pair(n):
return n % 2 == 0
L'expression n % 2 == 0 vaut déjà True ou False.
Un musée fait payer \(5\) € aux moins de \(12\) ans, \(7\) € aux \(12\)-\(17\) ans et \(10\) € aux autres. Écris une fonction tarif(age), puis calcule le prix pour une famille avec deux adultes et des enfants de \(8\) et \(14\) ans.
def tarif(age):
if age < 12:
return 5
elif age < 18:
return 7
else:
return 10
print(2 * tarif(40) + tarif(8) + tarif(14))
Total : \(2 \times 10 + 5 + 7 = \mathbf{32}\) €.
Écris une fonction distance(xA, yA, xB, yB) qui renvoie la distance \(AB\) dans un repère orthonormé. Teste-la avec \(A(1 ; 2)\) et \(B(4 ; 6)\).
from math import sqrt
def distance(xA, yA, xB, yB):
return sqrt((xB - xA)**2 + (yB - yA)**2)
print(distance(1, 2, 4, 6))
Le programme affiche \(\sqrt{3^2 + 4^2} = \sqrt{25} = \mathbf{5.0}\).
Écris une fonction val_abs(x) qui renvoie \(|x|\) sans utiliser la fonction abs de Python.
def val_abs(x):
if x >= 0:
return x
else:
return -x
C'est exactement la définition : \(|x| = x\) si \(x \geqslant 0\), \(|x| = -x\) sinon.
n = 0
s = 0
while s < 20:
n = n + 1
s = s + n
print(n, s)
Qu'affiche ce programme ?
n |
\(1\) | \(2\) | \(3\) | \(4\) | \(5\) | \(6\) |
|---|---|---|---|---|---|---|
s |
\(1\) | \(3\) | \(6\) | \(10\) | \(15\) | \(21\) |
La boucle s'arrête dès que \(s \geqslant 20\) : affichage 6 21.
L = [3, 7, 2, 9]
Que valent len(L), L[0], sum(L) et max(L) ?
len(L) \(= \mathbf{4}\) ; L[0] \(= \mathbf{3}\) (les indices commencent à \(0\)) ; sum(L) \(= \mathbf{21}\) ; max(L) \(= \mathbf{9}\).
Écris une fonction moyenne(L) qui renvoie la moyenne des nombres de la liste L. Que renvoie moyenne([12, 15, 9]) ?
def moyenne(L):
return sum(L) / len(L)
moyenne([12, 15, 9]) renvoie \(\dfrac{36}{3} = \mathbf{12}\) (affiché 12.0).
c = 0
for i in range(1, 100):
if i % 7 == 0:
c = c + 1
print(c)
Que compte ce programme ? Qu'affiche-t-il ?
Il compte les multiples de \(7\) entre \(1\) et \(99\) : \(7, 14, \dots, 98\), soit \(\mathbf{14}\).
capital = 1000
annees = 0
while capital < 2000:
capital = capital * 1.05
annees = annees + 1
print(annees)
a) Que représente ce programme ?
b) Qu'affiche-t-il ?
a) Le nombre d'années nécessaires pour qu'un capital placé à \(5\,\%\) par an double.
b) \(1{,}05^{14} \approx 1{,}98\) et \(1{,}05^{15} \approx 2{,}08\) : il affiche \(\mathbf{15}\).
a) Écris un programme qui simule \(1\,000\) lancers d'un dé et affiche la fréquence d'apparition du \(6\).
b) Quelle valeur s'attend-on à obtenir environ ? Pourquoi ne l'obtient-on pas exactement ?
a)
import random
six = 0
for i in range(1000):
if random.randint(1, 6) == 6:
six = six + 1
print(six / 1000)
b) On s'attend à une fréquence proche de \(\dfrac{1}{6} \approx 0{,}167\). Le résultat varie d'une simulation à l'autre : c'est la fluctuation d'échantillonnage.
Une population de \(1\,000\) bactéries double toutes les heures. Écris un programme qui détermine au bout de combien d'heures elle dépasse un million, puis donne le résultat.
population = 1000
heures = 0
while population <= 1000000:
population = population * 2
heures = heures + 1
print(heures)
Il faut multiplier par plus de \(1\,000\), soit \(2^n > 1\,000\) : \(2^9 = 512\) et \(2^{10} = 1\,024\). Le programme affiche \(10\).
On cherche une solution de l'équation \(x^3 + x - 5 = 0\).
a) Écris un programme qui calcule \(f(x) = x^3 + x - 5\) pour \(x = 1 ; 1{,}1 ; 1{,}2 ; \ldots ; 2\).
b) Déduis-en un encadrement d'amplitude \(0{,}1\) de la solution.
a)
def f(x):
return x**3 + x - 5
for k in range(11):
x = 1 + k / 10
print(x, f(x))
b) On lit \(f(1{,}5) \approx -0{,}125 < 0\) et \(f(1{,}6) \approx 0{,}696 > 0\) : la solution est comprise entre \(1{,}5\) et \(1{,}6\).
Écris une fonction alignes(xA, yA, xB, yB, xC, yC) qui renvoie True si les points \(A\), \(B\), \(C\) sont alignés, en utilisant le déterminant de \(\overrightarrow{AB}\) et \(\overrightarrow{AC}\). Teste-la avec \(A(1 ; 2)\), \(B(3 ; 6)\), \(C(5 ; 10)\).
def alignes(xA, yA, xB, yB, xC, yC):
det = (xB - xA) * (yC - yA) - (xC - xA) * (yB - yA)
return det == 0
Avec \(A(1 ; 2)\), \(B(3 ; 6)\), \(C(5 ; 10)\) : \(\overrightarrow{AB}\begin{pmatrix} 2 \\ 4 \end{pmatrix}\), \(\overrightarrow{AC}\begin{pmatrix} 4 \\ 8 \end{pmatrix}\), \(\det = 2 \times 8 - 4 \times 4 = 0\) : la fonction renvoie True.
Avec des coordonnées décimales, le test == 0 peut échouer à cause des arrondis des flottants.
a) Écris un programme qui simule \(10\,000\) lancers de deux dés et calcule la fréquence de la somme \(7\).
b) Compare avec la probabilité théorique.
a)
import random
sept = 0
for i in range(10000):
s = random.randint(1, 6) + random.randint(1, 6)
if s == 7:
sept = sept + 1
print(sept / 10000)
b) Sur les \(36\) issues équiprobables, \(6\) donnent \(7\) : la probabilité vaut \(\dfrac{1}{6} \approx 0{,}167\). La fréquence obtenue en est proche.
Une course de taxi coûte \(3\) € de prise en charge plus \(1{,}50\) € par kilomètre.
a) Écris une fonction prix(d).
b) Écris un programme qui détermine la plus grande distance entière (en km) que l'on peut parcourir avec \(30\) €.
c) Vérifie le résultat par le calcul.
a)
def prix(d):
return 3 + 1.5 * d
b)
d = 0
while prix(d + 1) <= 30:
d = d + 1
print(d)
Le programme affiche \(18\).
c) \(3 + 1{,}5d \leqslant 30\) donne \(1{,}5d \leqslant 27\), soit \(d \leqslant 18\). Et \(\text{prix}(18) = 30\) € ✓