Cours

Programmation Python
Licence

MAMADOU Diarra
13/05/2022
Table des

matières
1 Introduction à Python ..................................................................................................................... 5
1.1 Présentation de Python ........................................................................................................... 5
1.2 Installation et manipulation de Python ................................................................................... 5
1.2.1 Prise en main en mode interactif .................................................................................... 5
1.2.2 Ecrire, conserver, ouvrir, exécuter un programme ......................................................... 5
2 Présentation des outils de programmation .................................................................................... 7
2.1 Exécution d’un premier programme ....................................................................................... 7
2.2 Quelques bases rapides en Python ......................................................................................... 7
2.2.1 Utilisation en mode interactif ......................................................................................... 7
2.2.2 Premiers calculs ............................................................................................................... 8
2.2.3 L’opérateur /.................................................................................................................... 8
2.2.4 L’opérateur % .................................................................................................................. 8
2.2.5 Affectation ....................................................................................................................... 9
2.2.6 Affichage - la fonction print() .......................................................................................... 9
2.2.7 Fonction range() ............................................................................................................ 10
2.2.8 Accès aux éléments d’une liste ..................................................................................... 11
2.2.9 Fonction len() ................................................................................................................ 11
2.2.10 Lecture d’informations au clavier - la fonction input() ................................................. 12
2.2.11 Règles générales d’écriture ........................................................................................... 12
2.3 Tests (Instructions conditionnelles) ...................................................................................... 13
2.3.1 Bloc d’instructions - Indentation ................................................................................... 13
2.3.2 Instruction if .................................................................................................................. 13
2.3.3 Instruction if … else ....................................................................................................... 15
2.3.4 Opérateur logique and .................................................................................................. 17
2.3.5 Opérateur logique or ..................................................................................................... 17
2.4 Boucles .................................................................................................................................. 18
2.4.1 Boucles bornées et non bornées ................................................................................... 18
2.4.2 Boucle for ...................................................................................................................... 18
2.4.3 Boucle while .................................................................................................................. 20
2.4.4 Comment choisir entre boucle for et boucle while ....................................................... 21
2.4.5 Transformation d’une boucle for en une boucle while ................................................. 21
2.5 Les instructions break et continue, et la clause else dans les boucles.................................. 21
2.5.1 Instruction break ........................................................................................................... 21
 2.5.2 Remarque : équivalent du do…while (faire…tant que) ................................................ 22
2.5.3 Instruction continue ...................................................................................................... 22
2.5.4 Clause else dans une boucle.......................................................................................... 23
2.6 Principaux types de données................................................................................................. 24
2.6.1 Fonction type() .............................................................................................................. 24
2.6.2 Type int (entier) ............................................................................................................. 25
2.6.3 Type float (flottant) ....................................................................................................... 25
2.6.4 Type str (chaîne de caractères) ..................................................................................... 25
2.6.5 Type bool (booléen) ...................................................................................................... 26
2.6.6 Type list (liste) ............................................................................................................... 26
2.6.7 Type complex (complexe) ............................................................................................. 35
2.7 Tuples en Python ................................................................................................................... 36
2.8 Dictionnaires en Python ........................................................................................................ 39
2.9 Comment créer un dictionnaire python? .............................................................................. 39
2.10 Comment ajouter des valeurs dans un dictionnaire python? ............................................... 40
2.11 Comment récupérer une valeur dans un dictionnaire python? ............................................ 40
2.12 Comment vérifier la présence d'une clé dans un dictionnaire python? ............................... 40
2.13 Comment supprimer une entrée dans un dictionnaire python? .......................................... 40
2.14 Comment récupérer les clés d'un dictionnaire python par une boucle? .............................. 41
2.15 Comment récupérer les valeurs d'un dictionnaire python par une boucle? ........................ 41
2.16 Comment récupérer les clés et les valeurs d'un dictionnaire python par une boucle? ........ 41
2.17 Comment utiliser des tuples comme clé dans un dictionnaire python? ............................... 42
2.18 Comment créer une copie indépendante d'un dictionnaire python?................................... 42
2.19 Comment fusionner des dictionnaires python ? ................................................................... 43
3 Fonctions en Python ...................................................................................................................... 43
3.1 Définition d’une fonction - def .............................................................................................. 43
3.2 Fonction sans paramètre ....................................................................................................... 44
3.3 Fonction avec paramètre ...................................................................................................... 45
3.4 Utilisation d’une variable comme argument......................................................................... 46
3.5 Fonction avec plusieurs paramètres ..................................................................................... 47
3.6 Variables locales, variables globales ..................................................................................... 47
3.7 Utilisation d’une variable globale - global ............................................................................. 48
3.8 « Vraies » fonctions et procédures........................................................................................ 49
3.9 Valeurs par défaut pour les paramètres ............................................................................... 49
3.10 Arguments avec étiquettes ................................................................................................... 50
3.11 Utilisation des fonctions dans un script ................................................................................ 51
 3.12 Modules et importations ....................................................................................................... 53
3.13 Package .................................................................................................................................. 56
4 Python et maths ............................................................................................................................ 58
4.1 Quelques bibliothèques ........................................................................................................ 58
4.2 Quelques fonctions mathématiques ..................................................................................... 60
4.3 Courbes.................................................................................................................................. 60
4.3.1 Utilisation de plot()........................................................................................................ 60
4.3.2 Définition du domaine des axes - xlim() et ylim().......................................................... 61
4.3.3 Ajout d’un titre - title() .................................................................................................. 62
4.3.4 Ajout d’une légende - legend() ...................................................................................... 63
4.3.5 Labels sur les axes - xlabel() et ylabel() ......................................................................... 64
4.3.6 Affichage de plusieurs courbes ..................................................................................... 65
4.3.7 Exemple avec un légende .............................................................................................. 66
4.3.8 Formats de courbes ....................................................................................................... 67
4.3.9 Style de ligne ................................................................................................................. 68
4.3.10 Symbole (« marker ») .................................................................................................... 69
4.3.11 Couleur .......................................................................................................................... 70
4.3.12 Largeur de ligne ............................................................................................................. 70
4.3.13 Tracé de formes ............................................................................................................. 71
4.3.14 L’instruction axis("equal") ............................................................................................. 72
4.3.15 Tracé d’un cercle ........................................................................................................... 73
4.3.16 Tracé de diagrammes en bâtons et histogrammes ....................................................... 75
4.3.17 Affichages de nuages de points ..................................................................................... 80
4.3.18 Tracé multiples .............................................................................................................. 82
4.3.19 Tutoriel sur mplot3d ...................................................................................................... 83
4.4 Tableaux et calcul matriciel ................................................................................................. 108
4.4.1 Tableaux - numpy.array() ....................................................................................... 108
4.4.2 Tableaux bidimensionnels (2D) ................................................................................... 109
4.4.3 La fonction numpy.size() ............................................................................................. 109
4.4.4 Fonction numpy.shape().............................................................................................. 109
4.4.5 Produit terme à terme................................................................................................. 109
4.4.6 Produit matriciel - numpy.dot()................................................................................... 110
4.4.7 Transposé .................................................................................................................... 110
4.4.8 Complexe conjugué - numpy.conj()............................................................................. 110
4.4.9 Transposé complexe conjugué .................................................................................... 111
4.4.10 Tableaux et slicing ....................................................................................................... 111
 4.4.11 Slicing des tableaux 2D ................................................................................................ 111
4.4.12 Tableaux de 0 - numpy.zeros() .................................................................................... 112
4.4.13 Tableaux de 1 - numpy.ones() ..................................................................................... 112
4.4.14 Matrice identité - numpy.eye() ................................................................................... 112
4.4.15 Déterminant - numpy.linalg.det()................................................................................ 112
4.4.16 Inverse - numpy.linalg.inv() ......................................................................................... 113
4.4.17 Résolution d’un système d’équations linéaires - numpy.linalg.solve() ....................... 113
4.4.18 Valeurs propres et vecteurs propres - numpy.linalg.eig() ........................................... 113
4.4.19 Changement de la taille d’un tableau ......................................................................... 114
4.4.20 Obtention d’un tableau 2D ligne ou colonne .............................................................. 114
5 Programmation orientée objet en python / classes.................................................................... 115
5.1 Classes ................................................................................................................................. 115
5.2 Objets .................................................................................................................................. 115
5.3 Attributs de classe ............................................................................................................... 115
5.4 Méthodes ............................................................................................................................ 116
5.5 Propriétés ............................................................................................................................ 117
5.6 La fonction dir...................................................................................................................... 118
5.7 Attribut spécial __dict__ ..................................................................................................... 119
5.8 Héritage de classe................................................................................................................ 119
5.9 Polymorphisme / surcharge de méthode............................................................................ 120
5.10 Conventions ......................................................................................................................... 123
6 Bibliographie................................................................................................................................ 124
1 Introduction à Python
1.1 Présentation de Python
Le langage de programmation Python a été créé en 1989 par Guido van Rossum, aux Pays-Bas.
Python présente de nombreuses caractéristiques :
Il est multiplateforme. C’est-à-dire qu’il fonctionne sur de nombreux systèmes d’exploitation
;
Il est gratuit. Vous pouvez l’installer sur autant d’ordinateurs que vous voulez (même sur votre
téléphone !) ;
C’est un langage de haut niveau. Il demande relativement peu de connaissance sur le
fonctionnement d’un ordinateur pour être utilisé ;
C’est un langage interprété. Un script Python n’a pas besoin d’être compilé pour être exécuté,
contrairement à des langages comme le C ou le C++ ;
Il est orienté objet.
Il est relativement simple à prendre en main.
il est très utilisé dans de nombreux domaines : bioinformatique, analyse de données, imagerie,
3D, web, réseau, matériels, etc.

1.2 Installation et manipulation de Python

1.2.1 Prise en main en mode interactif
Cliquez sur bouton Démarrer puis sur « Tous les programmes » puis double-cliquez sur le
dossier Python 3.x puis cliquez sur « IDLE (Python GUI) » (nom de l’environnement de travail).
Une fenêtre « Python Shell » s’ouvre alors.

1.2.2 Ecrire, conserver, ouvrir, exécuter un programme

En mode interactif, les lignes d’instruction ne sont plus accessibles une fois exécutées. Dans
cette partie, vous apprendrez à conserver un programme pour pouvoir l’exécuter à loisir ou
pour le modifier ultérieurement. - Dans la fenêtre Python Shell (celle du mode interactif),
sélectionnez New Window dans le menu File :
Une nouvelle fenêtre s’ouvre alors. C’est dans cette fenêtre que vous écrirez votre premier
programme. Tapez le script suivant :

Enregistrement du programme : Sélectionnez « Save as » dans le menu File.

une fenêtre d’enregistrement s’ouvre alors. Choisissez dans l’arborescence le dossier dans
lequel vous voulez enregistrer le programme, puis dans le champ d’enregistrement du fichier
saisissez le nom du programme suivi de l’extension .py, puis cliquez sur enregistrer :

Pour ouvrir un programme python, il suffira de sélectionner Open dans le menu File de
l’environnement IDLE puis de chercher dans vos dossiers le fichier python à ouvrir
Exécution du programme : Pour exécuter le programme, il suffit de sélectionner « Run Module
» dans le menu Run (si une modification du script a été effectuée, on vous proposera
d’enregistrer le script modifié avant de l’exécuter).

Le programme s’exécute dans la fenêtre Python shell.

2 Présentation des outils de programmation

2.1 Exécution d’un premier programme
Voici un premier exemple de programme :

for i in [0, 1, 2]:

print("valeur :", i)

print("Fin")

L’affichage après exécution est :

valeur : 0

valeur : 1

valeur : 2

Fin

2.2 Quelques bases rapides en Python

2.2.1 Utilisation en mode interactif
Note
Si vous n’utilisez pas Spyder mais IDLE, vous pouvez consulter cette introduction à IDLE.

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 >>>). Elle se présente de la façon suivante :

In [1]:

Exemple de première utilisation de IPython :

In [1]: 3 * 4

Out[1]: 12

In [2]: 5 + 2

Out[2]: 7

Les parties qui débutent par In et Out correspondent aux entrées et sorties respectivement.

2.2.2 Premiers calculs

Testez les calculs suivants :

>>> 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

Pour calculer une puissance, on utilise **.

>>> 5**2

2.2.3 L’opérateur /
Avertissement
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. En Python 2.7, on peut obtenir le même comportement qu’en
Python 3 grâce à l’instruction from __future__ import division.

Exemple

>>> 7 / 2

3.5

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

>>> 7 // 2

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

Exemple

>>> 7 % 2

>>> 6 % 2

2.2.5 Affectation

>>> a = 2

>>> a

>>> b = a + 3

>>> b

La première ligne contient l’instruction a = 2. Pour comprendre cette instruction, il faut

imaginer que les informations sont stockées dans des boîtes au sein de la mémoire de
l’ordinateur. Pour manipuler les informations, on donne des noms à ces boîtes. Ici on crée une
boîte appelée a et on lui affecte la valeur 2. Par la suite, on parlera de la variable a,
puisque a peut contenir des valeurs variables. Autrement dit, l’instruction a = 2 est une
instruction d”affection qui a pour effet de mettre la valeur 2 dans la variable a.

2.2.6 Affichage - la fonction print()

Pour afficher, on utilise la fonction print().

>>> print("bonjour")

bonjour

>>> a = 5

>>> print(a)

Il est possible de réaliser plusieurs affichages à la suite. Pour cela, on sépare les éléments par
des virgules.
>>> a = 5

>>> print("a vaut", a)

a vaut 5

Avertissement
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.

2.2.7 Fonction range()

Si vous avez besoin de créer sur une suite d’entiers, vous pouvez utiliser la fonction range().
Elle génère une suite arithmétique.

>>> range(10)

range(0, 10)

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(). Par exemple :

>>> 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) :

>>> 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.

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

>>> a = list(range(1,10,2))

>>> a

[1, 3, 5, 7, 9]

>>> a[0]

>>> a[2]

Pour accéder à un élément d’une liste, on indique entre crochets [] l’indice de l’élément.

Avertissement
En Python, l’indice du premier élément d’une liste est 0 (ceci est à distinguer d’autres
langages).

2.2.9 Fonction len()

La fonction len() renvoie le nombre d’éléments. Par exemple :

>>> a = list(range(7,10))

>>> a

[7, 8, 9]

>>> len(a)

3
2.2.10 Lecture d’informations au clavier - la fonction input()

x = int(input("Donnez un entier : "))

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.
Autre exemple de programme

n=3

print("Je vais vous demander", n, "nombres")

for i in range(n):

x = int(input("Donnez un nombre : "))

if x > 0:

print(x, "est positif")

else:

print(x, "est négatif ou nul")

print("Fin")

Pour faire une répétition : l’instruction for

for i in range(n):

bloc d'instructions

Pour faire un test : l’instruction if

if x > 0:

print(x, "est positif")

else:

print(x, "est négatif ou nul")

Les différentes sortes d’instruction

 les instructions simples

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

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

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).
Mots-clés

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

Commentaires usuels :

# Ceci est un commentaire

Commentaires en fin de ligne :

a = 2 # Ceci est un commentaire

2.3 Tests (Instructions conditionnelles)

L’instruction if est la structure de test la plus simple. Sa syntaxe en Python fait intervenir la
notion de bloc. Nous allons d’abord étudier cette notion plus en détail.

2.3.1 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 (habituellement 4 espaces mais ce n’est pas
obligatoire). 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.).

2.3.2 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 1 avec condition vraie :

x = 15

if x > 10:

print(x, "est plus grand que 10")

print("Fin")

Affichage après exécution :

15 est plus grand que 10

Fin

Exemple 1 avec condition fausse :

x=3

if x > 10:

print x, "est plus grand que 10"

print "Fin"

Affichage après exécution :

Fin

Exemple 2 avec condition vraie :

x=5

if x > 0:

print(x, "est plus grand que 0")

print("il est strictement positif")

print("Fin")

Dans cet exemple, le bloc après le if contient deux instructions. L’instruction print("Fin") ne
fait pas partie du bloc car elle n’est pas indentée.

Affichage après exécution :

5 est plus grand que 0

il est strictement positif

Fin

Exemple 2 avec condition fausse :

x = -2

if x > 0:

print(x, "est plus grand que 0")

print("il est strictement positif")

print("Fin")

Affichage après exécution :

Fin

2.3.3 Instruction if … else

Syntaxe
if condition:

Instruction A

else:

Instruction B

Exemple où la condition est vraie :

x=5

if x > 0:

print(x, "est positif")

else:

print(x, "est négatif ou nul")

print("Fin")

Affichage après exécution :

5 est strictement positif

Fin

Exemple où la condition est fausse :

x = -2

if x > 0:

print(x, "est positif")

else:

print(x, "est négatif ou nul")

print("Fin")

Affichage après exécution :

-2 est négatif ou nul

Fin

Une expression booléenne peut contenir les opérateurs de comparaison suivants :

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

Exemple

>>> 3 < 4

True

>>> 3 > 4

False

2.3.4 Opérateur logique and

>>> 2 < 3 and 3 < 4

True

>>> 2 < 3 and 3 > 4

False

2.3.5 Opérateur logique or

>>> 2 < 3 or 3 < 4

True
>>> 2 < 3 or 3 > 4

True

2.4 Boucles
Les boucles s’utilisent pour répéter plusieurs fois l’exécution d’une partie du programme.

2.4.1 Boucles bornées et non bornées

Boucle bornée

En général, quand on sait combien de fois doit avoir lieu la répétition, on utilise une boucle for.

Boucle non bornée

Si on ne connait pas à l’avance le nombre de répétitions, on choisit une boucle while.

2.4.2 Boucle for

Exemple d’utilisation :

for i in [0, 1, 2, 3]:

print("i a pour valeur", i)

Affichage après exécution :

i a pour valeur 0

i a pour valeur 1

i a pour valeur 2

i a pour valeur 3

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
fontion 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 :

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)

Dans l’exemple suivant, nous allons illustrer que la variable indiquée après for parcourt
toutes les valeurs de la liste donnée après in :

c = ["Marc", "est", "dans", "le", "jardin"]

for i in c:

print("i vaut", i)

>>>

i vaut Marc

i vaut est

i vaut dans

i vaut le
i vaut jardin

2.4.3 Boucle while

Syntaxe :

while condition:

Instruction A

Exemple de programme :

x=1

while x < 10:

print("x a pour valeur", x)

x=x*2

print("Fin")

Affichage après exécution :

x a pour valeur 1

x a pour valeur 2

x a pour valeur 4

x a pour valeur 8

Fin

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.

Dans l’exemple ci-dessus, x sera multiplié par 2 tant que sa valeur reste inférieure à 10.
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.

2.4.4 Comment choisir entre boucle for et boucle while

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.

Remarque : Il est toujours possible de remplacer une boucle for par une boucle while.

2.4.5 Transformation d’une boucle for en une boucle while

for i in range(4):

print("i a pour valeur", i)

Le programme ci-dessus est équivalent à:

i=0

while i < 4:

print("i a pour valeur", i)

i=i+1

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

2.5.1 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.

Exemple

for i in range(10):

print("debut iteration", i)

print("bonjour")

if i == 2:

break

print("fin iteration", i)

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.

2.5.2 Remarque : équivalent du do…while (faire…tant que)

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")

2.5.3 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.

Exemple

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

bonjour

debut iteration 2

bonjour

fin iteration 2

debut iteration 3

bonjour

fin iteration 3

apres la boucle

2.5.4 Clause else dans une boucle

La clause else dans un 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

2.6 Principaux types de données

Python est un language à 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.

2.6.1 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().

Exemples :

>>> type(15)

int

>>> a = 15

>>> type(a)

int

>>> a = "toto"
>>> type(a)

str

2.6.2 Type int (entier)

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

>>> type(128)

int

2.6.3 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.

Exemples :

>>> a = 14.5

>>> type(a)

float

>>> a = 11.

>>> type(a)

float

>>> a

11.0

>>> a = 3.25e7

>>> type(a)

float

>>> a

3.25e+7

2.6.4 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)

str

>>> b = "Bonsoir"

>>> type(b)

str

2.6.5 Type bool (booléen)

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

>>> 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.

2.6.6 Type list (liste)

Les listes (ou list / array ) en python sont une variable dans laquelle on peut
mettre plusieurs variables.
2.6.6.1 Créer une liste en python
Pour créer une liste , rien de plus simple:

>>> liste = []

Vous pouvez voir le contenu de la liste en l'appelant comme ceci:

>>> liste

<type 'list'>

2.6.6.2 Ajouter une valeur à une liste python

Vous pouvez ajouter les valeurs que vous voulez lors de la création de la liste python :

>>> liste = [1,2,3]

>>> liste

[1, 2, 3]

Ou les ajouter après la création de la liste avec la méthode append (qui signifie "ajouter" en
anglais):

>>> liste = []

>>> liste

[]

>>> liste.append(1)

>>> liste

[1]

>>> liste.append("ok")

>>> liste

[1, 'ok']

On voit qu'il est possible de mélanger dans une même liste des variables de type différent. On
peut d'ailleurs mettre une liste dans une liste.

2.6.6.3 Afficher un item d'une liste

Pour lire une liste, on peut demander à voir l'index de la valeur qui nous intéresse:

>>> liste = ["a","d","m"]

>>> liste[0]

'a'

>>> liste[2]

'm'
Le premier item commence toujours avec l'index 0. Pour lire la premier item on utilise la valeur
0, le deuxième on utilise la valeur 1, etc.

Il est d'ailleurs possible de modifier une valeur avec son index

>>> liste = ["a","d","m"]

>>> liste[0]

'a'

>>> liste[2]

'm'

>>> liste[2] = "z"

>>> liste

['a', 'd', 'z']

2.6.6.4 Supprimer une entrée avec un index

Il est parfois nécessaire de supprimer une entrée de la liste. Pour cela vous pouvez utiliser la
fonction del .

>>> liste = ["a", "b", "c"]

>>> del liste[1]

>>> liste

['a', 'c']

2.6.6.5 Supprimer une entrée avec sa valeur

Il est possible de supprimer une entrée d'une liste avec sa valeur avec la méthode remove .

>>> liste = ["a", "b", "c"]

>>> liste.remove("a")

>>> liste

['b', 'c']
2.6.6.6 Inverser les valeurs d'une liste
Vous pouvez inverser les items d'une liste avec la méthode reverse .

>>> liste = ["a", "b", "c"]

>>> liste.reverse()

>>> liste

['c', 'b', 'a']

2.6.6.7 Compter le nombre d'items d'une liste

Il est possible de compter le nombre d'items d'une liste avec la fonction len .

>>> liste = [1,2,3,5,10]

>>> len(liste)

2.6.6.8 Compter le nombre d'occurences d'une valeur

Pour connaitre le nombre d'occurences d'une valeur dans une liste, vous pouvez utiliser la
méthode count .

>>> liste = ["a","a","a","b","c","c"]

>>> liste.count("a")

>>> liste.count("c")

2.6.6.9 Trouver l'index d'une valeur

La méthode index vous permet de connaitre la position de l'item cherché.

>>> liste = ["a","a","a","b","c","c"]

>>> liste.index("b")

3
2.6.6.10 Manipuler une liste
Voici quelques astuces pour manipuler des listes:

>>> liste = [1, 10, 100, 250, 500]

>>> liste[0]

>>> liste[-1] # Cherche la dernière occurence

500

>>> liste[-4:] # Affiche les 4 dernières occurrences

[500, 250, 100, 10]

>>> liste[:] # Affiche toutes les occurences

[1, 10, 100, 250, 500]

>>> liste[2:4] = [69, 70]

[1, 10, 69, 70, 500]

>>> liste[:] = [] # vide la liste

[]

2.6.6.11 Boucler sur une liste

Pour afficher les valeurs d'une liste, on peut utiliser une boucle:

>>> liste = ["a","d","m"]

>>> for lettre in liste:

... print lettre

...

d
m

Si vous voulez en plus récupérer l'index, vous pouvez utiliser la fonction enumerate .

>>> for lettre in enumerate(liste):

... print lettre

...

(0, 'a')

(1, 'd')

(2, 'm')

Les valeurs retournées par la boucle sont des tuples.

2.6.6.12 Copier une liste

Beaucoup de débutants font l'erreur de copier une liste de cette manière

>>> x = [1,2,3]

>>> y = x

Or si vous changez une valeur de la liste y , la liste x sera elle aussi affectée par cette
modification:

>>> x = [1,2,3]

>>> y = x

>>> y[0] = 4

>>> x

[4, 2, 3]

En fait cette syntaxe permet de travailler sur un même élément nommé différemment

Alors comment copier une liste qui sera indépendante?

>>> x = [1,2,3]
>>> y = x[:]

>>> y[0] = 9

>>> x

[1, 2, 3]

>>> y

[9, 2, 3]

Pour des données plus complexes, vous pouvez utiliser la fonction deepcopy du module copy

>>> import copy

>>> x = [[1,2], 2]

>>> y = copy.deepcopy(x)

>>> y[1] = [1,2,3]

>>> x

[[1, 2], 2]

>>> y

[[1, 2], [1, 2, 3]]

2.6.6.13 Transformer une string en liste

Parfois il peut être utile de transformer une chaine de caractère en liste. Cela est possible avec
la méthode split .

>>> ma_chaine = "Olivier:ENGEL:Strasbourg"

>>> ma_chaine.split(":")

['Olivier', 'ENGEL', 'Strasbourg']

2.6.6.14 Transformer une liste en string

L'inverse est possible avec la méthode " join ".
>>> liste = ["Olivier","ENGEL","Strasbourg"]

>>> ":".join(liste)

'Olivier:ENGEL:Strasbourg'

2.6.6.15 Trouver un item dans une liste

Pour savoir si un élément est dans une liste, vous pouvez utiliser le mot clé in de cette manière:

>>> liste = [1,2,3,5,10]

>>> 3 in liste

True

>>> 11 in liste

False

2.6.6.16 La fonction range

La fonction range génère une liste composée d'une simple suite arithmétique.

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2.6.6.17 Agrandir une liste par une liste

Pour mettre bout à bout deux listes, vous pouvez utiliser la méthode extend

>>> x = [1, 2, 3, 4]

>>> y = [4, 5, 1, 0]

>>> x.extend(y)

>>> print x

[1, 2, 3, 4, 4, 5, 1, 0]

2.6.6.18 Permutations
La permutation d'un ensemble d'éléments est une liste de tous les cas possibles. Si vous avez
besoin de cette fonctionnalité, inutile de réinventer la roue, itertools s'en occupe pour vous.
>>> from itertools import permutations

>>> list(permutations(['a', 'b', 'c']))

[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]

2.6.6.19 Permutation d'une liste de liste

Comment afficher tous les cas possibles d'une liste elle-même composée de liste? Avec
l'outil product de itertools :

>>> from itertools import product

>>> list(product(['a', 'b'], ['c', 'd']))

[('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]

2.6.6.20 Astuces
Afficher les 2 premiers éléments d'une liste

>>> liste = [1,2,3,4,5]

>>> liste[:2]

[1, 2]

Afficher le dernier item d'une liste:

>>> liste = [1, 2, 3, 4, 5, 6]

>>> liste[-1]

Afficher le 3ème élément en partant de la fin:

>>> liste = [1, 2, 3, 4, 5, 6]

>>> liste[-3]

Afficher les 3 derniers éléments d'une liste:

>>> liste = [1, 2, 3, 4, 5, 6]

>>> liste[-3:]

[4, 5, 6]

Vous pouvez additionner deux listes pour les combiner ensemble en utilisant l'opérateur + :

>>> x = [1, 2, 3]

>>> y = [4, 5, 6]

>>> x + y

[1, 2, 3, 4, 5, 6]

Vous pouvez même mutiplier une liste:

>>> x = [1, 2]

>>> x*5

[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

Ce qui peut être utile pour initialiser une liste:

>>> [0] * 5

[0, 0, 0, 0, 0]

2.6.7 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.

Exemples :

>>> a = 2 + 3j

>>> type(a)

complex

>>> a
(2+3j)

>>> b = 1 + j

Traceback (most recent call last):

File "<pyshell#21>", line 1, in <module>

b=1+j

NameError: name 'j' is not defined

>>> b = 1 + 1j

>>> a * b

(-1+5j)

>>> 1j**2

(-1+0j)

2.7 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.

>>> 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

En fait, cela revient à :

>>> (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

>>> v

Comment écrire une fonction qui renvoie un p-uplet de valeurs ?

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

>>> a = test()

>>> a

(3, 4)

>>> b, c = test()

>>> b

>>> c

4
Remarque : Après return, il aurait été possible d’utiliser une notation avec des parenthèses
pour le tuple, par exemple return (3, 4).
Comment itérer sur les éléments d’un tuple ?

Comme une liste, il est possible de parcourir un tuple avec une boucle for.

for i in a:

print(i)

Résultat

La valeur d’un élément du tuple est obtenue en utilisant la même syntaxe que pour une liste.

>>> a[0]

>>> a[1]

Comment créer un tuple qui contient un seul élément ?

Si on utilise seulement des parenthèses, on n’obtient pas le résultat escompté.

>>> a = (3)

>>> a

>>> type(a)

int

En effet, les parenthèses sont alors considérées comme celles d’une expression
mathématique, comme par exemple dans 3*(4+1).

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

Deuxième approche

>>> d, = b

>>> d

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

Il est possible d’utiliser la syntaxe nom_de_variable, = aussi avec une liste à un élément.

>>> u = [5]

>>> v, = u

>>> v

2.8 Dictionnaires en Python

Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index , on utilise
des clés alphanumériques.

2.9 Comment créer un dictionnaire python?

Pour initialiser un dictionnaire, on utile la syntaxe suivante:

>>> a = {}
ou

>>> a = dict()

2.10 Comment ajouter des valeurs dans un dictionnaire python?

Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur:

>>> a = {}

>>> a["nom"] = "Wayne"

>>> a["prenom"] = "Bruce"

>>> a

{'nom': 'Wayne', 'prenom': 'Bruce'}

Vous pouvez utiliser des clés numériques comme dans la logique des listes .

2.11 Comment récupérer une valeur dans un dictionnaire python?

La méthode get vous permet de récupérer une valeur dans un dictionnaire et si la clé est
introuvable, vous pouvez donner une valeur à retourner par défaut:

>>> data = {"name": "Wayne", "age": 45}

>>> data.get("name")

'Wayne'

>>> data.get("adresse", "Adresse inconnue")

'Adresse inconnue'

2.12 Comment vérifier la présence d'une clé dans un dictionnaire python?

Vous pouvez utiliser la méthode haskey pour vérifier la présence d'une clé que vous cherchez:

>>> a.has_key("nom")

True

2.13 Comment supprimer une entrée dans un dictionnaire python?

Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes:
>>> del a["nom"]

>>> a

{'prenom': 'Bruce'}

2.14 Comment récupérer les clés d'un dictionnaire python par une boucle?
Pour récupérer les clés on utilise la méthode keys .

>>> fiche = {"nom":"Wayne", "prenom":"Bruce"}

>>> for cle in fiche.keys():

... print cle

...

nom

prenom

2.15 Comment récupérer les valeurs d'un dictionnaire python par une boucle?
Pour cela on utilise la méthode values .

>>> fiche = {"nom":"Wayne", "prenom":"Bruce"}

>>> for valeur in fiche.values():

... print valeur

...

Wayne

Bruce

2.16 Comment récupérer les clés et les valeurs d'un dictionnaire python par une boucle?
Pour récupérer les clés et les valeurs en même temps, on utilise la méthode items qui retourne
un tuple .

>>> fiche = {"nom":"Wayne","prenom":"Bruce"}

>>> for cle,valeur in fiche.items():

... print cle, valeur

...

nom Wayne

prenom Bruce

2.17 Comment utiliser des tuples comme clé dans un dictionnaire python?
Une des forces de python est la combinaison tuple/dictionnaire qui fait des merveilles dans
certains cas comme lors de l'utilisation de coordonnées.

>>> b = {}

>>> b[(32)]=12

>>> b[(45)]=13

>>> b

{(4, 5): 13, (3, 2): 12}

2.18 Comment créer une copie indépendante d'un dictionnaire python?

Comme pour toute variable, vous ne pouvez pas copier un dictionnaire en faisant dic1 = dic2 :

>>> d = {"k1":"Bruce", "k2":"Wayne"}

>>> e = d

>>> d["k1"] = "BATMAN"

>>> e

{'k2': 'Wayne', 'k1': 'BATMAN'}

Pour créer une copie indépendante vous pouvez utiliser la méthode copy :

>>> d = {"k1":"Bruce", "k2":"Wayne"}

>>> e = d.copy()

>>> d["k1"] = "BATMAN"

>>> e

{'k2': 'Wayne', 'k1': 'Bruce'}

2.19 Comment fusionner des dictionnaires python ?

La méthode update permet de fusionner deux dictionaires .

>>> a = {'nom': 'Wayne'}

>>> b = {'prenom': 'bruce'}

>>> a.update(b)

>>> print(a)

{'nom': 'Wayne', 'prenom': 'Bruce'}

3 Fonctions en Python
Nous avons déjà rencontré diverses fonctions prédéfinies : print(), input(), range(), len().

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() qui avait été définie par quelqu’un d’autre.

3.1 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

Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à 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.

3.2 Fonction sans paramètre

Exemple

def compteur3():

i=0

while i < 3:

print(i)

i=i+1

print("bonjour")

compteur3()

compteur3()

Affichage après exécution :

bonjour

En entrant ces quelques lignes, nous avons défini 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).

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().

Il est également possible de sauvegarder ce programme en tant que script au sein d’IDLE.
Après avoir exécuté ce script, pour utiliser à nouveau la fonction que nous venons de définir,
il suffit de l’appeler par son nom au niveau du shell. Ainsi :
>>> compteur3()

provoque l’affichage de :

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.

Exemple de fonction qui appelle 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 à notre langage de programmation.

3.3 Fonction avec paramètre

Exemple
def compteur(stop):

i=0

while i < stop:

print(i)

i=i+1

compteur(4)

compteur(2)

Affichage après exécution :

Pour tester cette nouvelle fonction, il nous suffit de l’appeler avec un argument.

3.4 Utilisation d’une variable comme argument

L’argument que nous utilisons dans l’appel d’une fonction peut être une variable.

Exemple

def compteur(stop):

i=0

while i < stop:

print(i)

i=i+1

a=5

compteur(a)

Affichage après exécution :

0
1

Avertissement
Dans l’exemple ci-dessus, l’argument que nous passons à 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 :

 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 si vous le voulez, mais vous devez bien
comprendre qu’ils ne désignent pas la même chose (en dépit du fait qu’ils puissent
contenir une valeur identique).

3.5 Fonction avec plusieurs paramètres

Exemple

La fonction suivante utilise trois paramètres : start qui contient la valeur de départ, stop la
borne supérieure exclue comme dans l’exemple précédent 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 :

3.6 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 trouvait les variables du programme principal. Dans l’espace de
noms local, nous aurons 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 d’une fonction, ces
variables ne sont accessibles qu’à la fonction elle-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.

Exemple

def test():

b=5

print(a, b)

a=2

b=7

test()

print(a, b)

Affichage après exécution :

25

27

3.7 Utilisation d’une variable globale - global

Il peut se faire par exemple que vous ayez à définir une fonction qui soit capable de modifier
une variable globale. Pour atteindre ce résultat, il vous suffira d’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.

On va ici créer une fonction qui a accès à la variable globale b.

def test():
 global b

b=5

print(a, b)

a=2

b=7

test()

print(a, b)

Affichage après exécution :

25

25

3.8 « Vraies » fonctions et procédures

Pour les puristes, 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 y = sin(a). On comprend
aisément que dans cette expression, la fonction sin() renvoie une valeur (le sinus de
l’argument) qui est directement affectée à la variable y.

Voici un exemple extrêmement simple :

def cube(w):

return w**3

>>> cube(3)

27

>>> a = cube(4)

>>> a

64

3.9 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.
Exemples :

def politesse(nom, titre ="Monsieur"):

print("Veuillez agréer,", titre, nom, ", mes salutations distinguées.")

>>> 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.

3.10 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 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)

>>> 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é

>>> oiseau()

Ce perroquet ne pourra pas danser la java

si vous le branchez sur 100 volts !

L'auteur de ceci est complètement allumé

3.11 Récursivité en python

Python admet la récursivité des fonctions, ce qui signifie qu'une fonction définie peut s'appeler elle-
même.

La récursivité est un concept mathématique et de programmation courant. Cela signifie qu'une

fonction s'appelle elle-même. Cela a l'avantage de signifier que vous pouvez parcourir les données
pour atteindre un résultat.

Le développeur doit être très prudent avec la récursivité car il peut être assez facile de se glisser dans
l'écriture d'une fonction qui ne se termine jamais, ou qui utilise des quantités excessives de mémoire
ou de puissance de processeur. Cependant, lorsqu'elle est écrite correctement, la récursivité peut être
une approche de programmation très efficace et mathématiquement élégante.

Dans cet exemple, recur_factoriel() est une fonction que nous avons définie pour s'appeler elle-même
.

Pour un nouveau développeur, cela peut prendre un certain temps pour comprendre comment cela
fonctionne exactement, la meilleure façon de le savoir est de le tester et de le modifier.

# Factoriel d’un nombre utilisant une fonction recursive

def recur_factoriel(n):
if n == 1:
return n
else:
return n*recur_factoriel(n-1)
num = 7
# choix si le nombre est negatif
if num < 0:
print("Désolé, le factoriel n’existe pas pour un nombre negatif ")
elif num == 0:
print("le factorial de 0 est 1")
else:
print("le factoriel de ", num, "est", recur_factoriel(num))
Autre exemple : fonction fibonacci

# Program to print the fibonacci series upto n_terms

#Fonction recursive
def recursive_fibonacci(n):
if n <= 1:
return n
else:
return(recursive_fibonacci(n-1) + recursive_fibonacci(n-2))

n_terms = 10

# check if the number of terms is valid

 if n_terms <= 0:
print("Invalid input ! Please input a positive value")
else:
print("Fibonacci series:")
for i in range(n_terms):
print(recursive_fibonacci(i))

3.12 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. Veuillez donc essayer vous-
même le petit programme ci-dessous, lequel calcule le volume d’une sphère a l’aide de la
formule :

V=43πR3V=43πR3

Exemple :

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))

A bien y regarder, 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().

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é.

En fait, le corps principal d’un programme Python constitue lui-même une entité un peu
particulière, qui est toujours reconnue dans le fonctionnement interne de l’interpréteur sous
le nom réservé __main__ (le mot « main » signifie « principal », en anglais. Il est encadré par
des caractères « souligné » en double, pour éviter toute confusion avec d’autres symboles).
L’exécution d’un script commence toujours avec la première instruction de cette entité
__main__, où qu’elle puisse se trouver dans le listing. Les instructions qui suivent sont alors
exécutées l’une après l’autre, dans l’ordre, jusqu’au premier appel de fonction. Un appel de
fonction est comme un détour dans le flux de l’exécution : au lieu de passer à l’instruction
suivante, l’interpréteur exécute la fonction appelée, puis revient au programme appelant pour
continuer le travail interrompu. Pour que ce mécanisme puisse fonctionner, il faut que
l’interpréteur ait pu lire la définition de la fonction avant l’entité __main__, et celle-ci sera
donc placée en général à la fin du script.

Dans notre exemple, l’entité __main__ appelle une première fonction qui elle-même en
appelle une deuxième. Cette situation est très fréquente en programmation. Si vous voulez
comprendre correctement ce qui se passe dans un programme, vous devez donc apprendre à
lire un script, non pas de la première à la dernière ligne, mais plutôt en suivant un
cheminement analogue à ce qui se passe lors de l’exécution de ce script. Cela signifie
concrètement que vous devrez souvent analyser un script en commençant par ses dernières
lignes !

3.13 Modules et importations

Dans cette page, nous allons répondre aux questions suivantes :

 comment utiliser une même fonction dans plusieurs programmes différents ?

 comment avoir la définition d’une fonction dans un fichier différent de celui qui
contient le programme principal ?

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é rect.py qui va définir 2 fonctions
: perimetre(long, larg) et surface(long, larg). 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.

#fonction surface

def surface(long,larg):

return(long*larg)
 #fonction perimetre

def perimetre(long,larg):

return(2*(long+larg))

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.

Exemple : on importe une seule fonction

from rect import perimetre

a=5

b=10

p = perimetre(a, b)

print("le perimètre du rectangle est", p)

Avertissement
Le fichier rect.py doit être dans le même répertoire que le programme principal (ou bien se
trouver dans le « path » de Python).

Exemple : on importe explicitement les deux fonctions

from rect import perimetre, surface

a=5

b=10

u = perimetre(a, b)

print("le perimetre vaut", u)

v = surface(a, b)

print("la surface vaut", v)

Exemple : on importe toutes les fonctions

from rect import *

a=5

b=10
u = perimetre(a, b)

print("le perimetre vaut", u)

v = surface(a, b)

print("la surface vaut", v)

Avertissement
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.

Exemple : on importe le module

import rect

a=5

b=10

u = perimetre(a, b)

print("le perimetre vaut", u)

v = surface(a, b)

print("la surface vaut", v)

Remarque : Dans ce cas, il faut préciser le nom du module devant la fonction.

Exemple : on importe le module et on lui donne un alias

import puissance as pu

a=5

u = pu.carre(a)

print("le carre vaut", u)

v = pu.cube(a)

print("le cube vaut", v)

Exemple : on importe une fonction d’un module et on lui donne un alias

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)

3.14 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 :

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.
Complément

Dans la documentation de Python, il est fait une distinction entre script et module. Voici
quelques précisions sur cette distinction.

En Python, lorsqu’on crée un fichier qui rassemble des instructions au lieu de les taper une à
une dans l’interpréteur, on appelle ce fichier un script et on le sauvegarde avec une
extension .py, par exemple essai.py.

Quand on est amené à travailler sur un programme long, il est utile de séparer le programme
en plusieurs fichiers. Certaines parties peuvent alors être réutilisées par d’autres programmes.

Il est par exemple possible d’effectuer la définition des fonctions dans un fichier séparé pour
ensuite les utiliser dans un script ou dans l’interpréteur. Le fichier qui contient ces définitions
a aussi une extension .py, mais on appelle ce fichier un module.

Les modalités pour importer un module sont expliquées plus haut dans cette page.
A l’intérieur d’un module, le nom du module (en tant que chaîne de caractères) peut être
obtenu grâce à la variable globale __name__. Par exemple, si on utilise le
module puissance.py défini précédemment, on a dans l’interpréteur :

>>> import puissance

>>> puissance.__name__

'puissance'

Un même fichier .py peut jouer le rôle de script ou de module suivant son utilisation.

Exécution d’un module en tant que script

Quand on utilise un fichier en tant que script, la variable globale __name__ prend pour
valeur '__main__'. Ceci permet d’avoir dans le fichier un bloc d’instructions qui sera exécuté
uniquement lorsque le fichier est lancé en tant que script.

Par exemple, pour le fichier puissance2.py suivant :

def carre(valeur):

resultat = valeur**2

return resultat

if __name__ == "__main__":

a=3

print("le carre vaut", carre(a))

On peut lancer une exécution directe en tant que script et on obtient alors :

le carre vaut 9

Ou bien on peut importer puissance2 en tant que module, par exemple dans le fichier suivant
:

import puissance2 as pu2

b=4

print("le carre vaut", pu2.carre(b))

Si on exécute ce script, on obtient :

le carre vaut 16
4 Python et mathématiques
4.1 Quelques bibliothèques
Numpy, Scipy et Matplotlib

Numpy : Un package incontournable pour commencer à faire du calcul scientifique sous Python

Scipy : un ensemble d’extensions permettant de compléter Numpy

Matplotlib : le package permettant de faire des visualisations 2D (mais pas que ...) de très haute
qualité, facilement et avec de très bonnes performances.

Installation des bibliothèques

Taper cmd pour obtenir l’invite de commande MS DOS

Normalement, si un module approprié est déjà installé, l’installer à nouveau n’aura aucun
effet. La mise à jour de modules existants doit être demandée explicitement :

python -m pip install --upgrade pip

Installation de numpy

python -m pip install numpy

Installation de matplotlib

python -m pip install matplotlib

Installation de scipy

python -m pip install scipy

Pandas est un module d'analyse de données. Il propose différents types de structures de

données pratiques à utiliser. Il fournit également la gestion de fichiers avec différents formats
de fichiers.

python -m pip install pandas

keras
python -m pip install keras

python -m pip install keras

python -m pip install pytorch

Autres bibliothèques

tensorflow

xgboost

seaborn

bokeh

plotly
pydot

4.2 Quelques fonctions mathématiques

4.3 Courbes
Pour tracer des courbes, Python n’est pas suffisant et nous avons besoin des
bibliothèques NumPy et matplotlib utilisées dans ce cours.

il suffit de faire :

from pylab import *

Il est alors possible d’accéder directement aux fonctions de NumPy et matplotlib.

Pour la syntaxe « standard », il faut importer le package numpy et le

module pyplot de matplotlib.

4.3.1 Utilisation de 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 1

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

Exemple 2
Dans cet exemple, nous allons tracer la fonction cosinus.
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

4.3.2 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().

xlim(xmin, xmax)
ylim(ymin, ymax)
Exemple 1
Syntaxe « PyLab »

from pylab import *

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

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

show()
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.xlim(-1, 5)

plt.show()
(Source code)

4.3.3 Ajout d’un titre - title()

On peut ajouter un titre grâce à l’instruction title().

Syntaxe « PyLab »

from pylab import *

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

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

show()
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.title("Fonction cosinus")

plt.show()

4.3.4 Ajout d’une légende - legend()

Syntaxe « PyLab »

from pylab import *

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

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

show()
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, label="cos(x)")
plt.legend()

plt.show()

Avertissement
Pour faire afficher le label, il ne faut pas oublier de faire appel à l’instruction legend().
4.3.5 Labels sur les axes - xlabel() et ylabel()
Des labels sur les axes peuvent être ajoutés avec les fonctions xlabel() et ylabel().
Syntaxe « PyLab »

from pylab import *

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

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

show()
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.xlabel("abscisses")
plt.ylabel("ordonnees")

plt.show()
4.3.6 Affichage de plusieurs courbes
Pour afficher plusieurs courbes sur un même graphe, on peut procéder de la façon suivante :
Syntaxe « PyLab »

from pylab import *

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

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

show()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

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

y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1)
plt.plot(x, y2)
plt.show()
4.3.7 Exemple avec un légende
Syntaxe « PyLab »

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()

Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

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

y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, label="cos(x)")
plt.plot(x, y2, label="sin(x)")
plt.legend()
plt.show()
4.3.8 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 :

Syntaxe « PyLab »

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()

Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

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

y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, "r--", label="cos(x)")
plt.plot(x, y2, "b:o", label="sin(x)")
plt.legend()
plt.show()
4.3.9 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
Avertissement
Si on ne veut pas faire apparaître de ligne, il suffit d’indiquer un symbole sans préciser un style
de ligne.
Exemple

Syntaxe « PyLab »

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()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

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

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

4.3.10 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

p pentagon marker
 Chaîne Effet
* star marker

h hexagon1 marker

H hexagon2 marker

+ plus marker

x x marker

D diamond marker

d thin_diamond marker

| vline marker

_ hline marker

4.3.11 Couleur
Les chaînes de caractères suivantes permettent de définir la couleur :

Chaîne Couleur en anglais Couleur en français

b blue bleu

g green vert

r red rouge

c cyan cyan

m magenta magenta

y yellow jaune

k black noir

w white blanc

4.3.12 Largeur de ligne

Pour modifier la largeur des lignes, il est possible de changer la valeur de l’argument linewidth.
Syntaxe « PyLab »

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()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

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

y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, label="cos(x)")
plt.plot(x, y2, label="sin(x)", linewidth=4)
plt.legend()
plt.show()

4.3.13 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.
Syntaxe « PyLab »

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()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

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

4.3.14 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.

Syntaxe « PyLab »

from pylab import *

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

Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt

x = np.array([0, 1, 1, 0, 0])
y = np.array([0, 0, 1, 1, 0])
plt.plot(x, y)
plt.axis("equal")
plt.show()
Il est aussi possible de fixer le domaine des abscisses en utilisant xlim().
Syntaxe « PyLab »

from pylab import *

x = array([0, 1, 1, 0, 0])
y = array([0, 0, 1, 1, 0])
plot(x, y)
axis("equal")
xlim(-1, 2)
show()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt
x = np.array([0, 1, 1, 0, 0])
y = np.array([0, 0, 1, 1, 0])
plt.plot(x, y)
plt.axis("equal")
plt.xlim(-1, 2)
plt.show()

4.3.15 Tracé d’un cercle

On peut tracer utiliser une courbe paramétrique pour tracer un cercle.

Sans axis("equal"), la courbe n’apparaît pas comme un cercle.

Syntaxe « PyLab »

from pylab import *

theta = linspace(0, 2*pi, 40)
x = cos(theta)
y = sin(theta)
plot(x, y)
show()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt
theta = np.linspace(0, 2*np.pi, 40)
x = np.cos(theta)
y = np.sin(theta)
plt.plot(x, y)
plt.show()

Avec axis("equal"), on obtient bien un cercle.

Syntaxe « PyLab »

from pylab import *

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

x = cos(theta)
y = sin(theta)
plot(x, y)
axis("equal")
show()
Syntaxe « standard »

import numpy as np
import matplotlib.pyplot as plt
theta = np.linspace(0, 2*np.pi, 40)
x = np.cos(theta)
y = np.sin(theta)
plt.plot(x, y)
plt.axis("equal")
plt.show()
 4.3.16 Tracé de diagrammes en bâtons et histogrammes

On peut tracer assez facilement à partir de séries statistiques des diagrammes en bâtons et
des histogrammes. Voici un exemple de chaque :

 Pour les diagrammes en bâtons, on utilise la fonction bar(valeurs,effectifs).

Diagramme en bâtons

import matplotlib.pyplot as plt

import numpy as np

x = [3, 5, 6, 7]

y = [4, 1, 3, 4]

plt.bar(x,y)

plt.show()

Plotting with categorical variables

Il est également possible de créer un graphique à l'aide de variables catégorielles. Matplotlib vous
permet de transmettre des variables catégorielles directement à de nombreuses fonctions de traçage.
Par exemple:

import matplotlib.pyplot as plt

names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]
plt.figure(figsize=(9, 3))
plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Bar Chart

import matplotlib.pyplot as plt

# x-coordinates of left sides of bars
left = [1, 2, 3, 4, 5]
# heights of bars
height = [10, 24, 36, 40, 5]
# labels for bars
tick_label = ['one', 'two', 'three', 'four', 'five']
# plotting a bar chart
plt.bar(left, height, tick_label = tick_label,
width = 0.8, color = ['red', 'green'])
# naming the x-axis
plt.xlabel('x - axis')
# naming the y-axis
plt.ylabel('y - axis')
# plot title
plt.title('My bar chart!')
# function to show the plot
plt.show()
Output :
• Ici, nous utilisons la fonction plt.bar () pour tracer un histogramme.

• Les coordonnées x du côté gauche des barres sont transmises avec les hauteurs des barres.

• vous pouvez également donner un nom aux coordonnées de l'axe x en définissant tick_labels

Histogramme

filter_none
edit
play_arrow
brightness_4

import matplotlib.pyplot as plt

# frequencies
ages = [2,5,70,40,30,45,50,45,43,40,44,
60,7,13,57,18,90,77,32,21,20,40]
# setting the ranges and no. of intervals
range = (0, 100)
bins = 10
# plotting a histogram
plt.hist(ages, bins, range, color = 'green',
histtype = 'bar', rwidth = 0.8)
# x-axis label
plt.xlabel('age')
# frequency label
plt.ylabel('No. of people')
# plot title
plt.title('My histogram')
# function to show the plot
plt.show()
Output:
  Here, we use plt.hist() function to plot a histogram.
 frequencies are passed as the ages list.
 Range could be set by defining a tuple containing min and max value.
 Next step is to “bin” the range of values—that is, divide the entire range of values into a
series of intervals—and then count how many values fall into each interval. Here we
have defined bins = 10. So, there are a total of 100/10 = 10 intervals.

Pie-chart

import matplotlib.pyplot as plt

# defining labels
activities = ['eat', 'sleep', 'work', 'play']
# portion covered by each label
slices = [3, 7, 8, 6]
# color for each label
colors = ['r', 'y', 'g', 'b']
# plotting the pie chart
plt.pie(slices, labels = activities, colors=colors,
startangle=90, shadow = True, explode = (0, 0, 0.1, 0),
radius = 1.2, autopct = '%1.1f%%')
# plotting legend
plt.legend()
# showing the plot
plt.show()
Output of above program looks like this:
  Here, we plot a pie chart by using plt.pie() method.
 First of all, we define the labels using a list called activities.
 Then, portion of each label can be defined using another list called slices.
 Color for each label is defined using a list called colors.
 shadow = True will show a shadow beneath each label in pie-chart.
 startangle rotates the start of the pie chart by given degrees counterclockwise from the
x-axis.
 explode is used to set the fraction of radius with which we offset each wedge.
autopct is used to format the value of each label. Here, we have set it to show the percentage
value only upto 1 decimal place.
Pour les histogrammes, on utilise la fonction hist(liste,[n]) qui trace l'histogramme de la liste
répartie en n groupes(si n est précisé). Par exemple si on lance deux dés au hasard et qu'on
fait leur somme et qu'on répète 1000 fois ceci. On peut tracer l'histogramme des résultats en
écrivant : Histogramme

import matplotlib.pyplot as plt

import numpy as np

from random import *

liste =[randint(1,6)+randint(1,6) for _ in range(1000)]

plt.hist(liste,11)

plt.show()
4.3.17 Affichages de nuages de points

Pour tracer des points, il suffit d'utiliser la fonction plt.scatter(abscisses,

ordonnées) où abscisses est la liste des abscisses des points qu'on veut tracer et ordonnées la
liste des ordonnées.
Par exemple si on veut placer les points (1,2), (3,3), (2,1) et (1,3) :
Nuage de points

import matplotlib.pyplot as plt

import numpy as np

x = [ 1, 3, 2, 1]

y = [ 2, 3, 1, 3]

plt.scatter(x,y)

plt.show()

Il peut être intéressant de modifier la couleur selon que les coordonnées vérifient une
condition ou pas. Pour cela, on peut fournir en plus une liste de couleur pour chaque point
avec l'argument c= liste_couleurs. On peut modifier la taille des points avec l'argument s=.
Voici un nuage de 5000 points pris au hasard. On a coloré en rouge ceux qui vérifient la
condition y<x².
Nuage de points

import matplotlib.pyplot as plt

import numpy as np

from random import *

# Fonction qui crée la liste de couleurs en fonction de la condition

def donner_couleur(x,y):

couleurs=[]

for i in range(len(x)):

if y[i]<x[i]**2 : couleurs.append("r")

else : couleurs.append("b")

return couleurs

x = [random() for _ in range(5000)]

y = [random() for _ in range(5000)]

plt.scatter(x,y,s=1,c=donner_couleur(x,y))

plt.show()
Representation en 3D
from pylab import *
from mpl_toolkits.mplot3d import Axes3D
fig = figure()
ax = Axes3D(fig)
X = np.arange(-4, 4, 0.25)
Y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='hot')
show()

4.3.18 Tracé multiples

En vous basant sur le code suivant, essayez d'obtenir le graphique représenté dans l'illustration de
droite

from pylab import *

subplot(2,2,1)
subplot(2,2,3)
subplot(2,2,4)
show()
 es

4.3.19 Tutoriel sur mplot3d

Un objet Axes3D est créé comme tout autre axe en utilisant le mot clé projection='3d'. Créez une
nouvelle figure matplotlib.figure.figure et ajoutez-lui un nouvel axe de type Axes3D :

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

Dans sa nouvelle version 1.0.0: cette approche est préférable pour créer des courbes en 3D
axes.

Note

Prior to version 1.0.0, the method of creating a 3D axes was different. For those using older
versions of matplotlib, change ax = fig.add_subplot(111, projection='3d') to ax = Axes3D(fig).
Line plots

Axes3D.plot(xs, ys, *args, **kwargs)

Plot 2D or 3D data.

Argument Description

xs, ys x, y coordinates of vertices

zs z value(s), either one for all points or one for each point.

zdir Which direction to use as z (‘x’, ‘y’ or ‘z’) when plotting a 2D set.

Other arguments are passed on to plot()

import matplotlib as mpl

 from mpl_toolkits.mplot3d import Axes3D

import numpy as np

import matplotlib.pyplot as plt

mpl.rcParams['legend.fontsize'] = 10

fig = plt.figure()

ax = fig.gca(projection='3d')

theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)

z = np.linspace(-2, 2, 100)

r = z**2 + 1

x = r * np.sin(theta)

y = r * np.cos(theta)

ax.plot(x, y, z, label='parametric curve')

ax.legend()

plt.show()

Scatter plots

Axes3D.scatter(xs, ys, zs=0, zdir='z', s=20, c=None, depthshade=True, *args, **kwargs)

Create a scatter plot.
Argument Description

xs, ys Positions of data points.

Either an array of the same length as xs and ys or a single value to place

zs
all points in the same plane. Default is 0.

zdir Which direction to use as z (‘x’, ‘y’ or ‘z’) when plotting a 2D set.

s Size in points^2. It is a scalar or an array of the same length as x and y.

A color. c can be a single color format string, or a sequence of color

specifications of length N, or a sequence of N numbers to be mapped to
colors using the cmap and norm specified via kwargs (see below). Note
c that c should not be a single numeric RGB or RGBA sequence because
that is indistinguishable from an array of values to be colormapped. c can
be a 2-D array in which the rows are RGB or RGBA, however, including
the case of a single row to specify the same color for all points.

Whether or not to shade the scatter markers to give the appearance of

depthshade
depth. Default is True.

Keyword arguments are passed on to scatter().

Returns a Patch3DCollection

'''

==============

3D scatterplot

==============

Demonstration of a basic scatterplot in 3D.

'''

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

import numpy as np

def randrange(n, vmin, vmax):

'''

Helper function to make an array of random numbers having shape (n, )

 with each number distributed Uniform(vmin, vmax).

'''

return (vmax - vmin)*np.random.rand(n) + vmin

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

n = 100

# For each set of style and range settings, plot n random points in the box

# defined by x in [23, 32], y in [0, 100], z in [zlow, zhigh].

for c, m, zlow, zhigh in [('r', 'o', -50, -25), ('b', '^', -30, -5)]:

xs = randrange(n, 23, 32)

ys = randrange(n, 0, 100)

zs = randrange(n, zlow, zhigh)

ax.scatter(xs, ys, zs, c=c, marker=m)

ax.set_xlabel('X Label')

ax.set_ylabel('Y Label')

ax.set_zlabel('Z Label')

plt.show()
Wireframe plots

Axes3D.plot_wireframe(X, Y, Z, *args, **kwargs)

Plot a 3D wireframe.

The rstride and cstride kwargs set the stride used to sample the input data to
generate the graph. If either is 0 the input data in not sampled along this direction
producing a 3D line plot rather than a wireframe plot. The stride arguments are
only used by default if in the ‘classic’ mode. They are now superseded
by rcount and ccount. Will raise ValueError if both stride and count are used.

` The rcount and ccount kwargs supersedes rstride and

cstride for default sampling method for wireframe plotting. These arguments will
determine at most how many evenly spaced samples will be taken from the input data
to generate the graph. This is the default sampling method unless using the ‘classic’
style. Will raise ValueError if both stride and count are specified. If either is zero, then
the input data is not sampled along this direction, producing a 3D line plot rather than
a wireframe plot. Added in v2.0.0.

Argument Description

X, Y, Data values as 2D arrays

rstride Array row stride (step size), defaults to 1

 Argument Description

cstride Array column stride (step size), defaults to 1

rcount Use at most this many rows, defaults to 50

ccount Use at most this many columns, defaults to 50

Keyword arguments are passed on to LineCollection.

Returns a Line3DCollection

''' =================

3D wireframe plot

=================

A very basic demonstration of a wireframe plot.

'''

from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

# Grab some test data.

X, Y, Z = axes3d.get_test_data(0.05)

# Plot a basic wireframe.

ax.plot_wireframe(X, Y, Z, rstride=10, cstride=10)

plt.show()
Surface plots

Axes3D.plot_surface(X, Y, Z, *args, **kwargs)

Create a surface plot.

By default it will be colored in shades of a solid color, but it also supports color mapping
by supplying the cmap argument.

The rstride and cstride kwargs set the stride used to sample the input data to generate
the graph. If 1k by 1k arrays are passed in, the default values for the strides will result
in a 100x100 grid being plotted. Defaults to 10. Raises a ValueError if both stride and
count kwargs (see next section) are provided.

The rcount and ccount kwargs supersedes rstride and cstride for default sampling
method for surface plotting. These arguments will determine at most how many evenly
spaced samples will be taken from the input data to generate the graph. This is the
default sampling method unless using the ‘classic’ style. Will raise ValueError if both
stride and count are specified. Added in v2.0.0.

Argument Description

X, Y, Z Data values as 2D arrays

rstride Array row stride (step size)

 Argument Description

cstride Array column stride (step size)

rcount Use at most this many rows, defaults to 50

ccount Use at most this many columns, defaults to 50

color Color of the surface patches

cmap A colormap for the surface patches.

facecolors Face colors for the individual patches

norm An instance of Normalize to map values to colors

vmin Minimum value to map

vmax Maximum value to map

shade Whether to shade the facecolors

Other arguments are passed on to Poly3DCollection

''' ======================

3D surface (color map)

======================

Demonstrates plotting a 3D surface colored with the coolwarm color map.

The surface is made opaque by using antialiased=False.

Also demonstrates using the LinearLocator and custom formatting for the

z axis tick labels.

'''

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

from matplotlib import cm

from matplotlib.ticker import LinearLocator, FormatStrFormatter

import numpy as np

fig = plt.figure()
ax = fig.gca(projection='3d')

# Make data.

X = np.arange(-5, 5, 0.25)

Y = np.arange(-5, 5, 0.25)

X, Y = np.meshgrid(X, Y)

R = np.sqrt(X**2 + Y**2)

Z = np.sin(R)

# Plot the surface.

surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,

linewidth=0, antialiased=False)

# Customize the z axis.

ax.set_zlim(-1.01, 1.01)

ax.zaxis.set_major_locator(LinearLocator(10))

ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))

# Add a color bar which maps values to colors.

fig.colorbar(surf, shrink=0.5, aspect=5)

plt.show()
''' ========================

3D surface (solid color)

========================

Demonstrates a very basic plot of a 3D surface using a solid color.

'''

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

import numpy as np

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

# Make data

u = np.linspace(0, 2 * np.pi, 100)

v = np.linspace(0, np.pi, 100)

x = 10 * np.outer(np.cos(u), np.sin(v))

y = 10 * np.outer(np.sin(u), np.sin(v))

z = 10 * np.outer(np.ones(np.size(u)), np.cos(v))
# Plot the surface

ax.plot_surface(x, y, z, color='b')

plt.show()

''' =========================

3D surface (checkerboard)

=========================

Demonstrates plotting a 3D surface colored in a checkerboard pattern.

'''

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

from matplotlib import cm

from matplotlib.ticker import LinearLocator

import numpy as np

fig = plt.figure()

ax = fig.gca(projection='3d')

# Make data.
X = np.arange(-5, 5, 0.25)

xlen = len(X)

Y = np.arange(-5, 5, 0.25)

ylen = len(Y)

X, Y = np.meshgrid(X, Y)

R = np.sqrt(X**2 + Y**2)

Z = np.sin(R)

# Create an empty array of strings with the same shape as the meshgrid, and

# populate it with two colors in a checkerboard pattern.

colortuple = ('y', 'b')

colors = np.empty(X.shape, dtype=str)

for y in range(ylen):

for x in range(xlen):

colors[x, y] = colortuple[(x + y) % len(colortuple)]

# Plot the surface with face colors taken from the array we made.

surf = ax.plot_surface(X, Y, Z, facecolors=colors, linewidth=0)

# Customize the z axis.

ax.set_zlim(-1, 1)

ax.w_zaxis.set_major_locator(LinearLocator(6))

plt.show()
Tri-Surface plots

Axes3D.plot_trisurf(*args, **kwargs)
Argument Description

X, Y, Z Data values as 1D arrays

color Color of the surface patches

cmap A colormap for the surface patches.

norm An instance of Normalize to map values to colors

vmin Minimum value to map

vmax Maximum value to map

shade Whether to shade the facecolors

The (optional) triangulation can be specified in one of two ways; either:

plot_trisurf(triangulation, ...)

where triangulation is a Triangulation object, or:

plot_trisurf(X, Y, ...)
plot_trisurf(X, Y, triangles, ...)
plot_trisurf(X, Y, triangles=triangles, ...)
in which case a Triangulation object will be created. See Triangulation for a explanation
of these possibilities.

The remaining arguments are:

plot_trisurf(..., Z)

where Z is the array of values to contour, one per point in the triangulation.

Other arguments are passed on to Poly3DCollection

Exemples :

''' ======================

Triangular 3D surfaces

======================

Plot a 3D surface with a triangular mesh.

'''

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

import numpy as np

n_radii = 8

n_angles = 36

# Make radii and angles spaces (radius r=0 omitted to eliminate duplication).

radii = np.linspace(0.125, 1.0, n_radii)

angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)

# Repeat all angles for each radius.

angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)

# Convert polar (radii, angles) coords to cartesian (x, y) coords.

# (0, 0) is manually added at this stage, so there will be no duplicate

# points in the (x, y) plane.

x = np.append(0, (radii*np.cos(angles)).flatten())

y = np.append(0, (radii*np.sin(angles)).flatten())
# Compute z to make the pringle surface.

z = np.sin(-x*y)

fig = plt.figure()

ax = fig.gca(projection='3d')

ax.plot_trisurf(x, y, z, linewidth=0.2, antialiased=True)

plt.show()

''' ===========================

More triangular 3D surfaces

===========================

Two additional examples of plotting surfaces with triangular mesh.

The first demonstrates use of plot_trisurf's triangles argument, and the

second sets a Triangulation object's mask and passes the object directly

to plot_trisurf.

'''

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.tri as mtri

fig = plt.figure(figsize=plt.figaspect(0.5))

#============

# First plot

#============

# Make a mesh in the space of parameterisation variables u and v

u = np.linspace(0, 2.0 * np.pi, endpoint=True, num=50)

v = np.linspace(-0.5, 0.5, endpoint=True, num=10)

u, v = np.meshgrid(u, v)

u, v = u.flatten(), v.flatten()

# This is the Mobius mapping, taking a u, v pair and returning an x, y, z

# triple

x = (1 + 0.5 * v * np.cos(u / 2.0)) * np.cos(u)

y = (1 + 0.5 * v * np.cos(u / 2.0)) * np.sin(u)

z = 0.5 * v * np.sin(u / 2.0)

# Triangulate parameter space to determine the triangles

tri = mtri.Triangulation(u, v)

# Plot the surface. The triangles in parameter space determine which x, y, z

# points are connected by an edge.

ax = fig.add_subplot(1, 2, 1, projection='3d')

ax.plot_trisurf(x, y, z, triangles=tri.triangles, cmap=plt.cm.Spectral)

ax.set_zlim(-1, 1)

#============

# Second plot

#============

# Make parameter spaces radii and angles.

n_angles = 36

n_radii = 8

min_radius = 0.25

radii = np.linspace(min_radius, 0.95, n_radii)

angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)

angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)

angles[:, 1::2] += np.pi/n_angles

# Map radius, angle pairs to x, y, z points.

x = (radii*np.cos(angles)).flatten()

y = (radii*np.sin(angles)).flatten()

z = (np.cos(radii)*np.cos(angles*3.0)).flatten()

# Create the Triangulation; no triangles so Delaunay triangulation created.

triang = mtri.Triangulation(x, y)

# Mask off unwanted triangles.

xmid = x[triang.triangles].mean(axis=1)

ymid = y[triang.triangles].mean(axis=1)

mask = np.where(xmid**2 + ymid**2 < min_radius**2, 1, 0)

triang.set_mask(mask)

# Plot the surface.

ax = fig.add_subplot(1, 2, 2, projection='3d')

ax.plot_trisurf(triang, z, cmap=plt.cm.CMRmap)

plt.show()
 New in version 1.2.0: This plotting function was added for the v1.2.0 release.

''' ======================

Triangular 3D surfaces

======================

Plot a 3D surface with a triangular mesh.

'''

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

import numpy as np

n_radii = 8

n_angles = 36

# Make radii and angles spaces (radius r=0 omitted to eliminate duplication).

radii = np.linspace(0.125, 1.0, n_radii)

angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)

# Repeat all angles for each radius.

angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)

# Convert polar (radii, angles) coords to cartesian (x, y) coords.

# (0, 0) is manually added at this stage, so there will be no duplicate

# points in the (x, y) plane.

x = np.append(0, (radii*np.cos(angles)).flatten())

y = np.append(0, (radii*np.sin(angles)).flatten())

# Compute z to make the pringle surface.

z = np.sin(-x*y)

fig = plt.figure()

ax = fig.gca(projection='3d')

ax.plot_trisurf(x, y, z, linewidth=0.2, antialiased=True)

plt.show()

Contour plots

Axes3D.contour(X, Y, Z, *args, **kwargs)

Create a 3D contour plot.

Argument Description

X, Y, Data values as numpy.arrays

Z
 Argument Description

extend3d Whether to extend contour in 3D (default: False)

stride Stride (step size) for extending contour

zdir The direction to use: x, y or z (default)

If specified plot a projection of the contour lines on this position in

offset
plane normal to zdir

The positional and other keyword arguments are passed on to contour()

Returns a contour

from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

from matplotlib import cm

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

X, Y, Z = axes3d.get_test_data(0.05)

cset = ax.contour(X, Y, Z, cmap=cm.coolwarm)

ax.clabel(cset, fontsize=9, inline=1)

plt.show()
from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

from matplotlib import cm

fig = plt.figure()

ax = fig.gca(projection='3d')

X, Y, Z = axes3d.get_test_data(0.05)

cset = ax.contour(X, Y, Z, extend3d=True, cmap=cm.coolwarm)

ax.clabel(cset, fontsize=9, inline=1)

plt.show()
from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

from matplotlib import cm

fig = plt.figure()

ax = fig.gca(projection='3d')

X, Y, Z = axes3d.get_test_data(0.05)

ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3)

cset = ax.contour(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)

cset = ax.contour(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)

cset = ax.contour(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)

ax.set_xlabel('X')

ax.set_xlim(-40, 40)

ax.set_ylabel('Y')
ax.set_ylim(-40, 40)

ax.set_zlabel('Z')

ax.set_zlim(-100, 100)

plt.show()

Filled contour plots

Axes3D.contourf(X, Y, Z, *args, **kwargs)

Create a 3D contourf plot.

Argument Description

X, Y, Data values as numpy.arrays

zdir The direction to use: x, y or z (default)

If specified plot a projection of the filled contour on this position in

offset
plane normal to zdir

The positional and keyword arguments are passed on to contourf()

Returns a contourf
 Changed in version 1.1.0: The zdir and offset kwargs were added.

from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

from matplotlib import cm

fig = plt.figure()

ax = fig.gca(projection='3d')

X, Y, Z = axes3d.get_test_data(0.05)

cset = ax.contourf(X, Y, Z, cmap=cm.coolwarm)

ax.clabel(cset, fontsize=9, inline=1)

plt.show()

""" .. versionadded:: 1.1.0

This demo depends on new features added to contourf3d. """

from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

from matplotlib import cm

fig = plt.figure()
ax = fig.gca(projection='3d')

X, Y, Z = axes3d.get_test_data(0.05)

ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3)

cset = ax.contourf(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)

cset = ax.contourf(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)

cset = ax.contourf(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)

ax.set_xlabel('X')

ax.set_xlim(-40, 40)

ax.set_ylabel('Y')

ax.set_ylim(-40, 40)

ax.set_zlabel('Z')

ax.set_zlim(-100, 100)

plt.show()

Nouveau dans la version 1.1.0 : La fonctionnalité présentée dans le deuxième exemple de

contourf3d a été activée à la suite d'une correction de bogue pour la version 1.1.0.

Polygon plots

Axes3D.add_collection3d(col, zs=0, zdir='z')

 Add a 3D collection object to the plot.

2D collection types are converted to a 3D version by modifying the object and adding z
coordinate information.

Supported are:

 PolyCollection
 LineColleciton
 PatchCollection

4.4 Tableaux et calcul matriciel

Dans cette page, nous utilisons un style de programmation orienté objet pour l’utilisation de
la bibliothèque NumPy. Il existe toutefois un style plus simple basé sur l’interface « PyLab »,
qui se rapproche plus du style de programmation utilisé dans Matlab et pour lequel vous
pouvez trouver une présentation dans la page Tableaux et calcul matriciel avec PyLab
Nous allons voir comment créer des tableaux avec la fonction numpy.array() de NumPy. Ces
tableaux pourront être utilisés comme des vecteurs ou des matrices grâce à des fonctions
de NumPy (numpy.dot(), numpy.linalg.det(), numpy.linalg.inv(), numpy.linalg.eig(), etc.) qui
permettent de réaliser des calculs matriciels utilisés en algèbre.
Nous allons travailler en interactif.
Premièrement, nous allons importer le module numpy. Pour cela, il suffit de faire :

import numpy as np

Note
Dans la syntaxe « standard », on importe la totalité du module numpy et on lui donne un alias
pour alléger ensuite l’écriture de l’appel des fonctions. L’alias qui est le plus couramment utilisé
est np. Pour en savoir plus sur l’importation et la création d’un alias, vous pouvez consulter la
page Modules et importations.
4.4.1 Tableaux - numpy.array()
Pour créer des tableaux, nous allons utiliser numpy.array().

Tableaux monodimensionnels (1D)

Pour créer un tableau 1D, il suffit de passer une liste de nombres en argument
de numpy.array(). Un liste est constituée de nombres séparés par des virgules et entourés de
crochets ([ et ]).

>>> a = np.array([4,7,9])
>>> a
array([4, 7, 9])

Pour connaître le type du résultat de numpy.array(), on peut utiliser la fonction type().

>>> type(a)
numpy.ndarray

On constate que ce type est issu du package numpy. Ce type est différent de celui d’une liste.

>>> type([4, 7, 9])

list

4.4.2 Tableaux bidimensionnels (2D)

Pour créer un tableau 2D, il faut transmettre à numpy.array() une liste de listes grâce à des
crochets imbriqués.

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

>>> a
array([[1, 2, 3],
[4, 5, 6]])

4.4.3 La fonction numpy.size()

La fonction numpy.size() renvoie le nombre d’éléments du tableau.

>>> a = np.array([2,5,6,8])
>>> np.size(a)
4
>>> b = np.array([[1, 2, 3],
[4, 5, 6]])
>>> np.size(b)
6

4.4.4 Fonction numpy.shape()

La fonction numpy.shape() (forme, en anglais) renvoie la taille du tableau.

>>> a = np.array([2,5,6,8])
>>> np.shape(a)
(4,)
>>> b = np.array([[1, 2, 3],
[4, 5, 6]])
>>> np.shape(b)
(2, 3)

On distingue bien ici que a et b correspondent à des tableaux 1D et 2D, respectivement.

4.4.5 Produit terme à terme

Il est possible de réaliser un produit terme à terme grâce à l’opérateur *. Il faut dans ce cas que les deux
tableaux aient la même taille.

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

[4, 5, 6]])
>>> b = np.array([[2, 1, 3],
[3, 2, 1]])
>>> a*b
array([[ 2, 2, 9],
[12, 10, 6]])

4.4.6 Produit matriciel - numpy.dot()

Un tableau peut jouer le rôle d’une matrice si on lui applique une opération de calcul matriciel.
Par exemple, la fonction numpy.dot() permet de réaliser le produit matriciel.

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

[4, 5, 6]])
>>> b = np.array([[4],
[2],
[1]])
>>> np.dot(a,b)
array([[11],
[32]])

Le produit d’une matrice de taille n x m par une matrice m x p donne une matrice n x p.
4.4.7 Transposé

>>> a.T
array([[1, 4],
[2, 5],
[3, 6]])

4.4.8 Complexe conjugué - numpy.conj()

>>> u = np.array([[ 2j, 4+3j],

[2+5j, 5],
[3, 6+2j]])
>>> np.conj(u)
array([[ 0.-2.j, 4.-3.j],
[ 2.-5.j, 5.+0.j],
 [ 3.+0.j, 6.-2.j]])

4.4.9 Transposé complexe conjugué

>>> np.conj(u).T
array([[ 0.-2.j, 2.-5.j, 3.+0.j],
[ 4.-3.j, 5.+0.j, 6.-2.j]])

4.4.10 Tableaux et slicing

Lors de la manipulation des tableaux, on a souvent besoin de récupérer une partie d’un
tableau. Pour cela, Python permet d’extraire des tranches d’un tableau grâce une technique
appelée slicing (tranchage, en français). Elle consiste à indiquer entre crochets des indices
pour définir le début et la fin de la tranche et à les séparer par deux-points :.

>>> a = np.array([12, 25, 34, 56, 87])

>>> a[1:3]
array([25, 34])

Dans la tranche [n:m], l’élément d’indice n est inclus, mais pas celui d’indice m. Un moyen
pour mémoriser ce mécanisme consiste à considérer que les limites de la tranche sont définies
par les numéros des positions situées entre les éléments, comme dans le schéma ci-dessous :

Il est aussi possible de ne pas mettre de début ou de fin.

>>> a[1:]
array([25, 34, 56, 87])
>>> a[:3]
array([12, 25, 34])
>>> a[:]
array([12, 25, 34, 56, 87])

4.4.11 Slicing des tableaux 2D

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

[4, 5, 6]])
>>> a[0,1]
2
>>> a[:,1:3]
array([[2, 3],
[5, 6]])
>>> a[:,1]
array([2, 5])
>>> a[0,:]
array([1, 2, 3])

Avertissement
a[:,n] donne un tableau 1D correspondant à la colonne d’indice n de a. Si on veut obtenir un
tableau 2D correspondant à la colonne d’indice n, il faut faire du slicing en utilisant a[:,n:n+1].
>>> a[:,1:2]
array([[2],
[5]])

4.4.12 Tableaux de 0 - numpy.zeros()

zeros(n) renvoie un tableau 1D de n zéros.

>>> np.zeros(3)
array([ 0., 0., 0.])

zeros((m,n)) renvoie tableau 2D de taille m x n, c’est-à-dire de shape (m,n).

>>> np.zeros((2,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.]])

4.4.13 Tableaux de 1 - numpy.ones()

>>> np.ones(3)
array([ 1., 1., 1.])
>>> np.ones((2,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.]])

4.4.14 Matrice identité - numpy.eye()

eye(n) renvoie tableau 2D carré de taille n x n, avec des uns sur la diagonale et
des zéros partout ailleurs.

>>> np.eye(3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])

4.4.15 Déterminant - numpy.linalg.det()

>>> from numpy.linalg import det
>>> a = np.array([[1, 2],
[3, 4]])
>>> det(a)
-2.0

4.4.16 Inverse - numpy.linalg.inv()

>>> from numpy.linalg import inv

>>> a = np.array([[1, 3, 3],
[1, 4, 3],
[1, 3, 4]])
>>> inv(a)
array([[ 7., -3., -3.],
[-1., 1., 0.],
[-1., 0., 1.]])

4.4.17 Résolution d’un système d’équations linéaires - numpy.linalg.solve()

Pour résoudre le système d’équations linéaires 3 * x0 + x1 = 9 et x0 + 2 * x1 = 8 :

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

>>> b = np.array([9,8])
>>> x = np.linalg.solve(a, b)
>>> x
array([ 2., 3.])

Pour vérifier que la solution est correcte :

>>> np.allclose(np.dot(a, x), b)

True

4.4.18 Valeurs propres et vecteurs propres - numpy.linalg.eig()

>>> from numpy.linalg import eig

>>> A = np.array([[ 1, 1, -2 ], [-1, 2, 1], [0, 1, -1]])
>>> A
array([[ 1, 1, -2],
[-1, 2, 1],
[ 0, 1, -1]])
>>> D, V = eig(A)
>>> D
array([ 2., 1., -1.])
>>> V
array([[ 3.01511345e-01, -8.01783726e-01, 7.07106781e-01],
[ 9.04534034e-01, -5.34522484e-01, -3.52543159e-16],
[ 3.01511345e-01, -2.67261242e-01, 7.07106781e-01]])

Les colonnes de V sont les vecteurs propres de A associés aux valeurs propres qui apparaissent
dans D.

Exercice : Vérifier que les colonnes de V sont bien des vecteurs propres de A

4.4.19 Changement de la taille d’un tableau

Il est possible de changer la taille d’un tableau en utilisant l’attribut shape de ce tableau.

>>> u = np.arange(1, 16)

>>> u
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
>>> np.shape(u)
(15,)
>>> u.shape = (3, 5)
>>> u
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
>>> np.shape(u)
(3, 5)

4.4.20 Obtention d’un tableau 2D ligne ou colonne

>>> a = np.arange(1, 6)
>>> a
array([1, 2, 3, 4, 5])
>>> a.shape = (1, np.size(a))
>>> a
array([[1, 2, 3, 4, 5]])
>>> a.shape = (np.size(a), 1)
>>> a
array([[1],
[2],
 [3],
[4],
[5]])

5 Programmation orientée objet en python / classes

La programmation orientée objet (POO) permet de créer des entités (objets) que l'on peut
manipuler . La programmation orientée objet impose des structures solides et claires. Les
objets peuvent interagir entre eux, cela facilite grandement la compréhension du code et sa
maintenance. On oppose souvent la programmation objet à la programmation procédurale ,
la première étant plus "professionnelle" que l'autre car plus fiable et plus propre.

5.1 Classes

Une classe regroupe des fonctions et des attributs qui définissent un objet. On appelle par
ailleurs les fonctions d'une classe des " méthodes ".

Créons une classe Voiture :

# coding: utf-8

class Voiture:

def __init__(self):

self.nom = "Ferrari"

Notre classe Voiture est une sorte d'usine à créer des voitures.

La méthode __init__() est appelée lors de la création d'un objet.

self.nom est une manière de stocker une information dans la classe. On parle d'attribut de
classe. Dans notre cas, on stock le nom dans l'attribut nom .

5.2 Objets

Un objet est une instance d'une classe . On peut créer autant d'objets que l'on désire avec
une classe .

Créons maintenant notre voiture:

>>> ma_voiture = Voiture()

5.3 Attributs de classe

Les attributs de classe permettent de stocker des informations au niveau de la classe. Elle sont
similaires aux variables.

Dans notre exemple:

>>> ma_voiture = Voiture()

>>> ma_voiture.nom

'Ferrari'

Vous pouvez à tout moment créer un attribut pour votre objet:

>>> ma_voiture.modele = "250"

Et le lire ainsi:

>>> ma_voiture.modele

'250'

5.4 Méthodes

Les méthodes sont des fonctions définies dans une classe.

Créons une nouvelle méthode dans notre classe voiture:

# coding: utf-8

class Voiture:

def __init__(self):

self.nom = "Ferrari"

def donne_moi_le_modele(self):

return "250"

Utilison cette méthode:

>>> ma_voiture=Voiture()

>>> ma_voiture.donne_moi_le_modele()
'250'

5.5 Propriétés

Quelque soit le langage, pour la programmation orientée objet il est de préférable de passer
par des propriétés pour changer les valeurs des attributs. Alors bien que cela ne soit pas
obligatoire, il existe une convention de passer par des getter (ou accesseur en francais) et
des setter ( mutateurs ) pour changer la valeur d'un attribut. Cela permet de garder une
cohérence pour le programmeur, si je change un attribut souvent cela peut également
impacter d'autres attributs et les mutateurs permettent de faire cette modification une fois
pour toute.

Un exemple d'utilisation de propriétés:

# coding: utf-8

class Voiture(object):

def __init__(self):

self._roues=4

def _get_roues(self):

print "Récupération du nombre de roues"

return self._roues

def _set_roues(self, v):

print "Changement du nombre de roues"

self._roues = v

roues=property(_get_roues, _set_roues)

Quand on changera la valeur du nombre de roues, un message apparaîtra. En soi cela

n'apporte rien mais au lieu de faire un simple print , vous pouvez par exemple envoyer un
mail, etc.

Testons notre classe :

>>> ma_voiture=Voiture()

>>> ma_voiture.roues=5
Changement du nombre de roues

>>> ma_voiture.roues

Récupération du nombre de roues

Il existe une autre syntaxe en passant par des décorateurs:

class Voiture(object):

def __init__(self):

self._roues=4

@property

def roues(self):

print "Récupération du nombre de roues"

return self._roues

@roues.setter

def roues(self, v):

print "Changement du nombre de roues"

self._roues = v

Le résultat sera le même, mais la lecture du code se trouve amélioré.

5.6 La fonction dir

Parfois il est intéressant de decortiquer un objet pour résoudre à un bug ou pour comprendre
un script.

La fonction dir vous donne un aperçu des méthodes de l'objet:

>>> dir(ma_voiture)

['__doc__', '__init__', '__module__', 'donne_moi_le_modele', 'nom']

5.7 Attribut spécial __dict__

Cet attribut spécial vous donne les valeurs des attributs de l'instance:

>>> ma_voiture.__dict__

{'nom': 'Ferrari'}

5.8 Héritage de classe

L'héritage est un concept très utile. Cela permet de créer de nouvelles classes mais avec une
base existante.

Gardons l'exemple de la voiture et créons une classe VoitureSport :

class Voiture:

roues = 4

moteur = 1

def __init__(self):

self.nom = "A déterminer"

class VoitureSport(Voiture):

def __init__(self):

self.nom = "Ferrari"

On a indiqué que VoitureSport a hérité de classe Voiture , elle recupère donc toutes ses
méthodes et ses attributs.

On peut toujours instancier la classe Voiture si on le désire:

>>> ma_voiture=Voiture()

>>> ma_voiture.nom

'A déterminer'

>>> ma_voiture.roues

4
Instancions maintenant la classe VoitureSport :

>>> ma_voiture_sport=VoitureSport()

>>> ma_voiture_sport.nom

'Ferrari'

>>> ma_voiture_sport.roues

On remarque tout d'abord que l'attribut roues a bien été hérité. Ensuite on remarque que la
méthode __init__ a écrasé la méthode de la classe Voiture . On parle alors de surcharge de
méthode.

5.9 Polymorphisme / surcharge de méthode

Comme nous l'avons vu plus haut si une classe hérite d'une autre classe, elle hérite les
méthodes de son parent .

Exemple:

# coding: utf-8

class Voiture:

roues = 4

moteur = 1

def __init__(self):

self.nom = "A déterminer"

def allumer(self):

print "La voiture démarre"

class VoitureSport(Voiture):

def __init__(self):

self.nom = "Ferrari"
ma_voiture_sport = VoitureSport()

ma_voiture_sport.allumer()

Le résultat:

La voiture démarre

Il est cependant possible d' écraser la méthode de la classe parente en la redéfinissant. On

parle alors de surcharger une méthode .

# coding: utf-8

class Voiture:

roues = 4

moteur = 1

def __init__(self):

self.nom = "A déterminer"

def allumer(self):

print "La voiture démarre"

class VoitureSport(Voiture):

def __init__(self):

self.nom = "Ferrari"

def allumer(self):

print "La voiture de sport démarre"

ma_voiture_sport = VoitureSport()

ma_voiture_sport.allumer()

Le résultat:
La voiture de sport démarre

Enfin dernier point intéressant: il est possible d'appeler la méthode du parent puis de faire la
spécificité de la méthode. On peut d'ailleurs appeler n'importe quelle autre méthode.

# coding: utf-8

class Voiture:

roues = 4

moteur = 1

def __init__(self):

self.nom = "A déterminer"

def allumer(self):

print "La voiture démarre"

class VoitureSport(Voiture):

def __init__(self):

self.nom = "Ferrari"

def allumer(self):

Voiture.allumer(self)

print "La voiture de sport démarre"

ma_voiture_sport = VoitureSport()

ma_voiture_sport.allumer()

Le résultat:

La voiture démarre

La voiture de sport démarre

Les classes Voiture et VoitureSport possédent donc chacune une méthode de même nom mais
ces méthodes n'éffectuent pas les mêmes tâches. On parle dans ce cas de polymorphisme .

5.10 Conventions

Prenez l'habitude de nommer votre classe uniquement avec des caractères alphanumériques
et commençant par une majuscule. Et à l'inverse l'instance peut être nommée sans majuscule.

voiture_sport = VoitureSport()
6 Bibliographie
Ouvrages :

Swinnen, Gérard, Apprendre à programmer avec Python 3, Eyrolles, 2010

Summerfield, Mark, Programming in Python 3, Addison-Wesley, 2 édition, 2009.

Martelli, Alex, Python en concentré, O'Reilly, 2004

Martelli, Alex, Martelli Ravenscroft, Anna, Ascher, David, Python par l'exemple, O'Reilly, 2006.

Lutz, Mark et Bailly, Yves, Python précis et concis, O'Reilly, 2 édition, 2005.

Sites web :

www.python.org
pypi.python.org/pypi
code.google.com/p/pythonxy/wiki/Downloads
matplotlib.org