Document Python de Rema de Rennes 1

Licence 1 PCSTM 2023–2024
Informatique
Mariko Dunseath Terao

14 janvier 2024
Table des matières
1 Représentation des nombres 1

1.1 Principe de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Représentation des nombres naturels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Représentation des réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Conséquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Erreurs numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.6 A retenir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 Bases de Python 8
2.1 Premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Types de donnée élémentaires, typage dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4 Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5 Type booléen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6 Types de données combinés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.7 Itérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.7.1 For x in range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.7.2 If continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.7.3 For break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.7.4 Boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3 List, Tuple, Range, Dictionary 24

3.1 List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.1.1 Définition d’une liste et itération sur ses éléments . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.1.2 Modification d’une liste et analyse de contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.3 Accès aux éléments d’une liste - Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.4 Définition en compréhension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2
3.2 Tuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4 Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4 Functions 34
4.1 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.2 Variables locales et variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.4 Fonction Lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.5 Passage de paramètres aux fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5 Initiation à Numpy, Matplotlib et Scipy 40

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2 Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.2.1 Titre, légendes et limites des axes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.2.2 Traits, marqueurs et légendes de courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.3 Ndarray à une dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.3.1 np.empty, np.zeros, np.ones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.3.2 np.array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.3.3 np.arange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.3.4 Adresse et copie de nd-array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.4 Ajustement de courbes par moindres carrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.1 Ajustement linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.2 Ajustement non linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
A Références 52
Chapitre 1
Représentation des nombres
1.1 Principe de base

Dans un ordinateur, toute donnée est encodée à l’aide de micro-transistors qui peuvent être soit dans l’état off soit
dans l’état on. On a l’habitude de dire que off correspond à zéro, et on correspond à 1. La plus petite quantité de
donnée enregistrable est appelée bit, sa valeur est soit 0, soit 1. Un objet en mémoire est donc une chaı̂ne de bits,
par exemple 10011000110101001111010010100010.
Ces chaı̂nes ont habituellement une longueur fixe. Les bits sont regroupés en bytes, en général de 8 bits, d’où le
nom d’octet en français.
Les bytes peuvent être regroupés pour former un mot. Un mot est habituellement composé de 4 bytes (c-à-d 32
bits), alors que sur certains super-ordinateurs tels que les Cray, il peut être de 8 bytes (64 bits). Un mot double est
deux fois plus long qu’un mot simple, les opérations qui les utilisent sont dites en double précision.
1.2 Représentation des nombres naturels

L’ensemble des nombres naturels est N = {0, 1, 2, 3, . . .}.
En notation décimale, les nombres sont représentés en base 10, par exemple 14092 doit être interprété comme
14092 = 0 × 10n−1 + 0 × 10n−2 + . . . + 1 × 104 + 4 × 103 + 0 × 102 + 9 × 101 + 2 × 100 .
D’une manière générale, on a donc
i = sn−1 10n−1 + sn−2 10n−2 + . . . + s2 102 + s1 101 + s0 100
avec 10 différentes valeurs possibles pour sk : 0, 1, 2, . . . , 9. Par convention, seules les valeurs sn−1 , sn−2 . . . s2 , s1 , s0
sont écrites, de gauche à droite par valeur décroissante de l’exposant de 10, en omettant tous les 0 à gauche. Du
point de vue conceptuel, il n’y a a priori pas de limite sur la valeur de n.
1
2 ©Mariko Dunseath Terao - Licence 1 PCSTM
Dans les ordinateurs, les nombres naturels sont stockés en représentation binaire, c-à-d
i = sn−1 2n−1 + sn−2 2n−2 + . . . + s2 22 + s1 21 + s0 20
avec seulement 2 différentes valeurs possibles pour les chiffres : sk = 0, 1.

Seules les valeurs sn−1 , sn−2 . . . s2 , s1 , s0 sont stockées en mémoire, par ordre croissant ou décroissant de l’exposant
de 2 selon les constructeurs d’ordinateurs. 1
Example : 21 = 16 + 4 + 1 = 1 × 24 + 0 × 23 + 1 × 22 + 0 × 21 + 1 × 20 = (00000000000000000000000000001101)2
ou (10110000000000000000000000000000)2 .
Le nombre de nombres représentables est 2n , le plus petit est 0, le plus grand est 2n − 1. En général, les entiers sont
encodés sur n = 32 bits c-à-d 4 bytes. Dans un système à 32 bits, le plus grand nombre naturel représentable est
232 − 1 = 4294976295 ≈ 4 milliards = 4 Giga. Si on tente de représenter un nombre naturel plus grand que le plus
grand représentable, par exemple suite à l’addition de deux très grands nombres, on a un dépassement de capacité
qui est un type d’erreur appelée overflow. Cette limitation implique entre autres l’impossibilité absolue de traiter
des fichiers de plus de 4 Giga-octets puisque l’adresse de certaines données est supérieure au plus grand entier
représentable. La nécessité de traiter des fichiers de plus en plus volumineux incite les constructeurs à augmenter
n, typiquement à 64 ; le plus grand entier représentable est alors de l’ordre de 1.8 × 1019 , c-à-d 18 Exa d’après la
nomenclature en informatique des nombres présentée à la table 1.1.
Noms Symbole Valeur

Yotta Y 1024
Zetta Z 1021
Exa E 1018
Peta P 1015
Tera T 1012
Giga G 109
Table 1.1 – Noms des nombres en informatique.
1.3 Représentation des réels

Pour représenter les nombres réels, les ordinateurs utilisent la technique de la “virgule flottante” (floating point),
basée sur la représentation scientifique courante, par exemple 0.625 × 1023 . Cette notation a trois composantes :
1. une base (10),
2. un exposant (23),
3. une mantisse (0.625).
Dans les ordinateurs, la base est le plus souvent de 2. Comme il ne change jamais, il n’a pas besoin de faire partie de
la représentation du nombre, seuls l’exposant et la mantisse doivent être stockés. Un nombre réel x s’écrit comme
p
X
x=s×2 × e
fk × 2−k
k=1
1. https://fr.wikipedia.org/wiki/Boutisme
Informatique 3
où s représente le signe (0 pour positif, 1 pour négatif), e est l’exposant (entier) et fk = 0 ou 1. Dans le seul cas
où x = 0, on a fk = 0, ∀k. Dans tous les autres cas, l’exposant est choisi de façon à ce que f1 = 1, on dit que le
nombre est normalisé. Comme f1 = 1 pour tous les nombres non nuls, il n’est pas nécessaire de le stocker, ce qui
permet de gagner 1 bit dans la représentation. 2
En simple précision, un nombre réel est le plus souvent stocké dans un mot de 32 bits : le chiffre le plus à gauche
correspond au signe, les 8 suivants correspondent à l’exposant et les 23 restants correspondent à la mantisse.
Exposant à 8-bits → −128 ≤ e ≤ 127 (27 = 128)

23
Mantisse à 23-bits → 21 ≤ M ≤ 1 − 12 ≃ 0.99999988
La limite supérieure correspond à

1 1 23

23
X 2 1− 2
23
1
M = 0.1111 . . . 111 = 2−k = 1 =1−
k=1
1− 2
2
où on a utilisé la valeur de la progression géométrique
a(1 − rn )
sn = a + ar + ar2 + . . . + arn−1 = .
1−r
Le plus grand nombre représentable est donc

23 !
1
1− × 2127 ≃ 1038 .
2
Le plus petit nombre non nul représentable est
1
× 2−128 ≃ 10−39 .
2
La précision avec laquelle un nombre réel peut être représenté est approximativement de 6 décimales car (1/2)23 ≃
10−7 .
En double précision, un nombre réel est stocké dans 2 mots (64 bits), avec un exposant à 11 bits et une mantisse
10
à 52 bits. Ceci permet de représenter des nombres réels entre 10−308 et 10308 ≈ 22 −1 = 21023 , avec une précision
d’environ 15 décimales, nécessaire et suffisante pour la plupart des calculs scientifiques.
A noter : le nombre de bits dans l’exposant détermine la gamme des nombres réels, le nombre de bits dans la
mantisse détermine la précision avec laquelle un nombre réel est représenté (le nombre de décimales).
1.4 Conséquences
1. Tout nombre n’est pas nécessairement représentable dans un ordinateur. Ceci est une conséquence de la
longueur fixe des représentations binaires utilisées. Quand le résultat d’une opération coı̈ncide avec un nombre
réel non représentable exactement, le système l’arrondit au nombre réel représentable le plus approche,
donnant lieu à une erreur d’arrondi.
Exemple : (0.1)10 = (0.0001100110011 . . .)2
2. https://fr.wikipedia.org/wiki/IEEE_754
2. Il existe un nombre ϵ > 0 qui est le plus petit nombre positif. Si le résultat d’un calcul tombe dans l’intervalle
(0, ϵ), il sera remplacé par 0. L’erreur d’arrondi produite à cette occasion est appelée un underflow.
Exemple : Si a > 2/ϵ, 1/a ≡ 0 et donc (1/a) × a ≡ 0.
3. Les nombres représentables ne sont pas distribués de manière homogène. La densité des nombres représen-
tables est très élevée près de 0 mais diminue lorsque leur valeur absolue augmente.
Exemple : dans un système à 16 bits, avec une mantisse à 7 bits et un exposant à 8 bits, la distance entre
2 valeurs successives de la mantisse est toujours (0.0000001)2 = 2−7 ≃ (0.0078)10 . Pour les nombres près de
0, l’exposant sera petit (e.g. -100) et la distance entre 2 nombres réels représentables successifs en décimale
flottante sera 0.00000012 × 2−100 ≃ 0.0078 × 10−30 = 7.8 × 10−33 . Quand l’exposant est grand (e.g. +100),
la distance entre 2 nombres réels représentables successifs sera environ (0.0000001)2 × 2100 ≃ 7.8 × 1027 .
1.5 Erreurs numériques
Les conséquences inéluctables de la précision finie avec laquelle les nombres sont stockés dans un ordinateur sont
les pertes de précision numérique dans les calculs impliquant des nombres réels.
Soit x un nombre exact, et x̄ une approximation de x.
L’erreur absolue est définie par ϵa = |x − x̄|.
L’erreur relative est définie par ϵr = |ϵa /x| = |x̄/x − 1|.
En limitant artificiellement le nombre de décimales, on met facilement en évidence que, par exemple, les lois de
distributivité et d’associativité en arithmétique ne peuvent plus être exactes :
— loi d’associativité pour la multiplication, si l’on travaille à 2 décimales :
(0.56 × 0.65) × 0.54 = 0.36 × 0.54 = 0.19
0.56 × (0.65 × 0.54) = 0.56 × 0.35 = 0.20
— loi de distributivité, si l’on travaille à 6 décimales :
(0.152755 − 0.152732)/0.910939−30 = 0.252487 × 1026
0.152755/0.910939−30 − 0.152732/0.910939−30 = 0.167690 × 1030 − 0.167664 × 1030 = 0.260000 × 1026
— loi d’associativité pour l’addition, si l’on travaille à 6 décimales :
(0.243875 × 106 + 0.412648 × 101 ) − 0.243826 × 106 = 0.243879 × 106 − 0.243826 × 106 = 0.000053 × 106 =
0.530000 × 102
(0.243875 × 106 − 0.243826 × 106 ) + 0.412648 × 101 = 0.000049 × 106 + 0.412648 × 101 = 0.531265 × 102
Les erreurs peuvent être classifiées en 3 types :

1. Erreur initiale : erreur dans les données initiales, par exemple provenant d’une mesure (expérimentale). Dans
ce cas, il n’y a pas grand chose à faire du point de vue numérique : rubbish in, rubbish out.
2. Erreur de troncation : erreur due à la méthode numérique utilisée pour résoudre un problème particulier.
Elle a lieu lorsqu’un processus infini ou continu est remplacé par un processus fini ou discret.
Exemples :
• évaluation de ex par série de Taylor
x2 x3 x4
ex = 1 + x + + + + O(x5 )
2! 3! 4!
La notation O(xn ) correspond à un nombre de même ordre que xn .
Informatique 5
• évaluation d’une intégrale définie par quadrature

Z b n
X
f (x) dx ≃ wi f (xi ).
a i=1
Dans ces cas, il ”suffirait” d’augmenter le nombre de termes ou de réduire le pas de discrétisation, mais ce
n’est pas toujours pragmatique et pire, les résultats peuvent aussi être affectés par le troisième type d’erreur.
3. Erreur d’arrondi : erreur due à la précision finie de la machine.
Normalement, un calcul numérique comprend de nombreuses étapes. Dans une étape typique, par exemple
z = x ∗ y, où ∗ est une des opérations arithmétiques, on prend 2 approximations x̄, ȳ des quantités exactes
x et y, et on calcule la valeur approchée z̄ de la quantité z.
Exemples : Supposons x̄ = x + δ, ȳ = y + η
• z =x−y
z̄ = (x̄ − ȳ)arrondi = x + δ − (y + η) + ϵ
où ϵ est l’erreur d’arrondi. On a donc
z̄ = z + δ − η + ϵ.
Selon les signes de δ, η, ϵ, l’erreur peut être grande ou petite. On remarque que si x et y sont presque
égaux, z est presque nul et l’erreur est donc significative.
• z = x/y
−1
x+δ x/y + δ/y x δ η
z̄ = (x̄/ȳ)arrondi = +ϵ= +ϵ= + 1+ +ϵ
y+η 1 + η/y y y y
En appliquant l’approximation bien connue (1 + x)α ≃ 1 + αx valable pour |x| < 1, |αx| ≪ 1 (avec x et
α réels ou complexes), et en négligeant le terme quadratique en erreur −δη/y 2 , on obtient
−1
x δ η x δ η 1 x
z̄ = + 1+ +ϵ≃ + 1− + ϵ ≃ z + δ − 2 η + ϵ.
y y y y y y y y
L’erreur en z̄ comprend donc des erreurs propagées de x et y plus une nouvelle erreur d’arrondi ϵ. On
remarque que pour y petit, l’erreur sera grande.
Il est très important de comprendre comment les différents types d’erreur peuvent se propager pendant un calcul :
1. De petites variations dans les données initiales peuvent donner lieu à de grands changements dans les résultats
finals. Un problème avec une telle propriété est dit mal-conditionné. Exemples : la météo, effet papillon.
2. Les erreurs de troncation dépendent normalement d’un paramètre N tel que si N → ∞ la solution approxi-
mée approche de plus en plus la solution exacte. Des erreurs de troncation peuvent donc être réduites en
choisissant N plus grand, ce qui n’est pas toujours possible en pratique.
3. Des erreurs d’arrondi s’accumulent au hasard, et souvent s’annulent. Il existe certains cas cependant où ces
erreurs peuvent grandir très rapidement. On appelle ce phénomène l’instabilité.
Illustration : on calcule e1/3 , en réalisant tous les calculs à 4 décimales pour forcer le trait.
• 13 ≃ 0.3333 ⇒ erreur initiale = 0.000033333 . . .
• L’erreur propagée est
e0.3333 − e1/3 = e0.3333 (1 − e0.00003333... ) ≃ −0.0000465196
• On calcule ex par la séries

x2 x3 x4
ex = 1 + x + + + + O(x5 )
2! 3! 4!
avec x = 0.3333. Si on néglige des termes O(x5 ), une erreur de troncation est introduite, qui est
0.33335 0.33336

− + + · · · ≃ −0.0000362750
5! 6!
• La sommation de la séries tronquée est faite avec des valeurs arrondies : on obtient
1 + 0.3333 + 0.0555 + 0.0062 + 0.0005 = 1.3955
• Si on fait le calcul à 10 décimales, on obtient le résultat 1.3955296304.

• La valeur correcte à 17 chiffres est 1.3956124250860895.
Une source importante d’erreurs d’arrondi est l’annulation numérique (cancellation error), en particulier quand on
essaie de calculer la différence de deux nombres presque égaux. La précision finie de l’ordinateur amène à une perte
importante de chiffres significatifs.
Exemple 1 : A trois chiffres significatifs,
1 1
− = 0.667 × 10−1 − 0.625 × 10−1 = 0.420 × 10−2 .
15 16
La valeur exacte est 0.417 × 10−2 .
Exemple 2 : Trouver les solutions de l’équation x2 − 178x + 2 = 0 par la formule analytique bien connue
√
−b ± b2 − 4ac
x± =
2a
avec a = 1, b = −178, c = 2.
Puisque b2 >> 4ac, le calcul de x− implique la différence de nombres très proches. Sur une simple calculatrice à
dix chiffres, on obtient
x+ = 1.779887634 × 102 x− = 1.123665 × 10−2 .
Le nombre de chiffres significatifs est fortement réduit pour x− . Dans ce cas, une meilleure précision est possible,
en utilisant la propriété x+ x− = c/a :
2
x− = = 1.123666439 × 10−2 .
1.779887634 × 102
Vérification : avec x− = 1.123665 × 10−2 , l’équation = 2.56231 × 10−6
avec x− = 1.123666439 × 10−2 , l’équation = 1.21 × 10−9 .
Exemple 3 : Relations de récurrence.
Les relations de récurrence sont particulièrement vulnérables à la propagation d’erreurs initiales et d’arrondi.
La relation de récurrence pour la fonction de Bessel Jn (x) est
2n
Jn+1 (x) = Jn (x) − Jn−1 (x).
x
Si n > x, le facteur 2n/x > 1 multiplie des erreurs dans Jn , avec pour résultat une perte énorme de précision. Par
exemple, à six décimales :
J0 (1) = 0.765198, J1 (1) = 0.440051
En appliquant les relations de récurrence, on obtient J7 (1) = 0.008605 au lieu de la réponse correcte, 0.000002.
Informatique 7
1.6 A retenir
Les ordinateurs sont des outils puissants, capables de réaliser des calculs hors de portée des capacités cérébrales.
Leurs limitations matérielles – le nombre fini de bits pour stocker les données, en particulier pour représenter les
nombres réels, le temps de calcul fini – impliquent des erreurs numériques qui doivent être soigneusement contrôlées.
Les solutions sont développées en Mathématiques numériques, un domaine scientifique devenu incontournable à l’ère
des super-calculateurs.
Les méthodes analytiques restent indispensables car elles résolvent exactement des problèmes relativement simples,
qui servent de modèles au traitement numérique des cas plus complexes.
Chapitre 2
Bases de Python
Ce chapitre ne requiert aucune connaissance préalable du langage Python.

A la fin de ce chapitre, vous serez capable d’écrire de petits scripts pour
1. écrire des messages à l’écran
2. introduire des données par le clavier
3. réaliser des opérations arithmétiques
4. faire des tests, prendre des décisions
5. définir des types de données combinés et itérer sur leurs éléments.
Les exemples de code sont fournis en format Jupyter notebook sur la plate-forme Nuvolos > L1 PCSTM Infor-
matique 2024 Group > Class supports, où Group est le nom du groupe de TP. Les codes de ce chapitre-ci sont
dans le carnet Jupyter 1_Basic.ipynb. Chaque code est dans une cellule séparée.
1. Décryptez le code de la première cellule.
1 # Comments are preceded by the hash character
2 name = input ( ’ Enter your name : ’)
3 print ( ’ Hello ’+ name )
4 x = input ( ’ please enter an integer : ’)
5 x = int ( x )
6 print (x , ’* ’ ,x , ’= ’ ,x * x )
7 x = float ( x )
8 print (x , ’* ’ ,x , ’= ’ ,x * x )
Basic/first.py
2. Lisez attentivement chaque ligne et essayez d’anticiper ce que fera le code : transcrivez sur feuille les valeurs
des variables, réalisez les calculs élémentaires.
3. Sélectionnez la cellule dans le notebook Jupyter à l’aide de la souris (le bord gauche de la cellule devient vert)
et exécutez-la en cliquant sur la touche Exécuter ou à l’aide du raccourci clavier majuscule - entrée.
4. Python est un langage interprété : le code est analysé et traduit en langage machine à chaque exécution.
5. Analysez les résultats affichés en dessous de la cellule et localisez dans le script Python la séquence précise
des instructions en jeu.
Cette étape est indispensable pour apprendre les instructions Python et comprendre comment le code fonc-
tionne.
8
Informatique 9
6. Le cas échéant, entrez les données demandées à l’écran.
7. La meilleure méthode pour apprendre et maı̂triser un langage de programmation est de le pratiquer. Il ne

faut donc pas hésiter à copier/coller des lignes de code et à les adapter à vos propres besoins.
8. Prenez également l’habitude de développer une synthèse personnelle des instructions Python et de vos re-
marques intéressantes associés au fur et à mesure de votre progression. Il est démontré que c’est un outil
efficace pour renforcer la mémorisation, bien supérieur à la relecture passive de notes de cours ou de TP.
9. Un langage informatique étant conçu par des êtres humains, il vaut mieux en apprendre les règles que d’essayer
de les deviner par essais et erreurs !
Remarques importantes
— La version de Python sur Nuvolos est 3.9. Avec les versions antérieures ou postérieures, les exemples peuvent
fournir des résultats différents ou ne pas fonctionner.
— Les commentaires sont limités au strict nécessaire car un bon code se commente de lui-même grâce au choix
judicieux des noms de variables et fonctions. En Python, l’indentation des blocs conditionnels et de boucles
contribue naturellement à la clarté des codes.
Remember :
— L’ordinateur n’a aucune intelligence, il exécute sans état d’âme les tâches qu’on lui donne à exécuter.
— Le rôle des interprétateurs et compilateurs est de traduire les codes rédigés dans des langages avancés, très
proches du langage courant, en code binaire, compréhensible par la machine. Ils fournissent souvent des
messages d’erreur mais leur fonction n’est pas de corriger les programmes, et encore moins de deviner les
intentions du programmeur.
2.1 Premier programme
1 # Comments are preceded by the hash character
2 name = input ( ’ Enter your name : ’)
3 print ( ’ Hello ’+ name )
4 x = input ( ’ please enter an integer : ’)
5 x = int ( x )
6 print (x , ’* ’ ,x , ’= ’ ,x * x )
7 x = float ( x )
8 print (x , ’* ’ ,x , ’= ’ ,x * x )
Basic/first.py
Code couleurs des listings

rouge : commentaire, précédé du caractère #
noir : variable, opération avec variable.
bleu : fonction, méthode
violet : chaı̂ne de caractères.
Analyse du code
Les numéros de ligne, précédés par L, correspondent aux chiffres le long de la marge gauche de l’encadré du code.
L1. Les commentaires sont précédés du caractère #.
L2. La fonction input affiche à l’écran la chaı̂ne de caractères ’Enter your name: ’. La chaı̂ne de caractères
entrée à l’écran est enregistrée dans la variable name.
Point de vigilance : En informatique, le symbole = n’est jamais l’égalité mathématique, il désigne une affec-
tation (en anglais : assignment), c-à-d que la valeur de la variable du membre de droite est enregistrée dans
la variable du membre de gauche.
L3. La fonction print imprime à l’écran la chaı̂ne de caractères ’Hello’ suivi du contenu de la variable name.
Le caractère + permet de concaténer – autrement dit juxtaposer – les deux chaı̂nes de caractères.
L4. La variable x est initialisée par la fonction input, c’est une chaı̂ne de caractères.
L5. La fonction int convertit la chaı̂ne de caractères x en un entier et la stocke dans la variable x. Si la donnée
lue n’est pas un entier, un message d’erreur est affiché. La conversion du type caractère à entier est nécessaire
pour réaliser des opérations arithmétiques sur x.
L6. Ici, la fonction print imprime le carré de x. On note que le produit de deux réels est réalisé par la commande
* et que l’on peut inclure une opération mathématique parmi les arguments de print. Cependant, comme x
est de type entier et non caractère, il ne peut plus être directement concaténé à des chaı̂nes de caractères. La
solution consiste à séparer les arguments de print par des virgules, ce qui ajoute un espace entre les éléments
affichés.
L7. La fonction float convertit x en un réel et le stocke dans la variable x.
L8. A l’impression, on constate qu’une variable réelle se distingue d’un entier par le point décimal.
Exécution du script :
Si le script comporte une erreur de syntaxe (par exemple une parenthèse oubliée), un message est affiché. En Python,
ces messages sont souvent très précis : ils décrivent le type d’erreur avec sa localisation (nom du programme,
Informatique 11
numéro de la ligne et position dans cette ligne). Une erreur peut générer en cascade d’autres messages d’erreur ou
des avertissements (warning), il faut donc toujours corriger leurs sources dans l’ordre d’apparition.
2.2 Types de donnée élémentaires, typage dynamique
1. Les données sont enregistrées dans des variables qui sont créées à la volée, avec le type adéquat. Python est
un langage à typage dynamique.
2. La fonction type() permet d’afficher le type d’une variable.
3. Une variable est stockée en mémoire à une adresse que l’on peut obtenir à l’aide de la fonction id().
Tout langage informatique définit des types de données (data types) qu’il est très important de connaı̂tre pour
réaliser des opérations. Les nombres entiers, réels et complexes, indispensables pour le calcul scientifique, sont des
types natifs à Python, comme illustré dans le code ci-dessous.
1 x =2024
2 print (x , type ( x ) , id ( x ) )
3 x =3.14159265359
4 print (x , type ( x ) , id ( x ) )
5 x =1 j
6 print (x , type ( x ) , id ( x ) )
7 x=x*x
8 print (x , type ( x ) , id ( x ) )
9 x =1.5 -2.3 j
10 print (x , type ( x ) , id ( x ) )
Basic/number.py
L1. On affecte à la variable x l’entier 2024.
L2. On imprime la variable x, son type et son adresse : x est un objet de la classe int, de l’anglais integer, en
français entier.
L3. On affecte à la variable x le réel 3.14159265359. En Python, la virgule n’est jamais utilisée pour le point
décimal.
L4. On imprime la variable x, son type et son adresse : x est un objet de la classe float, ce qui signifie en informa-
tique un nombre réel. Float fait référence à la notation en point décimal flottant, avec une mantisse variable
selon la puissance de la base. Par exemple, 3.14159265359 et 0.314159265359 × 101 sont des représentations
équivalentes du même nombre réel.
L5. On affecte à la variable x le nombre imaginaire i, noté 1j.
L6. x est de la classe complex.
L7. On affecte à la variable x le carré du nombre imaginaire i, stockée précédemment dans la variable x.
L8. On vérifie que le carré de i est bien le nombre complexe de partie réelle -1 et de partie imaginaire nulle.
L9. Le nombre complexe 1.5 − 2.3i s’écrit 1.5-2.3j.
En général, à chaque réaffectation, l’adresse de la variable change. Ceci est vrai même si l’on ne change pas de type,
comme on peut le constater dans l’exemple ci-dessous.
1 n =12
2 print ( ’n = ’ ,n , ’ address of n ’ , id ( n ) )
3 n = n +1
4 print ( ’n = ’ ,n , ’ address of n ’ , id ( n ) )
Basic/id.py
Informatique 13
L’adresse de n imprimée en ligne L4 est différente de celle imprimée en ligne L2. Les données de type numérique
sont immutables, c-à-d que changer leur valeur revient à en allouer une nouvelle.
2.3 Opérations arithmétiques
Les opérations arithmétiques courantes se définissent avec les symboles habituels comme montré dans le script
ci-dessous.
1 print ( ’ Demonstration of numerical data types and arithmetic operations ’)
2 x = int ( input ( ’ please enter an integer x : ’) )
3 y = int ( input ( ’ please enter an integer y : ’) )
4 print (x , ’/ ’ ,y , ’= ’ ,x / y )
5 print ( ’ Integer division : ’ ,x , ’ // ’ ,y , ’= ’ ,x // y )
6 print ( ’ Modulo : ’ ,x , ’% ’ ,y , ’= ’ ,x % y )
7 x = float ( input ( ’ please enter a real number x : ’) )
8 y = float ( input ( ’ please enter a real number y : ’) )
9 print (x , ’+ ’ ,y , ’= ’ ,x + y )
10 print (x , ’ - ’ ,y , ’= ’ ,x - y )
11 print (x , ’* ’ ,y , ’= ’ ,x * y )
12 print (x , ’/ ’ ,y , ’= ’ ,x / y )
13 print ( ’ Power : ’ ,x , ’ ** ’ ,y , ’= ’ ,x ** y )
14 i =1 j
15 print ( ’i **2= ’ ,i **2)
16 x = float ( input ( ’ enter real part of complex number z : ’) )
17 y = float ( input ( ’ enter imaginary part of complex number z : ’) )
18 z = complex ( x )
19 print ( ’ complex ( ’ ,x , ’) = ’ ,z )
20 z = complex (x , y )
21 print ( ’ complex ( ’ ,x , ’ , ’ ,y , ’) = ’ ,z )
22 print (z , ’* ’ ,z , ’= ’ ,z * z )
23 print ( ’ abs ( ’ ,z , ’) = ’ , abs ( z ) )
24 print ( ’ 1.0/ ’ ,z , ’= ’ ,1.0/ z )
Basic/arithmetic.py
Points de vigilance :
— Le quotient de deux entiers est toujours un réel : 3/2 donne 1.5, 4/2 donne 2.0.
— Pour la division entière, Python 3 utilise // : Le résultat de 1//2 est 0, 3//2 est 1. Par contre, le résultat
de 3.2//2.5 est le réel 1.0.
— Le nombre complexe i (tel que i2 = −1) est défini par 1j, comme en électricité et électronique.
Les fonctions mathématiques courantes telles que cos, sin, exp, sqrt, . . . nécessitent l’importation d’un module
spécifique. Voici 3 façons de procéder pour évaluer sin(x) :
importation sin(x)
import math math.sin(x)
import math as m m.sin(x)
from math import * sin(x)
Les fonctions mathématiques étant indispensables en sciences, des explications beaucoup plus approfondies sont
fournies à la section 3.3.
Informatique 15
2.4 Conditions
Il est possible de réaliser des tâches différentes selon les données grâce aux instructions conditionnelles. Celles-ci
peuvent être de la forme simple SI - ALORS, ou contenir plusieurs branches avec SINON SI ou SINON.
1 x = float ( input ( ’ Please enter x : ’) )
2 y = float ( input ( ’ Please enter y : ’) )
3 if x != y : print (x , ’ is different from ’ ,y )
4 if x > y : print (x , ’ is larger than ’ , y )
5 elif x == y : print (x , ’= ’ , y )
6 else : print (x , ’ is smaller than ’ , y )
Basic/if.py
Si plusieurs instructions doivent être exécutées après une condition, elles doivent être incluses dans un bloc d’ins-
tructions conditionnelles caractérisé par une indentation comme dans l’exemple suivant.
1 name = input ( ’ Please enter your name : ’)
2 year = input ( ’ Please enter your year of birth : ’)
3 if year . isdigit () :
4 age =2024 - int ( year )
5 print ( ’ Hello ’+ name + ’ at the end of this year you will be ’+ str ( age ) + ’ years old ’)
6 else : print ( ’ Hello ’+ name )
Basic/if block.py
Cette particularité de Python allège la syntaxe mais exige une grande rigueur dans la mise en page des codes.
Une erreur d’indentation n’est pas syntaxique et ne donne pas lieu à un message de l’interprétateur, elle est donc
souvent difficile à localiser et à corriger.
2.5 Type booléen

Aux conditions binaires sont associées les variables booléennes qui peuvent prendre deux valeurs (’Vrai’,’Faux’),
(’True’,’False’) ou encore (1,0). Toute valeur non nulle est True comme illustré dans le code suivant :
1 a = input ( ’ Enter an integer : ’)
2 b = input ( ’ Enter another integer , different or equal to the first one : ’)
3 test =( a == b )
4 if test : print ( ’ test = ’ , test ,a , ’ is equal to ’ ,b )
5 test =( a != b )
6 if test : print ( ’ test = ’ , test ,a , ’ is different from ’ ,b )
7 if 0: print ( ’ this line is never printed ’)
8 if 2: print ( ’ this line is always printed ’)
9 x = False
10 print ( ’x = False : ’ ,x , ’ type ( x ) : ’ , type ( x ) )
11 x = bool (0)
12 print ( ’x = bool (0) : ’ ,x , ’ type ( x ) : ’ , type ( x ) )
13 x = ’ False ’
14 print ( " x = ’ False ’: " ,x , ’ type ( x ) : ’ , type ( x ) )
15 if x : print ( ’ Hello ’)
Basic/bool.py
Point de vigilance : Ce script montre que toute valeur autre que False, bool(0) ou 0 est interprétée comme True.
Les opérateurs de comparaison sont
égal == plus grand que > plus grand ou égal >=

différent != plus petit que < plus petit ou égal <=
Les opérations de comparaison peuvent être combinées avec
et and vrai si les deux opérands sont vrais, sinon faux

ou or vrai si au moins un des deux opérands est vrai, sinon faux
Les résultats possibles pour ces deux opérateurs selon les valeurs possibles (vrai = V ; faux = F) des opérands sont
regroupés dans la table de vérité suivante :
A B A and B A or B
V V V V
V F F V
F V F V
F F F F
Des exemples d’application sont présentés dans le code comp.py.

1 a = -2
2 b =1
3 if a >0 and b >0: print ( ’a et b are both positive ’)
4 elif a <0 and b <0: print ( ’a et b are both negative ’)
5 elif a ==0 or b ==0: print ( ’ at least one of a et b is zero ’)
6 else : print ( ’a and b are of opposite sign ’)
Basic/comp.py
L’opérateur de négation est not. Quelques exemples d’utilisation sont dans le code not.py.
1 A = True
2 B = not A
3 print ( ’A ’ ,A )
4 print ( ’B ’ ,B )
5 A =1
6 B = not A
7 print ( ’A ’ ,A )
8 print ( ’B ’ ,B )
9 A =0
10 B = not A
11 print ( ’A ’ ,A )
12 print ( ’B ’ ,B )
Basic/not.py
Informatique 17
2.6 Types de données combinés
Python définit des types de données combinés, très pratiques pour regrouper plusieurs variables. Les plus importants
sont les listes, tuples, ranges et dictionnaires. Il en existe d’autres et l’on peut même définir ses propres types.
1 data =[ ’A ’ ,0 , ’ Python ’ , -3.1415]
2 print ( data , type ( data ) , id ( data ) )
3 data =( ’A ’ ,0 , ’ Python ’ , -3.1415)
5 data = range (5)
7 data ={ ’ year ’ :2024 , ’ month ’:1 , ’ day ’ :12}
Basic/ltrd.py
L1. On affecte à la variable data une liste délimitée par des crochets et composée de variables de différents types
séparées par des virgules.
L2. data est un objet de la classe list.
L3. On affecte à la variable data un tuple délimité par des parenthèses et composé de variables de différents types
séparées par des virgules.
L4. data est un objet de la classe tuple.
L5. On affecte à data un objet de la classe range comportant 5 éléments.
L6. data contient les 5 entiers de 0 à 4.
L7. On affecte à la variable data un dictionnaire. Ses éléments sont des paires dont les membres sont séparés par
le caractère :, le premier est l’indice identifiant l’élément, le second est la valeur de l’élément. Un dictionnaire
est délimité par des accolades.
L8. data est un objet de la classe dict.
On peut accéder successivement aux éléments d’une variable de type combiné à l’aide d’une boucle for.
1 data =[ ’A ’ ,0 , ’ Python ’ , -3.1415]
2 for x in data : print ( ’ list : ’ ,x )
3 data =( ’A ’ ,0 , ’ Python ’ , -3.1415)
4 for item in data : print ( ’ tuple : ’ , item )
5 data = range (5)
6 for i in data : print ( ’ range : ’ ,i )
7 data ={ ’ year ’ :2024 , ’ month ’:1 , ’ day ’ :12}
8 for x in data : print ( ’ dictionary : ’ ,x , data [ x ])
Basic/ltrd for.py
L2, L4, L6 L’instruction est explicite : pour chaque x dans data, on imprime x. Le nom de la variable x est
arbitraire, on peut tout aussi bien en définir un autre, par exemple item (en anglais : article, objet, point)
ou i.
L8 Itérer sur les éléments d’un dictionnaire revient à itérer sur ses indices et non ses valeurs. La valeur corres-
pondant à l’indice x s’obtient avec le nom du dictionnaire suivi de [x].
2.7 Itérations
Les ordinateurs sont capables d’exécuter très rapidement un grand nombre d’instructions en les itérant sur des
éléments d’un objet. En Python, l’instruction d’itération est for et on itère sur les éléments x d’un objet O dit
itérable avec l’instruction for x in O. Sont entre autres itérables les types de données combinés évoqués à la
section précédente et présentés en détail au chapitre 3 : list, tuple, dictionary, range sont itérables.
2.7.1 For x in range
Le type range permet d’itérer sur des entiers mais ses spécificités nécessitent une vigilance toute particulière.
1 print ( ’ Calculate sum of first m natural numbers ’)

2 m = int ( input ( ’ Please enter integer m : ’) )
3 sum =0
4 for i in range ( m ) :
5 sum = sum + i
6 print ( ’ i = ’ ,i , ’ sum = ’ , sum )
7 print ( ’ Sum of first ’ ,m , ’ natural numbers = ’ , sum )
Basic/for range.py
Analyse du code
L1. Ce programme calcule la somme des m premiers nombres entiers.
L2. On demande m et on convertit la chaı̂ne de caractères en un entier.
L3. On initialise la variable sum à 0.
L4. On définit la boucle de m itérations, d’indice i de 0 à m-1. Les instructions à exécuter dans la boucle (L5–L6)
sont indentées, c-à-d décalées vers la droite d’un même nombre d’espaces, typiquement 3 ou 4.
L5. Pour chaque valeur de i, on ajoute i à la variable sum. Le signe = est le symbole d’affectation (ou assignation) :
on attribue à la variable du membre de gauche la valeur du membre de droite. Le signe = n’est dont pas le
signe d’égalité comme en arithmétique !
NB : en Python, les variables sum des membres de gauche et de droite sont différentes même si elles ont le
même nom car leurs adresses en mémoire ne sont pas les mêmes ; en effet, les données de type numérique sont
immutables (cf fin de la section 1.1 et le code id.py).
L6. On imprime la valeur de i ainsi que la valeur de la somme partielle correspondante.
L7. La fin de la boucle est marquée par la suppression de l’indentation, les instructions hors de la boucle sont
alignées sur la colonne du for de L4. On imprime la valeur finale de la somme, sum.
Exemple de résultat d’exécution :

$ python3 loop.py
Calculate sum of first m natural numbers
Please enter integer m: 4
i= 0 sum= 0
i= 1 sum= 1
i= 2 sum= 3
i= 3 sum= 6
Informatique 19
Sum of first 4 natural numbers = 6

$
Le programme suivant calcule le produit des m premiers entiers non nuls. Les indices de la boucle commençant à 1
et non 0, il faut le spécifier lors de la définition de la boucle. De plus, il faut que la borne supérieure de la boucle
soit m+1 pour que i prenne la valeur m.
1 print ( ’ Calculate product of integers from 1 to m ’)

2 m = int ( input ( ’ Please enter positive integer m : ’) )
3 prod =1
4 for i in range (1 , m +1) :
5 prod = prod * i
6 print ( ’ i = ’ ,i , ’ prod = ’ , prod )
7 print ( ’ Product of integers from 1 to ’ ,m , ’= ’ , prod )
Basic/for range2.py

$ python3 loop2.py
Calculate product of integers from 1 to m
Please enter positive integer m: 4
i= 1 prod= 1
i= 2 prod= 2
i= 3 prod= 6
i= 4 prod= 24
Product of integers from 1 to 4 = 24
Le programme suivant calcule la somme des m premiers entiers pairs. Le pas d’itération est 2, il faut le spécifier
en troisième position de la liste des paramètres de range. Si le pas d’itération est différent de 1, il faut donc
nécessairement spécifier d’abord la limite inférieure et la limite supérieure de la boucle.
1 print ( ’ Calculate sum of first m even natural numbers ’)

3 sum =0
4 for i in range (0 ,2* m ,2) :
5 sum = sum + i
6 print ( ’ i = ’ ,i , ’ sum = ’ , sum )
7 print ( ’ Sum of first ’ ,m , ’ even natural numbers = ’ , sum )
Basic/for range3.py

$ python3 loop3.py
Calculate sum of first m even natural numbers
i= 0 sum= 0
i= 2 sum= 2
i= 4 sum= 6
i= 6 sum= 12
Sum of first 4 even natural numbers = 12
$
Informatique 21
— En Python, l’indentation définit les blocs d’instructions des boucles. Ce parti pris allège la syntaxe 1 mais
exige une plus grande rigueur dans la mise en page des codes.
— La fonction range(from,to,step) retourne une suite d’entiers de from à to-1 par pas de step, utilisés par
le compteur de la boucle for.
— Par défaut, step=1, il faut donc le spécifier seulement si il est différent de 1.
— Quelle que soit la valeur du paramètre from, le nombre d’itérations d’une boucle for est donné par (to -
from - 1). Ce décalage d’une unité étant source fréquente d’erreur, il nécessite une attention permanente en
programmation Python.
2.7.2 If continue
Si à l’intérieur d’une boucle, on veut, sous certaines conditions, ne pas exécuter certaines instructions et passer
directement à l’itération suivante, on utilise la commande if ...: continue. Dans l’exemple ci-dessous, les valeurs
de i telles que 7 < i < 13 ne sont pas prises en compte dans la somme.
1 print ( ’ Calculate sum of integers from 1 to m , except between 8 and 12 ’)
2 m = int ( input ( ’ Please enter positive integer m ’) )
3 sum =0.0
5 if i >7 and i <13:
6 continue
7 sum = sum + i
8 print ( ’i = ’ ,i , ’ sum = ’ , sum )
9 print ( ’ After for loop : i = ’ ,i , ’ sum = ’ , sum )
Basic/if continue.py
2.7.3 For break
Une boucle peut être interrompue par la commande break. Dans l’exemple ci-dessous, on imprime les sommes
partielles des entiers de 1 à m tant que la somme est inférieure ou égale à Max.
1 print ( ’ Calculate sum of integers from 1 to m up to Max ’)
2 m = int ( input ( ’ Please enter positive integer m ’) )
3 Max = int ( input ( ’ Please enter positive integer Max ’) )
4 sum =0.0
6 if sum + i <= Max :
7 sum = sum + i
8 else :
9 i =i -1
10 break
11 print ( ’ i = ’ ,i , ’ sum = ’ , sum )
12 print ( ’ Sum of integers from 1 to ’ ,i , ’= ’ ,sum , ’ <= ’ , Max )
Basic/for break.py
L’exécution se poursuit avec la première instruction après la boucle concernée, sauf si l’instruction est else:...,
qui est exécutée seulement si la boucle n’a pas été interrompue par break. Ceci est illustré dans l’exemple ci-dessous.
1. En C, C++, Java, Perl, . . ., on utilise des accolades ; en Fortran on utilise le marqueur end do.
1 print ( ’ Test of for - else construct without break ’)

2 x = int ( input ( ’ Enter x >1: ’) )
3 for i in range ( x ) :
4 print ( ’i = ’ ,i )
5 else :
6 print ( ’ After else i = ’ ,i )
7 print ( ’ Test of for - else construct with break after i =5 ’)
8 x = int ( input ( ’ Enter x >1: ’) )
9 for i in range ( x ) :
10 print ( ’i = ’ ,i )
11 if i ==5:
12 break
13 else :
14 print ( ’ After else i = ’ ,i )
Basic/for else.py
La boucle while permet d’itérer des opérations lorsqu’on n’en connait pas d’avance le nombre. Un exemple typique
concerne le calcul de la série limitée d’une fonction, par exemple la série de Taylor Maclaurin de l’exponentielle
∞
x2 x3 x4 X xn
ex = 1 + x + + + + ... =
2! 3! 4! n=0
n!
où n! est la factorielle de n définie de manière récursive par n! = (n − 1)! n pour n > 0 et 0! = 1.
2.7.4 Boucle while
Dans l’exemple ci-dessous, on souhaite calculer la valeur de ex par développement limité avec une précision prec.
La boucle est optimisée pour minimiser le nombre de multiplications, en utilisant la définition de la factorielle
xn xn−1 x
= .
n! (n − 1)! n
1 print ( ’ Calculate exp ( x ) by Maclaurin series ’)

2 x = float ( input ( ’ Please enter x ’) )
3 prec = float ( input ( ’ Enter relative precision ’) )
4 expx =1.0
5 d=x
6 n =1
7 while abs ( d / expx ) > prec :
8 expx = expx + d
9 n = n +1
10 d=d*x/n
11 print ( ’ n = ’ ,n , ’ d = ’ ,d , ’ exp ( ’ ,x , ’) = ’ , expx )
Basic/while.py
Point de vigilance : Il ne faut utiliser une boucle while que si le nombre d’itérations n’est pas connu d’avance car
la condition d’arrêt rend le code difficile à appréhender.
Informatique 23
Dans l’exemple suivant, l’instruction while True: définit une boucle infinie car True est toujours vrai : on peut
utiliser toute valeur ne correspondant pas à faux (False, 0 ou vide).
4 expx =1.0
5 d=x
6 n =1
7 while True :
8 expx = expx + d
9 n = n +1
10 d=d*x/n
11 print ( ’ n = ’ ,n , ’ d = ’ ,d , ’ exp ( ’ ,x , ’) = ’ , expx )
12 if ( abs ( d / expx ) < prec ) :
13 break
Basic/inf for.py
Il faut bien entendu s’assurer que l’exécution de la boucle sera interrompue par un break, faute de quoi le code ne
s’arrêtera jamais ! Il est parfois donc plus prudent d’insérer un compteur dont la valeur devra être limitée à une
valeur raisonnable, même si un tel test ralentit le code, surtout si le nombre d’itérations est élevé.
Chapitre 3
List, Tuple, Range, Dictionary
Ce chapitre présente plus en détail les types de données combinés, en particulier les notions d’indice (slicing),
d’itération (boucle for), la nature mutable ou immutable, la définition par compréhension.
3.1 List
3.1.1 Définition d’une liste et itération sur ses éléments
Comme son nom l’indique, list est un objet pouvant contenir une suite ordonnée de variables, celles-ci pouvant
être de différents types.
1 print ( ’ Define list of planets ’)
2 planets =[ ’ Mercury ’ , ’ Venus ’ , ’ Earth ’ , ’ Mars ’ , ’ Jupiter ’ , ’ Saturn ’ , ’ Uranus ’ , ’ Neptune ’ , ’ Pluto ’]
3 print ( planets )
4 print ( ’ Number of planets : ’ , len ( planets ) )
5 for planet in planets : print ( planet )
6 for i , planet in enumerate ( planets ) : print ( ’ planet number ’ ,i , planet )
7 for planet in reversed ( planets ) : print ( planet )
LTRD/list.py
Analyse du code
L2 Création de la liste planets. Une liste est délimitée par des crochets [ ], ses éléments sont séparés par une
virgule.
L3. Impression des éléments de la liste.
L4. Le nombre d’éléments de list est obtenu avec la fonction len.
L5. Boucle (itération) sur les éléments de la liste. Noter qu’il ne faut pas préciser le nombre d’éléments ! Im-
pression de chaque planète, une par ligne.
L6. Boucle sur les éléments de la liste avec numéro d’ordre de chaque élément dans la variable i. L’indice du
premier élément d’une liste est 0.
L7. Boucle (itération) rétrograde sur les éléments de la liste.
24
Informatique 25
3.1.2 Modification d’une liste et analyse de contenu
Une liste est modifiable à l’aide de méthodes appliquées avec la syntaxe caractéristique de la programmation objet :
list.method.
1 print ( ’ Define list of planets ’)
2 planets =[ ’ Mercury ’ , ’ Venus ’ , ’ Earth ’ , ’ Mars ’ , ’ Jupiter ’ , ’ Saturn ’ , ’ Uranus ’ , ’ Neptune ’ , ’ Pluto ’]
3 print ( planets )
4 print ( ’ 2006 IAU GA : Pluto reclassified as dwarf planet ’)
5 Kuiper_belt =[]
6 Kuiper_belt . append ( planets [8])
7 planets . remove ( ’ Pluto ’)
8 Kuiper_belt . insert (0 , ’ Ceres ’)
9 Kuiper_belt . append ( ’ Haumea ’)
10 Kuiper_belt . append ( ’ Makemake ’)
11 Kuiper_belt . append ( ’ Eris ’)
12 print ( ’ Planets of solar system : ’)
13 print ( planets )
14 print ( ’ Kuiper belt : ’)
15 print ( Kuiper_belt )
16 body = input ( ’ Enter name of body in solar system ’)
17 message = body
18 if body in planets : message += ’ is a planet ’
19 elif body in Kuiper_belt : message += ’ is in Kuiper belt ’
20 else : message += ’ is unknown in solar system ’
21 print ( message )
LTRD/list append.py
Analyse du code
L5. Création de la liste vide Kuiper_belt.
L6. Ajout du 9ème élément de la liste planets à la liste Kuiper_belt.
Rappel : L’indice du premier élément d’une liste est 0, celui d’indice 8 est donc le 9ème .
L7. Suppression de l’élément ’Pluto’ de la liste planets.
L8. Insertion de l’élément ’Ceres’ en tête (indice 0) de la liste Kuiper_belt.
L9–11. Ajout des éléments ’Haumea’, ’Makemake’ et ’Eris’ à la fin de liste Kuiper_belt.
L12-15. Impression des éléments des listes.
L16. Lecture du nom d’un corps du système solaire.
L17. Initialisation de message avec le nom du corps.
L18. Si le corps est dans la liste des planètes, on ajoute à message la chaı̂ne de caractères ’is a planet’.
L19. Sinon, si le corps est dans la ceinture de Kuiper, on ajoute à message ’is in Kuiper belt’.
L20. Sinon, on ajoute à message ’is unknown in solar system’.
L21. On imprime message.
3.1.3 Accès aux éléments d’une liste - Slicing
Les éléments d’une liste étant ordonnés, on peut y accéder par leurs indices, indiqués par un slice de la forme
[start:stop:step] :
— start correspond à l’élément de départ.
— stop correspond à l’élément de fin 1 , il n’est pas inclus dans la sélection. Ce principe d’exclusion, fondamental
en langage Python, s’applique à de nombreux autres objets. Il est une source fréquente d’erreur qui doit
faire l’objet de la plus grande vigilance en début d’apprentissage, jusqu’à ce que l’automatisme soit acquis.
— start et stop peuvent être négatifs, auxquels cas ils sont comptés depuis la fin de la liste. Ainsi, l’indice
négatif [-1] correspond au dernier élément de la liste.
— step correspond à l’incrément de la sélection. Sa valeur par défaut est 1, l’omettre est une bonne pratique.
Sa valeur peut être négative.
Une première application de ces règles de base est montrée dans slice.py.
1 mylist =[1 ,2 ,3 ,4 ,5 ,6 ,7]
2 print ( type ( mylist ) )
3 print ( " Full list : " , mylist )
4 print ( ’ Number of elements : ’ , len ( mylist ) )
5 print ( " First element : " , mylist [0])
6 print ( " First 3 elements : " , mylist [:3])
7 print ( " Second and third elements : " , mylist [1:3])
8 print ( " Last element : " , mylist [ -1])
9 print ( " Third element from the end : " , mylist [ -3])
10 print ( " Last 3 elements : " , mylist [ -3:])
11 print ( " All elements except last 3: " , mylist [: -3])
12 print ( " Elements with even indices : " , mylist [::2])
13 print ( " Elements with odd indices : " , mylist [1::2])
14 print ( mylist [ -1:2: -1])
LTRD/slice.py
Analyse du code
L1 On crée la liste contenant les entiers de 1 à 7.
L2 On vérifie que le type est <class ’list’>.
L3. On imprime la liste en indiquant son nom. Cependant, si la liste est trop longue, seuls les quelques premiers
et derniers éléments peuvent être imprimés, les intermédiaires étant remplacés par . . ..
L4. Le nombre d’éléments d’une liste (longueur, en anglais length) est obtenu par la fonction len.
L5. Le premier élément a toujours l’indice 0.
L6. Le slice [:3] correspond aux 3 premiers à partir de 0.
L7. Le slice [1:3] est semblable à [0:3] mais sans l’élément d’indice 0.
L8. [-1] correspond au dernier élément de la liste.
L9. [-n] correspond au nème élément depuis la fin de la liste.
L10. [-n:] correspond aux n derniers éléments.
L11. [:-n] correspond aux éléments à l’exclusion des n derniers.
L12. [::2] correspond aux éléments d’indices pairs.
L13. [1::2] correspond aux éléments d’indices impairs.
L14. Impression dans l’ordre rétrograde, du dernier à celui d’indice 2 exclus, c-à-d [7, 6, 5, 4].
1. C’est en réalité le nombre d’éléments dans le cas par défaut où start=0 et step=1.
Informatique 27
3.1.4 Définition en compréhension
La méthode la plus élémentaire pour définir une liste est d’en énumérer les éléments, par exemple
E = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20}.
En langage Python, elle peut être définie en compréhension, de manière analogue à la définition en compréhension
d’un ensemble en mathématiques
E = {n | n ∈ N, 0 ≤ n ≤ 20, n%2 = 0} ou E = {2 ∗ n | n ∈ N, 0 ≤ n ≤ 10}.
1 E =[ n for n in range (0 ,21 ,2) ]

2 print ( E )
3 E =[ n for n in range (21) if n %2==0]
4 print ( E )
5 E =[2* n for n in range (11) ]
6 print ( E )
LTRD/comprehension.py
En Python, on dispose d’itérateurs capables de parcourir non seulement des listes d’entiers (comme dans les autres
langages tels que C, C++ et Fortran) mais également des listes d’objets. De plus, il n’est pas nécessaire de spécifier
le nombre d’éléments à traiter, la boucle for s’arrêtant automatiquement une fois la liste parcourue. Ceci permet
de créer des listes à partir d’autres de manière claire et élégante, par exemple une suite d’angles en degré que l’on
convertit en radian et vice-versa :
1 from math import pi
2 deg2rad = pi /180.
3 rad2deg =180./ pi
4 deg =[ theta for theta in range (0 ,190 ,10) ]
5 print ( deg )
6 rad =[ theta * deg2rad for theta in deg ]
7 print ( rad )
8 deg =[ theta * rad2deg for theta in rad ]
9 print ( deg )
LTRD/angle conversion.py
3.2 Tuple
Un tuple est une liste non modifiable d’objets, on dit qu’il est de type immutable. Une fois défini, on ne peut pas
modifier ses éléments, ni en rajouter ni en retirer.
1 print ( ’ Tuple : ’)
2 solar_system =( ’ Mercury ’ , ’ Venus ’ , ’ Earth ’ , ’ Mars ’ , ’ Jupiter ’ , ’ Saturn ’ , ’ Uranus ’ , ’ Neptune ’)
3 # equivalent to :
4 solar_system = ’ Mercury ’ , ’ Venus ’ , ’ Earth ’ , ’ Mars ’ , ’ Jupiter ’ , ’ Saturn ’ , ’ Uranus ’ , ’ Neptune ’
5 print ( solar_system )
6 for planet in solar_system :
7 print ( planet )
8 for planet in range ( len ( solar_system ) ) :
9 print ( ’ Planet ’ , planet +1 , ’ is ’ , solar_system [ planet ])
LTRD/tuple.py
Analyse du code
L2. Un tuple se distingue d’une liste par le fait qu’il est défini avec des parenthèses () au lieu de [ ]. Les
éléments sont séparés par des virgules, ils peuvent être de nature hétérogène.
L4. Dans certains cas, comme ici, on peut omettre les parenthèses définissant un tuple.
L6. On itère sur les éléments du tuple solar_system. La boucle for itère automatiquement sur tous les
éléments du tuple, on n’a pas besoin de préciser leur nombre.
L7. Les instructions de la boucle d’itération sont indentées. Ici, on imprime la valeur de chaque élément du
tuple solar_system.
L8. La fin d’une boucle est simplement indiquée en terminant l’indentation du bloc d’instructions : la première
instruction après la boucle for est alignée sur la colonne de ladite instruction for.
Le nombre d’éléments d’un tuple est obtenu avec la fonction len. Ici, on itère à nouveau sur les éléments
du tuple solar_system, cette fois-ci à l’aide d’un compteur digital prenant len(solar_system) valeurs
successives en commençant par 0. On constate bien que cette façon de faire n’est pas élégante et doit être
évitée, les lignes L6-L7 étant préférables car plus concises et claires.
On peut accéder aux éléments d’un tuple comme pour ceux d’une liste, à l’aide de slice. Le code ci-dessous est
à comparer à slice.py.
1 mytuple =(1 ,2 ,3 ,4 ,5 ,6 ,7)
2 print ( type ( mytuple ) )
3 print ( " Full tuple : " , mytuple )
4 print ( ’ Number of elements : ’ , len ( mytuple ) )
5 print ( " First element : " , mytuple [0])
6 print ( " First 3 elements : " , mytuple [:3])
7 print ( " Second and third elements : " , mytuple [1:3])
8 print ( " Last element : " , mytuple [ -1])
9 print ( " Third element from the end : " , mytuple [ -3])
10 print ( " Last 3 elements : " , mytuple [ -3:])
11 print ( " All elements except last 3: " , mytuple [: -3])
12 print ( " Elements with even indices : " , mytuple [::2])
13 print ( " Elements with odd indices : " , mytuple [1::2])
14 print ( mytuple [ -1:2: -1])
LTRD/tuple slice.py
Informatique 29
Analyse du code
L1 On crée le tuple contenant les entiers de 1 à 7.
L2 On vérifie que le type est <class ’tuple’>.
L3. On imprime les éléments du tuple en indiquant son nom. Cependant, si il y en a trop, seuls les quelques
premiers et derniers peuvent être imprimés, les intermédiaires étant remplacés par . . ..
L4. Le nombre d’éléments d’un tuple (longueur, en anglais length) est obtenu par la fonction len.
L5. Le premier élément a toujours l’indice 0.
L6. Le slice [:3] correspond aux 3 premiers à partir de 0.
L7. Le slice [1:3] est semblable à [0:3] mais sans l’élément d’indice 0.
L8. [-1] correspond au dernier élément du tuple.
L9. [-n] correspond au nème élément depuis la fin du tuple.
L10. [-n:] correspond aux n derniers éléments.
L11. [:-n] correspond aux éléments à l’exclusion des n derniers.
L12. [::2] correspond aux éléments d’indices pairs.
L13. [1::2] correspond aux éléments d’indices impairs.
L14. Impression dans l’ordre rétrograde, du dernier à celui d’indice 2 exclus, c-à-d (7, 6, 5, 4).
Comme un tuple est immutable, il y a moins de fonctions associées :
— on ne peut pas ajouter un élément à un tuple
— on ne peut pas supprimer un élément d’un tuple
— on ne peut pas trier un tuple.
Il n’est donc pas possible de transposer aux tuples les opérations sur les listes des fichiers slice2.py et list_cat_mul.py.
Par rapport à list, les avantages du tuple sont :

— la possibilité de les utiliser comme des clés de dictionnaire (cf section suivante)
— la protection contre les modifications intempestives
— la rapidité.
3.3 Range
La fonction range retourne une séquence d’entiers, par défaut commençant à 0, d’incrément 1 et s’arrêtant avant
un nombre spécifié.
1 print ( ’ Calculate sum of first m natural numbers ’)
2 m = int ( input ( ’ Please enter integer m : ’) )
3 sum =0
4 for i in range ( m ) :
5 sum = sum + i
6 print ( ’ i = ’ ,i , ’ sum = ’ , sum )
7 print ( ’ Sum of first ’ ,m , ’ natural numbers = ’ , sum )
LTRD/loop range.py
Analyse du code
L1. Ce programme calcule la somme des m premiers nombres entiers.
L2. On demande m et on convertit la chaı̂ne de caractères en un entier.
L3. On initialise la variable sum à 0.
L4. On définit la boucle de m itérations, d’indice i de 0 à m-1. Les instructions à exécuter dans la boucle (L5–L6)
sont indentées, c-à-d décalées vers la droite d’un même nombre d’espaces, typiquement 3 ou 4.
L5. Pour chaque valeur de i, on ajoute i à la variable sum. Le signe = est le symbole d’affectation (ou assignation) :
on attribue à la variable du membre de gauche la valeur du membre de droite. Le signe = n’est dont pas le
signe d’égalité comme en arithmétique !
NB : en Python, les variables sum des membres de gauche et de droite sont différentes même si elles ont le
même nom car leurs adresses en mémoire ne sont pas les mêmes ; en effet, les données de type numérique sont
immutables (cf fin de la section 1.1 et le code id.py).
L6. On imprime la valeur de i ainsi que la valeur de la somme partielle correspondante.
L7. La fin de la boucle est marquée par la suppression de l’indentation, les instructions hors de la boucle sont
alignées sur la colonne du for de L4. On imprime la valeur finale de la somme, sum.

$ python3 loop.py
Calculate sum of first m natural numbers
Please enter integer m: 4
i= 0 sum= 0
i= 1 sum= 1
i= 2 sum= 3
i= 3 sum= 6
Sum of first 4 natural numbers = 6
Informatique 31
Le programme suivant calcule le produit des m premiers entiers non nuls. Les indices de la boucle commençant à 1
et non 0, il faut le spécifier lors de la définition de la boucle. De plus, il faut que la borne supérieure de la boucle
soit m+1 pour que i prenne la valeur m.
1 print ( ’ Calculate product of integers from 1 to m ’)

3 prod =1
5 prod = prod * i
6 print ( ’ i = ’ ,i , ’ prod = ’ , prod )
7 print ( ’ Product of integers from 1 to ’ ,m , ’= ’ , prod )
LTRD/loop range2.py

$ python3 loop2.py
Calculate product of integers from 1 to m
i= 1 prod= 1
i= 2 prod= 2
i= 3 prod= 6
i= 4 prod= 24
Product of integers from 1 to 4 = 24
Le programme suivant calcule la somme des m premiers entiers pairs. Le pas d’itération est 2, il faut le spécifier
en troisième position de la liste des paramètres de range. Si le pas d’itération est différent de 1, il faut donc
nécessairement spécifier d’abord la limite inférieure et la limite supérieure de la boucle.
1 print ( ’ Calculate sum of first m even natural numbers ’)
3 sum =0
4 for i in range (0 ,2* m ,2) :
5 sum = sum + i
6 print ( ’ i = ’ ,i , ’ sum = ’ , sum )
7 print ( ’ Sum of first ’ ,m , ’ even natural numbers = ’ , sum )
LTRD/loop range3.py
— La fonction range(from,to,step) retourne une suite d’entiers de from à to-1 par pas de step, utilisés par
le compteur de la boucle for.
— Par défaut, step=1, il faut donc le spécifier seulement si il est différent de 1.
— Quelle que soit la valeur du paramètre from, le nombre d’itérations d’une boucle for est donné par (to -
from - 1). Ce décalage d’une unité étant source fréquente d’erreur, il nécessite une attention permanente en
programmation Python.
Remarque importante
A cause de ses spécificités, les boucles sur range sont à proscrire au maximum !
Au lieu d’itérer sur les indices d’un objet itérable, il faut itérer sur ses éléments.
3.4 Dictionary
— Un dictionnaire est un ensemble de paires (key,value). Chaque valeur value est repérée par une clé (en
anglais key) qui peut être n’importe quel objet immutable, par exemple un nombre mais aussi une chaı̂ne
de caractères ou un élément de tuple.
— Chaque clé est unique, c-à-d qu’elle ne peut pas être répétée dans le même dictionnaire. Si on stocke une
valeur pour une clé déjà présente dans le dictionnaire, l’ancienne valeur est perdue.
1 ’’’
2 Create dictionary with student marks , calculate average mark
3 ’’’
4 students = ( ’ Nicola ’ , ’ Emily ’ , ’ Jennifer ’ , ’ Helen ’ , ’ John ’)
5 marks = {}
6 total = 0
7 for student in students :
8 print ( student )
9 marks [ student ] = int ( input ( ’ Enter marks : ’) )
10 total = total + marks [ student ]
11 for student in marks : print ( student , marks [ student ])
12 average = total / len ( students )
13 print ( ’ Average marks of ’ , len ( students ) , ’ students ’ , average )
14 print ( len ( marks ) , marks . keys () )
15 print ( marks . items () )
16 student = ’ Emily ’
17 print ( student , marks [ student ])
18 if ’ Helen ’ in marks : del marks [ ’ Helen ’]
19 print ( marks )
20 marks2 ={}
21 if ’ Maria ’ not in marks : marks2 [ ’ Maria ’ ]=18
22 print ( marks2 )
23 marks . update ( marks2 )
24 print ( marks )
LTRD/dictionary.py
Analyse du code
L4. Création du tuple students.
L5. Création du dictionnaire vide marks.
L6. Initialisation de la somme des notes.
L7. Itération sur les éléments du tuple students.
L8. Impression du nom de l’étudiant.
L9. Ajout de la clé student et lecture à l’écran de la valeur (note) de l’élément correspondant du dictionnaire
marks.
L10. Ajout de la note à la somme des notes.
L11. Boucle sur les clés du dictionnaire marks, impression de chaque clé et valeur sur une ligne.
L12-13. Calcul et impression de la note moyenne.
L14-15. Impression du nombre d’éléments de marks, des clés et des paires (clé,valeur).
L16-17. Impressions des données concernant ’Emily’.
L18-19. Si ’Helen’ est une des clés du dictionnaire marks, on retire l’élément. On imprime marks.
L20-21. On crée le dictionnaire vide marks2. Si ’Maria’ n’est pas une des clés du dictionnaire marks, on l’ajoute
au dictionnaire marks2 avec la valeur à 18.
L23-24. On fusionne les dictionnaires marks et marks2 et on imprime marks.
Informatique 33
Opérations sur un dictionnaire d :
len(d) nombre d’éléments du dictionnaire d

d.keys() affiche les key du dictionnaire
d.values() affiche les valeurs du dictionnaire
d.items() affiche les paires (key,value)
d[’x’] affiche l’élément correspondant à la clé ’x’
’x’ in d ’x’ est une clé
’x’ not in d ’x’ n’est pas une clé
del d[’x’] destruction de l’élément de clé x
d.update(q) mise à jour du dictionnaire d avec le dictionnaire q
On peut définir des dictionnaire par compréhension, comme pour les listes.
1 import math as m
2
3 my_dic ={ x : x * x for x in (0 ,2 ,4 ,6 ,8 ,10) }

4 print ( my_dic )
5
6 my_dic ={ x : m . cos ( x * m . pi /4) for x in range ( -8 ,9) }

7 print ( my_dic )
LTRD/dictionary comprehension.py
Dans un dictionnaire, la notion d’ordre est ambiguë : s’agit-il de l’ordre des keys ou des valeurs ? Avant Python
3.6, l’ordre était complètement aléatoire. Depuis Python 3.7, l’ordre est celui de création.
Point de vigilance : on constate que les données de type list, tuple, range et dictionary ont des proprié-
tés communes qui facilitent leur apprentissage. Ces objets ont cependant des différences importantes, qu’il faut
connaı̂tre faute de quoi on risque de perdre beaucoup de temps en débogage ...
Chapitre 4
Functions
C’est en assemblant des briques que l’on construit les édifices. De même, en informatique, le débutant doit faire ses
armes sur de petits bouts de code (toy codes) avant de se lancer dans la résolution de problèmes réels.
Pour pouvoir recycler des sections de code dans d’autres programmes, on les transforme en fonctions avec des
entrées et des sorties bien définies. Les fonctions doivent pouvoir être utilisées comme des boı̂tes noires, c-à-d
qu’à données égales, les résultats devraient être strictement identiques. Cette vision idéaliste de la programmation
fonctionnelle est en fait extrêmement difficile à appliquer car aucun langage ne peut satisfaire tous les besoins.
C’est par l’expérience sur le terrain et le partage de bonnes pratiques que l’on apprend à developper des programmes
corrects, clairs, efficaces, facilement adaptables à d’autres situations et portables sur le long terme.
Ces critères sont antinomiques : un code ultra efficace dans un cas sera tellement bien adapté au jeu de données ou
à un ordinateur spécifique qu’il ne le sera pas du tout à d’autres. Par exemple, un code de simulation d’interaction
gravitationnelle à N -corps (multitudes d’objets obéissant à une même loi physique dont peuvent surgir des com-
portements collectifs complexes) sera difficilement réutilisable pour optimiser l’exploitation d’une centrale nucléaire
(système multiphysique avec fortes contraintes économiques). Les qualités indispensables en programmation scien-
tifique sont donc, outre la maı̂trise purement technique du langage et de l’interfaçage avec le hardware, la mémoire
des expériences accumulées, la capacité de prendre du recul et le sens des compromis.
La validation de codes est une part intégrale et sans doute la plus gratifiante du métier : elle requiert non seulement
de la perspicacité pour sélectionner les solutions mais aussi de l’imagination pour concevoir des tests significatifs.
Une stratégie de travail consiste à décomposer les problèmes en sous-problèmes, chacun avec un nombre réduit de
données qui seront les arguments d’entrée (paramètres) de la fonction correspondante. Celle-ci doit retourner au
plus une seule variable qui peut être un tuple comprenant plusieurs variables. Une fonction informatique est donc
à concevoir comme une fonction mathématique. Si la fonction modifie d’autres variables du programme global, on
dit que ce sont des effets de bord. Ils sont à éviter car les erreurs seront plus difficiles à détecter et à rectifier.
Ce chapitre est une introduction aux fonctions en langage Python. Il présente les notions essentielles suivantes :
— la syntaxe
— la portée des variables
— l’importation de fonctions décrites dans des fichiers séparés, les modules
— les fonctions élémentaires lambda
— les listes de fonctions
— le transfert de données entre fonctions.
34
Informatique 35
4.1 Notions de base

En langage Python, une fonction est typiquement de la forme suivante
def function_name (arg1, arg2, arg3):

instructions ...
result1 = ...
result2 = ...
return result1, result2
arg1, arg2, arg3 sont les éventuels arguments (paramètres) de la fonction.

result1, result2 sont les éventuels résultats de la fonction, qui peuvent être de types différents.
1 def square ( y ) :
2 return y * y
3
4 print ( ’ Calculate square of x ’)

5 x = float ( input ( ’ Enter x : ’) )
6 print (x , ’* ’ ,x , ’= ’ , square ( x ) )
Function/function.py
Analyse du script
L2. Les instructions de la fonction doivent être indentées de manière régulière. Il vaut mieux limiter cette
indentation à 3 ou 4 caractères afin d’éviter les trop longues lignes de code. Ici, la fonction retourne le carré
du nombre fourni en paramètre.
L4. Le retour à la colonne correspondant à l’instruction def indique la fin de la fonction.
L6. Une fonction peut être appelée à partir d’une autre fonction, ici print.
Point de vigilance : Une fonction a sa propre zone mémoire, elle peut par conséquent être appelée pour n’importe
quels paramètres sous la seule condition que leur type autorise les opérations dans la fonction. Les noms des pa-
ramètres n’ont aucune importance, seule compte la correspondance des types, d’une part dans la définition de la
fonction (L1 : le paramètre est y) et d’autre part dans son appel (L6 : le paramètre est x). Python étant un langage
à typage dynamique, on peut appeler la fonction square de function.py pour des nombres de type entier, float,
complexe, . . . tant que l’opération * est valide.
Une fonction peut être définie n’importe où dans un code pourvu qu’elle soit placée avant la ligne où elle est appelée
pour la première fois.
1 print ( ’ Calculate cube of x ’)
3
4 def cube ( x ) :
5 return x * x * x
6
7 print (x , ’* ’ ,x , ’= ’ , cube ( x ) )
Function/function 2.py
Point de vigilance : on peut définir plusieurs fois la même fonction dans un même programme, chaque redéfinition
d’une fonction se substituant à la précédente, selon le principe de typage dynamique.
Une fonction peut retourner plusieurs valeurs. Elles peuvent être affectées à des variables à condition que leur
nombre coı̈ncide avec le nombre de valeurs retournées.
1 print ( ’ Calculate square and cube of x ’)
3
4 def square_cube ( x ) :
5 return x *x , x * x *x , ’ done ’
6
7 print ( square_cube ( x ) )
8 sq , cub , message = square_cube ( x )
9 print (x , ’* ’ ,x , ’= ’ , sq )
10 print (x , ’* ’ ,x , ’* ’ ,x , ’= ’ , cub )
11 print ( message )
Function/function 3.py
4.2 Variables locales et variables globales

En informatique, la portée – scope en anglais – d’une variable est la portion du programme où elle est définie.
Cette notion est étroitement liée à celle de variable locale et variable globale.
1. une variable définie dans une fonction est locale à cette fonction, elle est inaccessible en dehors de la fonction.
2. une variable locale a préséance sur une variable globale de même nom.
Ces deux règles sont illustrées dans le code suivant :

1 import math as m
2 pi = m . pi
3 a = m . sqrt (2.0)
4 def myfun () :
5 pi = ’ pi ’
6 print ( ’ From myfun , pi = ’ , pi )
7 print ( ’ From myfun , a = ’ ,a )
8 return 0
9 myfun ()
10 print ( ’ From main function , pi = ’ , pi )
11 print ( ’ From main function , a = ’ ,a )
Function/local global.py
Analyse du script
L2–3. pi et a sont des variables globales.
L5. pi est une variable locale à la fonction myfun, sa valeur a préséance sur celle de la valeur globale pi définie
plus haut.
L7. Il n’y a pas de variable locale a, celle définie plus haut qui est globale, est utilisée. Si la variable globale a
est indéfinie au moment de l’appel à la fonction myfun, on aura une erreur.
L8. Une bonne pratique de Python est qu’une fonction retourne toujours une valeur, ici 0.
L10. En sortie de la fonction myfun, sa variable locale pi devient inaccessible. Dans le programme principal,
c’est la valeur de la variable globale pi définie en L2 qui est imprimée.
Informatique 37
4.3 Modules
Python comprend de très nombreux modules de fonctions qui peuvent être importés par la commande import.
L’instruction import math permet d’importer le module de fonctions mathématiques incluant par exemple la
fonction exponentielle. Celle-ci doit alors être appelée avec le préfixe math. : math.exp(x) ≡ ex . Cette syntaxe
reflète l’aspect orienté objet du langage Python.
1 import math
5 expx = 1.0
6 d = x
7 n = 1
8 while abs ( d / expx ) > prec :
9 expx = expx + d
10 n = n + 1
11 d = d * x/n
12 print ( f ’ { n :2 d } exp ({ x :8.5 e }) :{ expx :23.16 e } d ={ d :5.2 e } ’)
13 print ( f ’ Exact exp ({ x :8.5 e }) ={ math . exp ( x ) :23.16 e } ’)
Function/module.py
1 import math
2 print ( ’ Demonstration of some mathematical functions ’)
3 a = float ( input ( ’ please enter a real number a : ’) )
4 b = float ( input ( ’ please enter a real number b : ’) )
5 c = float ( input ( ’ please enter a real number c : ’) )
6 d = float ( input ( ’ please enter a real number d : ’) )
7 e = float ( input ( ’ please enter a real number e : ’) )
8 print ( ’ max ( ’ ,a , ’ , ’ ,b , ’ , ’ ,c , ’ , ’ ,d , ’ , ’ ,e , ’) = ’ , max (a ,b ,c ,d , e ) )
9 print ( ’ min ( ’ ,a , ’ , ’ ,b , ’ , ’ ,c , ’ , ’ ,d , ’ , ’ ,e , ’) = ’ , min (a ,b ,c ,d , e ) )
10 print ( ’ abs ( ’ ,a , ’) = ’ , abs ( a ) )
11 print ( ’ ceil ( ’ ,a , ’) = ’ , math . ceil ( a ) )
12 print ( ’ floor ( ’ ,a , ’) = ’ , math . floor ( a ) )
13 print ( ’ sqrt ( ’ ,a , ’) = ’ , math . sqrt ( a ) )
14 print ( ’ exp ( ’ ,a , ’) = ’ , math . exp ( a ) )
15 print ( ’ log ( ’ ,a , ’) = ’ , math . log ( a ) )
16 print ( ’ log10 ( ’ ,a , ’) = ’ , math . log10 ( a ) )
17 print ( ’ math . e = ’ , math . e )
18 pi = math . pi
19 print ( ’ math . pi = ’ , math . pi )
20 print ( ’ cos ( ’ ,pi , ’) = ’ , math . cos ( pi ) )
21 print ( ’ sin ( ’ ,pi , ’) = ’ , math . sin ( pi ) )
22 print ( ’ tan ( ’ ,pi , ’) = ’ , math . tan ( pi ) )
23 print ( ’ acos ( ’ ,0.0 , ’) = ’ , math . acos (0.0) )
24 print ( ’ asin ( ’ ,1.0 , ’) = ’ , math . asin (1.0) )
25 print ( ’ atan ( ’ ,1.0 , ’) = ’ , math . atan (1.0) )
26 print ( ’ atan2 ( ’ ,0.5 , ’ , ’ ,0.5 , ’) = ’ , math . atan2 (0.5 ,0.5) )
27 print ( ’ atan2 ( ’ , -0.5 , ’ , ’ , -0.5 , ’) = ’ , math . atan2 ( -0.5 , -0.5) )
Function/math fun.py
4.4 Fonction Lambda
Pour les fonctions élémentaires avec typiquement une seule ligne d’instruction, il est commode de définir une
fonction lambda
f = lambda x : instruction évaluant la valeur à retourner
1 cube = lambda x : x * x * x
2 print ( ’ cube (4.0) : ’ , cube (4.0) )
3 norm = lambda x , y : ( x * x + y * y ) **0.5
4 print ( ’ norm (3 ,4) : ’ , norm (3 ,4) )
5 print ( ’( lambda x :2* x ) (3) : ’ , ( lambda x :2* x ) (3) )
Function/lambda.py
— Une fonction lambda peut être utilisée n’importe où, là où une fonction est requise.
— On place entre lambda et : les variables et paramètres nécessaires pour évaluer la fonction lambda.
— Une fonction lambda ne peut contenir qu’une seule instruction, et pas de commande telle que print car
aucune valeur utile ne serait retournée.
Les fonctions lambda sont très utiles pour améliorer la lisibilité de codes où l’on manipule des fonctions ma-
thématiques courtes, comme démontré dans l’exemple suivant. On rappelle qu’une liste peuvent être définie en
compréhension à l’aide d’une fonction
1 def f ( x ) :
2 return x * x + 2* x + 1
3
4 X = [ x for x in range (6) ]

5 print ( X )
6 FX = [ f ( x ) for x in X ]
7 print ( FX )
Function/list function.py
L’équivalent avec une fonction lambda est tout simplement

1 X = [ x for x in range (6) ]
2 print ( X )
3 FX = [( lambda x : x * x +2* x +1) ( x ) for x in X ]
4 print ( FX )
Function/list lambda.py
Points de vigilance : en L3, les parenthèses autour de la fonction lambda sont obligatoires.
Informatique 39
4.5 Passage de paramètres aux fonctions

En Python, toutes les variables sont des objets. On peut les classer en deux catégories :
— immutables : les nombres, chaı̂nes de caractères, booléens, tuples, . . .. Lors d’une réaffectation, par exemple
x=2, test = ’true’, l’ancienne variable est détruite et remplacée par une autre. Contrairement aux variables
mutables, elles sont transmises par valeur (call-by-value).
— mutables : les objets tels que list, dictionary, . . .. Elles peuvent être modifiées à l’aide de fonctions func-
tion que l’on fait agir sur un objet object avec la syntaxe object.function(parameters) où parameters
est la liste des paramètres éventuels. Contrairement aux variables immutables, elles sont transmises par ré-
férence (call-by-object-reference, également connu comme call-by-reference et call-by-sharing).
Modifier une variable immutable à l’intérieur d’une fonction n’a aucun effet sur sa valeur dans la fonction d’appel :
en effet, lors de la modification, la nouvelle valeur est affectée à une nouvelle variable qui devient inaccessible
lorsqu’on quitte la fonction. Ceci est clairement illustré dans l’exemple suivant, où l’on imprime également les
adresses des variables, dans la fonction d’appel et dans la fonction appelée add1. Le changement d’adresse de x
dans add1 ne se répercute pas dans la fonction d’appel.
1 def add1 ( x ) :
2 print ( ’ From function add1 : x = ’ ,x , ’ id ( x ) = ’ , id ( x ) )
3 x = x +1
4 print ( ’ From function add1 : x = ’ ,x , ’ id ( x ) = ’ , id ( x ) )
5 x = int ( input ( ’ Enter an integer : ’) )
6 print ( ’x = ’ ,x , ’ id ( x ) = ’ , id ( x ) )
7 add1 ( x )
8 print ( ’x = ’ ,x , ’ id ( x ) = ’ , id ( x ) )
Function/fun immutable.py
Il est cependant possible de modifier une variable mutable à l’intérieur d’une fonction, avec prise en compte de la
modification dans la fonction d’appel. Ceci est illustré dans le code suivant où l’on modifie un élément d’une liste
x à l’aide de la fonction add. Le changement d’adresse de x dans add1 se répercute dans la fonction d’appel.
1 def add (x ,i , n ) :
2 print ( ’ From add : x [ ’ ,i , ’ ]= ’ ,x [ i ] , ’ id ( x [ ’ ,i , ’ ]) = ’ , id ( x [ i ]) )
3 x [ i ]= x [ i ]+ n
4 print ( ’ From add : x [ ’ ,i , ’ ]= ’ ,x [ i ] , ’ id ( x [ ’ ,i , ’ ]) = ’ , id ( x [ i ]) )
5 x =[ x for x in range (10) ]
6 print ( ’ Before add x : ’ ,x )
7 i =3
8 n =100
9 add (x ,i , n )
10 print ( ’ After add x : ’ ,x )
Function/fun mutable.py
Le transfert de paramètres immutables à une fonction se fait par valeur comme en C et C++ où on passe plus
précisément une copie de la valeur. Celui de paramètres mutables se fait par référence comme en Fortran, ainsi
qu’en C et C++ dans le cas où on passe le pointeur vers la variable au lieu de la copie. Plus brièvement, on dit qu’en
Python, le transfert de paramètres à une fonction se fait par affectation.
Chapitre 5
Initiation à Numpy, Matplotlib et Scipy
Python doit sa popularité à l’existence de nombreux packages (paquets, extensions, bibliothèques) comprenant des
objets et des méthodes associées pour le développement rapide de scripts. Ce chapitre est consacré à la présentation
de trois packages essentiels pour le calcul scientifique :
1. Numpy pour la création et manipulation aisée de vecteurs et matrices,
2. Matplotlib pour la visualisation graphique
3. Scipy, une collection de codes Open Source pour le calcul scientifique.
En sciences, de grandes quantités de données sont générées et manipulées, typiquement lors de la résolution d’équa-
tions aux dérivées partielles comme en météorologie, climatologie, imagerie médicale, astrophysique, etc. Vu la
masse des données disponibles, leur analyse ainsi que leur visualisation pour en extraire les informations les plus
pertinentes sont des enjeux de plus en plus importants. Python est un outil actuellement très en vogue dans la
communauté des data scientists comme on peut l’apprécier par la puissance et la variété des outils disponibles
en intelligence artificielle et Machine Learning.
Les données scientifiques en masse sont toujours des nombres de même type, habituellement réels double précision,
parfois complexes (traitement du signal, physique quantique, . . .). Les entiers sont plutôt limités aux indices de
tableaux, nombres quantiques, . . .
Les ordinateurs peuvent réaliser des calculs à très grande vitesse grâce à la vectorisation des opérations basée
sur la manipulation de vecteurs et de matrices d’éléments de type homogène. En Python, ces structures portent le
nom de Nd-array, intégrées de manière native dans Numpy, Matplotlib et Scipy.
Il est important de distinguer les Nd-array des list. Un objet de type list est une suite d’objets de types a
priori différents, dont le nombre et l’ordre peuvent être modifiés en cours de calcul. Il nécessite la mise en oeuvre
d’opérations informatiques sophistiquées mais inefficaces en calcul scientifique intensif.
L’utilisation des list doit donc être strictement limitée à ce à quoi ils sont destinés : des suites relativement
courtes d’objets hétérogènes ou dont le nombre ne peut intrinsèquement pas être estimé d’avance, par exemple
des données alpha-numériques, des étiquettes d’objets, . . .
40
Informatique 41
5.1 Introduction
1 import numpy as np
2 import matplotlib . pyplot as plt
3 x = np . linspace (0. ,1. ,11)
4 print ( x )
5 print ( type ( x ) )
6 plt . plot (x , x *x , ’ -o ’)
7 plt . show ()
Numpy/linspace.py
Analyse du script
L1. Importation de Numpy. Tous ses objets et méthodes doivent être invoqués avec le préfixe np.
L2. Importation de matplotlib.pyplot. Tous ses objets et méthodes doivent être invoqués avec le préfixe plt.
L3. Création du vecteur x de 11 réels régulièrement espacés de 0 à 1.
L4. Affichage de x :
[ 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
Notez ici l’absence de virgule entre les éléments du vecteur x. Un vecteur n’est pas une liste !
L5. Impression du type de x, ici numpy.ndarray.
L6. Création du graphique (x, x2 ) : calcul en une seule opération (opération vectorielle) du carré de toutes les
composantes du vecteur x.
L7. Affichage du graphique.
1.0
0.8
0.6
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0
Figure 5.1 – Résultat de linspace.py
Un ndarray est un tableau d’éléments homogènes à N -dimensions

N = 1 : vecteur ; N = 2 : matrice ; N = 3 : tableau 3-D ; etc . . .
1 ’’’
2 Plot cosinus and sinus
3 ’’’
6 print ( np . pi )
7 x = np . linspace (0.0 ,2.0* np . pi ,360)
8 ys = np . sin ( x )
9 yc = np . cos ( x )
10 print ( ’ type ( x ) : ’ , type ( x ) , ’ type ( ys ) : ’ , type ( ys ) , ’ type ( yc ) : ’ , type ( yc ) )
11 plt . plot (x , ys )
12 plt . plot (x , yc )
13 plt . show ()
14 plt . plot ( yc , ys )
15 plt . show ()
Numpy/trigo.py
Analyse du script
L6. Impression de la variable pi, de valeur π.
L7. Création d’une numpy.ndarray x de 360 réels régulièrement espacés de 0 à 2π.
L8–9. Calcul en une seule opération (opération vectorielle) de sin x (resp. cos x) pour toutes les valeurs de x
du numpy.ndarray x et stockage dans le numpy.ndarray ys (resp. yc).
L10 Vérification du type numpy.ndarray des variables x, ys et yc
L11–12. Création des courbes (x, sin x) et (x, cos x).
L14. Création de la courbe (cos x, sin x).
1.00 1.00
0.75 0.75
0.50 0.50
0.25 0.25
0.00 0.00
0.25 0.25
0.50 0.50
0.75 0.75
1.00 1.00
0 1 2 3 4 5 6 1.0 0.5 0.0 0.5 1.0
Figure 5.2 – Plots 1 et 2 de trigo.py
Calcul en une seule opération (opération vectorielle) des fonctions sin et cos pour toutes les composantes
du vecteur x.
Si x est un numpy.ndarray, np.sin(x) et np.cos(x) sont aussi des numpy.ndarrays, de même taille.
L’utilisation de Numpy dispense d’itérer explicitement sur les éléments du vecteur.
Il ne faut pas confondre les fonctions np.cos et np.sin avec les fonctions math.cos et math.sin qui ne
peuvent agir que sur un scalaire à la fois.
Informatique 43
5.2 Matplotlib
5.2.1 Titre, légendes et limites des axes
3 x = np . linspace (0. ,2. ,101)
4 plt . plot (x , np . exp ( - x ) * np . sin (10* x ) )
5 plt . title ( ’f ( x ) = exp ( - x ) sin (10 x ) ’)
6 plt . xlabel ( ’x ’)
7 plt . ylabel ( ’f ( x ) ’)
8 plt . xlim (0.0 ,2.0)
9 plt . ylim ( -1.0 ,1.0)
10 plt . show ()
Numpy/title.py
Analyse du script
L3. Création d’un vecteur x de 101 réels régulièrement espacés de 0 à 2.
L4. Création du graphique (x, e−x sin(10x)).
L5. Définition du titre.
L6. Définition de la légende de l’axe des abscisses.
L7. Définition de la légende de l’axe des ordonnées.
L8. Définition des limites de l’axe des abscisses.
L9. Définition des limites de l’axe des ordonnées.
f(x)=exp(-x) sin(10x)
1.00
0.75
0.50
0.25
0.00
f(x)
0.25
0.50
0.75
1.00
0.00 0.25 0.50 0.75 1.00 1.25 1.50 1.75 2.00
x
Figure 5.3 – Résultat de title.py

5.2.2 Traits, marqueurs et légendes de courbes
1 """
2 Color code : default = blue
3 ’b ’= blue , ’ g ’= green , ’ r ’= red , ’ c ’= cyan , ’ m ’= magenta , ’ y ’= yellow , ’ k ’= black , ’ w ’= white
4 Line style :
5 ’ - ’= solid line , ’ - - ’= dashed line , ’ -. ’= dash - dot line , ’: ’= dotted line
6 Marker code :
7 ’o ’= circle marker , ’ v ’= triangle down marker
8 More style and color codes at
9 https :// matplotlib . org / stable / api / markers_api . html
10 """
13 x = np . linspace (0. ,10. ,11)
14 y=x*x
15 plt . plot (x ,y , ’m - -* ’ , label = ’x * x ’)
16 y =100* np . exp ( -0.1* x )
17 plt . plot (x ,y , ’b - o ’ , label = ’ 100 exp ( - x /100) ’)
18 plt . legend ()
19 plt . show ()
Numpy/label.py
Analyse du script
L15. Plot de la courbe 1 avec légende.
L17. Plot de la courbe 2 avec légende.
L18. Création des légendes.
100
80
60
40
20
x*x
0 100 exp(-x/100)
0 2 4 6 8 10
Figure 5.4 – Résultat de label.py
Pour la description des paramètres possibles de matplotlib.pyplot.legend :

https://matplotlib.org/stable/users/explain/axes/legend_guide.html
Informatique 45
5.3 Ndarray à une dimension
5.3.1 np.empty, np.zeros, np.ones
La création de simples vecteurs comprenant n éléments est illustrée dans l’exemple suivant.
2 A = np . empty (3)
3 print ( ’A np . empty (3) : ’ ,A )
4 A = np . zeros (4)
5 print ( ’A np . zeros (5) : ’ ,A )
6 B = np . ones (5)
7 print ( ’B np . ones (5) : ’ ,B )
8 C = np . pi * np . ones (5)
9 print ( ’C np . pi * np . ones (5) : ’ ,C )
10 print ( ’ np . cos ( C ) : ’ , np . cos ( C ) )
11 print ( ’ np . sin ( C /2) : ’ , np . sin ( C /2) )
12 print ( ’ 2* B + C : ’ ,2* B + C )
Numpy/np empty zeros ones.py
Analyse du script
L2. Création du vecteur A de 3 éléments dont les valeurs ne sont pas initialisées. Les valeurs effectives peuvent
varier.
L4. Création du vecteur A de 4 éléments nuls.
L6. Création du vecteur B de 5 éléments égaux à 1.
L8. Création du vecteur C de 5 éléments égaux à π.
L10. Impression du vecteur des cosinus des éléments de C : cos π = −1.
L11. Impression du vecteur des sinus des éléments de C divisés par 2 : sin π/2 = 1.
L12. Impression du vecteur de 5 éléments 2 + /pi.
Remarque importante :
L’utilisation de ndarray dispense des boucles pour réaliser des opérations sur les composants.
Ceci démontre la supériorité des ndarray sur les list.
5.3.2 np.array
La création de vecteurs comprenant des éléments spécifiques se fait avec la fonction np.array.
2
3 v = np . array ([0 ,1 ,2])

4 print ( " np . array with integers :\ n " ,v )
5
6 v = np . array ([0 ,1 ,2] , dtype = float )

7 print ( " np . array with dtype = float :\ n " ,v )
8
9 v = np . array ([ np . pi , np . e ])
10 print ( " np . array with pi and e :\ n " ,v )
11
12 for x in v :
13 print ( x )
Numpy/np array.py
Analyse du script
L3 Création du vecteur v comprenant les entiers 0, 1 et 2.
L6 Création du vecteur v comprenant les réels 0.0, 1.0 et 2.0.
L12–13 Remarque importante :
Un ndarray est un objet itérable, c-à-d une suite d’éléments accessibles successivement.
On peut ainsi l’utiliser pour définir une boucle for sur ses éléments.
5.3.3 np.arange
La fonction np.arange(a,b,x) permet de créer un vecteur d’éléments régulièrement espacés de x dans l’intervalle
semi-ouvert [a,b[. Pour des arguments entiers, il est similaire à range mais retourne un ndarray.
2
3 v = np . arange (1 ,11 ,2)

4 print ( " np . arange (1 ,11 ,2) : " ,v )
5
6 v = np . arange (1 ,12 ,2)

7 print ( " np . arange (1 ,12 ,2) : " ,v )
8
9 v = np . arange (0.0 ,1.0 ,0.25)

10 print ( " np . arange (0.0 ,1.0 ,0.25) : " ,v )
Numpy/np arange.py
Analyse du script
L3–4 Création d’un ndarray d’entiers de 1 à 9 par pas de 2. La valeur 11 est exclue du ndarray.
L6–7 Création d’un ndarray d’entiers de 1 à 11 par pas de 2. La valeur 11 est incluse dans le ndarray car elle
est plus petite que la borne supérieure 12.
L9-10 Création d’un ndarray de float de 0.0 à 0.75 par pas de 0.25. La valeur de la borne supérieure, 1.0, est
exclue du ndarray.
Informatique 47
5.3.4 Adresse et copie de nd-array
Comme pour les listes ordinaires, il faut faire attention lorsque l’on veut faire des copies de nd.arrays. Pour conser-
ver une copie indépendante d’un vecteur, il faut utiliser la méthode numpy.copy, comme illustré dans l’exemple
suivante.
3 x = np . linspace (0. ,1. ,11)
4 print ( ’x = ’ ,x )
5 print ( ’ type ( x ) ’ , type ( x ) )
6 y=x # Shallow copy : any change in a element of x is mirrowed in y
7 print ( ’y = x ’)
8 print ( ’y = ’ ,y )
9 print ( ’ type ( y ) ’ , type ( y ) )
10 print ( ’ id ( x ) = ’ , id ( x ) , ’ id ( y ) = ’ , id ( y ) )
11
12 print ( ’\ n ’)
13 x [0]=33.0
14 print ( ’ After x [0]=33.0 ’)
15 print ( ’x = ’ ,x )
16 print ( ’y = ’ ,y )
17
18 print ( ’\ n ’)
19 y = np . copy ( x ) # Deep copy : x and y refer to different objects
20 print ( ’y = np . copy ( x ) : ’)
21 print ( ’y = ’ ,y )
22 print ( ’ id ( x ) = ’ , id ( x ) , ’ id ( y ) = ’ , id ( y ) )
23 x [0]=42.0
24 print ( ’ After x [0]=42.0 ’)
25 print ( ’x = ’ ,x )
26 print ( ’y = ’ ,y )
27
28 print ( ’\ n ’)
29 print ( ’ id ( x ) = ’ , id ( x ) )
30 x = x +5.0 # The values of x +5.0 are in a new object x
31 print ( ’ After x = x +5.0: ’)
32 print ( ’ id ( x ) = ’ , id ( x ) )
33 print ( ’x = ’ ,x )
34 print ( ’y = ’ ,y )
Numpy/array copy.py
x= [ 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]

type(x) <class ’numpy.ndarray’>
y=x
y= [ 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
type(y) <class ’numpy.ndarray’>
id(x) = 139730957160496 id(y)= 139730957160496
After x[0]=33.0
x= [ 33. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
y= [ 33. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
y=np.copy(x):
y= [ 33. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
id(x) = 139730957160496 id(y)= 139730806797136
After x[0]=42.0
x= [ 42. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
y= [ 33. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
id(x)= 139730957160496
After x=x+5.0:
id(x)= 139730863130704
x= [ 47. 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 6. ]
y= [ 33. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
Informatique 49
5.4 Ajustement de courbes par moindres carrés
5.4.1 Ajustement linéaire
2 import scipy . optimize as opt
4
5 def fitfun (x , a , b ) :
6 return a * x + b
7
8 print ( " \ nFile expt1 . dat : " )

9 expt = np . loadtxt ( ’ expt1 . dat ’)
10 x = expt [: ,0]
11 y = expt [: ,1]
12
13 popt , pcov = opt . curve_fit ( fitfun ,x , y )

14 print ( " a = {0} \ t b = {1} " . format ( popt [0] , popt [1]) )
15
16 xplot = np . linspace ( x [0] , x [ -1] ,2* len ( x ) )

17 fplot = fitfun ( xplot , popt [0] , popt [1])
18
19 plt . plot (x ,y , ’ bo ’)
20 plt . plot ( xplot , fplot , ’r - ’)
21 plt . show ()
22
23 def rsq (y , f ) :
24 ybar = np . mean ( y )
25 stot = sum (( y - ybar ) **2)
26 sres = sum (( y - f ) **2)
27 return (1.0 - sres / stot )
28
29 f = fitfun (x , popt [0] , popt [1])

30 print ( " R **2 = {0} " . format ( rsq (y , f ) ) )
Numpy/curve fit1.py
0.0 0.5 1.0 1.5 2.0 2.5 3.0
Figure 5.5 – Plot de curve fit1.py

Analyse du script
L2. Importation du package d’optimisation.
L5–6. Fonction d’ajustement linéaire ax + b.
L9 Lecture des données du fichier exp1.dat
L10-11 La première colonne de expt correspond aux valeurs des abscisses x, la seconde aux valeurs des ordonnées
y.
L13. Appel de la méthode de fit par moindres carrés opt.curve_fit. Elle retourne le ndarray popt contenant
les paramètres de la fonction de fit (ici a et b de fitfun) ainsi que la matrice pcov de covariance de popt,
dont les éléments diagonaux correspondent à l’estimation des variances des paramètres de fit.
Pour une documentation complète,
cf https ://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve fit.html.
L14. Impression des coefficients a et b du fit linéaire.
L16. Définition du ndarray xplot des abscisses x deux fois plus dense que dans le ndarray x des données
initiales. x[-1] correspond à la dernière valeur du ndarray.
L17. Evaluation de la fonction ajustée sur l’ensemble des abscisses xplot.
L19. Plot du graphique des données initiales sous forme de points bleus.
L20. Plot du graphique du fit (courbe continue rouge).
L21. Affichage des courbes.
L23–27. Fonction de calcul du résidu de moindres carrés.
L29. Evaluation de la fonction de fit pour l’ensemble des données x.
L30. Calcul et impression du résidu de moindres carrés.
5.4.2 Ajustement non linéaire
L’exemple suivant montre l’ajustement de données à une somme de courbes trigonométrques.

2 import scipy . optimize as opt
4
5 def fitfun2 (x , a , b ) :
6 return a * np . sin ( x ) + b * np . cos ( x )
7
8 print ( " \ nFile expt2 . dat : " )

9 expt = np . loadtxt ( ’ expt2 . dat ’)
10 x = expt [: ,0]
11 y = expt [: ,1]
12
13 popt , pcov = opt . curve_fit ( fitfun2 ,x , y )

14 print ( " a = {0} \ t b = {1} " . format ( popt [0] , popt [1]) )
15
16 xplot = np . linspace ( x [0] , x [ -1] ,2* len ( x ) )

17 fplot = fitfun2 ( xplot , popt [0] , popt [1])
18 plt . plot (x ,y , ’ bo ’)
19 plt . plot ( xplot , fplot , ’r - ’)
20 plt . show ()
Numpy/curve fit2.py
Informatique 51
Analyse du script
L5–6. Fonction d’ajustement non-linéaire a sin(x) + b cos(x).
Pour les autres lignes, se référer au code curve_fit1.py.
1.5
1.0
0.5
0.0
0.5
1.0
3 2 1 0 1 2 3
Figure 5.6 – Plot de curve fit2.py

Annexe A
Références
1. Brève introduction : https ://fr.wikipedia.org/wiki/Python (langage)/

2. Python Software Foundation : https ://www.python.org/
3. Ressources pour apprendre Python : http ://www.diveintopython3.net/
4. Catalogues de formations en ligne :
— https ://python.developpez.com/cours
— http ://www.france-ioi.org/algo/chapters.php
— https ://wiki.python.org/moin/BeginnersGuide
52

Document Python de Rema de Rennes 1

Transféré par

Droits d'auteur :

Formats disponibles

Document Python de Rema de Rennes 1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Document Python de Rema de Rennes 1

Transféré par

Droits d'auteur :

Formats disponibles

Licence 1 PCSTM 2023–2024

Mariko Dunseath Terao

1 Représentation des nombres 1

3 List, Tuple, Range, Dictionary 24

5 Initiation à Numpy, Matplotlib et Scipy 40

Représentation des nombres

1.1 Principe de base

1.2 Représentation des nombres naturels

14092 = 0 × 10n−1 + 0 × 10n−2 + . . . + 1 × 104 + 4 × 103 + 0 × 102 + 9 × 101 + 2 × 100 .

D’une manière générale, on a donc

i = sn−1 10n−1 + sn−2 10n−2 + . . . + s2 102 + s1 101 + s0 100

i = sn−1 2n−1 + sn−2 2n−2 + . . . + s2 22 + s1 21 + s0 20

avec seulement 2 différentes valeurs possibles pour les chiffres : sk = 0, 1.

Noms Symbole Valeur

Table 1.1 – Noms des nombres en informatique.

1.3 Représentation des réels

Exposant à 8-bits → −128 ≤ e ≤ 127 (27 = 128)

La limite supérieure correspond à

où on a utilisé la valeur de la progression géométrique

Le plus grand nombre représentable est donc

Le plus petit nombre non nul représentable est

1.5 Erreurs numériques

Les erreurs peuvent être classifiées en 3 types :

• évaluation d’une intégrale définie par quadrature

e0.3333 − e1/3 = e0.3333 (1 − e0.00003333... ) ≃ −0.0000465196

• On calcule ex par la séries

1 + 0.3333 + 0.0555 + 0.0062 + 0.0005 = 1.3955

• Si on fait le calcul à 10 décimales, on obtient le résultat 1.3955296304.

Ce chapitre ne requiert aucune connaissance préalable du langage Python.

6. Le cas échéant, entrez les données demandées à l’écran.

7. La meilleure méthode pour apprendre et maı̂triser un langage de programmation est de le pratiquer. Il ne

Code couleurs des listings

L7. La fonction float convertit x en un réel et le stocke dans la variable x.

L1. On affecte à la variable x l’entier 2024.

L5. On affecte à la variable x le nombre imaginaire i, noté 1j.

L6. x est de la classe complex.

L9. Le nombre complexe 1.5 − 2.3i s’écrit 1.5-2.3j.

2.5 Type booléen

égal == plus grand que > plus grand ou égal >=

Les opérations de comparaison peuvent être combinées avec

et and vrai si les deux opérands sont vrais, sinon faux

Des exemples d’application sont présentés dans le code comp.py.

2.6 Types de données combinés

L2. data est un objet de la classe list.

L4. data est un objet de la classe tuple.

L5. On affecte à data un objet de la classe range comportant 5 éléments.

L6. data contient les 5 entiers de 0 à 4.

L8. data est un objet de la classe dict.

2.7.1 For x in range

1 print ( ’ Calculate sum of first m natural numbers ’)

L2. On demande m et on convertit la chaı̂ne de caractères en un entier.

L3. On initialise la variable sum à 0.

L6. On imprime la valeur de i ainsi que la valeur de la somme partielle correspondante.

Exemple de résultat d’exécution :

Sum of first 4 natural numbers = 6

1 print ( ’ Calculate product of integers from 1 to m ’)

Exemple de résultat d’exécution :

1 print ( ’ Calculate sum of first m even natural numbers ’)

Exemple de résultat d’exécution :

2.7.3 For break