Vous êtes sur la page 1sur 18

12.

Présentation du langage python


12.1. Introduction
Le langage de programmation python a été créé en 1989 par Guido van Rossum, aux Pays-
Bas. Sa première version publique remonte à 1991. Au fil du temps et avec le développement de
la communauté Open Source, le python s’est forgé une notoriété et il est considéré actuellement
comme le langage par excellence pour le calcul scientifique vue sa simplicité à le prendre en main
et surtout pour sa richesse en modules (packages) prêts à être utilisés dans les programmes. La
dernière version de python est la version 3. Plus précisément, la version 3.7 a été publiée en
Février 2020. La version 3 est considérée actuellement comme la version standard de python,
mais il existe des versions plus anciennes telles que la version 2 qui est devenue obsolète et
qu’il faut dans la mesure du possible évitez d’utiliser. Le langage python présente de nombreux

avantages :

• Il est gratuit. On peut l’installer à partir d’internet sur autant d’ordinateurs qu’on veut.

• Il est multiplateforme. C’est-à-dire qu’il fonctionne sur de nombreux systèmes d’exploita-


tion (Windows, Mac OS X, Linux, Android, et jusqu’aux supercalculateurs).

• C’est un langage évolué proche du langage naturel et demande relativement peu de


connaissances en informatique. Désormais, Il peut être utilisé par les physiciens, matheux,
chimistes, biologistes, etc pour résoudre leurs problèmes numériques.

• Le python n’a pas besoin d’être compilé pour être exécuté comme les langages Fortran,
C et C++. Que ce soit une instruction ou un script, Python est directement interprété
par l’ordinateur.

• Il est très utilisé en physique numérique et analyse de données.


Toutes ces caractéristiques font que python est désormais utilisé dans toutes les universités du
monde.

12.2. Installation de python


Il est possible d’installer gratuitement python sur un ordinateur pour les principales plate-
formes utilisées en informatique à savoir Windows, Mac OS X ou Linux. Pour celà, il faut
télécharger l’installateur qui convient à votre plateforme à partir du site https://www.
anaconda.com/distribution/ et selon l’architecture de votre machine.

54
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Fig. 12.1. – Site anaconda pour le téléchargement de python.

Pour le système d’exploitation Linux, l’installateur python d’anaconda peut être lancé la
manière suivante :
$ ./Anaconda3-2020.02-Linux-x86_64.sh
Une fois l’installation terminée, on peut lancer python directement à partir de la ligne de
commande, comme suit :
$python
Python 3.7.6 (default, Jan 8 2020, 19:59:22)
[GCC 7.3.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
Les trois chevrons >>> indiquent la disponibilité de la ligne de commandes de python (prompt
en anglais) qui permet à l’utilisateur d’exécuter directement des instructions. Ce mode s’appelle
le mode commande de python.
Tapez par exemple l’instruction :
print("Cours PNAD")
Puis validez cette commande en appuyant sur la touche Entrée. En résumé, voici ce qui doit
apparaı̂tre sur votre écran :
>>> print (" Cours PNAD")
Cours PNAD
On peut aussi effectuer des calculs comme suit :
>>> 5*8+5
45
Le mode commandes est donc un système interactif dans lequel on peut entrer des commandes
que python interprètent au moment où on valide la commande en appuyant sur la touche Entrée.
On peut à chaque fois entrer une nouvelle commande ou bien quitter l’interpréteur python, soit
en tapant la commande exit() puis en validant en appuyant sur la touche Entrée, soit en
pressant simultanément les touches Ctrl et D au clavier.
Pour écrire un script ou plusieurs lignes de code, il est plus approprié d’utiliser un éditeur.

55
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

12.3. L’éditeur de texte idle


L’apprentissage du langage python va nécessiter d’écrire plusieurs lignes de code à l’aide d’un
éditeur de texte. L’installateur d’anaconda fournit un éditeur de texte très simple à utiliser,
c’est l’éditeur idle. Pour lancer l’éditeur idle à partir de la ligne de commande linux, on procède
comme suit :

$idle3

Biensûr, il existe d’autres éditeurs de textes qu’on peut utiliser à partir de linux pour pro-
grammer en python, on peut citer vim,emacs, etc. Mais, nous avons choisi pour ce cours,
l’éditeur idle.
On ne doit jamais utiliser des programmes comme Microsoft Word, WordPad ou LibreOffice
pour écrire des lignes de code python, ce sont des traitements de texte.

Fig. 12.2. – Interface de l’éditeur idle. La fenêtre de gauche représente le shell où sera exécuté le code
python. La fenêtre de droite représente un nouveau fichier pour saisir le code. Ces deux
fenêtres doivent être mises toujours côte à côte pour une bonne utilisation de idle.

• Pour ouvrir un nouveau fichier de saisie, dans la fenêtre Python 3.7.6 Shell, cliquer sur
File,New File.

• Pour Exécuter le code, dans la fenêtre de saisie, cliquer sur Run,Run Module

• Pour Enregistrer votre nouveau code, dans la fenêtre de saisie, clique sur File, Save as.
Le nom du fichier doit terminer par l’extension .py pour garantir la surbrillance de la
syntaxe de python.

12.4. Les variables


Dans la plupart des langages informatiques, le nom d’une variable représente une valeur d’un
type donné stocké dans un emplacement de la mémoire. Ceci n’est pas le cas en Python, où
les variables sont typées dynamiquement. C’est-à-dire, qu’il n’y’a aucune déclaration explicite
des variables dans le programme. Le type est affecté dynamiquement selon la valeur que vous
attribuez à la variable.

56
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Exemple 1. Cet exemple illustre le typage dynamique de python pour les variables.

a=4 # ici a est un entier.

b=3.14 # b est un réel.

nom=’sabeur’ # nom est une chaîne de caractères.

rep=True # et rep est une variable booléenne.

Le signe # marque le début d’un commentaire, c’est-à-dire le texte qui suit ce signe jusqu’à
la fin de la ligne n’est pas considéré par l’interpréteur de python.

12.4.1. Les chaı̂nes de caractères


Une chaı̂ne de caractères est une séquence de caractères entre guillemets simples ’ ou doubles
". Les chaı̂nes de caractères peuvent être concaténées avec l’opérateur plus +. Quant au décou-
page, l’opérateur : est utilisé pour extraire une partie de la chaı̂ne.

Exemple 2. Cet exemple présente les opérations de concaténation et de découpage des chaı̂nes
de caractères.

>>> str1 = ’Physique Numérique et ’


>>> str2 = ’Analyse de Données’
>>> print(str1+str2) # Concaténation
Physique Numérique et Analyse de Données.
>>> print(str1[0:8]) # Découpage
Physique

12.4.2. Les tuples


Un tuple est une séquence d’objets arbitraires séparés par des virgules et inclus entre des
parenthèses. Si le tuple contient un seul objet, une virgule finale est requise, par exemple, x
= (alpha,). Le tuple peut contenir parmi ses objets un autre tuple. Les tuples prennent en
charge les mêmes opérations que les chaı̂nes de caractères. Elles sont par contre immutables
(Non modifiables).

Exemple 3. Cet exemple présente la création et la manipulation des tuples.

>>> etudiant=(’Mejahed’, ’Abdelkader’,(05,07,62)) #Creation d’un tuple


>>> nom,prenom,datenais=etudiant #decoupage du tuple
>>> print(nom)
Mejahed
>>> print(etudiant[0]+’ ’+etudiant[1]) # Découpage
Mejahed Abdelkader
>>>Annee=datenais[2]
>>>print(Annee)
62

57
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

12.4.3. Les listes


Les listes sont similaire aux tuples, seulement elles sont modifiables. Les éléments et la lon-
gueur d’une liste peuvent être modifiés à tout moment dans le programme. Les éléments d’une
liste sont séparés par des virgules et inclus entre crochets. Voici quelques opérations qui peut
être effectuée sur des listes :
>>> a = [1.0, 2.0, 3.0, 4.0] # Création d’une liste
>>> a.append(5.0) # ajout de 5.0 à la liste
>>> print(a)
[1.0, 2.0, 3.0, 4.0, 5.0]
>>> a.insert(0,0.0) # Insérer 0.0 à la position 0
>>> print(a)
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
>>> print(len(a)) # Déterminer la longueur de la liste
6
>>> a[2:5] = [1.0, 1.0, 1.0] # Éléments d’indices 2,3 et 4 du tableau
>>> print(a)
[0.0, 1.0, 1.0, 1.0, 1.0, 5.0]
Si a est objet modifiable, tel qu’une liste, l’instruction d’affectation b = a n’entraı̂ne pas la
création d’un nouvel objet indépendant b, mais crée simplement une nouvelle référence à a.
Ainsi, tout changement faite à b sera reflétée dans a. Pour créer une copie indépendante d’une
liste a, il faut utiliser l’instruction c = a [ :].
Exemple 4. Cet exemple illustre comment pointer vers une liste ou créer une copie de la liste.
>>> a = [1.0, 2.0, 3.0]
>>> b = a # La variable b pointe vers la liste a
>>> b[0] = 5.0 # Le premier element de b est changé
>>> print(a)
[5.0, 2.0, 3.0] # Le changement affecte la liste a
>>> c = a[:] # c est une copie indépendante de a
>>> c[0] = 1.0 # On change le premier élément de c
>>> print(a)
[5.0, 2.0, 3.0] # La liste a n’est pas affecté par le changement
Les matrices peuvent être représentées sous forme de listes imbriquées, chaque ligne étant un
élément de la liste.
Exemple 5. Voici un exemple de création d’une matrice 3 × 3 sous forme d’une liste.
>>> a = [[1, 2, 3], \
[4, 5, 6], \
[7, 8, 9]]
>>> print(a[1]) # afficher la seconde ligne de la matrice a
[4, 5, 6]
>>> print(a[1][2]) # Afficher le 3ème élément de la 2ème ligne de a
6
Python utilise La barre oblique inverse \ comme caractère de continuation. Il faut savoir
aussi que les indices des séquences commencent à partir de 0, de sorte que [0] représente la
première ligne, un [1] la deuxième ligne, etc.
En calcul numérique, il es préférable d’utiliser l’objet array du module numpy pour repré-
senter les tableaux et matrices numériques. Cet objet sera discuté plus tard.

58
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

12.4.4. Les opérateurs arithmétiques


Python supporte les opérations arithmétiques usuelles :
+ Addition
- soustraction
* multiplication
/ division
** puissance
% reste de division

12.4.5. Les opérateurs de comparaison


Les opérateurs de comparaison retournent la valeur logique True ou False. Ces opérateurs
sont présentés dans le tableau suivant :

> Supérieur
< Inférieur
>= Supérieur ou égal
<= Inférieur ou égal
== égal
!= Différent

Remarque 3. Si les variables comparées ne sont pas de même type. Une conversion de type est
effectuée par l’interprêteur avant de procéder à la comparaison. Si la comparaison n’est pas
possible, une erreur est générée.

12.5. Lecture et affichage des données


12.5.1. La fonction de lecture input()
La fonction input() prend en argument une chaı̂ne de caractères et demande à l’utilisateur
d’entrer une valeur à partir du clavier et renvoie celle-ci dans une variable. Il faut ensuite
convertir cette dernière dans le type de données souhaitée. On peut vérifier le type de donnée
associée à la variable par la fonction type()

>>> a=input(’a=’))
3.12
>>> print(type(a))
<class ’str’>

Pour convertir la chaı̂ne de caractère en entier, on utilise la fonction int

>>> a=int(input(’a=’))
3
>>> print(type(a))
<class ’int’>

De même, pour convertir la chaı̂ne de caractère en réel, on utilise la fonction float

59
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

>>> a=float(input(’a=’))
3.14
>>> print(type(a))
<class ’float’>

On peut aussi permettre à l’interpréteur d’évaluer la chaı̂ne de caractère en utilisant la


fonction eval

>>> a=eval(input(’a=’))
3.14
>>> print(type(a))
<class ’float’>

12.5.2. La fonction d’affichage print()


La fonction print() affiche l’argument qu’on lui passe entre parenthèses et un retour à ligne.
Ce retour à ligne supplémentaire est ajouté par défaut. Si toutefois, on ne veut pas afficher ce
retour à la ligne, on peut utiliser l’argument par mot-clé end, comme présenté dans l’exemple
ci dessous :

>>> print (" Vive l\’Algérie !")


Vive l’Algérie!
>>> print ("Vive l\’Algérie !", end ="")
Vive l’Algérie !>>>

On peut aussi modifier ce comportement en passant à la fonction print() l’argument par


mot-clé sep :

>>> a=32
>>> b=1.72
>>> c=’alpha’
>>> print(a,b,c,sep="-"
32-1.72-alpha

12.5.3. La méthode .format() de print()


La méthode .format() permet une meilleure organisation de l’affichage des variables, telle que
le nombres de digits d’un entier ou le nombre de chiffres après la virgules d’un réel.
La forme générale de la mé thode .format() est la suivante :

print(’{:format1} {:format2},...’.format(arg1,arg2,...))

Où format1,format2,etc sont les formats d’affichage des arguments arg1,arg2,etc respective-
ment. Le tableau ci-dessous résume les principaux formats utilisés en affichage :

:wd format entier avec w nombre de cases occupées


:w.df format réel avec w nombre de caractères, d nombre de décimales
:w.dE format exponentiel
:ws format chaı̂ne de caractères, w nombre de caractères

60
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Exemple 6. Dans cet exemple, on utilise le format d pour formater l’entier a, f pour formater
le réel b et s pour formater la chaı̂ne de caractère c.
>>> a=1980
>>> b=1.728967345
>>> c=’beta’
>>> print("a= {:4d} b={:.4f} c={:s}".format(a,b,c))
a=1980 b=1.7290 beta

12.6. Les tests


Un test est un mécanisme de programmation qui permet à l’ordinateur de prendre un décision
concernant l’exécution d’un bloc d’instructions. Le python utilise l’instruction if pour traiter
la validité d’un test sur une condition logique.
if condition:
bloc d’instructions
Le bloc doit être indenté (laisser en général quatres espaces ou une tabulation) pour permettre
au python de savoir quelles sont les instructions à exécuter si la condition est vraie.
Voici un premier exemple :
a=7
if a>0:
print(’Le nombre est positif’)
Il existe une autre variante du test composée d’un bloc d’instructions à exécuter si la condition
est vraie et d’un autre bloc d’instructions si la condition est fausse.
if condition:
bloc1
else:
bloc2
Cet exemple illustre ce cas :
a=7
if a>0:
print(’Le nombre est positif’)
else:
print(’Le nombre est négatif ou nul’)
L’instruction if peut aussi être suivi par plusieurs tests imbriqués elif: (else if) comme
suit :
if condition1:
bloc1
elif condition2:
bloc2
elif condition3:
bloc3
.
.
.

61
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Les deux exemples précédents peuvent être développés autrement en utilisant l’instruction
elif:

a=7
if a>0:
print(’Le nombre est positif’)
elif a<0:
print(’Le nombre est négatif’)
else:
print(’le nombre est nul’)

12.7. Les boucles


Les boucles permettent d’exécuter une ou plusieurs instructions un certain nombre de fois
(répétition). Le python fournis plusieurs mécanismes pour réaliser des tâches répétitives. Nous
verrons d’abord l’instruction while

while condition:
bloc d’instructions

Le python exécute le bloc d’instructions indenté si la condition est vraie. Après l’exécution
du bloc, la condition est à nouveau évaluée. Si elle est toujours vraie, le bloc est exécuté de
nouveau. Ce processus se poursuit jusqu’à ce que la condition devienne fausse. Voici un exemple
de la boucle while en python :

i=0
while i<=10:
print(i)
i=i+1

Ce exemple permet d’afficher les nombres entiers de 0 à 10.


Une autre instruction répétitive disponible en python est la boucle for

for element in sequence:


bloc d’instruction

L’exemple suivant illustre l’utilisation de la boucle for pour afficher les couleurs d’une liste.
couleurs=[’vert’, ’rouge’, blanc] for coul in couleurs : print(coul)
Ici l’élément coul est une couleur dans la liste couleurs. Les valeurs vert, rouge et blanc seront
affichées en sortie de ce programme.

12.7.1. Les fonctions range() et list()


L’instruction range() est une fonction spéciale en python qui génère des nombres entiers
compris dans un intervalle. Elle est très utile dans la boucle for. On peut utiliser cette fonction
en combinaison avec la boucle for pour afficher les nombre entre 0 et 10. Le compteur i sera
incrémenté automatiquement dans la boucle for :

for i in range(10):
print(i)

62
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Remarque 4. L’instruction range() fonctionne sur le modèle range([début,] fin[, pas]).


Les arguments entre crochets sont optionnels. Ces arguments optionnels par défaut sont 0 pour
début et 1 pour pas.
La fonction list() combinée avec la fonction range() permet de générer une liste de
nombre entiers comme l’illustre cet exemple :

>>>print(list(range(5))
[0,1,2,3,4]

12.8. Les fonctions


Les fonctions permettent de réaliser plusieurs fois la même opération au sein d’un programme.
L’utilisation des fonctions dans un programme rendent le code plus lisible et plus clair. Le
mécanisme d’une fonction est constitué de trois éléments :
1. Passer aucune, une ou plusieurs variables (paramètres) entre parenthèses à la fonction.
2. Effectuer une tâche.
3. Renvoyer en retour aucune ou un objet au programme principal.
Par exemple la fonction sin consiste à calculer le sinus d’une valeur donnée et de la renvoyer
au programme principal :

>>>sin(pi/4)
0.7071067811865476

Pour définir une fonction en python, on procède comme suit :

def nom_fonction(param1,param2,...):
instructions
return valeurs_de_retour

où param1, param2 ,· · · sont les paramètres de la fonction. Un paramètre peut être n’importe
quel objet python, y compris une fonction. Les paramètres peuvent recevoir des valeurs par
défaut.
Remarque 5. Le paramètre dans l’appel d’une fonction est facultatif. Si l’instruction de retour
ou les valeurs de retour sont omis, la fonction renvoie l’objet nul.
Dans l’exemple qui suit, la fonction derive calcule les deux premières dérivées d’une fonction
f(x) par la formule de dérivation numérique centrée :

def derive(f,x,h=0.0001): # h a la valeur par défaut 0.0001


df =(f(x+h) - f(x-h))/(2.0*h)
ddf =(f(x+h) - 2.0*f(x) + f(x-h))/h**2
return df,ddf

63
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

12.9. Les fichiers


12.9.1. Ouverture d’un fichier
Pour ouvrir un fichier sous python, un objet fichier est créer de la manière suivante :

objfichier=open(nomfichier,mode)

Où nomfichier est le nom du fichier sur le support de stockage et mode est l’action
d’ouverture adoptée. Les modes d’ouverture sont résumés dans le tableau ci-dessous :

’r’ ouverture en lecture


’w’ ouverture en écriture, le fichier est écrasé
’a’ ajout en fin de fichier
’r+’ lecture/écriture sur fichier existant
’w+’ lecture/écriture sur nouveau fichier
’a+’ ajout en fin d’un nouveau fichier

12.9.2. Fermeture d’un fichier


Il est recommandé de fermer un fichier lorsque l’accès à celui-ci n’est plus requis. Cela peut
être fait avec la méthode .close() comme suit :

objetfichier.close()

12.9.3. Lecture à partir d’un fichier


Il existe trois méthodes de lecture à partir d’un fichier :
1. La méthode objetfichier.read(n) permet de lire n caractères à partir d’un fichier.
2. La méthode objetfichier.readline(n) permet de lire n caractères à partir d’une
ligne d’un fichier et retourne une chaı̂ne de caractères.
3. La méthode objetfichier.readlines() sans argument permet de lire toute les
lignes du fichiers et retourne une liste de chaı̂ne de caractères
L’exemple suivant illustre une lecture de plusieurs lignes d’un fichier de données

data=open(’results.dat’,’r’)
lines=data.readlines()
print(lines)

On peut aussi parcourir les lignes du fichier dans une boucle comme suit :

data=open(’results.dat’,’r’)
for line in data:
print(line)

On peut même découper les éléments d’une ligne et les mettre dans des listes séparées par :

data=open(’results.dat’,’r’)
for line in data:
lines=line.split()
print(lines)

64
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

12.9.4. Écriture dans un fichier


La méthode nomfichier.write(chaîne) permet d’écrire une chaı̂ne de caractère dans
un fichier. On peut aussi écrire une liste de chaı̂ne de caractères en utilisant la méthode
nomfichier.writelines(liste de chaîne).
L’exemple ci-dessous illustre l’écriture des valeurs d’une fonction (x, sin(x)) dans un fichier
en utilisant la méthode .write() :

from math import sin,pi


f = open(’sinfile.dat’,’w’)
x=0
while x<=pi:
f.write(’{:8.2f} {:8.2f}’.format(x,sin(x)))
f.write(’\n’)
x=x+0.1
f.close()

Remarque 6. On peut utiliser la fonction print pour diriger la sortie d’écriture vers un fichier
de la manière suivante :

print(val1,val2,...,file=fichierobjet)

12.10. Les modules


Il est judicieux de stocker des fonctions utiles dans des modules. Un module est simplement
un fichier où résident les fonctions. Le nom du module est le nom du fichier. Un module peut
être chargé dans un programme par l’instruction :

from nom_module import *

On peut aussi charger quelques fonctions à partir d’un module de python comme suit :

from nom_module import fonc1,fonc2,...

12.10.1. Les modules d’intérêt en physique numérique


Les modules les plus utilisés en python pour la physique numérique sont présentés dans le
tableau ci-dessous :

Module Utilité
math regroupe les fonctions mathématiques
numpy traitement des vecteurs et matrices
matplotlib Tracé de graphiques
scipy méthodes de calcul scientifique
random génération de nombres aléatoires

65
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

12.10.2. Le module numpy


Le module numpy est très utile pour manipuler les vecteurs et les matrices. Il dispose aussi
d’un sous module appelé linalg pour les opérations d’algèbre linéaire.
Pour intégrer les deux modules dans un programme, on procède comme suit :

import numpy as np
import numpy.linalg as alg

Pour créer un vecteur avec numpy, on écrit :

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

Ce qui permet de créer le vecteur a = (1, 2, 3).


Pour créer une matrice composée de deux lignes par exemple, on écrit :

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

Ce qui permet de créer la matrice


 
1 2 3
m=
4 5 6

L’attribut shape permet de connaı̂tre la taille d’une matrice, c’est-à-dire le nombre de lignes
et de colonnes comme dans cet exemple :

>>>print(m.shape)
(2,3)

L’attribut reshape permet de changer le nombre de lignes et de colonnes d’une matrice de


la manière suivante :

>>>m.reshape(3,2)
>>>print(m)
[[1 2]
[3 4]
[5 6]]

L’accès à un terme d’une matrice se fait par l’opération d’indexage des éléments m[i,j].
Les indices commencent toujours par i = 0 pour la 1ère ligne et j = 0 pour la première colonne.
numpy dispose de deux fonctions zeros() et ones() pour initialiser les vecteurs ou ma-
trices par des 0 ou des 1.
La fonction zeros() permet d’initialiser un vecteur ou une matrice par des 0.

>>>m=np.zeros((2,3))
>>>print(m)
[[0. 0. 0.]
[0. 0. 0.]]

La fonction ones() permet d’initialiser un vecteur ou une matrice par des 1.

66
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

>>>m=np.ones((2,2))
>>>print(m)
[[1. 1.]
[1. 1.]]

Ces deux fonctions génèrent par défaut des float mais on peut générer des entiers en passant
l’argument int à la fonction comme suit :

>>>m=np.zeros((2,3),int)
>>>print(m)
[[0 0 0]
[0 0 0]]

et

>>>m=np.ones((2,2),int)
>>>print(m)
[[1 1]
[1 1]]

Si on veut initialiser une matrice avec un autre élément, numpy dispose de la fonction
full(). Par exemple initialiser un matrice 2 × 2 par le nombre π, on procède comme suit :

>>>import numpy as np
>>>from math import pi
>>>m=np.full((2,2),pi)
>>>print(m)
[[3.14159265 3.14159265]
[3.14159265 3.14159265]]

L’exemple suivant montre comment on peut lire les éléments d’une matrice n × n dans une
double boucle for :

import numpy as np
n=int(input(’n=’))
m=np.zeros((n,n)) #creation d’une matrice nxn composés de 0

for i in range(n):
for j in range(n):
print(’m[’,i,’,’,j,’]=’)
m[i,j]=eval(input(’m[’,i,j,’]=’))

numpy permet aussi de générer des matrices utiles en algèbre linéaire telle que la matrice
identité ou la matrice diagonale. Pour générer par exemple une matrice identité d’ordre 3, on
écrit :

>>>m=np.eye(3)
>>>print(m)
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

67
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Et pour générer par exemple une matrice diagonale


 
1 0 0
m= 0 2 0 
0 0 3

, On écrit :

>>>m=np.diag([1,2,3])
>>>print(m)
[[1. 0. 0.]
[0. 2. 0.]
[0. 0. 3.]]

Remarque 7. Pour effectuer des opérations arithmétiques entre les éléments des matrices. Les
opérateurs d’addition, soustraction et multiplication sont valables aussi sous numpy.
Par exemple pour effectuer l’opération suivante :
     
1 2 1 0 4 2
+3 =
3 4 0 1 3 7

, on peut procéder comme suit :

>>>a=np.array([[1,2],[3,4]])
>>>n=np.eye(2)
>>>c=a+3*b
>>>print(c)
[[4. 2]
[3. 7.]]

D’autres opérations très importantes en algèbre linéaire sont disponibles avec le module
numpy et son sous module linalg, les plus importantes sont le calcul de la transposée, le
calcul du déterminant, de la puissance d’une matrice, de la trace, du produit scalaire et du
produit matriciel et bien d’autres opérations.
Pour calculer la transposée d’une matrice, on écrit :

>>>a=np.array([[1,2,3],[4,5,6],[7,8,9]])
>>>b=np.transpose(a)
>>>print(b)
[[1. 4. 7.]
[2. 5. 8.]
[3. 6. 9.]
]

Pour calculer la trace d’une matrice :

>>>a=np.array([[1,2,3],[4,5,6],[7,8,9]])
>>>print(np.trace(a))
15.

Pour calculer le produit scalaire de deux vecteurs, par exemple a = (1, 2, 3) et b = (4, 5, 6) :

68
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

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

Pour calculer le produit scalaire de a et b, on écrit :

>>>print(np.cross(a,b))
[-3 6 -3]

Pour calculer la puissance A3 d’une matrice


 
1 2 3
A= 4 5 6 
7 8 9

, on écrit :

>>>a=np.array([[1,2,3],[4,5,6],[7,8,9]])
>>>b=alg.matrix_power(a,3)
>>>print(b)
[[ 468 576 684]
[1062 1305 1548]
[1656 2034 2412]]

Pour calculer le déterminant de la même matrice A, on écrit :

>>>print(alg.det(a))
6.66133814775094e-16

12.10.3. Le module matplotlib


matplotlib est un module qui fournit un système de dessin assez puissant. Dans cette
section, nous allons donner une brève présentation du sous module matplotlib.pyplot
qui est très utile pour afficher les données sous forme de courbes et permet aussi de produire
des figures qui peuvent être intégrés dans des documents. La fonction la plus importante de
matplotlib est plot. Elle permet de tracer des données en 2D. En Voici un exemple simple :

import numpy as np
import matplotlib.pyplot as plt

# calcul des coordonnées x, y de la fonction sin(x)


x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)

# Tracer les point(x,y) avec pyplot de matplotlib


plt.plot(x, y)
plt.show() # Affichage de la courbe

69
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Ce code donne la figure suivante :

Fig. 12.3. – Courbe de sin(x) générée par pyplot de matplotlib.

Avec quelques instructions supplémentaires, nous pouvons facilement tracer plusieurs courbes
à la fois et ajouter un titre, une légende et des étiquettes pour les axes x et y :

import numpy as np
import matplotlib.pyplot as plt

# calcul des coordonnées x, y de la fonction sin(x) et cos(x)


x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

# Tracer les point(x,y) avec pyplot de matplotlib


plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel(’x’) #étiquette axe x
plt.ylabel(’f(x)’) #étiquette axe y
plt.title(’Sin(x) et Cos(x)’) #titre de la figure
plt.legend([’Sin(x)’, ’Cos(x)’]) #légendes
plt.savefig(’sin_cos.png’) #image à générer
plt.show() # Affichage des courbes

Ce qui produira à l’écran la figure suivante :

70
Dr Sid Ahmed Sabeur Faculté de Physique, USTOMB

Fig. 12.4. – Courbe de sin(x) et cos(x) générées par pyplot de matplotlib.

et générera un fichier sin_cos.png.

71

Vous aimerez peut-être aussi