Introduction à Python

Chapitre 2
Introduction à
Python
Patient : What do I do ?
Obstetrician : Nothing, dear, you're not qualied.
Monty Python's The Meaning of Life
2.1
Installation de Python et des bibliothèques.
Vous avez la possibilité d'installer manuellement
vantes :
NumPy SciPy SymPy MatPlotLib
Python 1
,
,
et
Python v.3.3.0
ainsi que les bibliothèques sui-
. Ces bibliothèques constituent la conguration mini-
male pour les applications que nous étudierons. Pour chacune d'elles, il faudrait : télécharger la version
qui est compatible avec votre version de
, la décompresser et l'installer (en cliquant sur le chier
setup.py).
Il est néanmoins plus simple d'installer automatiquement une distribution contenant non seulement
l'interpréteur
Python
, mais aussi un choix de bibliothèques parmi les plus courantes ainsi qu'une in-
terface pour aider à développer des programmes. Nous choisirons la distribution
WinPython
dont les
bibliothèques sont orientées pour un usage scientique et qui a la particularité d'être portable. Cette
caractéristique présente deux avantages : d'une part, cette distribution peut se déployer rapidement sur
l'ensemble des ordinateurs d'une salle d'informatique et, d'autre part, les élèves ont la possibilité de l'emporter sur la clé USB où ils enregistrent leurs programmes.
Téléchargez
WinPython-3.3.0
à l'adresse :
http://code.google.com/p/winpython/downloads/list.
Exécutez le chier, choisissez un répertoire d'installation et. . . c'est tout. Vous pouvez commencer à
travailler en lançant la console
Spyder
. Si vous souhaitez installer
Python
WinPython Control Panel
sur une clé USB, vous
pouvez désinstaller les bibliothèques qui ne vous intéressent pas à l'aide de
.
2.2
Lexique
Guide rapide de Python pour les habitués de C,. . .
1. Le passage de la version 2.x à la version 3.0 constitue une évolution majeure de
profondeur si bien que le principe de compatibilité descendante a été rompu.
11
Python
, le code a été revu en
12
CHAPITRE 2.
INTRODUCTION À
PYTHON
2.2.1 Instructions de base
Caractères spéciaux
commentaire :
# ceci est un commentaire
a\ Enter
-b
écriture sur plusieurs lignes :
Tab
: il importe de bien respecter les indentations car elles permettent de dénir des blocs. Contraire-
ment au langage C, il n'y a pas d'accolades en
Python
.
Mots-clés réservés
and as assert break class continue def del elif else except false finally for
from global if import in is lambda none nonlocal not or pass raise return
true try while with yield
Opérations mathématiques
+ - * / : opérations usuelles
2**3 : élévation à la puissance
10//3 : partie entière d'une division
10%3 : reste d'une division
1e-3 : réel 0, 001
1+3j ou complex(1,3) : complexe 1 + 3.i
(avec
i2 = −1)
Opérateur de comparaison
< > <= (inférieur ou égal) >= (supérieur ou égal)
== (comparaison et non aectation) =! (diérent)
Variables
nom : sensible à la casse (majuscule/minuscule)
aectation :
suppression :
a=7
del a
a=b=2
permutation : a,b = b,a (pas besoin d'une troisième variable)
raccourcis : a+=1 (pour a=a+1), a-=1 , a*=2 , a/=2
types : bool (booléen), int (entier), float (réel), complex (complexe), list
set (ensemble), tuple (liste ordonnée non modiable), dict (dictionnaire), str
aectation multiple :
(liste ordonnée),
(chaine de carac-
tères entre "guillemets", 'apostrophe' ou """triple guillemets""")
dans une chaine entre "guillemets" inclure les guillemets de cette façon :
"J'ai dit \"Stop!\""
dans une chaine entre 'apostrophes' inclure les apostrophes de cette façon :
'J\'ai de la chance'
Les variables locales - dénies avant d'appeler une fonction - sont lisibles lors de l'exécution de la fonction
[règle 1]. Elles ne peuvent être modiées qu'en agissant sur l'objet par un mot-clé ou par une méthode
[règle 2].
Les variables locales - dénies dans une fonction - sont supprimées après l'exécution de la fonction [règle
3].
On peut transformer des variables locales en variables globales (à l'aide de
lors de l'exécution d'une fonction [règle 4].
global )
pour les modier
2.2.
13
LEXIQUE
Exemple :
l i s t e =[1 ,2 ,3]
i =1
def
fonction ( ) :
#nécessaire pour pouvoir modifier i [ règle 4]
#modification p o s s i b l e [ règle 2]
p r i n t ( " d a n s l a f o n c t i o n " , i ) #variable i a c c e s s i b l e
#même si on ne l 'a pas déclarée comme globale [ règle 1]
i +=1 #impossible si on n 'a pas déclaré i comme gl o b al [ règle 2]
u=2 #variable l o c al e qui sera supprimée [ règle 3]
fonction ()
p r i n t ( l i s t e ) #la l i s t e a bien été modifiée par la fonction
p r i n t ( i ) #la variable i a pu être modifiée
#car e l l e a été déclarée comme globale
p r i n t ( u ) #provoque une erreur car u a été supprimée
global
del
i
liste [0]
Entrée-Sortie
â g e ? " ) #age est une chaine de caractères
#transforme la chaine de caractères en un entier .
a g e=i n p u t ( " V o t r e
a g e=i n t ( a g e )
p r i n t ( " a g e+1=" , a g e +1)
Test
if
a >0:
print (" p o s i t i f ")
elif
a <0:
print (" négatif ")
else :
p r i n t ( " nul " )
Boucles
boucle for
c h a i n e=" B o n j o u r "
for
lettre
in
chaine :
print ( l e t t r e )
boucle while
i =0
while
i <10:
print ( i )
i +=1
break
while
True :
l e t t r e =i n p u t ( " Taper Q p o u r
if
l e t t r e==Q :
break
quitter ")
14
CHAPITRE 2.
INTRODUCTION À
PYTHON
continue
i =1
while
i <10:
if
i %3==0:
i +=2
continue
i +=1
#retour direct au while sans executer la suite
Fonction
#par défaut b=2 ( paramètre nommé) ,
#sauf si on impose une autre valeur
r e t u r n ( a+b )
r e s u l t a t =a d d i t i o n ( 1 ) #donne 3
r e s u l t a t =a d d i t i o n ( 1 , 3 ) #donne 4
def
a d d i t i o n ( a , b=2):
def
division (a , b ):
q u o t i e n t=a // b
r e s t e =a%b
return
#renvoie deux valeurs
quotient , r e s t e
c , d= d i v i s i o n ( 1 0 , 3 )
Pour les fonctions limitées à une seule instruction, on peut utiliser des fonctions lambda :
f=lambda
f (1 ,3)
a , b : a+b
# donne 4
Pour les fonctions avec un nombre de paramètres inconnus :
def fonction(*parametres): que l'on appelle par fonction(a,b,c)
la variable parametres représente un tuple (voir plus loin)
Pour les fonctions avec un nombre de paramètres nommés inconnus :
def fonction(**parametres_nommes): que l'on appelle par fonction(a=1,b=2,c=3)
la variable parametres_nommes représente un dictionnaire (voir plus loin)
Pour les fonctions avec un nombre de paramètres, nommés ou non, inconnus :
def fonction(*parametres,**parametres_nommes):
Chaine de caractères
MaChaine=str() ou bien MaChaine=""
aectation : MaChaine=" aBcD "
création :
minuscule :
MaChaine.lower() #il s'agit méthode appliquée à MaChaine
#mais MaChaine n'est pas modifiée
majuscule :
MaChaine.upper()
première lettre en majuscule :
MaChaine.capitalize()
retirer les espaces au début et à la n :
MaChaine.strip()
MaChaine.center(10)
caractères : MaChaine.rjust(10)
centrer dans un espace de 10 caractères :
justier à droite dans un espace de 10
2.2.
15
LEXIQUE
découper une chaine en liste :
MaChaine="1 2 3"
MaChaine.split(" ") #la chaine est découpée en ['1','2','3']
reconstituer une chaine à partir d'une liste :
MaListe=['1','2','3'];" ".join(MaListe) #la chaine précédente est reconstituée
formater une chaine :
prenom="jean";nom="martin";"je m'appelle {0} {1}".format(prenom,nom)
"je m'appelle {prenom} {nom}".format(prenom="jean",nom="martin")
ou bien
accession à un caractère :
MaChaine[0] #1er élément indexé 0
on ne peut pas modier un élément par son index comme pour une liste
concaténation :
MaChaine+"efg"+str(var) #si var n'est pas une chaine de caractères
MaChaine[0:2] #sélectionne les 2 caractères indexés 0 et 1
MaChaine[:4] #sélectionne les 4 premiers caractères (à partir de l'index 0)
sélection d'une sous-chaine :
longueur d'une chaine :
len(MaChaine)
a=eval("1+1") #a=2
évaluation d'une chaine :
Liste ordonnée
création :
MaListe=list() ou bien MaListe=[]
MaListe=[1, 2, "trois"] #on peut lister des éléments de différents types
aectation :
MaCopie=list(MaListe)
si vous faites : MaCopie=MaListe les
s'appliqueront aussi à MaListe.
accession à un élément : MaListe[0] #1er élément indexé 0
modication d'un élément : MaListe[2]=3
création d'une copie :
ATTENTION
ajout à la n :
:
appliquées
à
MaCopie
MaListe.append(4) #MaListe est directement modfiée
#il ne faut pas coder: MaListe=MaListe.append(4)
insertion d'un élément :
concaténation :
modications
MaListe.insert(2,2.5) #insère 2.5 à la 2ème place (entre 2 et 3)
MaListe.extend([5,6,7])
ou bien
MaListe+=[5,6,7]
suppression d'un élément :
del MaListe[0] #supprime le 1er élément (on indique la valeur de l'index)
ou bien
MaListe.remove(2) #sup. le 1er élément qui vaut 2 (on indique la valeur de l'élément)
longueur d'une liste :
len(MaListe)
parcours des éléments d'une liste en précisant l'index :
for element in enumerate(MaListe):
print(element)
passage d'une liste à un ensemble (sans élément redondant) :
numpy.unique(MaListe)
opérations multiples sur une liste :
MaListe=[1,4,7]
[element * element for element in MaListe] #crée la liste [1,16,49]
MaListe=[1,4,7]
[element * element for element in MaListe if element%2==0] #crée la liste [16]
on peut également utiliser les fonctions
map()
et
filter() .
16
CHAPITRE 2.
INTRODUCTION À
PYTHON
carre=lambda x: x**2
list(map(carre,range(1,10))) #1 4 9 25 36 49 64 81
pair=lambda x: x%2==0
list(filter(pair,range(1,10))) #2 4 6 8
utilisation de listes pour créer des piles (dernier entrant, premier sortant) :
MaPile=[1,2,3]
MaPile.append(4) # [1, 2, 3, 4]
MaPile.pop() #4
Ensemble
Liste sans élément redondant.
MonEnsemble=set()
MonEnsemble=set([1,2,3]) #{1,2,3}
test d'un élément : 4 in MonEnsemble #False
union : e1=set([1,2,3]);e2=set([3,4,5]);e1|e2 #{1,2,3,4,5}
intersection : e1=set([1,2,3]);e2=set([3,4,5]);e1&e2 #{3}
diérence : e1=set([1,2,3]);e2=set([3,4,5]);e1-e2 #{1,2} seulement dans e1
diérence symétrique : e1=set([1,2,3]);e2=set([3,4,5]);e1^e2 #{1,2,4,5} union-intersection
création :
aectation :
Tuple
Liste non modiable après sa création. Création et aectation comme les listes mais avec des (parenthèses)
au lieu des [crochets].
MonTuple=(1,2,3)
MonTuple=(1,) #pour un élément unique, il faut mettre la virgule sinon Python
#enlèverait automatiquement les parenthèses et transformerait le tuple
#en une simple variable.
Dictionnaire
Liste non ordonnée où chaque élément est associé à une clé. Création et aectation comme les listes mais
avec des
{accolades} au lieu
MonDico=dict()
création :
des [crochets].
ou
MonDico={}
ou bien
MonDico={cle1:element1, cle2:element2}
insertion ou modication d'un élément :
MonDico["cle"]="element" #on peut utiliser n'importe quelle clé
#pour indexer n'importe quel élément
cas où l'élément est une fonction :
accession à un élément :
def fonction():
print("Hello")
MonDico["f"]=fonction #sans les parenthèses
MonDico["cle"] #si la clé ne correspond à aucun élément
#on aura une exception de type KeyError
2.2.
17
LEXIQUE
cas où l'élément est une fonction :
suppression d'un élément :
ou bien
MonDico["f"]() #avec les parenthèses
del MonDico["cle"] #supprime la clé et l'élément associé
MonDico.pop("cle")
parcours des clés :
for cle in MonDico.keys():
for element in MonDico.values():
for cle, element in MonDico.items():
parcours des éléments :
parcours des clés et des éléments :
Gestion des erreurs
try :
c=a / b
assert
#on t e s t e une operation à risque
c >0 #pour la suite du programme , on veut c>0
except
NameError :
except
TypeError :
except
ZeroDivisionError :
except
AssertionError :
p r i n t ( "a
p r i n t ( "a
p r i n t ( "b
ou
b n ' est
pas
défini ")
ou
b n ' est
pas
un
est
print (" le
nombre " )
nul " )
résultat
n ' est
division
n 'a
pas
positif ")
else :
print (" la
et
donne
bien
un
pas
résultat
provoqué
d ' erreur
\
positif ")
finally :
p r i n t ( " qu ' i l
y
ait
une
erreur
ou
pas ,
on
fait
la
suite ")
ou bien
try :
c=a / b
if
#on t e s t e une operation à risque
#pour la suite du programme , on veut c>0
r a i s e ValueError ( " l e r é s u l t a t n ' e s t pas p o s i t i f " )
#on génère un type d ' erreur ( i . e . on lève une exception )
c <=0:
except
NameError :
except
TypeError :
except
ZeroDivisionError :
except
ValueError :
p r i n t ( "a
p r i n t ( "a
p r i n t ( "b
print (" i l
ou
b n ' est
pas
défini ")
ou
b n ' est
pas
un
est
y
nombre " )
nul " )
a
un
problème " )
else :
print (" la
et
donne
division
bien
un
n 'a
pas
résultat
provoqué
d ' erreur
\
positif ")
finally :
p r i n t ( " qu ' i l
y
ait
une
erreur
ou
pas ,
on
fait
la
suite ")
Importation des bibliothèques
import math #importation de toutes les fonctions de la bibliothèque math
math.sqrt(9) #utilisation de la fonction sqrt de la bibliothèque math
import math as mathematique #importation en changeant le nom de la bibliothèque
from math import sqrt #importation de la seule fonction sqrt
18
CHAPITRE 2.
INTRODUCTION À
PYTHON
sqrt(9) #utilisation de la fonction sqrt importée (sans avoir besoin de préciser math.)
from math import * #importation de toutes les fonctions de la bibliothèque math
#on peut alors appeler toutes les fonctions sans avoir besoin de préciser math.
#mais attention aux doublons si on utilise plusieurs bibliothèques
import paquet.souspaquet #importation du souspaquet se trouvant
#dans un sous-répertoire de paquet
Biblothèques utiles :
os, math, random, . . .
2.2.2 Sauvegarde du code
Spyder
# −∗− coding : Latin −1−∗−
Dans l'éditeur de
import
, créez un chier où vous insérez au début :
os
Tapez votre code et insérez à la n :
os . system ( " pause " )
Sauvez le chier avec l'extension
Si vous n'utilisez pas
.py
et lancez l'exécution (Menu
Spyder
, prenez un éditeur type :
Exécution/Exécution).
NotePad++
et faites de même. Exécutez
directement le code en double-cliquant sur le nom du chier ou bien utilisez l'éditeur IDLE de Python
(clic droit sur le nom du chier) puis
Run/Run Module.
Prenez l'habitude de regrouper vos fonctions dans votre propre bibliothèque (par exemple dans un chier
MaBibliotheque.py)
an de les séparer du code principal (par exemple
CodePrincipal.py)
qui
commencera par :
# −∗− coding : Latin −1 −∗−
import
from
os
MaBiblotheque
∗
import
Insérez le code principal et terminez par :
os . system ( " pause " )
Pour
tester
une
fonction
MaBiblotheque.py
if
(ex
:
test(2))
de
MaBibliotheque.py,
ajoutez,
à
l'intérieur
du
chier
MaBibliotheque.py
depuis
:
__name__=="__main__" :
test (2)
os . system ( " pause " )
ainsi,
la
fonction
CodePrincipal.py
test(2)
ne
sera
pas
exécutée
lorsque
vous
appelez
Remarque :
Le code principal et les bibliothèques sont interprétés à la volée. Il faut donc que Python soit installé. Pour créer un exécutable "stand-alone", utilisez un outil comme
http://cx-freeze.sourceforge.net/).
cx_Freeze
(téléchargeable à :
2.2.
19
LEXIQUE
2.2.3 Lecture-écriture dans des chiers
se déplacer dans l'arborescence des répertoires :
import os
os.chdir("C:/Documents and Settings")
ouvrir un chier en mode lecture (r pour read) :
MonFichier1=open("fichier1.txt","r")
lire l'intégralité d'un chier ouvert :
contenu=MonFichier1.read()
créer un chier en mode écriture (w pour write) :
MonFichier2=open("fichier2.txt","w") #si ce fichier existe déjà, il est écrasé
ouvrir un chier en mode écriture à la suite (a pour append) :
MonFichier3=open("fichier3.txt","a")
écrire une chaine de caractères dans un chier :
MonFichier2.write("Ecrire")
MonFichier1.close()
fermer un chier :
Pour écrire des données en mode binaire (b pour binary) :
import
pickle
n o t e s ={
#b i b l i o t h è q u e pour l i r e et écrire n ' importe quel objet
" informatique " :20 ,
" physique " :
" maths " :
"S . I " :
" arts
19 ,
18 ,
17 ,
plastiques " :2 ,
}
with
o p e n ( ' n o t e s . d a t ' , ' wb ' )
as
MonFichier :
#l e s notes seront é c r i t e s dans le f i c h i e r notes . dat en binaire
M o n P i c k l e r=p i c k l e . P i c k l e r ( M o n F i c h i e r )
#Pickler est un objet que l 'on va écrire dans MonFichier
M o n P i c k l e r . dump ( n o t e s ) #écriture des notes
Pour lire des données en mode binaire (b pour binary) :
import
with
#b i b l i o t h è q u e pour l i r e et écrire n ' importe quel objet
as MonFichier :
#l e s notes seront lues à partir du f i c h i e r notes . dat en binaire
M o n D e p i c k l e r=p i c k l e . U n p i c k l e r ( M o n F i c h i e r )
#Unpickler est un objet que l 'on va l i r e à partir de MonFichier
pickle
open ( ' n o t e s . dat ' , ' rb ' )
n o t e s=M o n D e p i c k l e r . l o a d ( )
2.2.4 Utilisation des bibliothèques NumPy, SciPy, SymPy, MatPlotLib
NumPy
SciPy
PyLab PyPlot
MatPlotLib
SymPy
La bibliothèque
matrice,. . .) ;
est notamment utile pour gérer les problèmes d'algèbre linéaire (vecteur,
pour le traitement du signal ;
les sous-bibliothèques
et
MatPlotLib
MatLabR
R
MatLab
SciLab
Plotting
pour les graphiques 2D et 3D (ainsi que
pour les fonctions de
est que la syntaxe est très proche de
). L'intérêt de la bibliothèque
et donc de
cette méthode pour les représentations graphiques par rapport au module
.
. Nous privilégierons
de la bibliothèque
Dans toute la suite, nous importerons ces bibliothèques avec les mêmes conventions que
savoir :
import
import
import
import
numpy as np
scipy as sp
matplotlib as mpl
matplotlib.pyplot as plt
Spyder
, à
20
CHAPITRE 2.
INTRODUCTION À
PYTHON
from pylab import *
Vecteur - matrice
création :
MonVecteur= np.array([])
aectation :
vecteur en ligne :
MonVecteurLigne=np.array([1,2,3])
MonVecteurColonne=np.array([[1],[2],[3]])
vecteur en colonne :
matrice :
MaMatrice=np.array([[1,2,3],[4,5,6],[7,8,9]])
ou MaMatrix=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
np.matrix permet d'appliquer des méthodes spéciques aux matrices ;
on peut passer de array à matrix par np.asmatrix(MaMatrice)
et réciproquement par
np.asarray(MaMatrix) .
création automatique :
création d'un vecteur correspondant à progression arithmétique :
MonVecteurLigne=np.arange(1,10,2) # (début,fin,incrément)
MonVecteurLigne=np.linspace(1,9,5) # (debut,fin,NbreElements)
création d'une matrice aléatoire (éléments entre 0 et 1) de 2 lignes et 3 colonnes :
création d'une matrice nulle de 2 lignes et 3 colonnes :
np.random.rand((2,3))
np.zeros((2,3))
np.eye(3,3)
M (i, j) = f (x(i), y(j)) ; ex : f (x, y) = x2 + 2.y 3
création d'une matrice identité de dimension 3 :
création de la matrice
m×n
telle que
:
x = np.arange(-5, 5, 0.25)
y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(x, y)
Z=np.square(X)+2*np.power(Y,3)
voir une application au Ÿ graphiques à 3 dimensions.
MaCopie=MonVecteur.copy() ou MaCopie=np.copy(MonVecteur)
MaCopie=MonVecteur les modications appliquées à MaCopie
aussi à MonVecteur.
création d'une copie :
ATTENTION : si vous faites :
s'appliqueront
accession à un élément :
MaMatrice[1,2] #élément 2ème ligne, 3ème colonne (à partir de l'index 0)
accession à un élément indexé à partir de la n (index négatif ) :
MonVecteurLigne[-1] # dernier élément
accession à une ligne :
MaMatrice[1,:] #2ème ligne
MaMatrice[:,2] #3ème colonne
élément : MaMatrice[1,2]=10
accession à une colonne :
modication d'un
suppression d'un élément :
np.delete(MonVecteur,1) #supprime le 2eme élément (on indique la valeur de l'index)
concaténation :
MonVecteur=np.concatenate((MonVecteur,np.arange(5,8)))
sélection d'une sous-matrice :
MaMatrice[0:2,0:2] # LigneDebut:NbreLigne,ColonneDebut:NbreColonne (à partir de 0)
nombre d'éléments d'un vecteur ou d'une matrice :
size(MonVecteurLigne) # nombre total d'éléments
dimensions d'une matrice :
np.shape(MaMatrice) #(NbreLignes,NbreColonnes)
reformatage d'une matrice :
MonVecteurColonne=MonVecteurLigne.reshape(size(MonVecteurLigne),1)
une méthode plus élégante en ajoutant une dimension pour transformer le vecteur en matrice :
MonVecteurColonne=MonVecteurLigne[:,np.newaxis]
2.2.
21
LEXIQUE
si vous voulez un vecteur distinct, utilisez
np.copy(...)
parcours des éléments d'un vecteur en précisant l'index :
for element in enumerate(MonVecteur):
print(element)
opérations multiples sur un vecteur :
MonVecteur=np.array([1,4,7]);
np.square(MonVecteur) # crée le vecteur [1,16,49]
np.array([element**2 for element in MonVecteur if element%2==0]) # donne [16]
comparaison globale :
v1=np.array([1,2,3]);v2=np.array([1,2,4]);np.array_equal(v1,v2) # False
comparaison terme à terme :
v1=np.array([1,2,3]);v2=np.array([1,2,4]);v1==v2 # True True False
recherche dans un tableau :
f=lambda x: x<3
np.array(list(filter(f,MonVecteur))) #renvoie les éléments correspondants
tri d'un tableau :
np.sort(MonVecteur) #np.sort(MonVecteur)[::-1] pour le sens décroissant
passage d'un tableau à un ensemble (sans élément redondant) :
somme des éléments d'un vecteur :
unique(MonVecteurLigne)
np.sum(MonVecteurLigne)
np.sum(MaMatrice,axis=0) #addition verticale
somme des lignes d'une matrice :
somme des colonnes d'une matrice :
produit des éléments d'un vecteur :
np.sum(MaMatrice,axis=1) #addition horizontale
np.prod(MonVecteurLigne)
np.vdot(MonVecteur1,MonVecteur2)
produit scalaire de deux vecteurs :
produit vectoriel de deux vecteurs :
np.cross(MonVecteur1,MonVecteur2)
produit extérieur :
v1=np.array([1,2,3]);v2=np.array([4,5,6]);t=np.outer(v1,v2)
#construction de la table t[i,j]=v1[i].v2[j]
inverse d'une matrice :
np.linalg.inv(MaMatrice)
transposé d'une matrice :
np.transpose(MaMatrice)
transposé conjugué d'une matrice :
np.conjugate(np.transpose(M))
avec le type
matrix
:
MaMatrix.getH()
multiplication d'une matrice :
np.dot(MaMatrice,MaMatrice) #multiplication matricielle
ATTENTION avec le type matrix : MaMatrix*MaMatrix #multiplication matricielle
MaMatrice*MaMatrice #multiplication élément par élément
division d'une matrice :
np.dot(MaMatrice,np.linalg.inv(MaMatrice)) #multiplication matricielle par l'inverse
MaMatrice/MaMatrice #division élément par élément
résolution d'un système linéaire :
np.linalg.solve(MaMatrice,MonVecteur)
Polynôme
création à partir des coecients :
création à partir des racines :
degré :
MonPoly=np.poly1d(np.poly([1,1,2]))
MonPoly(1)
MonPoly.order
évaluation en
x=1
:
MonPoly=np.poly1d([2,1,1]);print(MonPoly)
pour
pour
2.x2 + x + 1.
(x − 1)2 .(x − 2).
22
CHAPITRE 2.
dérivation :
primitive :
racines :
INTRODUCTION À
PYTHON
np.polyder(MonPoly)
np.polyint(MonPoly)#avec cte=0
np.roots(MonPoly)
régression linéaire :
x=np.linspace(0,1,10);y=np.linspace(0,2,10);
np.poly1d(np.polyfit(x,y,1)) #1 pour linéaire, 2 pour quadratique,...
création d'une fraction rationnelle :
den=np.poly1d([4,2,3])
num=den*np.poly1d([1,2,3])
MaFraction=num/den
print(MaFraction[0]) #quotient
print(MaFraction[1]) #reste de la division euclidienne
Graphiques
"b"=bleu (par défaut), "k"=noir, "r"=rouge, "g"=vert, "c"=cyan, "m"=magenta, "y"=jaune,
"w"=blanc.
points non reliés : ".", "+", "o", "x", "*"
points reliés : ".-","+-","o-","x-","*-"
pointillés : "","-.",":"
couleurs :
sélectionner une fenêtre graphique :
MaFigure1=plt.figure() # crée une fenêtre et la sélectionne
acher la fenêtre graphique :
eacer la fenêtre graphique :
plt.show()
plt.clf() #clear figure
faire apparaître un quadrillage :
dénir les axes :
plt.grid(True)
plt.axis([0, 5, 0, 10]) # forme([xmin,xmax,ymin,ymax])
tracer un point de coordonnées
(1; 2),
en forme de cercle, en rouge :
plt.plot(1,2,"or")
tracer un nuage de points, en forme d'étoile :
plt.plot([2,4,6],'*') # forme ([1,2,3,...],[y1,y2,y3,...])
plt.plot([1,3], [2,4],'*') #forme ([x1,x2],[y1,y2])
(1; 2) et (3; 4) :
plt.plot([1,3], [2,4]) #forme ([x1,x2],[y1,y2])
2
tracer la fonction f (x) = x + 2.x + 3 pour x ∈ [−1, 3] :
tracer un segment entre les points
x=np.linspace(-1,3,100) #génère des 100 pts dans l'intervalle [-1,3]
plt.plot(x,x**2+2*x+3)
plt.xlabel('abscisse')
plt.ylabel('ordonnée')
plt.title('titre')
plt.show()
ou bien à partir de
SymPy
from sympy import symbols
from sympy.plotting import plot
x = symbols('x')
plot(x**2+2*x+3, (x, -1, 3))
2.2.
23
LEXIQUE
tracer les deux fonctions
f (x) = cos(x)
et
g(x) = sin(x)
sur la même gure :
x=np.linspace(0,2*pi,100) # génère 100 points dans l'intervalle [0,2.pi]
plt.plot(x,np.cos(x),x,np.sin(x))
axis("tight") #adaptation automatique de l'échelle (auto-scale)
ou bien :
x=np.linspace(0,2*pi,100)
plt.plot(x,sin(x),label='sin')
plt.plot(x,cos(x),label='cos')
plt.legend()
plt.show()
ou bien encore :
x=np.linspace(0,2*pi,100) # génère 100 points dans l'intervalle [0,2.pi]
f,=plt.plot(x,np.cos(x)) #liste dont le premier élément est f
g,=plt.plot(x,np.sin(x)) #idem avec g
plt.legend([f, g], ["cosinus", "sinus"]) #à mettre dans l'ordre
plt.show()
tracer les deux fonctions
f (x) = cos(x)
et
g(x) = sin(x)
sur deux gures l'une en dessous de l'autre :
x=np.linspace(0,2*pi,100) # génère 100 points dans l'intervalle [0,2.pi]
plt.figure(1) # figure 1
plt.subplot(211) # dans la figure en cours, créer une sous-figure: NL,NC,NSF
#on obtient une grille (NL=nbre de lignes,NC=nbre de colonnes)
#où l'on place la sous-figure NSF=num sous figure (entre 1 et NL*NC)
plt.plot(x,np.cos(x))
plt.subplot(212) # même grille, 2eme sous-figure
plt.plot(x,np.sin(x))
plt.show()
pour avoir 2 gures côte à côte :
subplot(1,2,1)
et
subplot(1,2,2)
tracer un graphique en échelle log-log :
x=np.logspace(1,3,10)
plt.loglog()
plt.plot(x,x**2)
plt.show()
tracer la courbe paramétrée
x = sin(t), y(t) = cos(t), z(t) = 2.t
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.gca(projection='3d')
t=linspace(0,6*pi,100);
x=np.sin(t)
y=np.cos(t)
z=2*t
ax.plot(x,y,z)
plt.show()
sur un graphique à 3 dimensions :
24
CHAPITRE 2.
tracer
z = x2 + 2.y 3
INTRODUCTION À
PYTHON
sur un graphique à 3 dimensions :
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_xlim3d(-1,1)
ax.set_ylim3d(-1,1)
x=np.linspace(-1,1,100)
y=np.linspace(-1,1,100)
X, Y = meshgrid(x,y)
Z=np.square(X)+2*np.power(Y,3)
surf = ax.plot_surface(X,Y,Z)
plt.show()
tracer les courbes de niveaux de
sin(π.x).cos(π.y)
pour
x ∈ [0, 1]
et
y ∈ [−1, 1]
:
nx,ny= 32,32
x = linspace(0,1,nx)
y = linspace(-1,1,ny)
X, Y = meshgrid(x,y)
F = sin(pi*X)*cos(pi*Y)
cs = contourf(X,Y,F)
Si la gure ne s'ache pas dans la fenêtre, cliquez sur gure options"
et
Apply.
Calcul symbolique
from sympy import *
x=symbols("x")
y=symbols("y")
Commencez par :
évaluer numériquement :
pi.evalf() #valeur numérique de pi
développer une expression :
simplier une expression :
calculer une limite :
expand((x+y)**3)
simplify((x+x*y)/x)
limit(sin(x)/x, x, 0) limit(1/x, x, oo) #oo=infini
diff(cos(2*x), x) diff(cos(2*x), x,2) #dérivée seconde
dériver une expression :
intégrer une expression :
integrate(sin(x), x)
integrate(x**3, (x, -1, 1)) #en précisant les bornes
series(cos(x), x,0,3) #en x=0 à l'ordre 3
une équation=0 : solve(x**4+2*x-1, x)
un système : solve([2*x+5*y-2,4*x-7*y-8],[x,y])
développer en série de Taylor :
résoudre
résoudre
factor(x**4+4*x**3+6*x**2+4*x+1)
diérentielle : f=Function("f");dsolve(diff(f(x),x, 2)+f(x),f(x))
factoriser un polynôme :
résoudre une équation
2.2.
25
LEXIQUE
Calcul numérique
trouver une racine par dichotomie (ex :
x = − cos x
pour
x ∈ [−π, π])
:
import scipy.optimize
f=lambda x:x+cos(x)
scipy.optimize.bisect(f,-pi,pi) #f,xmin,xmax
R2
calculer une intégrale (ex :
x2 .dx) :
x=1
import scipy.integrate
derivee=lambda x:x**2
resultat,erreur=scipy.integrate.quad(derivee,1,2) #derivee,xmin,xmax
résoudre une équation diérentielle du 1
er
ordre (ex :
df
dt
= −5.f (t)
avec
f (0) = 10)
import scipy.integrate
derivee=lambda f,t: -5*f
f0=10
t=linspace(0,2,100)
f_numerique=scipy.integrate.odeint(derivee,f0,t)
plt.plot(t,f_numerique)
résoudre un système d'équations diérentielles du premier ordre (ex : ci-dessous)
 dx
 dt = 1 + 2.x(t).y(t) − 3.x(t)
dy
dt = 2.x(t).y(t) + 4.z(t) − 5.x(t).y(t)
 dz
dt = 3.x(t) + 5.x(t).y(t) − 4.z(t)
avec

 x(0) = 1
y(0) = 2

z(0) = 3
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
# on crée un vecteur coords=[x,y,z]
# système d'équations d(coords)/dt = f(coords, t)
def equadiff(coords, t):
x = coords[0]; y = coords[1]; z = coords[2]
vx = 1+2*x*y-3*x
vy = 2*x*y + 4*z - 5*x*y
vz = 3*x + 5*x*y - 4*z
return [vx, vy, vz]
# conditions initiales
x0 = 1.; y0 = 2.; z0 = 3.
coords0 = [x0, y0, z0]
t = np.linspace(0, 1., 1000)
# résolution du système
soln = odeint(equadiff, coords0, t)
x = soln[:, 0]; y = soln[:, 1]; z = soln[:, 2]
# graphique
plt.figure()
plt.plot(t,x,t,y,t,z)
axis([0,1,0,5])
:
26
CHAPITRE 2.
⇒ transformer
0 en système
= −g
z (0) = 0
avec
z(0) = 10
= z 0 (t)
résoudre une équation diérentielle du second ordre
d2 z
ex : 2
d t
= −g ⇒
on pose
0
z =
dz
dt et l'on a :
dz0
dt
dz
dt
INTRODUCTION À
PYTHON
du premier ordre
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
# on crée un vecteur coords=[z,z']
# système d'équations d(coords)/dt = f(coords, t)
def equadiff(coords, t):
z = coords[0]
vz = coords[1]
az = -9.81
return [vz, az]
# conditions initiales
z0 = 10.
vz0 = 0.
coords0 = [z0, vz0]
t = np.linspace(0, 2., 1000)
# résolution du système
soln = odeint(equadiff, coords0, t)
z = soln[:, 0]
vz = soln[:, 1]
# graphique
plt.figure()
plt.plot(t,z)
axis([0,2,0,10])
prendre le gradient d'un champ scalaire
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from pylab import *
x = linspace(-3, 3, 100)
y = linspace(-3, 3, 100)
X, Y = meshgrid(x, y)
Ep = exp(-(X**2+Y**2))
Fy,Fx=gradient(Ep)
Fx=-Fx;Fy=-Fy
Quiv=quiver(X[::2,::2],Y[::2,::2],Fx[::2,::2],Fy[::2,::2]) #tous les 2pts
plt.show()
2.2.
LEXIQUE
prendre le Laplacien d'un champ scalaire
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from pylab import *
import numpy as np
from scipy import ndimage
gabarit = np.array([[0, 1, 0],[1, -4, 1], [0, 1, 0]])
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = meshgrid(x, y)
F = exp(-(X**2+Y**2))
Laplace = ndimage.convolve(F, gabarit)/(x[1]-x[0])**2
fig = plt.figure()
ax = fig.gca(projection='3d')
surf= ax.plot_surface(X,Y,Laplace)
plt.show()
27