Initiation à Python

pour les élèves du lycée

(et aussi les profs)

Stéphane Pasquet

14 septembre 2018
2
Avant-propos

À l’heure où vous lisez ceci, je construis ce document.

J’ai préféré le faire petit à petit car je suis novice en Python et quoi de mieux (pour
moi comme pour toutes les personnes qui sont dans mon cas) que d’apprendre petit
à petit ?
J’espère ainsi produire un document qui se veut réellement utile aux enseignants
comme aux élèves soucieux de se mettre à Python.
Il n’y a donc pas encore tous les chapitres. N’hésitez pas à me contacter (à l’aide
de la page de contact de mon site, [Link] pour me faire part
de vos suggestions.
Vous pouvez aussi consulter les articles de ce site qui parlent de Python.

Stéphane Pasquet

i
ii

Sommaire

1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1 Téléchargement du logiciel
d’installation . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Installation de Python . . . . . . . . . . . . . . . . . . . . 2
1.3 Lancement de la console . . . . . . . . . . . . . . . . . . 3
2 La logique de Python . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Appel d’un module . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Installer un module . . . . . . . . . . . . . . . . . . . . . . 9
3 Algorithmique et programmation . . . . . . . . . . . . . . . . . . 11
3.1 Déclaration des variables . . . . . . . . . . . . . . . . . . 11
3.2 Déclaration d’une fonction . . . . . . . . . . . . . . . . . . 11
3.3 Les tests : Si... Alors... Sinon... . . . . . . . . . . . . . . . 12
3.4 La boucle « Pour » . . . . . . . . . . . . . . . . . . . . . . 15
3.5 La boucle « Tant que » . . . . . . . . . . . . . . . . . . . . 16
4 Tracé de courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.1 Modules à installer . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Un exemple de courbe représentative de fonction . . . . . 17
4.3 Légendes . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 Courbes paramétriques . . . . . . . . . . . . . . . . . . . 19
4.5 Surfaces 3D . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.6 Export en PNG . . . . . . . . . . . . . . . . . . . . . . . . 21
4.7 Affichage dans un document LATEX . . . . . . . . . . . . . 21
5 Opérations mathématiques . . . . . . . . . . . . . . . . . . . . . 25
5.1 Le module « math » . . . . . . . . . . . . . . . . . . . . . 25
5.1.1 Les constantes . . . . . . . . . . . . . . . . . . . . . . . . 25
5.1.2 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 26
Racine carrée . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Puissances . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Logarithme népérien . . . . . . . . . . . . . . . . . . . . . . . 27
Logarithme décimal . . . . . . . . . . . . . . . . . . . . . . . 27
Fonctions trigonométriques : sinus, cosinus, tangente . . . . 27
Arccos, arcsin et arctan . . . . . . . . . . . . . . . . . . . . . 28
5.1.3 Conversions . . . . . . . . . . . . . . . . . . . . . . . . . 29
Convertir un angle en degrés . . . . . . . . . . . . . . . . . . 29
Convertir un angle en radians . . . . . . . . . . . . . . . . . . 29
 iii

5.1.4 Fonctions arithmétiques . . . . . . . . . . . . . . . . . . . 29

Pgcd de deux nombres entiers . . . . . . . . . . . . . . . . . 29
Modulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Quotient et reste . . . . . . . . . . . . . . . . . . . . . . . . . 30
Partie entière d’un nombre réel . . . . . . . . . . . . . . . . . 30
Factorielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Valeur absolue . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.2 Le module « cmath » . . . . . . . . . . . . . . . . . . . . 31
5.2.1 Formes cartésiennes, trigonométriques et exponentielles 31
Définir un nombre complexe . . . . . . . . . . . . . . . . . . . 31
Obtenir le module et un argument . . . . . . . . . . . . . . . 32
Obtenir les parties réelle et imaginaire . . . . . . . . . . . . . 32
5.3 Le module « random » . . . . . . . . . . . . . . . . . . . . 32
5.3.1 Choisir un nombre entier aléatoire entre deux autres . . 33
5.3.2 Choisir un nombre aléatoire choisi dans une liste . . . . 33
5.3.3 Choisir un nombre réel aléatoire entre 0 et 1 . . . . . . . 33
5.3.4 Choisir un nombre réel aléatoire entre deux autres . . . . 33
5.3.5 Choisir une lettre au hasard dans un mot . . . . . . . . . 34
5.3.6 Mélanger une liste . . . . . . . . . . . . . . . . . . . . . . 34
5.3.7 Choisir un sous-ensemble aléatoire . . . . . . . . . . . . 34
iv
 1
CHAPITRE

Installation

Installer Python est gratuit... et est fortement conseillé pour tout élève de Seconde
Générale en France.
En effet, ce langage est explicitement au programme et beaucoup d’enseignants
choisissent de l’utiliser pour l’enseignement de l’algorithmique.
Nous allons donc voir ici comment installer Python sur un ordinateur fonctionnant
avec Windows 10.

1.1 Téléchargement du logiciel

d’installation
Dans un premier temps, il faut aller sur la page :

[Link]

Vous verrez alors la fenêtre suivante :

1
2 Chapitre 1. Installation

Il faudra alors cliquer sur le bouton jaune (indiqué par une flèche sur l’image
ci-dessus) pour télécharger la dernière version du logiciel d’installation sur votre
ordinateur.

Ce téléchargement devrait prendre environ 1 minute, mais si votre

i connexion à Internet est faible, il faudra s’attendre à un peu plus...

1.2 Installation de Python

Dans le répertoire « Téléchargements » de Windows, le fichier suivant doit appa-
raître :

Il faut alors double-cliquer dessus (cliquer deux fois rapidement) pour le lancer.
L’installation commence alors.

Lorsque la fenêtre d’installation apparaît, cochez la case « Add Python 3.7 to

PATH » (en bas) puis cliquez sur « Install Now ».
Valider à chaque fois que cela vous est demandé jusqu’à la fin de l’installation.
Et voilà ! Vous pouvez maintenant programmer en Python !
1.3. Lancement de la console 3

1.3 Lancement de la console

Dans le menu de recherche de Windows,

tapez : « Python ». Vous devriez voir ceci :

« IDLE (Python 3.6 32-bit) » est le nom du programme à exécuter.

Sur cette copie d’écran, vous voyez Python 3.6 car j’avais déjà installé
la version précédente. Mais le jour où je fais ce tutoriel, la version 3.7 i
est accessible.

Avant de cliquer dessus le lien, je vous conseille de le mettre en raccourci dans la

barre des tâches car il sera ainsi plus pratique d’y avoir accès dans l’avenir.
Pour cela, cliquez avec le bouton droit de la souris sur ce lien, et cliquez sur
« Épingler à la barre des tâches » :
4 Chapitre 1. Installation

Voilà ! Vous avez maintenant une belle icône Python dans votre barre des tâches :

Quand vous cliquez sur cette icône, la fenêtre suivante apparaît :

La fenêtre désignée par « console » par la suite.

Cliquez alors sur « File », puis sur « New file » :

1.3. Lancement de la console 5

Cela aura pour conséquence d’ouvrir une autre fenêtre :

Fenêtre désignée par « fenêtre de programmation » par la suite.

C’est dans cette fenêtre que vous allez pouvoir écrire votre premier programme !
6 Chapitre 1. Installation
 2
CHAPITRE

La logique de Python

2.1 Introduction
On peut comparer Python à un smartphone : il peut faire quelques trucs sympas,
mais si on veut l’exploiter à fond, il va falloir lui ajouter des « applications » : pour
Python , on va plutôt parler de modules.

Par exemple, si on souhaite définir une fonction mathématique qui permet de

calculer la racine carrée d’un nombre a, on peut essayer de taper ceci dans la
fenêtre de programmation :

def racine(a):
return sqrt(a)

print(racine(9))

En anglais, « racine carrée » se dit « square root » et en abrégé, cela

donne : sqrt. Cette commande est utilisée par beaucoup de logiciel de i
calculs.

Mais en cliquant sur « Run » puis sur « Run Module » (ou en appuyant directement
sur la touche [F5]) pour exécuter notre programme, on voir apparaître dans la
console (la première fenêtre) :

7
8 Chapitre 2. La logique de Python

Quand on voit un texte en rouge, ce n’est jamais bon signe...

Ici, la raison de ce message est que Python ne connaît pas la commande « sqrt ».
Pour qu’il connaisse la commande, il faut faire appel à un module qui contient
toutes les fonctions mathématiques importantes : c’est le module math.

2.2 Appel d’un module

Pour faire appel au module math, on va taper ceci :
import math

def racine(a):
return [Link](a)

print(racine(9))

Et là, en appuyant sur [F5], on voit apparaître dans la console :

Console
3.0

qui est bien la racine carrée de 9... Ouf ! Tout fonctionne !

Remarquez que la commande qui permet de calculer est précédée du

module duquel elle vient.
La syntaxe générale est :
! import <module>

return <module>.<fonction>
2.3. Installer un module 9

Il existe toutefois une autre syntaxe plus légère :

from math import *

def racine(a):
return sqrt(a)

print(racine(9))

Mais attention ! Si on charge deux modules qui définissent tous les deux
une même fonction, il vaut mieux opter pour la première syntaxe.
Par exemple, si « module1 » et « module2 » définissent tous les deux
la fonction toto alors il faudra écrire : !
import module1
import module2

def toto_un(x):
return [Link](x)

def toto_deux(x):
return [Link](x)

Mais rassurez-vous, il est rare d’avoir deux modules définissant une

même fonction... Mais « rare » ne veut pas dire « jamais » !

2.3 Installer un module

Il n’est pas rare qu’un module ne soit pas installé par défaut. Aussi, il faut avant
toute chose apprendre à en installer.

Pour cela, il faut avant tout lancer la console de Windows : allez dans le module de
recherche de Windows (en cliquant sur le cercle qui est à côté du menu Démarrer,
en bas, dans la barre des tâches), puis tapez « Invite » : tout de suite, une suggestion
est proposée :
10 Chapitre 2. La logique de Python

Cliquez alors sur « Invite de commandes » : une fenêtre noire apparaît.

Pour installer le module nommé turtle, il suffit de taper :
Console
pip install turtle

Si par malheur PIP n’est pas installé, tapez avant tout :

Console
python -m ensurepip –default-pip

Voilà ! Tu as maintenant les bases pour comprendre le fonctionnement de Python.

Passons à l’algorithmique...
 3
CHAPITRE

Algorithmique et programmation

3.1 Déclaration des variables

Dans tout programme, il y a des variables : ce sont des lettres (ou des mots) qui
contiennent des valeurs : des nombres ou des chaînes de caractères.
Voyons un exemple :

a, b, c = 1, 2, 3
d = a**2+b**3+c**4

print(d)

Ici, on a affecté :
— la valeur « 1 » à la variable a,
— la valeur « 2 » à la variable b,
— la valeur « 3 » à la variable c.
Ensuite, on a affecté une certaine valeur à la variable d. Cette valeur est égale à :

a2 + b 3 + c 4 .

On remarque que pour élever le nombre a à l’exposant n, on tape :

a**n. i

3.2 Déclaration d’une fonction

Nous l’avons vu dans le chapitre précédent, déclarer une fonction passe par la
commande def.

11
12 Chapitre 3. Algorithmique et programmation

from math import *

def hypotenuse(a,b):
c = sqrt(a**2+b**2)
return c

print(hypotenuse(3,4))

Console
5.0

Cette fonction permet de calculer la longueur de l’hypoténuse d’un triangle rec-

tangle dont la longueur des côtés perpendiculaires sont a et b.
Dans notre exemple, nous demandons la longueur de l’hypoténuse quand les deux
côtés valent 3 et 4.

3.3 Les tests : Si... Alors... Sinon...

Très souvent, dans un programme, nous avons besoin de tester des égalités ou des
inégalités.
Par exemple, si l’on souhaite savoir si un triangle est rectangle, alors il faudra
tester si le carré de l’hypoténuse est bien égal à la somme des carrés des deux
autres côtés.
Si la condition est vraie alors on peut exécuter une instruction. Sinon, on exécute
une autre instruction. Cela se traduit en Python de la manière suivante :

def isRectangular(a,b,c):
if a**2+b**2 == c**2:
return "Le triangle est rectangle."
else:
return "Le triangle n'est pas rectangle"

print(isRectangular(3,4,5))

Console
Le triangle est rectangle.
3.3. Les tests : Si... Alors... Sinon... 13

Il faut ici remarquer que le signe pour tester une égalité n’est pas un
simple signe « = » : il faut en mettre deux ! !

Pour tester une inégalité, on fera de même. À votre avis, que fait ce programme
et que va-t-il afficher ?

def fonction(a,b,c):
if a+b<c:
return "C'est OK !"
else:
return "Y'a comme un petit problème..."

print(fonction(8,9,16))

La condition testée est : « Si a + b < c » ; par conséquent, on exécute l’instruction

return "C’est OK !" uniquement si a + b < c. Sinon, on exécute l’instruction
return "Y’a comme un petit problème...".
On fait de plus appel à la fonction pour a = 8, b = 9 et c = 16. Comme a + b =
8 + 9 = 17, la condition a + b < c n’est pas remplie et donc le programme affiche :
Console
Y’a comme un petit problème...

Mais dites donc : ça ne ressemble pas à l’inégalité triangulaire par hasard ? On sait
que si un triangle doit avoir pour côtés a, b et c (en supposant que ces nombres
soient dans l’ordre croissant) alors il est constructible uniquement si le plus grand
côté (c’est-à-dire c) est plut petit que la somme des deux autres côtés (ici a + b).
Cette fonction teste donc si un triangle est constructible... Bien sûr, cette fonc-
tion n’est pas optimale car elle suppose que a < b < c. Alors, pourquoi ne pas
l’améliorer ? Il serait bon de trier les nombres a, b et c...

def fonction(a,b,c):
if a>b:
d=a
a=b
b=d
if b>c:
d=b
b=c
c=d
14 Chapitre 3. Algorithmique et programmation

if a>b:
d=a
a=b
b=d
if a+b<c:
return "C'est OK !"
else:
return "Y'a comme un petit problème..."

print(fonction(16,9,8))

Regardons pas-à-pas ce que fait notre fonction avec a = 16, b = 9 et c = 8 :

— Premier test : est-ce que a > b ? Oui.
Donc ici, d = 16, a = 9 et b = 16 : on a interverti a et b. La variable d est
nécessaire. En effet, imaginons qu’elle ne soit pas présente. Alors, on aurait
envie d’écrire comme instructions : a=b et b=a. Mais dans ce cas, a=b ferait
que a = 9 et ensuite, l’instruction b=a ferait que b = 9 (car aux dernières
nouvelle, à ce stade, on a mis la valeur « 9 » dans la variable a). Donc, ça
coince un peu... D’où la présence d’une variable intermédiaire.

À ce stade, a = 9, b = 16 et c = 8.

— Deuxième test : est-ce que b > c ? Oui.

Donc ici, d = 16, b = 8 et c = 16.

On a alors à ce stade : a = 9, b = 8 et c = 16.

Comme le deuxième test a réussi (b > c) il faut faire le test suivant :

Troisième test : est-ce que a > b ? Oui.

On répète alors le premier test : d = 9, a = 8 et b = 9.

À ce stade, on a alors : a = 8, b = 9 et c = 16. Le tri par ordre croissant

est fini.
— On peut maintenant faire le test : est-ce que a + b < c. La réponse est NON
donc la console affiche :
Console
Y’a comme un petit problème...
3.4. La boucle « Pour » 15

3.4 La boucle « Pour »

Quand on souhaite répéter n fois une instruction, plutôt que de l’écrire n fois, on
va préférer utiliser une boucle « Pour ». Écrivons un programme qui permet de
calculer la somme 1 + 2 + 3 + · · · + n :
def fonction(n):
s=0
for k in range(1,n+1):
s=s+k
return s

print(fonction(100))

Console
5050

La fonction range est bien pratique, mais elle est trompeuse, en effet,
on pourrait s’attendre à écrire range(1,n) mais cette petite fonction
sournoise s’arrête juste avant n ! C’est la raison pour laquelle il faut
toujours mettre n + 1 comme second argument de range. i
Pour résumer, range(a,b) signifie que l’on parcourt : a, a + 1, a + 2,
. . ., b − 1.

Pour parcourir un mot, on pourra faire comme ceci :

def fonction(mot):
for k in range(len(mot)):
print('La lettre', k, 'est :',mot[k])

fonction('maths')

Console
La lettre 0 est : m
La lettre 1 est : a
La lettre 2 est : t
La lettre 3 est : h
La lettre 4 est : s
16 Chapitre 3. Algorithmique et programmation

La fonction len permet de savoir le nombre de caractères dans une

chaîne (de caractères). range(len(mot)) permet donc de parcourir le
i mot exactement (sans oublier un caractère) car elle part de « 0 » et va
jusqu’à n − 1 (où n est le nombre de caractères dans mot : on a donc
bien n caractères.

3.5 La boucle « Tant que »

Cette boucle s’utilise quand on ne sait pas quand ça va s’arrêter.
Par exemple, si on regarde la somme 1+2+3+· · ·+n et que l’on souhaite s’arrêter
dès qu’elle dépasse 106 (par exemple), nous allons faire :

def fonction(x):
s=0
n=0
while s<=x: # tant que la somme s est plus petite
# ou égale à x
s=s+n
n=n+1
return n

print(fonction(10**6))

Console
1415

Ici, cela signifie que :

1 + 2 + 3 + · · · + 1 415 > 106
mais que :
1 + 2 + 3 + · · · + 1 414 6 106 .

Il faut toujours mettre l’exact contraire de la condition que l’on souhaite

dans la boucle « tant que ».
Par exemple ici, on voulait calculer la somme :
! 1 + 2 + 3 + ··· + n

jusqu’à ce qu’elle dépasse 106 donc tant qu’elle est inférieure ou égale
à 106 .
 4
CHAPITRE

Tracé de courbes

4.1 Modules à installer

Dans un premier temps, si ce n’est déjà fait, il faut installer quelques modules.
Dans le terminal de votre OS (tapez « cmd » dans la recherche sous Windows, puis
cliquez sur « Invite de commande »), tapez les lignes suivantes :

pip install numpy

pip install scipy
pip install matplotlib
Le module le plus important est matplotlib ; les deux autres vont servir à tracer
des courbes non triviales (qui font intervenir des constantes comme π – contenue
dans le module numpy).

4.2 Un exemple de courbe représentative

de fonction
import numpy as np
import [Link] as plt

x = [Link](0, 2*[Link], 100)

y = [Link](x)
[Link](x, y)

[Link]() # affiche la figure a l'écran

La compilation de ce code aura pour effet d’ouvrir une fenêtre contenant la courbe
page suivante.

17
18 Chapitre 4. Tracé de courbes

Comme vous avez pu le deviner,

— x=[Link](a,b,n) définit l’intervalle [a ; b] sur lequel tracer la courbe,
où n est le pas entre deux images (plus n est grand, plus la courbe sera lisse,
mais « 100 » suffit amplement à mon avis) ;
— y=[Link](x) est la ligne qui définit la fonction à tracer (ici, on trace la
fonction x 7→ cos x définie dans le module numpy).

4.3 Légendes
Dans le cas où l’on souhaite tracer plusieurs courbes, une légende s’avèrera peut-
être utile.

import numpy as np
import [Link] as plt
x = [Link](0, 2*[Link], 30)
y = [Link](x)
z = [Link](x)
[Link](x, y, label="cos(x)")
[Link](x,z,label="sin(x)")
[Link]()
[Link]()
4.4. Courbes paramétriques 19

4.4 Courbes paramétriques

import numpy as np
import [Link] as plt

t = [Link](0, 2*[Link], 100)

x = [Link](2*t)
y = [Link](3*t)
[Link](x, y)
[Link]()

Ce code produira la figure page suivante.

20 Chapitre 4. Tracé de courbes

4.5 Surfaces 3D
from pylab import *
from mpl_toolkits.mplot3d import Axes3D

ax = Axes3D(figure())
X = [Link](-4, 4, 0.25)
Y = [Link](-4, 4, 0.25)
X, Y = [Link](X, Y)
R = [Link](X**2 + Y**2)
Z = [Link](R)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='cool')
ax.plot_surface(X, Y, R, rstride=1, cstride=1, cmap='hot')
show()

Ce code produira la figure page suivante.

4.6. Export en PNG 21

Pour avoir toutes les palettes (en tout cas, un bon nombre) de l’option cmap, on
peut regarder la page Internet suivante :

[Link]

4.6 Export en PNG

Toutes les courbes tracées dans la fenêtre qui s’ouvre après compilation peuvent
être sauvegardées au format PNG en cliquant sur l’icône représentant une disquette
(ouais... une disquette !) en bas de la fenêtre.

4.7 Affichage dans un document LATEX

Il y a une subtilité que j’ai découverte en écrivant ce document : le code suivant
fonctionne correctement en le tapant directement dans la console Python.
22 Chapitre 4. Tracé de courbes

from pylab import *

from mpl_toolkits.mplot3d import Axes3D

ax = Axes3D(figure())
X = [Link](-1, 1, 0.025)
Y = [Link](-1, 1, 0.025)
X, Y = [Link](X, Y)
R = [Link](X**2 + Y**2)
ax.plot_surface(X, Y, R, rstride=1, cstride=1, cmap='bone')
savefig('[Link]', bbox_inches='tight')

La dernière ligne sauvegarde bien l’image créée. Mais pour créer un document en
LATEX avec le package pythontex, vous savez qu’il y a :
— une première compilation pdflatex ;
— un appel à un script Python qui s’appuie sur la première compilation ;
— une seconde compilation pdflatex
Ainsi, si vous tapez dans votre fichier source le code suivant :

Code LaTeX

\begin{pycode}
from pylab import *
from mpl_toolkits.mplot3d import Axes3D

ax = Axes3D(figure())
X = [Link](-1, 1, 0.025)
Y = [Link](-1, 1, 0.025)
X, Y = [Link](X, Y)
R = [Link](X**2 + Y**2)
ax.plot_surface(X, Y, R, rstride=1, cstride=1, cmap='bone')
savefig('[Link]', bbox_inches='tight')
\end{pycode}

\includegraphics{[Link]}

cela va produire une erreur car lors de la première compilation, l’image n’existe
pas encore.
4.7. Affichage dans un document LATEX 23

Une astuce est alors de mettre en en-tête du document :

Code LaTeX

\newif\ifpythontex
\newcommand{\includegraphicx}[2][]{%
\ifpythontex
\includegraphics[#1]{#2}
\fi
}
\pythontexfalse

et de mettre :

Code LaTeX

\includegraphicx[scale=1]{[Link]}

à la place de :

Code LaTeX

\includegraphics[scale=1]{[Link]}

En compilant une première fois, on laisse pythontexfalse pour indiquer que l’on
ne souhaite pas prendre en compte l’image et pour la seconde compilation, on
change en :

Code LaTeX

\pythontextrue

Et là, l’image apparaît.

24 Chapitre 4. Tracé de courbes
 5
CHAPITRE

Opérations mathématiques

Dans ce chapitre, je ne parlerai que pas des opérations de base (+, −, ∗ et /).

5.1 Le module « math »

Pour faire appel aux opérations contenues dans ce module, on le charge :
import math

Il existe beaucoup d’opérations (de fonctions) dans ce module, et je ne vais parler

que des principales pour les élèves du lycée.

5.1.1 Les constantes

import math
print([Link])

affiche le nombre π.
Console
3.141592653589793

import math
print(math.e)

affiche le nombre e.
Console
2.718281828459045

25
26 Chapitre 5. Opérations mathématiques

import math
[Link]

désigne +∞.

5.1.2 Les fonctions

Racine carrée

import math
print([Link](3))
√
affiche une valeur approchée du nombre 3.
Console
1.7320508075688772

Puissances

import math
print([Link](3,5))

affiche le nombre 35 .
Console
243.0

Exponentielle

import math
print([Link](3))

affiche une valeur approchée du nombre e3 .

Console
20.085536923187668
5.1. Le module « math » 27

Logarithme népérien

import math
print([Link](3))

affiche une valeur approchée du nombre ln 3.

Console
1.0986122886681098

Logarithme décimal

import math
print(math.log10(3))

ln 3
affiche une valeur approchée du nombre log 3 = .
ln 10
Console
0.47712125471966244

Fonctions trigonométriques : sinus, cosinus, tangente

Les angles sont exprimés en radians.

import math
print([Link]([Link]/5))
π
affiche une valeur approchée du nombre cos .
5
Console
0.8090169943749475

import math
print([Link]([Link]/5))
π
affiche une valeur approchée du nombre sin .
5
28 Chapitre 5. Opérations mathématiques

Console
0.5877852522924731

import math
print([Link]([Link]/5))
π
affiche une valeur approchée du nombre tan .
5
Console
0.7265425280053609

Arccos, arcsin et arctan

Ici aussi, les angles sont en radians.

import math
print([Link](1/2))
1
affiche l’angle, en radians, dont le cosinus vaut .
2
Console
1.0471975511965979

import math
print([Link](1/2))
1
affiche l’angle, en radians, dont le sinus vaut .
2
Console
0.5235987755982989

import math
print([Link](1))

affiche l’angle, en radians, dont la tangente vaut 1.

Console
0.7853981633974483
5.1. Le module « math » 29

5.1.3 Conversions

Convertir un angle en degrés

import math
print([Link]([Link]/5))

π
convertit l’angle radians en degrés.
5
Console
36.0

Convertir un angle en radians

import math
print([Link](60))

convertit l’angle 60° en radians.

Console
1.0471975511965976

5.1.4 Fonctions arithmétiques

Pgcd de deux nombres entiers

import math
print([Link](78,152))

affiche pgcd (78 ; 152).

Console
2
30 Chapitre 5. Opérations mathématiques

Modulo

import math
print(5 % 3)

affiche 5 mod 3, c’est-à-dire le reste de la division euclidienne de 5 par 3.

Console
2

Quotient et reste

print(divmod(78,15)

affiche le quotient et le reste de la division euclidienne de 78 par 15.

Console
(5, 3)

C’est une fonction native de Python, donc définie même sans charger
! le module math.

Partie entière d’un nombre réel

print(int(78.152))

affiche la partie entière d’un nombre réel (c’est-à-dire ce qu’il y a avant la virgule).

Console
78

! Il n’est pas utile ici de charger le module math.

5.2. Le module « cmath » 31

Factorielle

import math
print([Link](12))

affiche 12 !, c’est-à-dire le résultat de 1 × 2 × 3 × 4 × · · · × 12.

Console
479001600

Valeur absolue

import math
print([Link](-89.23))

affiche | − 89, 23 | .
Console
89.23

5.2 Le module « cmath »

Ce module concerne les nombres complexes.

5.2.1 Formes cartésiennes, trigonométriques et exponen-

tielles
Définir un nombre complexe
Un nombre complexe z = a + ib peut être défini par sa partie réelle et sa partie
imaginaire ainsi :
import cmath
z = complex(a,b)
32 Chapitre 5. Opérations mathématiques

Obtenir le module et un argument

Si z = a + ib, alors le couple ( | z | ; arg z) est donné par :

import cmath
print([Link](complex([Link](3)/2,1/2)))
√ √
 3 1  3 1
 !!
affiche le couple + i ; arg + i .

 2 2 2 2


Console
(0.9999999999999999, 0.5235987755982989)

Pour obtenir ces valeurs, des calculs sont faits et des fois, ils donnent
des
 √ valeurs approchées. C’est le cas dans l’exemple précédent. En effet,
 3 1 
! 
+ i = 1 mais la fonction retourne « 0.99999999. . . ». Il faut
 2 2


donc faire preuve d’analyse quand besoin est.

Obtenir les parties réelle et imaginaire

import cmath
print([Link](2,[Link]/3))

π
renvoie la forme algébrique du nombre 2ei 3 .
Console
(1.0000000000000002+1.7320508075688772j)

Là encore, attention aux valeurs approchées.

! De plus, remarquez que « i » est remplacé par « j » dans Python.

5.3 Le module « random »

Ce module permet de faire intervenir le hasard (... enfin... presque !).
5.3. Le module « random » 33

5.3.1 Choisir un nombre entier aléatoire entre deux autres

import random
print([Link](1,20))

affiche un nombre entier aléatoire entre 1 et 20 (compris).

Console
20

5.3.2 Choisir un nombre aléatoire choisi dans une liste

import random
print([Link]([-1,1]))

affiche un nombre choisi aléatoirement parmi les valeurs informées (ici, −1 et 1).
Console
-1

5.3.3 Choisir un nombre réel aléatoire entre 0 et 1

import random
print([Link]())

Console
0.7828354120016724

5.3.4 Choisir un nombre réel aléatoire entre deux autres

import random
print([Link](0,10))

affiche un nombre réel compris entre 0 et 10 (compris).

Console
3.754766915954255
34 Chapitre 5. Opérations mathématiques

5.3.5 Choisir une lettre au hasard dans un mot

import random
print([Link]('ABCDEFGHIJKLMNOPQRSTUVWXYZ'))

affiche une lettre de l’alphabet au hasard.

Console
Q

5.3.6 Mélanger une liste

import random
items = ['a','b','c','d']
[Link](items)
print(items)

affiche une lettre de l’alphabet au hasard.

Console
[’c’, ’d’, ’b’, ’a’]

5.3.7 Choisir un sous-ensemble aléatoire

import random
print([Link]([1, 2, 3, 4, 5], 3))

affiche une liste de 3 éléments choisis au hasard dans la liste indiquée.

Console
[5, 3, 4]