Cours de Programmation Scientifique avec python

Licence Fondamentale de physique

2021-2022

Par
Tamba KOLANI
Master Génie Logiciel
koltemb@gmail.com
A l’origine de toute erreur attribuée à l’ordinateur, vous
trouverez au moins deux humaines, la première
consistant à attribuer l’erreur à l’ordinateur
Sommaire
BASE DE PYTHON...........................................................................................................................1
Présentation des outils de programmation ........................................................................................1
Environnement Anaconda et quelques base de python .....................................................................1
Utilisation en mode interactif ..........................................................................................................1
Opération arithmétique ................................................................................................................1
Opérateur / ..................................................................................................................................2
Opérateur % ................................................................................................................................2
Affectation ..................................................................................................................................2
Affichage - la fonction print() ......................................................................................................2
La fonction range() et list() ..........................................................................................................3
Accès aux éléments d’une liste ........................................................................................................4
La fonction len() .........................................................................................................................4
Lecture d’informations au clavier - la fonction input() .....................................................................5
Règles générales d’écriture..............................................................................................................5
Les identificateurs .......................................................................................................................5
Les mots-clés ..............................................................................................................................5
Les différentes sortes d’instruction ..............................................................................................5
TESTS : LES INSTRUCTIONS CONDITIONNELLES .....................................................................6
Bloc d’instructions - Indentation .....................................................................................................6
Instruction if ...................................................................................................................................6
Instruction if … else........................................................................................................................6
BOUCLES..........................................................................................................................................8
Boucles bornées et non bornées .......................................................................................................8
Boucle while ...............................................................................................................................9
Les instructions break et continue, et la clause else dans les boucles ................................................9
L’instruction break ......................................................................................................................9
L’instruction continue ............................................................................................................... 10
La clause else dans une boucle .................................................................................................. 11
LES PRINCIPAUX TYPES DE DONNEES ..................................................................................... 12
La fonction type() ......................................................................................................................... 12
Le type int (entier) ........................................................................................................................ 12
Le type float (flottant) ................................................................................................................... 12
Le type str (chaîne de caractères)................................................................................................... 12
Le type bool (booléen) .................................................................................................................. 13
Le type list (liste) .......................................................................................................................... 13
 Le type complex (complexe) ......................................................................................................... 13
TUPLES EN PYTHON .................................................................................................................... 15
Parcourir un tuple.......................................................................................................................... 16
Dictionnaires en Python ................................................................................................................ 17
Création d’un dictionnaire ......................................................................................................... 18
Parcourir un dictionnaire ........................................................................................................... 18
FONCTIONS EN PYTHON ............................................................................................................. 19
Définition d’une fonction - def ...................................................................................................... 19
Corps de la fonction ...................................................................................................................... 19
Fonction sans paramètre ................................................................................................................ 19
Fonction avec paramètre ............................................................................................................... 20
Fonction avec plusieurs paramètres ............................................................................................... 21
Variables locales, variables globales.............................................................................................. 21
Utilisation d’une variable globale - global ..................................................................................... 22
Fonctions et procédures ................................................................................................................. 23
Valeurs par défaut pour les paramètres ........................................................................................ 23
Arguments avec étiquettes ............................................................................................................. 23
Utilisation des fonctions dans un script .......................................................................................... 24
Modules et importations ................................................................................................................ 26
Notion de package ........................................................................................................................ 28
Découverte de la bibliothèque Numpy ............................................................................................... 30
Introduction .................................................................................................................................. 30
Variables prédéfinies..................................................................................................................... 30
Tableaux - numpy.array() .............................................................................................................. 30
Création .................................................................................................................................... 30
Affichage .................................................................................................................................. 30
Accès aux éléments d’un tableau ............................................................................................... 30
Tableau 2D ................................................................................................................................... 31
Affichage .................................................................................................................................. 31
Accès aux éléments d’un tableau 2D ......................................................................................... 31
La fonction numpy.arange() .......................................................................................................... 31
La fonction numpy.linspace() ........................................................................................................ 32
Action d’une fonction mathématique sur un tableau ...................................................................... 32
Fonctions mathématiques avec NumPy ......................................................................................... 33
Nombres aléatoires .................................................................................................................... 34
 BASE DE PYTHON

Présentation des outils de programmation

Dans cette introduction à Python pour la programmation scientifique, nous
utiliserons Python comme langage et les bibliothèques NumPy et Matplotlib pour
le calcul scientifique et la visualisation.
Les versions 2 et 3 du langage Python présentent des différences. Nous donnerons
par défaut des programmes adaptés pour les versions 3 et ultérieures. Néanmoins,
comme les versions 2.x de Python sont encore fréquemment utilisées dans le
domaine de la programmation scientifique, nous signalerons si possible quelques
spécificités de la version 2.
Pour exécuter les programmes de ce cours sur votre ordinateur, il vous faudra
disposer de Python et des bibliothèques NumPy et Matplotlib. Pour cela il faudra
installer le logiciel gratuit Anaconda qui offre une installation aisée de l’ensemble
de l’environnement de développement nécessaire. On peut aussi utiliser pycharm
ou tout autre environnement de développement intégré supportant le langage
python

Environnement Anaconda et quelques base de python

L’interface d’Anaconda présente différents environnement qui permettent
d’exécuter python. Dans le cadre de notre cours nous utiliserons soit Jupyter
Notebook ou Spyder.

Utilisation en mode interactif

Opération arithmétique
Dans Spyder, on dispose d’une zone de fenêtre pour l’interpréteur de commandes
IPython. Son invite de commande est différente de celle de l’interpréteur Python
standard (qui est >>>).
Exemple (Ouvrir Sypder faire ceci dans la console IPython)
In [1]: 3 * 4
Out[1]: 12

In [2]: 5 + 2
Out[2]: 7

Page | 1
Exemple2
4 + 5
3 - 7 # les espaces sont optionnels
5 + 2 * 3 # la priorité des opérations mathématiques est-elle respectée
?
(6 + 3) * 2

Opérateur /
L’opérateur / ne donne pas les mêmes résultats suivant les versions de Python. En
Python 2, il réalise par défaut une division euclidienne, aussi appelée division
entière (c’est-à-dire une division dont le résultat est un entier). En Python 3, il
réalise une division décimale standard comme sur une calculatrice
7 / 2
3.5

Pour réaliser une division entière, il faut utiliser //

7 // 2
3

Opérateur %
L’opérateur % (appelé opérateur modulo) fournit le reste de la division entière
d’un nombre par un autre.
7 % 2
1

Affectation
L’affectation consiste à attribuer une valeur à une variable
>>>a = 2
>>>a
2
>>>b = a + 3
>>>b
5

Affichage - la fonction print()

Pour afficher, on utilise la fonction print().
>>>print("bonjour")

Page | 2
bonjour
>>>a = 5
>>>print(a)
5

Il est possible de réaliser plusieurs affichages à la suite. Pour cela, on sépare les
éléments par des virgules : c’est la concaténation.
>>>a = 5
>>>print("a vaut", a)
a vaut 5

Attention
En Python 2, on ne mettait pas de parenthèses.
 Python 2 : print "a vaut", a
 Python 3 : print("a vaut", a)
Pour ne pas aller à la ligne et continuer sur la même ligne lors du prochain print :
 Python 2 : print "a vaut", a,
 Python 3 : print("a vaut", a, end=" ")
Il est possible avec Python 2.7 d’utiliser la syntaxe de Python 3 pour la fonction
print grâce à l’instruction from __future__ import print_function.

La fonction range() et list()

Cette fonction permet de créer sur une suite d’entiers. En effet range(n) génère
une suite arithmétique de 0 à n-1. En Python 3, si on souhaite afficher les valeurs,
il est nécessaire de convertir le résultat en liste grâce à la fonction list().
>>>range(10)
range(0, 10)

>>>list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le nombre de fin qui lui est passé n’est jamais dans la liste générée. Par exemple,
range(10) génère 10 valeurs, exactement les indices des éléments d’une séquence
de longueur 10. Il est possible de faire commencer l’intervalle à un autre nombre,
ou de spécifier un incrément différent (même négatif)

Page | 3
>>>list(range(5, 10))
[5, 6, 7, 8, 9]
>>>list(range(0, 10, 3))
[0, 3, 6, 9]
>>>list(range(-10, -100, -30))
[-10, -40, -70]

De manière générale, on a :
range(valeur_initiale, borne_de_fin, pas)
Le pas peut être positif ou négatif. La valeur de la borne de fin (maximale ou
minimale) n’est jamais atteinte.
Exercice
Créer une liste contenant les entiers pairs allant de 10 à 20.

Accès aux éléments d’une liste

Pour accéder à un élément d’une liste, on indique entre crochets [] l’indice de
l’élément. Comme dans la plupart des langages, en python, l’indice du premier
élément d’une liste est 0.
>>>a = list(range(1,10,2))
>>>a
[1, 3, 5, 7, 9]
>>>a[0]
1
>>>a[2]
5

La fonction len()
La fonction len() renvoie le nombre d’éléments
>>>a = list(range(7,10))
>>>a
[7, 8, 9]
>>>len(a)
3

Page | 4
Lecture d’informations au clavier - la fonction input()
Par défaut, la fonction input() renvoie une chaîne de caractères. Il faut donc
utiliser la fonction int() qui permet d’obtenir un entier.
x = int(input("Donnez un entier : "))

Règles générales d’écriture

Les identificateurs
Un identificateur est une suite de caractères servant à désigner les différentes
entitées manipulées par un programme : variables, fonctions, classes…
En Python, un identificateur est formé de lettres ou de chiffres. Il ne contient pas
d’espace. Le premier caractère doit obligatoirement être une lettre. Il peut contenir
le caractère « _ » (underscore, en français « souligné »). Il est sensible à la casse
(distinction entre majuscule et minuscule).

Les mots-clés
Les mots réservés par le langage Python (if, for, etc.) ne peuvent pas être utilisés
comme identificateurs.

Les différentes sortes d’instruction

 les instructions simples,
 les instructions composées comme if ou for,
 les blocs d’instructions

Page | 5
 TESTS : LES INSTRUCTIONS CONDITIONNELLES

L’instruction if est la structure de test la plus simple. Sa syntaxe en Python fait

intervenir la notion de bloc.

Bloc d’instructions - Indentation

Un bloc est défini par une indentation obtenue en décalant le début des
instructions vers la droite grâce à des espaces en début de ligne (tabulation).
Toutes les instructions d’un même bloc doivent être indentées exactement au
même niveau (c’est-à-dire décalées à droite d’un même nombre d’espaces).
Un bloc peut contenir une ou plusieurs instructions, et notamment des instructions
composées (tests, boucles, etc.).
Instruction if
Syntaxe
if condition:
Instruction A
« condition » est une expression booléenne, c’est-à-dire une expression qui prend
pour valeur True (Vrai) ou False (Faux).
L’instruction A n’est exécutée que si la condition est vérifiée (c’est-à-dire si elle
prend pour valeur True).
L’instruction if est une instruction composée. Le : (deux-points) à la fin de la ligne
introduit le bloc d’instructions qui sera exécuté si la condition est vérifiée.
Exemple
x = int(input("Donnez un entier : "))
if x > 10:
print(x, "est plus grand que 10")
print("Fin")

Instruction if … else
Syntaxe
if condition:
Instruction A
else:
Instruction B

Page | 6
Ici si « condition » est vrai alors Instruction A sera exécutée sinon, c’est
instruction B
Exemple
x = int(input("Donnez un entier : "))
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
print("Fin")

Remarque
Une expression booléenne peut contenir les opérateurs de comparaison ou
logiques
Opérateur Signification
x == y x est égal à y
x != y x est différent de y
x>y x est plus grand que y
x<y x est plus petit que y
x >= y x est plus grand ou égal à y
x <= y x est plus petit ou égal à y
and ET
or OU

Exemple
>>>3 < 4
True
>>>3 > 4
False
>>>2 < 3 and 3 < 4
True
>>>2 < 3 and 3 > 4
False

Page | 7
 BOUCLES

Les boucles s’utilisent pour répéter plusieurs fois l’exécution d’une partie du
programme.
Boucles bornées et non bornées
Boucle bornée
Quand on sait combien de fois doit avoir lieu la répétition, on utilise généralement
la boucle for.
Boucle non bornée
Si on ne connait pas à l’avance le nombre de répétitions, on choisit une boucle
while.
Exemple d’une boucle for
for i in [0, 1, 2, 3]:
print("i a pour valeur", i)
L’instruction for est une instruction composée, c’est-à-dire une instruction dont
l’en-tête se termine par deux points (:), suivie d’un bloc indenté qui constitue le
corps de la boucle.
On dit que l’on réalise une itération de la boucle à chaque fois que le corps de la
boucle est exécuté.
Dans l’en-tête de la boucle, on précise après le mot-clé for le nom d’une variable
(i dans l’exemple ci-dessus) qui prendra successivement toutes les valeurs qui sont
données après le mot-clé in. On dit souvent que cette variable (ici i) est un
compteur car elle sert à numéroter les itérations de la boucle.
Il est possible d’obtenir le même résultat sans donner la liste des valeurs, mais en
utilisant la fonction range().
for i in range(4):
print("i a pour valeur", i)

Pour parcourir les indices d’une liste, il est possible de combiner range() et len()
comme ci-dessous :
c = ["Marc", "est", "dans", "le", "jardin"]
for i in range(len(c)):
print("i vaut", i, "et c[i] vaut", c[i])

Affichage après exécution :

Page | 8
i vaut 0 et c[i] vaut Marc
i vaut 1 et c[i] vaut est
i vaut 2 et c[i] vaut dans
i vaut 3 et c[i] vaut le
i vaut 4 et c[i] vaut jardin

Rappel : La fonction len() renvoie le nombre d’éléments

>>>c = ["Marc", "est", "dans", "le", "jardin"]
>>>len(c)
5

Boucle while
Syntaxe
while condition:
Instruction A

Le mot-clé while signifie tant que en anglais. Le corps de la boucle (c’est-à-dire

le bloc d’instructions indentées) sera répété tant que la condition est vraie.

Remarque : Si la condition est fausse au départ, le corps de la boucle n’est jamais

exécuté. Si la condition reste toujours vraie, alors le corps de la boucle est répété
indéfiniment.

x = 1
while x < 10:
print("x a pour valeur", x)
x = x * 2
print("Fin")

En général, si on connaît avant de démarrer la boucle le nombre d’itérations à

exécuter, on choisit une boucle for. Au contraire, si la décision d’arrêter la boucle
ne peut se faire que par un test, on choisit une boucle while.

Les instructions break et continue, et la clause else dans les boucles

L’instruction break
L’instruction break permet de « casser » l’exécution d’une boucle (while ou for).
Elle fait sortir de la boucle et passer à l’instruction suivante.

for i in range(10):
print("debut iteration", i)
print("bonjour")
if i == 2:
break
print("fin iteration", i)

Page | 9
print("apres la boucle")

Affichage après exécution

debut iteration 0
bonjour
fin iteration 0
debut iteration 1
bonjour
fin iteration 1
debut iteration 2
bonjour
apres la boucle

Remarque
Dans le cas de boucles imbriquées, l’instruction break ne fait sortir que de la
boucle la plus interne.
Dans de nombreux langages, il existe une instruction do…while qui permet de
créer une boucle pour laquelle on ne connaît pas à l’avance le nombre de
répétition, mais qui doit s’exécuter au moins une fois. Cette instruction n’existe
pas en Python, mais on peut facilement reproduire son fonctionnement de la façon
suivante :

while True:
n = int(input("donnez un entier > 0 : "))
print("vous avez fourni", n)
if n > 0:
break
print("reponse correcte")

L’instruction continue
L’instruction continue permet de passer prématurément au tour de boucle suivant.
Elle fait continuer sur la prochaine itération de la boucle.

for i in range(4):
print("debut iteration", i)
print("bonjour")
if i < 2:
continue
print("fin iteration", i)
print("apres la boucle")

Affichage après exécution

debut iteration 0
bonjour
debut iteration 1

Page | 10
bonjour
debut iteration 2
bonjour
fin iteration 2
debut iteration 3
bonjour
fin iteration 3
apres la boucle

La clause else dans une boucle

La clause else dans une boucle permet de définir un bloc d’instructions qui sera
exécuté à la fin seulement si la boucle s’est déroulée complétement sans être
interrompue par un break.
Contrairement aux instructions présentes après la boucle, qui s’exécutent dans
tous les cas (avec ou sans interruption par un break), le bloc d’instructions défini
dans la clause else ne s’exécutera pas lors de l’interruption par un break. Après
l’interruption, on passera directement aux instructions après la boucle.
Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se termine
par épuisement de la liste (avec for) ou quand la condition devient fausse (avec
while), mais pas quand la boucle est interrompue par un break. Ceci est illustré
dans la boucle suivante, qui recherche des nombres premiers.

for n in range(2, 8):

for x in range(2, n):
if n % x == 0:
print(n, "egale", x, "*", n/x)
break
else:
print(n, "est un nombre premier")

Affichage après exécution

2 est un nombre premier

3 est un nombre premier
4 egale 2 * 2.0
5 est un nombre premier
6 egale 2 * 3.0
7 est un nombre premier

Page | 11
 LES PRINCIPAUX TYPES DE DONNEES

Comme PHP, Python est un langage à typage dynamique, ce qui signifie qu’il
n’est pas nécessaire de déclarer les variables avant de pouvoir leur affecter une
valeur. La valeur que l’on affecte possède un type qui dépend de la nature des
données (nombre entier, nombre à virgule, chaîne de caractères, etc). Le type du
contenu d’une variable peut donc changer si on change sa valeur.

La fonction type()
Pour connaître le type d’une donnée ou le type de la valeur d’une variable, il suffit
d’utiliser la fonction type().

Exemple
>>>type(15)
int
>>>a = 15
>>>type(a)
int
>>>a = "toto"
type(a)
str

Le type int (entier)

Ce type est utilisé pour stocker un entier, en anglais integer. Pour cette raison, on
appelle ce type int

Le type float (flottant)

Ce type est utilisé pour stocker des nombres à virgule flottante, désignés en
anglais par l’expression floating point numbers. Pour cette raison, on appelle ce
type : float. En français, on parle de flottant.

Exemple
>>>a = 14.5
>>>type(a)
float

Le type str (chaîne de caractères)

Sous Python, une donnée de type str est une suite quelconque de caractères
délimitée soit par des apostrophes (simple quotes), soit par des guillemets (double
quotes). str est l’abréviation de string, qui veut dire chaîne en français.

>>>a = 'Bonjour'
>>>type(a)

Page | 12
str
>>>b = "Bonsoir"
>>>type(b)
str

Le type bool (booléen)

Le type bool est utilisé pour les booléens. Un booléen peut prendre les valeurs
True ou False (vrai ou faux).

>>>a = True
>>>type(a)
bool
>>>b = not(a)
>>>b
False
Remarque : la fonction not est un opérateur logique qui renvoie l’opposé de la
valeur booléenne transmise. Pour True, on obtient False. Réciproquement, il
renvoie False quand on lui transmet True.

Le type list (liste)

Sous Python, on peut définir une liste comme une collection d’éléments séparés
par des virgules, l’ensemble étant enfermé dans des crochets.

>>>jour = ["lundi", "mardi", "mercredi", 1800, 20.357, "jeudi", "vendredi"]

>>>type(jour)
list
>>>jour
['lundi', 'mardi', 'mercredi', 1800, 20.356999999999999, 'jeudi', 'vendredi']

Le type complex (complexe)

Python possède par défaut un type pour manipuler les nombres complexes. La
partie imaginaire est indiquée grâce à la lettre « j » ou « J ». La lettre mathématique
utilisée habituellement, le « i », n’est pas utilisée en Python car la variable i est
souvent utilisée dans les boucles.

>>>a = 2 + 3j
>>>type(a)
complex
>>>a
(2+3j)

Remarque
Si la partie imaginaire vaut j simplement il faut écrire 1j. Cette oublie génère
souvent des erreurs de type : NameError: name 'j' is not defined

Page | 13
Page | 14
 TUPLES EN PYTHON
A partir des types de base (int, float, etc.), il est possible d’en élaborer de
nouveaux. On les appelle des types construits.
Un exemple de type construit est le « tuple ». Il permet de créer une collection
ordonnée de plusieurs éléments. En mathématiques, on parle de p-uplet. Par
exemple, un quadruplet est constitué de 4 éléments.
Les tuples ressemblent aux listes, mais on ne peut pas les modifier une fois qu’ils
ont été créés.
On dit qu’un tuple n’est pas mutable. On le définit avec des parenthèses.
Exemple
>>>a = (3, 4, 7)
>>>type(a)
<class 'tuple'>

Parfois, les tuples ne sont pas entourés de parenthèses, même s’il s’agit quand
même de tuples. Ainsi, on peut utiliser la notation suivante
>>>b, c = 5, 6
>>>b
5
>>>c
6

En fait, cela revient à faire

>>>(b, c) = (5, 6)

Cette syntaxe avec plusieurs variables à gauche du signe = peut aussi être utilisée
avec une variable unique à droite si celle-ci contient un tuple
>>>a = (3, 4)
>>>u, v = a
>u
3
>v
4

NB
Il est très facile de créer une fonction qui renvoie un tuple. Il suffit d’indiquer ce
tuple après return.

def test():
return 3, 4

On peut donc faire :

>>>a = test()
>>>a
(3, 4)

Page | 15
>>>b, c = test()
>>>b
3
>>>c
4

Parcourir un tuple
Tout Comme une liste, il est possible de parcourir un tuple avec une boucle for.
>>>a = (3, 4)
for i in a:
print(i)

Résultat
3
4
La valeur d’un élément du tuple est obtenue en utilisant la même syntaxe que pour
une liste.
>>>a[0]
3
>>>a[1]
4

Pour créer un tuple contenant un seul élément, il faut donc utiliser une syntaxe
spécifique qui contient une virgule.
>>>b = (3,)
>>>b
(3,)
>>>type(b)
<class 'tuple'>

Si on veut récupérer l’unique valeur présente dans le tuple, on va pouvoir utiliser

les approches suivantes :

 Première approche
>>>c = b[0]
>>>c
3

 Deuxième approche
>>>d, = b
>>>d
3

La deuxième approche avec une virgule d, = b est plus légère que la syntaxe qui
utilise des crochets c = b[0].

Page | 16
Il est possible d’utiliser la syntaxe nom_de_variable, = aussi avec une liste à un
élément.
>>>u = [5]
>>>v, = u
>>>v
5

Dictionnaires en Python
Comme on l’a vu avec les listes et les tuples, à partir des types de base (int, float,
etc.) il est possible d’élaborer de nouveaux types qu’on appelle des types
construits.
Un nouvel exemple de type construit est le dictionnaire.

Les éléments d’une liste ou d’un tuple sont ordonnés et on accéde à un élément
grâce à sa position en utilisant un numéro qu’on appelle l’indice de l’élément.
Un dictionnaire en Python va aussi permettre de rassembler des éléments mais
ceux-ci seront identifiés par une clé. On peut faire l’analogie avec un dictionnaire
de français où on accède à une définition avec un mot.
Contrairement aux listes qui sont délimitées par des crochets, on utilise des
accolades pour les dictionnaires.
Exemple
mon_dictionnaire = {
"voiture": "véhicule à quatre roues",
"vélo": "véhicule à deux roues"
}

Un élément a été défini ci-dessus dans le dictionnaire en précisant une clé au

moyen d’une chaîne de caractères suivie de : puis de la valeur associée (clé:
valeur)
On accède à une valeur du dictionnaire en utilisant la clé entourée par des crochets
avec la syntaxe suivante
mon_dictionnaire["voiture"]

Résultat : 'véhicule à quatre roues'

Construire une entrée dans un dictionnaire

Pour construire une entrée dans un dictionnaire, il suffit d’affecter une valeur pour
chaque nouvelle clé. Avec l’exemple précédent,
>>>mon_dictionnaire["tricycle"] = "véhicule à trois roues"
>>>mon_dictionnaire
{
'voiture': 'véhicule à quatre roues',
'vélo': 'véhicule à deux roues',

Page | 17
 'tricycle': 'véhicule à trois roues'
}

Le type d’un dictionnaire est dict.

Création d’un dictionnaire

Nous avons vu ci-dessous qu’il était possible de créer un dictionnaire avec des
accolades qui entourent les éléments. Une autre approche possible consiste à créer
un dictionnaire vide et à ajouter les éléments au fur et à mesure.
>>>nombre_de_pneus = {}
>>>nombre_de_pneus["voiture"] = 4
>>>nombre_de_pneus["vélo"] = 2
>>>nombre_de_pneus
{'voiture': 4, 'vélo': 2}

Parcourir un dictionnaire
Pour parcourir un dictionnaire on va se servir de la fonction items() comme ceci :
>>>nombre_de_roues = {"voiture": 4, "vélo": 2, "tricycle": 3}
>>>for i in nombre_de_roues.items():
print(i)

('voiture', 4)
('vélo', 2)
('tricycle', 3)

On peut aussi utiliser la paire clé/valeur :

>>>nombre_de_roues = {"voiture": 4, "vélo": 2, "tricycle": 3}

>>>for cle, valeur in nombre_de_roues.items():
print("l'élément de clé", cle, "vaut", valeur)

l'élément de clé voiture vaut 4

l'élément de clé vélo vaut 2
l'élément de clé tricycle vaut 3

Page | 18
 FONCTIONS EN PYTHON

Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec
seulement des paramètres différents, on peut l’isoler au sein d’une fonction. Cette
approche est également intéressante si la personne qui définit la fonction est
différente de celle qui l’utilise. Par exemple, nous avons déjà utilisé la fonction
print(),input(), range(), len() qui sont des fonctions natives de python

Définition d’une fonction - def

Syntaxe
La syntaxe Python pour la définition d’une fonction est la suivante
def nom_fonction(liste de paramètres):
bloc d'instructions

On peut utiliser n’imorte quel nom pour la fonction, à l’exception des mots-clés
réservés du langage, et à la condition de n’utiliser aucun caractère spécial ou
accentué (le caractère souligné « _ » est permis). Comme c’est le cas pour les
noms de variables, on utilise par convention des minuscules, notamment au début
du nom (les noms commençant par une majuscule seront réservés aux classes).

Corps de la fonction
Comme les instructions if, for et while, l’instruction def est une instruction
composée. La ligne contenant cette instruction se termine obligatoirement par un
deux-points (:), qui introduisent un bloc d’instructions qui est précisé grâce à
l’indentation. Ce bloc d’instructions constitue le corps de la fonction.

Fonction sans paramètre

def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1

print("bonjour")
compteur3()
compteur3()

Nous venons de définir une fonction très simple qui compte jusqu’à 2. Notez bien
les parenthèses, les deux points, et l’indentation du bloc d’instructions qui suit la
ligne d’en-tête (c’est ce bloc d’instructions qui constitue le corps de la fonction
proprement dite).

Page | 19
Après la définition de la fonction, on trouve le programme principal qui débute
par l’instruction print("bonjour"). Il y a ensuite au sein du programme principal,
l’appel de la fonction grâce à compteur3().
Nous pouvons maintenant réutiliser cette fonction à plusieurs reprises, autant de
fois que nous le souhaitons.
Nous pouvons également l’incorporer dans la définition d’une autre fonction.

def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1

def double_compteur3():
compteur3()
compteur3()

print("bonjour")
double_compteur3()

Une première fonction peut donc appeler une deuxième fonction, qui elle-même
en appelle une troisième, etc.

Créer une nouvelle fonction offre l’opportunité de donner un nom à tout un

ensemble d’instructions. De cette manière, on peut simplifier le corps principal
d’un programme, en dissimulant un algorithme secondaire complexe sous une
commande unique, à laquelle on peut donner un nom explicite.
Une fonction est donc en quelque sorte une nouvelle instruction personnalisée,
qu’il est possible d’ajouter librement au programme.

Fonction avec paramètre

def compteur(stop):
i = 0
while i < stop:
print(i)
i = i + 1

a = 5
compteur(a)

Dans l’exemple ci-dessus, l’argument passé à la fonction compteur() est le

contenu de la variable a. A l’intérieur de la fonction, cet argument est affecté au
paramètre stop, qui est une tout autre variable.
Notez donc bien dès à présent que :

Page | 20
  Le nom d’une variable que nous passons comme argument n’a rien à voir
avec le nom du paramètre correspondant dans la fonction.
 Ces noms peuvent être identiques, mais il faut bien comprendre qu’ils ne
désignent pas la même chose (en dépit du fait qu’ils puissent contenir une
valeur identique).

Fonction avec plusieurs paramètres

La fonction suivante utilise trois paramètres : start qui contient la valeur de départ,
stop la borne supérieure exclue et step le pas du compteur.

def compteur_complet(start, stop, step):

i = start
while i < stop:
print(i)
i = i + step

compteur_complet(1, 7, 2)

Affichage après exécution donne :

1
3
5

Ainsi :
 Pour définir une fonction avec plusieurs paramètres, il suffit d’inclure ceux-
ci entre les parenthèses qui suivent le nom de la fonction, en les séparant à
l’aide de virgules.
 Lors de l’appel de la fonction, les arguments utilisés doivent être fournis
dans le même ordre que celui des paramètres correspondants (en les
séparant eux aussi à l’aide de virgules). Le premier argument sera affecté
au premier paramètre, le second argument sera affecté au second paramètre,
et ainsi de suite.

Variables locales, variables globales

Lorsqu’une fonction est appelée, Python réserve pour elle (dans la mémoire de
l’ordinateur) un espace de noms. Cet espace de noms local à la fonction est à
distinguer de l’espace de noms global où se trouvent les variables du programme
principal. Dans l’espace de noms local, nous avons des variables qui ne sont
accessibles qu’au sein de la fonction. C’est par exemple le cas des variables
« start », « stop », « step » et « i » dans l’exemple précédent.
A chaque fois que nous définissons des variables à l’intérieur du corps (ou
paramètre) d’une fonction, ces variables ne sont accessibles qu’à la fonction elle-

Page | 21
même. On dit que ces variables sont des variables locales à la fonction. Une
variable locale peut avoir le même nom qu’une variable de l’espace de noms
global mais elle reste néanmoins indépendante.
Les contenus des variables locales sont stockés dans l’espace de noms local qui
est inaccessible depuis l’extérieur de la fonction.
Les variables définies à l’extérieur d’une fonction sont des variables globales.
Leur contenu est « visible » de l’intérieur d’une fonction, mais la fonction ne peut
pas le modifier de façon globale (la modification n’est valable que dans le corps
de la fonction.
Exemple
def test():
b = 5
print(a, b)

a = 2
b = 7
test()
print(a, b)

Ce programme va afficher
2 5
2 7

Utilisation d’une variable globale - global

Il est possible d’écrire une fonction qui modifie une variable globale. Pour
atteindre ce résultat, il faut utiliser l’instruction « global ». Cette instruction
permet d’indiquer à l’intérieur de la définition d’une fonction quelles sont les
variables à traiter globalement.
L’exemple suivant illustre bien cela :

def test():
global b
b = 5
print(a, b)

a = 2
b = 7
test()
print(a, b)

Ce programme donnera :
2 5
2 5

Page | 22
Fonctions et procédures
Les fonctions que nous avons décrites jusqu’à présent ne sont pas tout à fait des
fonctions au sens strict, mais plus exactement des procédures. Une « vraie »
fonction (au sens strict) doit en effet renvoyer une valeur lorsqu’elle se termine.
Une « vraie » fonction peut s’utiliser à la droite du signe égale dans des
expressions telles que 𝑦 = sin(𝑎) . On comprend aisément que dans cette
expression, la fonction sin(𝑎) renvoie une valeur (le sinus de l’argument a) qui
est directement affectée à la variable y.
Exemple
def cube(w):
return w**3

On aura
>>>cube(3)
27
>>>a = cube(4)
>>>a
64

Valeurs par défaut pour les paramètres

Dans la définition d’une fonction, il est possible de définir un argument par défaut
pour chacun des paramètres. On obtient ainsi une fonction qui peut être appelée
avec une partie seulement des arguments attendus.
Exemple
def politesse(nom, titre ="Monsieur"):
print("Veuillez agréer,", titre, nom, ", mes salutations distinguées.")

On aura :
>>>politesse("Dupont")
Veuillez agréer, Monsieur Dupont , mes salutations distinguées.
>>>politesse('Durand', 'Mademoiselle')
Veuillez agréer, Mademoiselle Durand , mes salutations distinguées.
Lorsque l’on appelle cette fonction en ne lui fournissant que le premier argument,
le second reçoit tout de même une valeur par défaut. Si l’on fournit les deux
arguments, la valeur par défaut pour le deuxième est tout simplement ignorée.

Arguments avec étiquettes

Dans la plupart des langages de programmation, les arguments que l’on fournit
lors de l’appel d’une fonction doivent être fournis exactement dans le même ordre
que celui des paramètres qui leur correspondent dans la définition de la fonction.
Python autorise cependant une souplesse beaucoup plus grande. Si les paramètres
annoncés dans la définition de la fonction ont reçu chacun une valeur par défaut,
sous la forme déjà décrite ci-dessus, on peut faire appel à la fonction en

Page | 23
fournissant les arguments correspondants dans n’importe quel ordre, à la
condition de désigner nommément les paramètres correspondants.
Exemple :
def oiseau(voltage=100, etat="allumé", action="danser la java"):
print("Ce perroquet ne pourra pas", action)
print("si vous le branchez sur", voltage, "volts !")
print("L'auteur de ceci est complètement", etat)

On aura à l’exécution :
>>>oiseau(etat="givré", voltage=250, action="vous approuver")
Ce perroquet ne pourra pas vous approuver
si vous le branchez sur 250 volts !
L'auteur de ceci est complètement givré

Ou
>>>oiseau()
Ce perroquet ne pourra pas danser la java
si vous le branchez sur 100 volts !
L'auteur de ceci est complètement allumé

Utilisation des fonctions dans un script

Pour cette première approche des fonctions, nous n’avons utilisé jusqu’ici que des
fonctions dans des scripts et pas de programme principal dans le script. Soit la
formule suivante de calcule du volume d’une sphère :
4
𝑉 = п𝑅 3
3
Nous allons utiliser la bibliothèque Numpy qui contient п. Nous verrons plus en
détails cette bibliothèque dans la suite du cours.

import numpy as np

def cube(n):
return n**3

def volume_sphere(r):
return 4 / 3 * np.pi * cube(r)

r = float(input("Entrez la valeur du rayon : "))

print("Le volume de cette sphere vaut", volume_sphere(r))

Ce programme comporte deux parties :

 les deux fonctions cube() et volume_sphere()
 le corps principal du programme.
Dans le corps principal du programme, il y a un appel de la fonction
volume_sphere().

Page | 24
A l’intérieur de la fonction volume_sphere(), il y a un appel de la fonction cube().
Notez bien que les deux parties du programme ont été disposées dans un certain
ordre :
 d’abord la définition des fonctions,
 et ensuite le corps principal du programme.
Cette disposition est nécessaire, parce que l’interpréteur exécute les lignes
d’instructions du programme l’une après l’autre, dans l’ordre où elles apparaissent
dans le code source. Dans le script, la définition des fonctions doit donc précéder
leur utilisation.
Pour vous en convaincre, intervertissez cet ordre (en plaçant par exemple le corps
principal du programme au début), et prenez note du type de message d’erreur qui
est affiché lorsque vous essayez d’exécuter le script ainsi modifié.

Page | 25
Modules et importations
Très souvent, on utilise des fonctions déjà définies (dans une bibliothèque). Par
exemple, avec la bibliothèque « matplotlib », on peut utiliser la fonction « plot() »

Page | 26
pour tracer des courbes sans avoir à écrire nous-mêmes cette fonction. Nous allons
donc voir à présent comment définir des fonctions dans un module et faire en sorte
qu’un utilisateur puisse appeler ces fonctions dans son programme.
Par exemple, nous allons créer un fichier nommé puissance.py qui va définir 2
fonctions : carre() et cube(). Un tel fichier est appelé un module et il va pouvoir
être importé dans un autre fichier, et en particulier dans le fichier qui contient le
programme principal.
def carre(valeur):
resultat = valeur**2
return resultat

def cube(valeur):
resultat = valeur**3
return resultat

Il est maintenant possible d’utiliser dans un programme principal les fonctions

qui ont été définies dans le module puissance.py. Pour cela, il faut importer les
fonctions à partir du module.
from puissance import carre

a = 5
u = carre(a)
print("le carre vaut", u)

On peut importer explicitement les deux fonctions

from puissance import carre, cube

a = 5
u = carre(a)
print("le carre vaut", u)
v = cube(a)
print("le cube vaut", v)

On peut importer toutes les fonctions

from puissance import *

a = 5
u = carre(a)
print("le carre vaut", u)
v = cube(a)
print("le cube vaut", v)

Page | 27
L’importation de toutes les fonctions avec * est fortement déconseillée. En effet,
elle ne permet pas d’avoir une vision claire des fonctions qui ont été importées.
Ceci est donc une source potentielle d’erreurs. Il faut plutôt importer le module.
Dans ce cas, il faut préciser le nom du module devant la fonction.
import puissance

a = 5
u = puissance.carre(a)
print("le carre vaut", u)
v = puissance.cube(a)
print("le cube vaut", v)

On peut aussi importer le module et lui donner un alias comme suit :

import puissance as pu
a = 5
u = pu.carre(a)
print("le carre vaut", u)
v = pu.cube(a)
print("le cube vaut", v)

Il est aussi possible de donner un alias à une fonction comme dans l’exemple
suivant :
from puissance import carre as ca

a = 5
u = ca(a)
print("le carre vaut", u)

Notion de package
Quand on a un grand nombre de modules, il peut être intéressant de les organiser
dans des dossiers. Un dossier qui rassemble des modules est appelé un package
(paquetage en français). Le nom du package est le même que celui du dossier. Par
exemple, on crée un dossier package1 dans lequel on place le fichier module1.py
suivant :
def fonction1(a):
return a**2

On peut ensuite utiliser la fonction fonction1() définie dans module1.py, en

important package1.module1 comme dans l’exemple qui suit :

Page | 28
import package1.module1

u = package1.module1.fonction1(3)
print("u vaut", u)

Remarque
Il est aussi possible d’avoir des dossiers imbriqués, c’est-à-dire des dossiers qui
contiennent d’autres dossiers.

Page | 29
 Découverte de la bibliothèque Numpy

Introduction
La bibliothèque NumPy permet d’effectuer des calculs numériques avec Python.
Elle introduit une gestion facilitée des tableaux de nombres.
Pour utiliser NumPy, il faut au préalable l’importer comme nous l’avons vu
précédemment
import numpy as np

Variables prédéfinies
Variable pi
NumPy permet d’obtenir la valeur de pi.
import numpy as np

np.pi
3.141592653589793

Tableaux - numpy.array()
Création
Les tableaux (en anglais, array) peuvent être créés avec numpy.array(). On utilise
des crochets pour délimiter les listes d’éléments dans les tableaux.
import numpy as np

a = np.array([1, 2, 3, 4])

Affichage
>>>a
array([1, 2, 3, 4])
>>>type(a)
numpy.ndarray

On voit que l’on a obtenu un objet de type numpy.ndarray.

Accès aux éléments d’un tableau

Comme pour les listes, les indices des éléments commencent à zéro.
>>>a[0]

Page | 30
1
>>>a[3]
4

Tableau 2D
Il est possible de créer un tableau 2D en utilisant une liste de listes au moyen de
crochets imbriqués. Les listes internes correspondent à des lignes du tableau.
b = np.array([[1, 2, 3], [4, 5, 6]])

Affichage
>>>b
array([[1, 2, 3],
[4, 5, 6]])
>>>type(b)
numpy.ndarray

Accès aux éléments d’un tableau 2D

On utilise une syntaxe avec deux indices. Le premier indice est l’indice de la ligne
du tableau.
>>>b[0,1]
2
>>>b[1,2]
6

La fonction numpy.arange()
Elle est équivalente à la fonction native range() de python
>>>m = np.arange(3, 15, 2)
>>>m
array([ 3, 5, 7, 9, 11, 13])
>>>type(m)
numpy.ndarray

La différence entre la fonction range et numpy.arange() :

 numpy.arange() retourne un objet de type numpy.ndarray.
 range() retourne un objet de type range.

>>>n = range(3, 15, 2)

>>>n

Page | 31
range(3, 15, 2)
>>>type(n)
range

Il faut également la distinguer d’une liste

>>>u = [3, 7, 10]
>>>type(u)
list

Il est possible d’obtenir des listes en combinant list et range().

>>>list(range(3, 15, 2))
[3, 5, 7, 9, 11, 13]

Il est à noter que numpy.arange() accepte des arguments qui ne sont pas entiers.
>>>np.arange(0, 11*np.pi, np.pi)
array([ 0. , 3.14159265, 6.28318531, 9.42477796,
12.56637061, 15.70796327, 18.84955592, 21.99114858,
25.13274123, 28.27433388, 31.41592654])

La fonction numpy.linspace()
La fonction numpy.linspace() permet d’obtenir un tableau 1D allant d’une valeur
de départ à une valeur de fin avec un nombre donné d’éléments.
>>>np.linspace(3, 9, 10)
array([ 3. , 3.66666667, 4.33333333, 5. , 5.66666667,
6.33333333, 7. , 7.66666667, 8.33333333, 9. ])

Action d’une fonction mathématique sur un tableau

NumPy dispose d’un grand nombre de fonctions mathématiques qui peuvent être
appliquées directement à un tableau. Dans ce cas, la fonction est appliquée à
chacun des éléments du tableau.
>>>x = np.linspace(-np.pi/2, np.pi/2, 3)
>>>x
array([-1.57079633, 0. , 1.57079633])
>>>y = np.sin(x)
>>>y
array([-1., 0., 1.])

Page | 32
Fonctions mathématiques avec NumPy
Il existe des fonctions mathématiques qui sont accessibles grâce à NumPy. Il
s’agit en autre de :
Fonctions trigonométriques
Numpy.sin(x) Sinus
Numpy.cos(x) Cosinus
Numpy.tan(x) Tangente
Numpy.arcsin(x) Arcsinus
Numpy.arccos(x) Arccosinus
Numpy.arctan(x) Arctangente
Fonctions hyperpoliques
Numpy.sinh(x) Sinus hyperpolique
Numpy.cosh(x) Cosinus hyperpolique
Numpy.tanh(x) Tangente hyperpolique
Numpy.arcsinh(x) Arcsinus hyperpolique
Numpy.arcosh(x) Arccosinus hyperpolique
Numpy.arctanh(x) Arctangente hyperpolique
Fonctions diverses
X**n x à la puissance n, exemple : x**2
Numpy.sqrt(x) racine carrée
Numpy.exp(x) exponentielle
Numpy.log(x) logarithme népérien
Numpy.abs(x) valeur absolue
Numpy.sign(x) signe
Fonctions utiles pour les nombres complexes
Numpy.real(x) partie réelle
Numpy.imag(x) partie imaginaire
Numpy.abs(x) module
Numpy.angle(x) argument en radians
Numpy.conj(x) complexe conjugué
Arrondis
Numpy. around(x,n) arrondi à n décimales
Numpy. trunc(x) retourne la partie entière du nombre (le nombre est
tronqué)

Page | 33
Exemple
>>>import numpy as np
>>>x = np.array([ 2 + 3j, 1j, 1])
>>>np.real(x)
array([ 2., 0., 1.])
>>>np.imag(x)
array([ 3., 1., 0.])
>>>np.abs(x)
array([ 3.60555128, 1. , 1. ])
>>>np.angle(x)
array([ 0.98279372, 1.57079633, 0. ])
>>>np.conj(x)
array([ 2.-3.j, 0.-1.j, 1.-0.j])
>>>x = np.array([3.73637, 5.4374345])
>>>np.around(x,2)
array([ 3.74, 5.44])
>>>np.around(x,0)
array([ 4., 5.])

Nombres aléatoires
La fonction numpy.random.random() permet d’obtenir des nombres compris
entre 0 et 1 par tirage aléatoire avec une loi uniforme. Il faut noter que ces nombres
aléatoires sont générés par un algorithme et ils ne sont donc pas vraiment «
aléatoires » mais pseudo-aléatoires.
La fonction numpy.random.random() peut être utilisée avec des arguments pour
obtenir des tableaux. Les arguments précisent alors la forme (shape) du tableau
souhaité.
>>>np.random.random()
0.5540884899329033
>>>np.random.random(3)
array([ 0.86431861, 0.88519197, 0.30663316])
>>>np.random.random((2,3))
array([[ 0.66265691, 0.39385577, 0.09319192],
[ 0.43483474, 0.42859904, 0.79189574]])

Remarque
Il existe encore d’autres fonctions dans la bibliothèque numpy. Pour plus
d’informations on peut consulter la documentation sur le site officiel :
https://numpy.org/

Page | 34
 Les courbes avec Python

Introduction
En programmation scientifique, il est très courant d’utiliser les courbes pour
représenter les données. Pour tracer les courbes en python en plus de la
bibliothèque « numpy » pour manipuler les données, on utilisera la bibliothèque
« matplotlib » pour les courbes. Cette dernière dispose de fonctions utiles pour la
représentation graphique

Création d’une courbe

Dans la suite du cours, nous importerons le module « pylab » qui contient les
bibliothèques « numpy » et « matplotlib ». On peut par contre importer les
bibliothèques individuellement si on le souhaite

La fonction plot()
L’instruction « plot() » permet de tracer des courbes qui relient des points dont
les abscisses et ordonnées sont fournies dans des tableaux.
Exemple
 Syntaxe « PyLab »
from pylab import *

x = array([1, 3, 4, 6])
y = array([2, 3, 5, 1])
plot(x, y)

show() # affiche la figure a l'ecran

 Syntaxe « standard »
import numpy as np
import matplotlib.pyplot as plt

x = np.array([1, 3, 4, 6])
y = np.array([2, 3, 5, 1])
plt.plot(x, y)

plt.show() # affiche la figure a l'ecran

Page | 35
 Figure 1: Courbe affichée

Retour sur la fonction linespace() de numpy

La fonction linespace() renvoie des nombres régulièrement espacés sur un
intervalle spécifié. Sa signature est la suivante :
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False,
dtype=None, axis=0)
 Start : La valeur de départ de la séquence.
 Stop : La valeur de fin de la séquence, sauf si le « endpoint » est défini sur
False. Dans ce cas, la séquence se compose de tout sauf le dernier de num+1
échantillons régulièrement espacés, de sorte que l'arrêt soit exclu. Notez
que la taille du pas change lorsque le « endpoint » est False.
 Num : Nombre d'échantillons à générer. La valeur par défaut est 50. Cette
valeur ne doit pas être négative.
 Endpoint : Si True, stop est le dernier échantillon. Sinon, il n'est pas inclus.
La valeur par défaut est True.
 Retstep : Si True, renvoie (échantillons, « pas »), où « pas » est l'espacement
entre les échantillons.
 Dtype : Le type du tableau de sortie. Si dtype n'est pas fourni, le type de
données est déduit de start et stop. Le dtype inféré ne sera jamais un entier ;
float est choisi même si les arguments produiraient un tableau d'entiers.
 Axis : L'axe dans le résultat pour stocker les échantillons. Pertinent
uniquement si start ou stop sont de type tableau. Par défaut (0), les
échantillons seront le long d'un nouvel axe inséré au début. Utilisez -1 pour
obtenir un axe à la fin.
Page | 36
Nous allons utiliser cette dernière pour tracer la fonction cosinus sur l’intervalle
[0, 2𝜋]
 Syntaxe « PyLab »
from pylab import *

x = linspace(0, 2*pi, 30)

y = cos(x)
plot(x, y)

show() # affiche la figure a l'ecran

 Syntaxe « standard »
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2*np.pi, 30)

y = np.cos(x)
plt.plot(x, y)

plt.show() # affiche la figure a l'ecran

Figure 2: Courbe de cosinus

Page | 37
Définition du domaine des axes - xlim() et ylim()
Il est possible fixer indépendamment les domaines des abscisses et des ordonnées
en utilisant les fonctions xlim() et ylim(). Leurs signatures sont les suivantes :
𝑥𝑙𝑖𝑚 (𝑥𝑚𝑖𝑛, 𝑥𝑚𝑎𝑥 )
𝑦𝑙𝑖𝑚(𝑦𝑚𝑖𝑛, 𝑦𝑚𝑎𝑥)
Ces fonctions sont disponibles dans « pyplot » de matplotlib
Exemple
from pylab import *

x = linspace(0, 2*pi, 30)

y = cos(x)
plot(x, y)
xlim(-1, 5)

show()

Figure 3: Fonction cosinus sur [-1, 5]

Exemple 2
from pylab import *

x = linspace(0, 2*pi, 30)

y = cos(x)
plot(x, y)
xlim(0, 2*pi)
ylim(-2, 2)

show()

Page | 38
 Figure 4: Courbe 2 de cosinus

Ajout d’un titre - title()

On peut ajouter un titre à une courbe grâce à la fonction « title() ». Cette fonction
est disponible dans « pyplot » de matplotlib
from pylab import *

x = linspace(0, 2*pi, 30)

y = cos(x)
plot(x, y)
title("Fonction cosinus")

show()

Figure 5: Ajout d'un titre

Page | 39
Ajout d’une légende - legend()
Comme son nom l’indique cette fonction permet d’ajouter une légende à la
courbe. Cette fonction est disponible dans « pyplot » de matplotlib
from pylab import *

x = linspace(0, 2*pi, 30)

y = cos(x)
plot(x, y, label="cos(x)")
legend()

show()

Figure 6: Ajout d'une légende

Note
Pour faire afficher le label, il ne faut pas oublier de faire appel à l’instruction
legend().

Labels sur les axes - xlabel() et ylabel()

Des labels sur les axes peuvent être ajoutés avec les fonctions xlabel() et ylabel().
Ces fonctions sont disponibles dans « pyplot » de matplotlib
from pylab import *

x = linspace(0, 2*pi, 30)

y = cos(x)
plot(x, y)
xlabel("abscisses")
ylabel("ordonnees")

show()

Page | 40
 Figure 7: Label sur les axes

Affichage de plusieurs courbes

Pour afficher plusieurs courbes sur un même graphe, on peut procéder de la
façon suivante :
from pylab import *

x = linspace(0, 2*pi, 30)

y1 = cos(x)
y2 = sin(x)
plot(x, y1)
plot(x, y2)

show()

On peut ajouter une légende aux courbes. Dans ce cas on écrira :

from pylab import *

x = linspace(0, 2*pi, 30)

y1 = cos(x)
y2 = sin(x)
plot(x, y1, label="cos(x)")
plot(x, y2, label="sin(x)")
legend()

show()

Page | 41
 Figure 8: Affichage de plusieurs courbes

Formats de courbes
Il est possible de préciser la couleur, le style de ligne et de symbole (« marker »)
en ajoutant une chaîne de caractères de la façon suivante :
from pylab import *

x = linspace(0, 2*pi, 30)

y1 = cos(x)
y2 = sin(x)
plot(x, y1, "r--", label="cos(x)")
plot(x, y2, "b:o", label="sin(x)")
legend()

show()

Figure 9: Courbe avec marqueur

Page | 42
Style de ligne
Les chaînes de caractères suivantes permettent de définir le style de ligne :
Chaîne Effet
- ligne continue
-- tirets
: ligne en pointillé
-. tirets points

Remarque
Si on ne veut pas faire apparaître de ligne, il suffit d’indiquer un symbole sans
préciser un style de ligne.
Exemple
from pylab import *

x = linspace(0, 2*pi, 20)

y = sin(x)
plot(x, y, "o-", label="ligne -")
plot(x, y-0.5, "o--", label="ligne --")
plot(x, y-1, "o:", label="ligne :")
plot(x, y-1.5, "o-.", label="ligne -.")
plot(x, y-2, "o", label="pas de ligne")
legend()

show()

Figure 10: Différents styles de courbes

Page | 43
Symbole (« marker »)
Les chaînes de caractères suivantes permettent de définir le symbole («marker»):
Chaîne Effet
. point marker
, pixel marker
o circle marker
V triangle_down marker
^ triangle_up marker
< triangle_left marker
> triangle_right marker
1 tri_down marker
2 tri_up marker
3 tri_left marker
4 tri_right marker
s square marker
+ plus marker

Couleur
Les chaînes de caractères suivantes permettent de définir la couleur :
Chaîne Couleur
b Bleu (Blue)
g Vert (Green)
r Rouge (Red)
c Cyan (Cyan)
m Magenta (Magenta)
y Jaune (Yellow)
k Noir (Black)
w Blanc (White)

Largeur de ligne
Pour modifier la largeur des lignes, il est possible de changer la valeur de
l’argument « linewidth » de la fonction plot de « matplotlib.pyplot ».
from pylab import *
x = linspace(0, 2*pi, 30)
y1 = cos(x)
y2 = sin(x)
plot(x, y1, label="cos(x)")
plot(x, y2, label="sin(x)", linewidth=4)
legend()
show()

Page | 44
 Figure 11: Largeur de ligne

Tracé de formes
Comme la fonction « plot() » ne fait que relier des points, il est possible de lui
fournir plusieurs points avec la même abscisse.
from pylab import *

x = array([0, 1, 1, 0, 0])
y = array([0, 0, 1, 1, 0])
plot(x, y)
xlim(-1, 2)
ylim(-1, 2)

show()

Page | 45
L’instruction axis("equal")
L’instruction « axis("equal") » permet d’avoir la même échelle sur l’axe des
abscisses et l’axe des ordonnées afin de préserver la forme lors de l’affichage. En
particulier, grâce à cette commande un carré apparaît vraiment comme un carré,
de même pour un cercle. Elle est disponible depuis « matplotlib.pyplot »
from pylab import *

x = array([0, 1, 1, 0, 0])
y = array([0, 0, 1, 1, 0])
plot(x, y)
axis("equal")

show()

Tracé d’un cercle

On peut utiliser une courbe paramétrique pour tracer un cercle. Avec
axis("equal"), on obtient bien un cercle, sans, on obtient une forme elliptique.
from pylab import *

theta = linspace(0, 2*pi, 40)

x = cos(theta)
y = sin(theta)
plot(x, y)
axis("equal")

show()

Page | 46
Figure 12: Cercle avec les courbes paramétriques

Page | 47
 Tableaux et calcul matriciel avec NumPy

Introduction

Page | 48