Cours

Programmation Python
Licence

MAMADOU Diarra
22/11/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() ........................................................................................ 10
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() ................................................. 11
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 .................................................................................................................................. 17
2.4.1 Boucles bornées et non bornées ................................................................................... 17
2.4.2 Boucle for ...................................................................................................................... 17
2.4.3 Boucle while .................................................................................................................. 19
2.4.4 Comment choisir entre boucle for et boucle while ....................................................... 20
2.4.5 Transformation d’une boucle for en une boucle while ................................................. 20
2.5 Les instructions break et continue, et la clause else dans les boucles.................................. 20
2.5.1 L’instruction break ........................................................................................................ 20
2.5.2 Remarque : équivalent du do…while (faire…tant que) ................................................ 21
2.5.3 Instruction continue ...................................................................................................... 22
 2.5.4 Clause else dans une boucle.......................................................................................... 23
2.6 Principaux types de données................................................................................................. 23
2.6.1 La fonction type() .......................................................................................................... 24
2.6.2 Le type int (entier) ......................................................................................................... 24
2.6.3 Le type float (flottant) ................................................................................................... 24
2.6.4 Le type str (chaîne de caractères) ................................................................................. 25
2.6.5 Le type bool (booléen) .................................................................................................. 25
2.6.6 Le type list (liste)............................................................................................................ 26
2.6.7 Le type complex (complexe) ......................................................................................... 26
2.7 Tuples en Python ................................................................................................................... 27
2.8 Dictionnaires en Python ........................................................................................................ 30
2.8.1 Comment construire une entrée dans un dictionnaire ? .............................................. 30
2.8.2 Comment créer un dictionnaire ? ................................................................................. 31
2.8.3 Comment parcourir un dictionnaire ? ........................................................................... 31
2.9 istes........................................................................................................................................ 31
2.9.1 Définition ....................................................................................................................... 31
2.9.2 Utilisation .......................................................................................................................... 32
2.9.3 Opération sur les listes .................................................................................................. 32
2.9.4 Indiçage négatif ............................................................................................................. 33
2.9.5 Fonction len() ................................................................................................................ 34
2.9.6 Listes de listes¶ ............................................................................................................. 34
2.9.7 Minimum, maximum et somme d'une liste .................................................................. 35
2.10 Ensembles.............................................................................................................................. 36
3 Fonctions en Python ...................................................................................................................... 37
3.1 Définition d’une fonction - def .............................................................................................. 38
3.2 Fonction sans paramètre ....................................................................................................... 38
3.3 Fonction avec paramètre ...................................................................................................... 40
3.4 Utilisation d’une variable comme argument......................................................................... 40
3.5 Fonction avec plusieurs paramètres ..................................................................................... 41
3.6 Variables locales, variables globales ..................................................................................... 42
3.7 Utilisation d’une variable globale - global ............................................................................. 43
3.8 « Vraies » fonctions et procédures........................................................................................ 43
3.9 Valeurs par défaut pour les paramètres ............................................................................... 44
3.10 Arguments avec étiquettes ................................................................................................... 44
3.11 Utilisation des fonctions dans un script ................................................................................ 45
3.12 Modules et importations ....................................................................................................... 46
 3.13 Package .................................................................................................................................. 48
4 Python et maths ............................................................................................................................ 50
4.1 Quelques bibliothèques ........................................................................................................ 50
4.2 Quelques fonctions mathématiques ..................................................................................... 51
4.3 Courbes.................................................................................................................................. 51
4.3.1 Utilisation de plot()........................................................................................................ 51
4.3.2 Définition du domaine des axes - xlim() et ylim().......................................................... 52
4.3.3 Ajout d’un titre - title() .................................................................................................. 53
4.3.4 Ajout d’une légende - legend() ...................................................................................... 54
4.3.5 Labels sur les axes - xlabel() et ylabel() ......................................................................... 54
4.3.6 Affichage de plusieurs courbes ..................................................................................... 55
4.3.7 Exemple avec un légende .............................................................................................. 56
4.3.8 Formats de courbes ....................................................................................................... 56
4.3.9 Style de ligne ................................................................................................................. 57
4.3.10 Symbole (« marker ») .................................................................................................... 58
4.3.11 Couleur .......................................................................................................................... 59
4.3.12 Largeur de ligne ............................................................................................................. 59
4.3.13 Tracé de formes ............................................................................................................. 60
4.3.14 L’instruction axis("equal") ............................................................................................. 60
4.3.15 Tracé d’un cercle ........................................................................................................... 62
4.3.16 Tracé de diagrammes en bâtons et histogrammes ....................................................... 63
4.3.17 Affichages de nuages de points ..................................................................................... 66
4.3.18 Tracé multiples .............................................................................................................. 68
4.3.19 Tutoriel sur mplot3d ...................................................................................................... 68
4.4 Tableaux et calcul matriciel ................................................................................................... 91
4.4.1 Tableaux - [Link]() ......................................................................................... 91
4.4.2 Tableaux bidimensionnels (2D) ..................................................................................... 92
4.4.3 La fonction [Link]() ............................................................................................... 92
4.4.4 La fonction [Link]() ............................................................................................ 92
4.4.5 Produit terme à terme................................................................................................... 92
4.4.6 Produit matriciel - [Link]()..................................................................................... 93
4.4.7 Transposé ...................................................................................................................... 93
4.4.8 Complexe conjugué - [Link]()............................................................................... 93
4.4.9 Transposé complexe conjugué ...................................................................................... 93
4.4.10 Tableaux et slicing ......................................................................................................... 94
4.4.11 Slicing des tableaux 2D .................................................................................................. 94
 4.4.12 Tableaux de 0 - [Link]() ...................................................................................... 95
4.4.13 Tableaux de 1 - [Link]() ....................................................................................... 95
4.4.14 Matrice identité - [Link]() ..................................................................................... 95
4.4.15 Déterminant - [Link]().................................................................................. 95
4.4.16 Inverse - [Link]() ........................................................................................... 96
4.4.17 Résolution d’un système d’équations linéaires - [Link]() ......................... 96
4.4.18 Valeurs propres et vecteurs propres - [Link]() ............................................. 96
4.4.19 Changement de la taille d’un tableau ........................................................................... 97
4.4.20 Obtention d’un tableau 2D ligne ou colonne ................................................................ 97
5 Bibliographie.................................................................................................................................. 98
 Programmation Python

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 /
En Python 3, il réalise une division décimale standard comme sur une calculatrice.

Exemple

>>> 7 / 2

3.5

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

>>> 7 // 2

2.2.4 L’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être manipulé par la suite.

Exercice : calculs basiques en python

#oérateurs arithmétiques en python

a=7 // affectation

b=2 // affectation

print("a =\n", a) // affichage

print("b =\n", b) // affichage

print("le produit de", a, "par", b, "est : ", a*b) // produit

print("la difference de ", a, " et", b, "est : ", a-b) // soustraction

print("le somme de", a, " et ", b, "est : ", a+b) // addition

print("la division réelle de", a, "par", b, "est : ", a/b) // division

print("la division entière de", a, "par", b, "est : ", a//b) // division entière

print("le reste de la division entière", a, "par", b, "est : ", a%b) // modulo

print(a, " exposant", b, "est : ", a**b)

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

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.

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)

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

Les identificateurs
Un identificateur est une suite de caractères servant à désigner les différentes entitées
manipulées par un programme : variables, fonctions, classes…

En Python, un identificateur est formé de lettres ou de chiffres. Il ne contient pas d’espace. Le

premier caractère doit obligatoirement être une lettre. Il peut contenir le caractère « _ »
(underscore, en français « souligné »). Il est sensible à la casse (distinction entre majuscule et
minuscule).
Les mots-clés

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

Les commentaires usuels :

# Ceci est un commentaire

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

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 L’instruction break

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

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 une boucle permet de définir un bloc d’instructions qui sera exécuté à la
fin seulement si la boucle s’est déroulée complétement sans être interrompue par un break.

Contrairement aux instructions présentes après la boucle, qui s’exécutent dans tous les cas
(avec ou sans interruption par un break), le bloc d’instructions défini dans la clause else ne
s’exécutera pas lors de l’interruption par un break. Après l’interruption, on passera
directement aux instructions après la boucle.

Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se termine par
épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas
quand la boucle est interrompue par un break. Ceci est illustré dans la boucle suivante, qui
recherche des nombres premiers :

for n in range(2, 8):

for x in range(2, n):

if n % x == 0:

print(n, "egale", x, "*", n/x)

break

else:

print(n, "est un nombre premier")

Affichage après exécution :

2 est un nombre premier

3 est un nombre premier

4 egale 2 * 2.0

5 est un nombre premier

6 egale 2 * 3.0

7 est un nombre premier

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 La fonction type()

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

Exemples :

>>> type(15)

int

>>> a = 15

>>> type(a)

int

>>> a = "toto"

>>> type(a)

str

2.6.2 Le 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 Le type float (flottant)

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

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 Le type str (chaîne de caractères)

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

>>> a = 'Bonjour'

>>> type(a)

str

>>> b = "Bonsoir"

>>> type(b)

str

2.6.5 Le 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 Le type list (liste)
Sous Python, on peut définir une liste comme une collection d’éléments séparés par des
virgules, l’ensemble étant enfermé dans des crochets.

Exemple :

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

>>> type(jour)

list

>>> jour

['lundi', 'mardi', 'mercredi', 1800, 20.356999999999999, 'jeudi', 'vendredi']

2.6.7 Le type complex (complexe)

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

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

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

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

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

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

Comme on l’a vu avec les listes et les tuples, à partir des types de base (int, float, etc.) il est
possible d’élaborer de nouveaux types qu’on appelle des types construits.

Un nouvel exemple de type construit est le dictionnaire.

Les éléments d’une liste ou d’un tuple sont ordonnés et on accède à un élément grâce à sa
position en utilisant un numéro qu’on appelle l’indice de l’élément.

Un dictionnaire en Python va aussi permettre de rassembler des éléments mais ceux-ci seront
identifiés par une clé.

Contrairement aux listes qui sont délimitées par des crochets, on utilise des accolades pour
les dictionnaires.

[1]: mon_dictionnaire = {"voiture": "véhicule à quatre roues", "vélo": "véhicule à deux roues
"}
Un élément a été défini ci-dessus dans le dictionnaire en précisant une clé au moyen d’une
chaîne de caractères suivie de : puis de la valeur associée

clé: valeur

On accède à une valeur du dictionnaire en utilisant la clé entourée par des crochets avec la
syntaxe suivante :

[2]: mon_dictionnaire["voiture"]
2.8.1 Comment construire une entrée dans un dictionnaire ?
Il est très facile d’ajouter un élément à un dictionnaire. Il suffit d’affecter une valeur pour la
nouvelle clé.
[3]: mon_dictionnaire["tricycle"] = "véhicule à trois roues"
[4]: mon_dictionnaire
Le type d’un dictionnaire est dict.

[5]: type(mon_dictionnaire)
Il est aussi possible d’utiliser des valeurs d’autres types.

Voici un exemple où les valeurs sont des entiers.

[6]: nombre_de_roues = {"voiture": 4, "vélo": 2}

[7]: type(nombre_de_roues)
[8]: nombre_de_roues["vélo"]
2.8.2 Comment créer un dictionnaire ?
Nous avons vu ci-dessous qu’il était possible de créer un dictionnaire avec des accolades qui
entourent les éléments. Une autre approche possible consiste à créer un dictionnaire vide et
à ajouter les éléments au fur et à mesure.

[9]: nombre_de_pneus = {}
nombre_de_pneus["voiture"] = 4
nombre_de_pneus["vélo"] = 2
[10]: nombre_de_pneus
2.8.3 Comment parcourir un dictionnaire ?
On utilise items().

Exemple pour une boucle for avec un indice i

[11]: nombre_de_roues = {"voiture": 4, "vélo": 2, "tricycle": 3}

for i in nombre_de_roues.items():
print(i)
('voiture', 4)
('vélo', 2)
('tricycle', 3)
Autre exemple pour une boucle for avec deux indices : cle et valeur

[12]: for cle, valeur in nombre_de_roues.items():

print("l'élément de clé", cle, "vaut", valeur)
l'élément de clé voiture vaut 4
l'élément de clé vélo vaut 2
l'élément de clé tricycle vaut 3

2.9 Listes
2.9.1 Définition
Une liste est une structure de données qui contient une série de valeurs. Python autorise la
construction de liste contenant des valeurs de types différents (par exemple entier et chaîne
de caractères), ce qui leur confère une grande flexibilité. Une liste est déclarée par une série
de valeurs (n'oubliez pas les guillemets, simples ou doubles, s'il s'agit de chaînes de caractères)
séparées par des virgules, et le tout encadré par des crochets. En voici quelques exemples :
>>> animaux = ["girafe", "tigre", "singe", "souris"]
>>> tailles = [5, 2.5, 1.75, 0.15]
>>> mixte = ["girafe", 5, "souris", 0.15]
>>> animaux
['girafe', 'tigre', 'singe', 'souris']
>>> tailles
[5, 2.5, 1.75, 0.15]
>>> mixte
['girafe', 5, 'souris', 0.15]
Lorsque l'on affiche une liste, Python la restitue telle qu'elle a été saisie.
2.9.2 Utilisation
Un des gros avantages d'une liste est que vous pouvez appeler ses éléments par leur position.
Ce numéro est appelé indice (ou index) de la liste.
liste : ["girafe", "tigre", "singe", "souris"]
indice : 0 1 2 3
Soyez très attentif au fait que les indices d'une liste de n éléments commencent à 0 et se
terminent à n-1. Voyez l'exemple suivant :
>>> animaux = ["girafe", "tigre", "singe", "souris"]
>>> animaux[0]
'girafe'
>>> animaux[1]
'tigre'
>>> animaux[3]
'souris'
2.9.3 Opération sur les listes
Tout comme les chaînes de caractères, les listes supportent l'opérateur + de concaténation,
ainsi que l'opérateur * pour la duplication :
>>> ani1 = ["girafe", "tigre"]
>>> ani2 = ["singe", "souris"]
>>> ani1 + ani2
['girafe', 'tigre', 'singe', 'souris']
>>> ani1 * 3
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
L'opérateur + est très pratique pour concaténer deux listes.
Vous pouvez aussi utiliser la méthode .append() lorsque vous souhaitez ajouter un seul
élément à la fin d'une liste.
Dans l'exemple suivant nous allons créer une liste vide :
>>> a = []
>>> a
[]
puis lui ajouter deux éléments, l'un après l'autre, d'abord avec la concaténation :
>>> a = a + [15]
>>> a
[15]
>>> a = a + [-5]
>>> a
[15, -5]
puis avec la méthode .append() :
>>> [Link](13)
>>> a
[15, -5, 13]
>>> [Link](-3)
>>> a
[15, -5, 13, -3]
Dans l'exemple ci-dessus, nous ajoutons des éléments à une liste en utilisant l'opérateur de
concaténation + ou la méthode .append(). Nous vous conseillons dans ce cas précis d'utiliser
la méthode .append() dont la syntaxe est plus élégante.
2.9.4 Indiçage négatif
La liste peut également être indexée avec des nombres négatifs selon le modèle suivant :
liste : ["girafe", "tigre", "singe", "souris"]
indice positif : 0 1 2 3
indice négatif : -4 -3 -2 -1
ou encore :
liste : ["A", "B", "C", "D", "E", "F"]
indice positif : 0 1 2 3 4 5
indice négatif : -6 -5 -4 -3 -2 -1
Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage est que
vous pouvez accéder au dernier élément d'une liste à l'aide de l'indice -1 sans pour autant
connaître la longueur de cette liste. L'avant-dernier élément a lui l'indice -2, l'avant-avant
dernier l'indice -3, etc.
>>> animaux = ["girafe", "tigre", "singe", "souris"]
>>> animaux[-1]
'souris'
>>> animaux[-2]
'singe'
Pour accéder au premier élément de la liste avec un indice négatif, il faut par contre connaître
le bon indice :
>>> animaux[-4]
'girafe'
Dans ce cas, on utilise plutôt animaux[0].
2.9.5 Fonction len()
L'instruction len() vous permet de connaître la longueur d'une liste, c'est-à-dire le nombre
d'éléments que contient la liste. Voici un exemple d'utilisation :
>>> animaux = ["girafe", "tigre", "singe", "souris"]
>>> len(animaux)
4
2.9.6 Listes de listes
Pour finir, sachez qu'il est tout à fait possible de construire des listes de listes. Cette
fonctionnalité peut parfois être très pratique. Par exemple :
>>> enclos1 = ["girafe", 4]
>>> enclos2 = ["tigre", 2]
>>> enclos3 = ["singe", 5]
>>> zoo = [enclos1, enclos2, enclos3]
>>> zoo
[['girafe', 4], ['tigre', 2], ['singe', 5]]
Dans cet exemple, chaque sous-liste contient une catégorie d'animal et le nombre d'animaux
pour chaque catégorie.
Pour accéder à un élément de la liste, on utilise l'indiçage habituel :
>>> zoo[1]
['tigre', 2]
Pour accéder à un élément de la sous-liste, on utilise un double indiçage :
>>> zoo[1][0]
'tigre'
>>> zoo[1][1]
2
2.9.7 Minimum, maximum et somme d'une liste
Les fonctions min(), max() et sum() renvoient respectivement le minimum, le maximum et la
somme d'une liste passée en argument.
>>> liste = list(range(10))
>>> liste
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sum(liste)
45
>>> min(liste)
0
>>> max(liste)
9
Même si en théorie ces fonctions peuvent prendre en argument une liste de strings, on les
utilisera la plupart du temps avec des types numériques (liste d'entiers et / ou de floats).
Nous avions déjà croisé min(), max() dans le chapitre 2 Variables. On avait vu que ces deux
fonctions pouvaient prendre plusieurs arguments entiers et / ou floats, par exemple :
>>> min(3, 4)
3
L'exemple suivant utilise la plupart des méthodes des listes :

>>>fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']

>>> [Link]('apple')
2
>>> [Link]('tangerine')
0
>>> [Link]('banana')
3
>>> [Link]('banana', 4) # Find next banana starting at position 4
6
>>> [Link]()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> [Link]('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> [Link]()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> [Link]()
'pear'

2.10 Ensembles
Python fournit également un type de donnée pour les ensembles. Un ensemble est une
collection non ordonnée sans éléments en double. Un ensemble permet de réaliser des tests
d'appartenance ou des suppressions de doublons de manière simple. Les ensembles savent
également effectuer les opérations mathématiques telles que les unions, intersections,
différences et différences symétriques.
On crée des ensembles en appelant avec des accolades ou avec la fonction set(). Notez
que {} ne crée pas un ensemble vide, mais un dictionnaire (une structure de données dont
nous allons parler dans la séquence suivante) vide ; utilisez set() pour ce cas.
Voici une brève démonstration :
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

Tout comme pour les listes en compréhension, il est possible d'écrire des ensembles en
compréhension :

>>> a = {x for x in 'abracadabra' if x not in 'abc'}

>>> a

{'r', 'd'}

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

1
2

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

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

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 :

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.

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 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 * [Link] * cube(r)

#programme principal

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.

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.

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

Très souvent, c’est une personne qui définit une fonction et une autre qui l’utilise. Par
exemple, avec la bibliothèque matplotlib, on peut utiliser la fonction plot() pour tracer des
courbes sans avoir à écrire nous-mêmes cette fonction.

Par exemple, nous allons créer un fichier nommé [Link] qui va définir 2 fonctions
: carre() et cube(). Un tel fichier est appelé un module et il va pouvoir être importé dans un
autre fichier, et en particulier dans le fichier qui contient le programme principal.

def carre(valeur):

resultat = valeur**2

return resultat

def cube(valeur):

resultat = valeur**3

return resultat

Il est maintenant possible d’utiliser dans un programme principal les fonctions qui ont été
définies dans le module [Link]. Pour cela, il faut importer les fonctions à partir du
module.

Exemple : on importe une seule fonction

from puissance import carre

a=5
u = carre(a)

print("le carre vaut", u)

Avertissement
Le fichier [Link] 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 puissance import carre, cube

a=5

u = carre(a)

print("le carre vaut", u)

v = cube(a)

print("le cube vaut", v)

Exemple : on importe toutes les fonctions

from puissance import *

a=5

u = carre(a)

print("le carre vaut", u)

v = cube(a)

print("le cube 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 puissance

a=5

u = [Link](a)

print("le carre vaut", u)

v = [Link](a)

print("le cube 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 = [Link](a)

print("le carre vaut", u)

v = [Link](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.13 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 [Link] suivant :

def fonction1(a):

return a**2

On peut ensuite utiliser la fonction fonction1() définie dans [Link], 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

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 [Link] 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 [Link] 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", [Link](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

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

from pylab import * import numpy as np

import [Link] as plt
x = array([1, 3, 4, 6])
y = array([2, 3, 5, 1]) x = [Link]([1, 3, 4, 6])
plot(x, y) y = [Link]([2, 3, 5, 1])
[Link](x, y)
show() # affiche la figure a l'ecran
[Link]() # affiche la figure a l'ecra
n

»
Exemple 2
Dans cet exemple, nous allons tracer la fonction cosinus.

Syntaxe « PyLab » Syntaxe « standard »

from pylab import * import numpy as np

import [Link] as plt
x = linspace(0, 2*pi, 30)
y = cos(x) x = [Link](0, 2*[Link], 30)
plot(x, y) y = [Link](x)
[Link](x, y)
show() # affiche la figure a l'ecran
[Link]() # affiche la figure a l'ecra
n

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

from pylab import * import numpy as np

import [Link] as plt
x = linspace(0, 2*pi, 30)
y = cos(x) x = [Link](0, 2*[Link], 30)
plot(x, y) y = [Link](x)
xlim(-1, 5) [Link](x, y)
[Link](-1, 5)
show()
[Link]()
4.3.3 Ajout d’un titre - title()
On peut ajouter un titre grâce à l’instruction title().

Syntaxe « PyLab » Syntaxe « standard »

from pylab import * import numpy as np

import [Link] as plt
x = linspace(0, 2*pi, 30)
y = cos(x) x = [Link](0, 2*[Link], 30)
plot(x, y) y = [Link](x)
title("Fonction cosinus") [Link](x, y)
[Link]("Fonction cosinus")
show() [Link]()
4.3.4 Ajout d’une légende - legend()
Syntaxe « PyLab » Syntaxe « standard »

from pylab import * import numpy as np

import [Link] as plt
x = linspace(0, 2*pi, 30) x = [Link](0, 2*[Link], 30)
y = cos(x) y = [Link](x)
plot(x, y, label="cos(x)") [Link](x, y, label="cos(x)")
legend() [Link]()
show() [Link]()

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

from pylab import * import numpy as np

x = linspace(0, 2*pi, 30) import [Link] as plt
y = cos(x) x = [Link](0, 2*[Link], 30)
plot(x, y) y = [Link](x)
xlabel("abscisses") [Link](x, y)
ylabel("ordonnees") [Link]("abscisses")
[Link]("ordonnees")
show() [Link]()

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

from pylab import * import numpy as np

x = linspace(0, 2*pi, 30) import [Link] as plt
y1 = cos(x) x = [Link](0, 2*[Link], 30)
y2 = sin(x) y1 = [Link](x)
plot(x, y1) y2 = [Link](x)
plot(x, y2) [Link](x, y1)
show() [Link](x, y2)
[Link]()
4.3.7 Exemple avec un légende
Syntaxe « PyLab » Syntaxe « standard »

from pylab import * import numpy as np

x = linspace(0, 2*pi, 30) import [Link] as plt
y1 = cos(x) x = [Link](0, 2*[Link], 30)
y2 = sin(x) y1 = [Link](x)
plot(x, y1, label="cos(x)") y2 = [Link](x)
plot(x, y2, label="sin(x)") [Link](x, y1, label="cos(x)")
legend() [Link](x, y2, label="sin(x)")
show() [Link]()
[Link]()

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

 from pylab import * import numpy as np
x = linspace(0, 2*pi, 30) import [Link] as plt
y1 = cos(x) x = [Link](0, 2*[Link], 30)
y2 = sin(x) y1 = [Link](x)
plot(x, y1, "r--", label="cos(x)") y2 = [Link](x)
plot(x, y2, "b:o", label="sin(x)") [Link](x, y1, "r--", label="cos(x)")
legend() [Link](x, y2, "b:o", label="sin(x)")
show() [Link]()
[Link]()

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

from pylab import * import numpy as np

x = linspace(0, 2*pi, 20) import [Link] as plt
y = sin(x) x = [Link](0, 2*[Link], 20)
plot(x, y, "o-", label="ligne -") y = [Link](x)
plot(x, y-0.5, "o--", label="ligne - [Link](x, y, "o-", label="ligne -")
-") [Link](x, y-0.5, "o--", label="ligne --
plot(x, y-1, "o:", label="ligne :") ")
[Link](x, y-1, "o:", label="ligne :")
 plot(x, y-1.5, "o-.", label="ligne - [Link](x, y-1.5, "o-.", label="ligne -.
.") ")
plot(x, y-2, "o", label="pas de lign [Link](x, y-2, "o", label="pas de ligne
e") ")
legend() [Link]()
show() [Link]()

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

from pylab import * import numpy as np

x = linspace(0, 2*pi, 30) import [Link] as plt
y1 = cos(x) x = [Link](0, 2*[Link], 30)
y2 = sin(x) y1 = [Link](x)
plot(x, y1, label="cos(x)") y2 = [Link](x)
 plot(x, y2, label="sin(x)", linewidth=4 [Link](x, y1, label="cos(x)")
) [Link](x, y2, label="sin(x)", linewid
legend() th=4)
show() [Link]()
[Link]()

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

from pylab import * import numpy as np

x = array([0, 1, 1, 0, 0]) import [Link] as plt
y = array([0, 0, 1, 1, 0]) x = [Link]([0, 1, 1, 0, 0])
plot(x, y) y = [Link]([0, 0, 1, 1, 0])
xlim(-1, 2) [Link](x, y)
ylim(-1, 2) [Link](-1, 2)
show() [Link](-1, 2)
[Link]()

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

from pylab import * import numpy as np

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

Il est aussi possible de fixer le domaine des abscisses en utilisant xlim().

Syntaxe « PyLab » Syntaxe « standard »

from pylab import * import numpy as np

x = array([0, 1, 1, 0, 0]) import [Link] as plt
y = array([0, 0, 1, 1, 0]) x = [Link]([0, 1, 1, 0, 0])
plot(x, y) y = [Link]([0, 0, 1, 1, 0])
axis("equal") [Link](x, y)
xlim(-1, 2) [Link]("equal")
show() [Link](-1, 2)
[Link]()
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 » Syntaxe « standard »

from pylab import * import numpy as np

theta = linspace(0, 2*pi, 40) import [Link] as plt
x = cos(theta) theta = [Link](0, 2*[Link], 40)
y = sin(theta) x = [Link](theta)
plot(x, y) y = [Link](theta)
show() [Link](x, y)
[Link]()

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

Syntaxe « PyLab » Syntaxe « standard »

from pylab import * import numpy as np

theta = linspace(0, 2*pi, 40) import [Link] as plt
x = cos(theta) theta = [Link](0, 2*[Link], 40)
y = sin(theta) x = [Link](theta)
plot(x, y) y = [Link](theta)
axis("equal") [Link](x, y)
show() [Link]("equal")
[Link]()
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 [Link] as plt
import numpy as np

x = [3, 5, 6, 7]

y = [4, 1, 3, 4]

[Link](x,y)

[Link]()

Tracé avec des variables catégorielles

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 [Link] as
plt
names = ['group_a',
'group_b', 'group_c']
values = [1, 10, 100]
[Link](figsize=(9, 3))
[Link](131)
[Link](names, values)
[Link](132)
[Link](names, values)
 [Link](133)
[Link](names, values)
[Link]('Categorical
Plotting')
[Link]()

Bar Chart

import [Link] 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
[Link](left, height, tick_label
= tick_label,
width = 0.8, color =
['red', 'green'])
# naming the x-axis
[Link]('x - axis')
# naming the y-axis
[Link]('y - axis')
# plot title
[Link]('My bar chart!')
# function to show the plot
[Link]()
• Ici, nous utilisons la fonction [Link] () 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 [Link] 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
[Link](ages, bins, range, color = 'green',
histtype = 'bar', rwidth = 0.8)
# x-axis label
[Link]('age')
# frequency label
[Link]('No. of people')
# plot title
[Link]('My histogram')
# function to show the plot
[Link]()
• Here, we use [Link]() 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 [Link] 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
[Link](slices, labels = activities,
colors=colors,
 startangle=90, shadow =
True, explode = (0, 0, 0.1, 0),
radius = 1.2, autopct =
'%1.1f%%')
# plotting legend
[Link]()
# showing the plot
[Link]()
• Here, we plot a pie chart by using [Link]() 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 [Link] as
plt

import numpy as np

from random import *

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

[Link](liste,11)

[Link]()

4.3.17 Affichages de nuages de points

Pour tracer des points, il suffit d'utiliser la fonction [Link](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
[Link] as
plt

import numpy as np

x = [ 1, 3, 2, 1]

y = [ 2, 3, 1, 3]

[Link](x,y)

[Link]()

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 [Link] 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 :
[Link]("r")

else : [Link]("b")

return couleurs

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

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

[Link](x,y,s=1,c=donner_couleur(x,y
))

[Link]()

Representation en 3D

from pylab import *

from mpl_toolkits.mplot3d
import Axes3D
fig = figure()
ax = Axes3D(fig)
X = [Link](-4, 4, 0.25)
Y = [Link](-4, 4, 0.25)
X, Y = [Link](X, Y)
R = [Link](X**2 + Y**2)
Z = [Link](R)
ax.plot_surface(X, Y, Z,
rstride=1, cstride=1,
cmap='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()

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 [Link] et ajoutez-lui un nouvel axe de type Axes3D :

import [Link] as plt

from mpl_toolkits.mplot3d import Axes3D
fig = [Link]()
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

Avant la version 1.0.0, la méthode de création des axes 3D était différente. Pour ceux qui
utilisent des versions plus anciennes de matplotlib, changez
ax = fig.add_subplot(111, projection='3d') en ax = Axes3D(fig).
Line plots

[Link](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 [Link] as plt

[Link]['[Link]'] = 10

fig = [Link]()

ax = [Link](projection='3d')

theta = [Link](-4 * [Link], 4 * [Link], 100)

z = [Link](-2, 2, 100)
 r = z**2 + 1

x = r * [Link](theta)

y = r * [Link](theta)

[Link](x, y, z, label='parametric curve')

[Link]()

[Link]()

Scatter plots

[Link](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

c 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
that c should not be a single numeric RGB or RGBA sequence because
Argument Description

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 [Link] 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)*[Link](n) + vmin

fig = [Link]()

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)

[Link](xs, ys, zs, c=c, marker=m)

ax.set_xlabel('X Label')

ax.set_ylabel('Y Label')

ax.set_zlabel('Z Label')

[Link]()

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

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 [Link] as plt

fig = [Link]()

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)

[Link]()

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

 Argument Description

rstride Array row stride (step size)

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 [Link] as plt

from matplotlib import cm

from [Link] import LinearLocator, FormatStrFormatter

import numpy as np
fig = [Link]()

ax = [Link](projection='3d')

# Make data.

X = [Link](-5, 5, 0.25)

Y = [Link](-5, 5, 0.25)

X, Y = [Link](X, Y)

R = [Link](X**2 + Y**2)

Z = [Link](R)

# Plot the surface.

surf = ax.plot_surface(X, Y, Z, cmap=[Link],

linewidth=0, antialiased=False)

# Customize the z axis.

ax.set_zlim(-1.01, 1.01)

[Link].set_major_locator(LinearLocator(10))

[Link].set_major_formatter(FormatStrFormatter('%.02f'))

# Add a color bar which maps values to colors.

[Link](surf, shrink=0.5, aspect=5)

[Link]()
''' ========================

3D surface (solid color)

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

Demonstrates a very basic plot of a

3D surface using a solid color.

'''

from mpl_toolkits.mplot3d import

Axes3D

import [Link] as plt

import numpy as np

fig = [Link]()

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

# Make data

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

v = [Link](0, [Link], 100)

x = 10 * [Link]([Link](u),
[Link](v))
y = 10 * [Link]([Link](u), [Link](v))

z = 10 * [Link]([Link]([Link](u)),
[Link](v))

# Plot the surface

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

[Link]()

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

3D surface (checkerboard)

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

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

'''

from mpl_toolkits.mplot3d import Axes3D

import [Link] as plt

from matplotlib import cm

from [Link] import LinearLocator

import numpy as np

fig = [Link]()

ax = [Link](projection='3d')

# Make data.

X = [Link](-5, 5, 0.25)

xlen = len(X)

Y = [Link](-5, 5, 0.25)

ylen = len(Y)

X, Y = [Link](X, Y)

R = [Link](X**2 + Y**2)
 Z = [Link](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 = [Link]([Link], 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))

[Link]()

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

Examples:

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

Triangular 3D surfaces

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

Plot a 3D surface with a triangular mesh.

'''

from mpl_toolkits.mplot3d import Axes3D

import [Link] 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 = [Link](0.125, 1.0, n_radii)

angles = [Link](0, 2*[Link], n_angles, endpoint=False)

# Repeat all angles for each radius.

angles = [Link](angles[..., [Link]], 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 = [Link](0, (radii*[Link](angles)).flatten())

y = [Link](0, (radii*[Link](angles)).flatten())

# Compute z to make the pringle surface.

z = [Link](-x*y)

fig = [Link]()

ax = [Link](projection='3d')

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

[Link]()
''' ===========================

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 [Link] as plt

from mpl_toolkits.mplot3d import Axes3D

import [Link] as mtri

fig = [Link](figsize=[Link](0.5))

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

# First plot
#============

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

u = [Link](0, 2.0 * [Link], endpoint=True, num=50)

v = [Link](-0.5, 0.5, endpoint=True, num=10)

u, v = [Link](u, v)

u, v = [Link](), [Link]()

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

# triple

x = (1 + 0.5 * v * [Link](u / 2.0)) * [Link](u)

y = (1 + 0.5 * v * [Link](u / 2.0)) * [Link](u)

z = 0.5 * v * [Link](u / 2.0)

# Triangulate parameter space to determine the triangles

tri = [Link](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=[Link], cmap=[Link])

ax.set_zlim(-1, 1)

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

# Second plot

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

# Make parameter spaces radii and angles.

n_angles = 36

n_radii = 8

min_radius = 0.25

radii = [Link](min_radius, 0.95, n_radii)

angles = [Link](0, 2*[Link], n_angles, endpoint=False)

 angles = [Link](angles[..., [Link]], n_radii, axis=1)

angles[:, 1::2] += [Link]/n_angles

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

x = (radii*[Link](angles)).flatten()

y = (radii*[Link](angles)).flatten()

z = ([Link](radii)*[Link](angles*3.0)).flatten()

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

triang = [Link](x, y)

# Mask off unwanted triangles.

xmid = x[[Link]].mean(axis=1)

ymid = y[[Link]].mean(axis=1)

mask = [Link](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=[Link])

[Link]()

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 [Link] 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 = [Link](0.125, 1.0, n_radii)

angles = [Link](0, 2*[Link], n_angles, endpoint=False)

# Repeat all angles for each radius.

angles = [Link](angles[..., [Link]], 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 = [Link](0, (radii*[Link](angles)).flatten())

y = [Link](0, (radii*[Link](angles)).flatten())

# Compute z to make the pringle surface.

z = [Link](-x*y)

fig = [Link]()

ax = [Link](projection='3d')

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

[Link]()
Contour plots

[Link](X, Y, Z, *args, **kwargs)

Create a 3D contour plot.

Argument Description

X, Y, Data values as [Link]

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 [Link] as plt

from matplotlib import cm

fig = [Link]()

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

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

cset = [Link](X, Y, Z,
cmap=[Link])

[Link](cset, fontsize=9, inline=1)

[Link]()

from mpl_toolkits.mplot3d import

axes3d

import [Link] as plt

from matplotlib import cm

fig = [Link]()

ax = [Link](projection='3d')

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

cset = [Link](X, Y, Z,
extend3d=True, cmap=[Link])

[Link](cset, fontsize=9, inline=1)

[Link]()

from mpl_toolkits.mplot3d import axes3d

import [Link] as plt

from matplotlib import cm

fig = [Link]()

ax = [Link](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 = [Link](X, Y, Z, zdir='z', offset=-100, cmap=[Link])

cset = [Link](X, Y, Z, zdir='x', offset=-40, cmap=[Link])

cset = [Link](X, Y, Z, zdir='y', offset=40, cmap=[Link])

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)

[Link]()
Filled contour plots

[Link](X, Y, Z, *args, **kwargs)

Create a 3D contourf plot.

Argument Description

X, Y, Data values as [Link]

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 [Link] as plt

from matplotlib import cm

fig = [Link]()

ax = [Link](projection='3d')

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

cset = [Link](X, Y, Z,
cmap=[Link])

[Link](cset, fontsize=9, inline=1)

[Link]()
 """ .. versionadded:: 1.1.0
This demo depends on new features
added to contourf3d. """
from mpl_toolkits.mplot3d import
axes3d
import [Link] as plt
from matplotlib import cm
fig = [Link]()
ax = [Link](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 = [Link](X, Y, Z, zdir='z',
offset=-100, cmap=[Link])
cset = [Link](X, Y, Z, zdir='x',
offset=-40, cmap=[Link])
cset = [Link](X, Y, Z, zdir='y',
offset=40, cmap=[Link])
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)
[Link]()

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 [Link]() de NumPy. Ces
tableaux pourront être utilisés comme des vecteurs ou des matrices grâce à des fonctions
de NumPy ([Link](), [Link](), [Link](), [Link](), 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.
4.4.1 Tableaux - [Link]()
Pour créer des tableaux, nous allons utiliser [Link]().

Tableaux monodimensionnels (1D)

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

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

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

>>> type(a)
[Link]

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 à [Link]() une liste de listes grâce à des
crochets imbriqués.

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

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

4.4.3 La fonction [Link]()

La fonction [Link]() renvoie le nombre d’éléments du tableau.

>>> a = [Link]([2,5,6,8])
>>> [Link](a)
4
>>> b = [Link]([[1, 2, 3],
[4, 5, 6]])
>>> [Link](b)
6

4.4.4 La fonction [Link]()

La fonction [Link]() (forme, en anglais) renvoie la taille du tableau.

>>> a = [Link]([2,5,6,8])
>>> [Link](a)
(4,)
>>> b = [Link]([[1, 2, 3],
[4, 5, 6]])
>>> [Link](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 = [Link]([[1, 2, 3],

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

4.4.6 Produit matriciel - [Link]()

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

>>> a = [Link]([[1, 2, 3],

[4, 5, 6]])
>>> b = [Link]([[4],
[2],
[1]])
>>> [Link](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é - [Link]()

>>> u = [Link]([[ 2j, 4+3j],

[2+5j, 5 ],
[ 3, 6+2j]])
>>> [Link](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é

>>> [Link](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 = [Link]([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 = [Link]([[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 - [Link]()

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

>>> [Link](3)
array([ 0., 0., 0.])

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

>>> [Link]((2,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.]])

4.4.13 Tableaux de 1 - [Link]()

>>> [Link](3)
array([ 1., 1., 1.])
>>> [Link]((2,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.]])

4.4.14 Matrice identité - [Link]()

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

>>> [Link](3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])

4.4.15 Déterminant - [Link]()

>>> from [Link] import det

>>> a = [Link]([[1, 2],
[3, 4]])
>>> det(a)
-2.0

4.4.16 Inverse - [Link]()

>>> from [Link] import inv

>>> a = [Link]([[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 - [Link]()

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

>>> a = [Link]([[3,1], [1,2]])

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

Pour vérifier que la solution est correcte :

>>> [Link]([Link](a, x), b)

True

4.4.18 Valeurs propres et vecteurs propres - [Link]()

>>> from [Link] import eig

>>> A = [Link]([[ 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 = [Link](1, 16)

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

4.4.20 Obtention d’un tableau 2D ligne ou colonne

>>> a = [Link](1, 6)
>>> a
array([1, 2, 3, 4, 5])
>>> [Link] = (1, [Link](a))
>>> a
array([[1, 2, 3, 4, 5]])
>>> [Link] = ([Link](a), 1)
>>> a
array([[1],
[2],
[3],
[4],
[5]])
5 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 :

[Link]
[Link]/pypi
[Link]/p/pythonxy/wiki/Downloads
[Link]