-->
Tutoriel PythonPython en mode calculatrice
Python permet de faire des calculs comme avec une calculatrice classique.
Il faut pour cela écrire : print( ) et entre les parenthèses écrire le calcul que l'on souhaite.
print(2+3*6)
Pour élever des nombres au carré ou à un autre exposant, on utilise la notation ** :
print(2**10)
Pour pouvoir calculer avec la racine carrée on utilise la fonction sqrt( ) (square root en anglais).
print(sqrt(2))
Mais comme nous le voyons ci-dessus, Python ne trouve pas cette fonction. Il faut pour cela la charger avant à l'aide de l'instruction from math import*
from math import*
print(sqrt(2))
La librairie math que l'on importe contient d'autres fonctions ou constantes telle qu'une valeur approchée de $\pi$ par exemple :
from math import*
print(pi)
On peut également calculer en chargeant cette librairie à l'aide des fonctions cosinus, sinus, tan, et on peut également utiliser leur fonction réciproque arccosinus ou $\cos^{-1}$ etc.
from math import*
print(cos(pi/4))
print(acos(1))
D'après ces résultats on peut voir que Python calcule avec des angles en radians.
D'autres fonctions sont utilisables, à l'aide de la librairie math, telles que exp (pour la fonction exponentielle), e (pour la constante $\text{e}$), log (pour $\ln$), log10 (pour le logarithme en base 10), floor (pour la partie entière) etc.
Toutes les fonctions mathématiques sont sur la documentation officielle de Python.
Pour pouvoir calculer avec des nombres aléatoires, il faut tout d'abord charger la librairie random et utiliser la fonction random pour obtenir un nombre aléatoire de l'intervalle $[0\, ; 1[$, ou randint pour obtenir un entier aléatoire entre deux bornes.
Dans les programmes ci-dessous on pourra cliquer plusieurs fois sur Exécuter pour observer les modifications aléatoires.
from random import*
print(random())
from random import*
print(randint(1,6))
Écrire ci-dessous un programme Python permettant de calculer : $\sqrt{2+3\times\left(11-\dfrac{2}{5}\right)^3}$.
from math import*
print( sqrt( 2+3*(11-2/5)**3 ) )
Le programme ci-dessous simule le lancé d'un dé à 6 faces. Modifier le pour simuler le lancé d'un dé à 20 faces.
from random import*
print(randint(1,6))
from random import*
print(randint(1,20))Les variables
Comme dans tout langage de programmation Python permet d'utiliser plusieurs type de variables. En mathématiques celles qui seront le plus utilisées sont les variables de type flottants (à savoir des nombres) ou des listes de flottant (des tableaux de nombres). Il en existe d'autres comme les chaines de caractères (les « mots » composés de n'importe quels caractères), les booléens (vrai ou faux) etc.
Dans l'exemple ci-dessous, on affecte la valeur $3$ à la variable $a$, dont on affiche le double ensuite.
a = 3
print(2*a)
On peut également utiliser plusieurs variables. Dans l'exemple suivant on calcule la moyenne de trois variables. On fera attention à bien ajouter des virgules à la fin d'au moins un des nombres entiers pour que la division soit décimale.
x = 5
y = 15
z = 11.0
print( (x+y+z)/3 )
L'affectation, représentée par le symbole d'égalité $=$, n'a rien à voir avec l'égalité en mathématiques.
Par exemple, en mathématiques, l'équation $x=x+1$, n'admet aucune solution. En effet, elle est équivalente à l'égalité $0=1$.
Par contre en Python, l'affectation $x=x+1$ a du sens. Elle signifie que la nouvelle valeur de la variable $x$ est égale à son ancienne valeur à laquelle on ajoute $1$.
x = 99
x = x+1
print(x)
Compléter la première ligne de l'algorithme ci-dessous pour que le résultat affiché soit $1993$.
ldc =
ldc = ldc - 28
print(ldc)
ldc = 2021
ldc = ldc - 28
print(ldc)
Les noms des variables peuvent comporter plusieurs lettres ou caractères. Cependant ils doivent toujours commencer par une lettre de préférence écrite en minuscule.
Les listes sont des tableaux dans lesquels chaque élément est une variable à laquelle on accède par numérotation.
Dans l'exemple suivant, on définit une liste composée de plusieurs nombres et on affiche chacun de ces éléments à l'aide de leur position dans la liste. La position numéro $0$ étant la première.
listeDeNombres = [100, 200, 75, 1993]
print(listeDeNombres[0])
print(listeDeNombres[1])
print(listeDeNombres[2])
print(listeDeNombres[3])
La fonction len donne la longueur d'une liste (length en anglais), c'est-à-dire le nombre d'éléments qu'elle contient.
listeDeNombres = [100, 200, 75, 1993]
n = len(listeDeNombres)
print(n)
Un exemple particulier, qui sera utile dans de nombreuses situations, est celui de la liste vide. On la définit à l'aide de deux crochets mais sans rien entre eux. On remarque que sa longueur est bien nulle.
liste = []
print(len(liste))
La fonction append permet d'ajouter à la fin d'une liste un nouvel élément.
liste = [14,15]
liste.append(8)
print(liste)
Pour insérer un élément à une certaine position dans une liste on utilise la fonction insert, en spécifiant en premier la position de l'élément à insérer puis sa valeur.
listeCar = [0,1,4,9,16,25,49,64]
listeCar.insert(6,36)
print(listeCar)
La fonction remove permet d'enlever un élément d'une liste en spécifiant sa valeur.
M = [0,2,4,6,145,8,10]
M.remove(145)
print(M)
Si dans une liste un élément est présent deux fois, la fonction remove supprime la première occurrence de l'élément.
K = [0,1,2,3,4,5,3,6,7]
K.remove(3)
print(K)
Si on veut supprimer un élément par sa position on utilisera la fonction pop.
K = [0,1,2,3,4,5,3,6,7]
K.pop(6)
print(K)
Compléter le programme ci-dessous pour qu'il affiche la liste des entiers impairs jusqu'à 15.
listeImpairs = [1,3,28,7,9,13]
listeImpairs.remove()
listeImpairs.insert(,)
listeImpairs.insert(,)
listeImpairs.append()
print(listeImpairs)
listeImpairs = [1,3,28,7,9,13]
listeImpairs.remove(28)
listeImpairs.insert(2,5)
listeImpairs.insert(5,11)
listeImpairs.append(15)
print(listeImpairs)
La fonction range permet de créer des listes de nombres successifs. Pour l'afficher il est nécessaire ajouter la fonction list comme dans l'exemple ci-dessous.
listeNombres = range(0,10)
print(list(listeNombres))
L'instruction range(a,b) crée une liste de nombres entiers $n$ tels que 1 $a \leq n < b$.
On remarquera donc que la borne supérieure est exclue.
Créer et afficher une liste contenant tous les entiers de 5 jusqu'à 55.
L = range(5,56)
print(list(L))
On peut ajouter un troisième argument à la fonction range pour obtenir le pas entre chaque nombre de la liste crée.
Le programme suivant crée et affiche la liste de tous les entiers pairs jusqu'à 100.
entiersPairs = range(0,101,2)
print(list(entiersPairs))
Créer et afficher une liste contenant la table de 7 jusqu'à 70.
table7 = range(0,71,7)
print(list(table7))
Dans le paragraphe 4 on verra comment construire des listes par compréhension à l'aide d'une boucle for et de range.
Les conditionnelles
La structure de base avec les conditionnelles en Python est de la forme :
Si condition alors instructions sinon autres instructions.
La partie sinon n'étant pas obligatoire en fonction de ce que l'on veut faire.
a = 18
b = a**3-500
if b >= 5000:
a = 0
print(a)
Le programme précédent affiche $0$ car la valeur de $b$ est bien supérieure ou égale à $5\,000$.
n = 10
m = 20
x = 0
if 2*n+1 < m:
print("x augmente de 1")
x = x+1
else:
print("x diminue de 1")
x = x-1
print(x)
Dans l'exemple précédent la condition n'est pas vérifiée, ce sont donc les instructions qui suivent else: qui sont exécutées.
Il est très important, lorsqu'après if conditions: ou else: on écrit les instructions qui doivent être exécutées, que celles-ci soient décalées d'un certain espace depuis la marge, et toutes avec le même. Lorsqu'une ligne commence à nouveau contre la marge, l'interpréteur Python comprend que l'on n'est plus dans les instructions qui suivent le if ou le else.
Ce principe s'appelle l'indentation du code.
Corriger les erreurs d'indentation du code ci-dessous pour qu'aucun message d'erreur n'apparaisse quand on exécute le programme.
a = 13
if a > 20:
print("a va augmenter")
a = a*100
else:
print("a va diminuer")
a = a/2
print(a)
a = 13
if a > 20:
print("a va augmenter")
a = a*100
else:
print("a va diminuer")
a = a/2
print(a)
Compléter la ligne 1 du programme ci-dessous pour qu'il affiche « Victoire » :
a =
b = a**2-10
if b == 111:
print("Victoire")
else:
print("Défaite")
a = 11
b = a**2-10
if b == 111:
print("Victoire")
else:
print("Défaite")
ou encore, pour les plus malins :
a = -11
b = a**2-10
if b == 111:
print("Victoire")
else:
print("Défaite")
Compléter la ligne 1 du programme ci-dessous pour qu'il affiche « Victoire » :
from math import*
a =
b = sqrt(1-a*a)
if b < 0.1:
print("Victoire !")
else:
print("Défaite...")
from math import*
a = 0.999
b = sqrt(1-a*a)
if b < 0.1:
print("Victoire !")
else:
print("Défaite...")
La structure si alors sinon est suffisante pour tous les énoncés de bac en Python, mais ceux qui veulent aller plus loin pour des projets personnels peuvent étudier la structure conditionnelle elif sur le site suivant.
Les boucles for
Les boucles for permettent de faire parcourir à une variable un ensemble de valeurs, généralement prises dans une liste de nombres.
Par exemple si on veut afficher la valeur des premiers carrés parfaits
$n$
$1$
$2$
$3$
$4$
$5$
$6$
$7$
$8$
$9$
$10$
$11$
$12$
$13$
$14$
$n^2$
$1$
$4$
$9$
$16$
$25$
$36$
$49$
$64$
$84$
$100$
$121$
$144$
$169$
$196$
on fait parcourir à une variable $i$ (par exemple), l'ensemble des entiers entre $1$ et $14$ et on affiche le résultat de $i^2$.
for i in range(1,15):
print(i**2)
Les boucles for permettent de calculer de longues sommes sans trop d'effort.
Par exemple, l'algorithme ci-dessous permet de calculer $s= 1+2+3+\dots+100$.
s = 0
for i in range(1,101):
s = s+i
print(s)
Écrire un programme Python permettant de calculer $1^2+2^2+3^2+\dots+999^2+1\,000^2$.
s = 0
for k in range(1,1001):
s = s+k**2
print(s)
Utiliser un algorithme pour vérifier que si $n$ est assez grand $s_n=1+\dfrac{1}{2^2}+\dfrac{1}{3^2}+\dots+\dfrac{1}{n^2}$ est proche de $\dfrac{\pi^2}{6}$.
from math import*
s = 0
for i in range(1,10000):
s = s+1/i**2
print(s)
print(pi**2/6)
Compléter l'algorithme suivant pour qu'il calcule et affiche le produit $p = 1\times2\times3\times\dots\times100$.
p = 1
for i in range( , ):
p =
print(p)
p = 1
for i in range(1,101):
p = p*i
print(p)
On peut créer des listes à l'aide des boucles for. Cette méthode est dite par compréhension. Le programme ci-dessous crée une liste composée des carrés parfaits jusqu'à $100$.
c = [i**2 for i in range(0,11)]
print(c)
Créer et afficher par compréhension une liste composée des inverses de tous les entiers de $1$ jusqu'à $100$. C'est-à-dire : $\dfrac{1}{1}$, $\dfrac{1}{2}$, $\dfrac{1}{3}$, $\dots$, $\dfrac{1}{100}$.
inv = [1.0/i for i in range(1,101)]
print(inv)
Compléter l'algorithme ci-dessous pour qu'il simule $1\,200$ lancés d'un dé à $6$ faces équilibré et affiche le nombre de fois où on obtient la face $6$.
from random import*
nb6 = 0
for i in
face = randint(
if face ==
nb6 =
print(nb6)
from random import*
nb6 = 0
for i in range(0,1200):
face = randint(1,6)
if face == 6:
nb6 = nb6+1
print(nb6)
Écrire un algorithme qui simule $1\,000$ lancés d'une pièce équilibrée, et qui affiche la fréquence de piles obtenus. On pourra assimiler une pièce à un « dé » à deux faces et s'inspirer de l'exercice précédent.
from random import*
nbpiles = 0
for i in range(0,1000):
face = randint(0,1)
if face == 0:
nbpiles = nbpiles+1
print(nbpiles/1000)Les boucles while
Une boucle while permet d'exécuter des instructions tant qu'une condition est vraie.
Le programme suivant va modifier et afficher la valeur de la variable $a$ tant que celle-ci sera inférieure à $100$.
a = 1
while a < 100:
a = a*2
print(a)
Pour afficher les multiples de $11$ qui sont inférieurs à $1\,000$ on peut procéder de la façon suivante :
mult = 0
while mult <= 1000:
print(mult)
mult = mult+11
Si en plus on veut compter combien de nombre on a affichés on peut ajouter un compteur de boucle :
mult = 0
n = 0
while mult <= 1000:
print(mult)
mult = mult+11
n = n+1
print("Nombre de multiples de 11 affichés : "+str(n))
L'instruction str(n) converti la variable $n$ qui est un flottant (un nombre) en une chaîne de caractères (string en anglais) pour que print puisse l'afficher.
Un pirate possède un coffre qui contient $1\,500$ pièces d'or. Tous les mois cette personne prélève exactement 12 pièces pour ses besoins personnels.
Compléter l'algorithme suivant pour qu'il affiche dans combien de semaines le coffre sera vide.
coffre = 1500
n = 0
while coffre
coffre =
n =
print(
coffre = 1500
n = 0
while coffre > 0:
coffre = coffre-12
n = n+1
print(n)
Pour la naissance de leur petite-fille, ses grands-parents ont décidé de placer 500 € pour chaque anniversaire à intérêts composés au taux annuel de 4 %.
Le 1er versement est fait le jour de sa naissance et le dernier lorsque la somme dépassera 15 000 €.
Compléter l’algorithme suivant pour qu’il affiche le nombre d'années à attendre pour que la somme voulue soit atteinte.
c = 500
n = 0
while c <= :
c = c*
c = c+
n =
print(n)
On utilise le fait qu'une augmentation de 4 % correspond à un coefficient multiplicateur de $1,04$.
c = 500
n = 0
while c <= 15000:
c = c*1.04
c = c+500
n = n+1
print(n)
D'après l'algorithme il faudra attendre 20 ans pour dépasser les 15 000 €.
Les fonctions
Le langage Python permet de définir des objets que l’on appelle fonctions et qui
pourront être appelés et utilisés plusieurs fois au sein d’un même programme.
Une fonction Python porte un nom, dépend d’un, ou de plusieurs paramètres, et renvoie, généralement, un résultat à la fin de son exécution.
Le programme ci-contre définit une fonction que l’on
décide d’appeler moyenne, qui prend deux paramètres
a, et b, et qui retourne la moyenne arithmétique de
ces deux nombres.
def moyenne(a,b):
return (a+b)/2
Si on exécute ce programme rien ne s’affiche. La fonction a juste été définie et non utilisée.
Complétons donc cet algorithme en demandant d’exécuter deux fois notre fonction moyenne avec des valeurs différentes.
def moyenne(a,b):
return (a+b)/2
print(moyenne(10,12))
print(moyenne(-13,24))
Une fonction Python ne retourne pas toujours une valeur, mais peut simplement exécuter des instructions. L'algorithme suivant définit une fonction qui affiche les entiers impairs jusqu'à un seuil $n$ donné en paramètre.
def impairs(n):
i = 1
while i <= n:
print(i)
i = i+2
On peut maintenant appeler cette fonction pour afficher les entiers pairs jusqu'à 50 :
def impairs(n):
i = 1
while i <= n:
print(i)
i = i+2
impairs(50)
Ou encore jusqu'à 100 :
def impairs(n):
i = 1
while i <= n:
print(i)
i = i+2
impairs(100)
Écrire un algorithme définissant la fonction $f$ donnée par $f(x)=\sqrt{x^2+1}$ et qui affiche ensuite quatre images obtenue par cette fonction (on choisira les antécédents comme on veut).
from math import*
def f(x):
return
print(f(
print(f(
print(f(
print(f(
from math import*
def f(x):
return sqrt(x**2+1)
print(f(0))
print(f(10))
print(f(-5))
print(f(1000))
Soit $(u_n)$ la suite définie pour tout entier $n$ par $u_0=200$ et $u_{n+1}=0,96u_n+10$.
La fonction suivante permet d'obtenir la valeur de n'importe quel terme de la suite.
def u(n):
u = 200
for i in range(0,n):
u = 0.98*u+10
return u
print(u(5))
print(u(10))
print(u(50))
print(u(100))
Soit $(v_n)$ la suite définie pour tout entier $n$ par $v_0=50$ et $v_{n+1}=\dfrac{2v_n+8}{v_n+1}$
Dans le programme ci-dessous, définir une fonction qui retourne le terme $v_n$ pour $n$ donné. On utilisera ensuite cette fonction pour afficher $v_{5}$, $v_{10}$, $v_{100}$ et $v_{1000}$
def v(
v = 50.0
for i in
v =
return
def v(n):
v = 50.0
for i in range(0,n):
v = (2*v+8)/(v+1)
return v
print(v(1))
print(v(5))
print(v(10))
print(v(100))
Soit $(u_n)$ la suite définie par $u_0=100$ et pour tout entier $n$, $u_{n+1}=1,03u_n-2$.
On admet que cette suite est strictement croissante et diverge vers $+\infty$. Compléter l'algorithme suivant pour que la fonction seuil retourne le rang du premier terme de la suite qui dépasse la valeur du paramètre A.
def seuil(A):
u = 100
n = 0
while u < :
n =
u =
return n
print(seuil(10000))
def seuil(A):
u = 100
n = 0
while u < A:
n = n+1
u = 1.03*u-2
return n
print(seuil(10000))
On peut utiliser également des listes avec des fonctions, comme ici pour déterminer la moyenne de tous les termes d'une liste donnée en paramètre.
def moyenneListe(L):
s = 0
for i in range(0,len(L)):
s = s + L[i]
return s/len(L)
A = [5, 12, 14, 8, 20, 7]
print(moyenneListe(A))
B = [145.1 ,189.1,52.6,13.8]
print(moyenneListe( B ))
On définit ci-dessous une fonction dist pour afficher la distance séparant deux points du plan. On utilise deux paramètres correspondant aux points,
chacun de ceux-ci étant sous la forme d'une liste à deux éléments.
from math import*
def dist(A,B):
d = sqrt((B[0]-A[0])**2+(B[1]-A[1])**2)
print(d)
return d
C = [10,-5]
D = [-3,4]
dist(C,D)
Écrire un programme qui contient une fonction qui permet d'afficher le fait qu'un quadrilatère est un parallélogramme ou non en fonction des coordonnées de quatre points données sous forme de listes de deux éléments comme dans l'exemple précédent.
def quadri(A,B,C,D):
def quadri(A,B,C,D):
xDiag1 = (A[0]+C[0])/2
yDiag1 = (A[1]+C[1])/2
xDiag2 = (B[0]+D[0])/2
yDiag2 = (B[1]+D[1])/2
if xDiag1 == xDiag2 and yDiag1 == yDiag2:
print("Le quadrilatère est un parallélogramme")
else:
print("Le quadrilatère n'est pas un parallélogramme")
P = [2,-2]
Q = [8,2]
R = [1,-4]
S = [-5,-8]
quadri(P,Q,R,S)