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 Python v.3.3.0 ainsi que les bibliothèques sui-
vantes : NumPy SciPy SymPy MatPlotLib
, , et . 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
Python 1
qui est compatible avec votre version de , la décompresser et l'installer (en cliquant sur le chier
[Link]).

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'em-
porter sur la clé USB où ils enregistrent leurs programmes.

Téléchargez WinPython-3.3.0 à l'adresse :

[Link]
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 sur une clé USB, vous
pouvez désinstaller les bibliothèques qui ne vous intéressent pas à l'aide de WinPython Control Panel
.

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 Python , le code a été revu en

profondeur si bien que le principe de compatibilité descendante a été rompu.

11
12 CHAPITRE 2. INTRODUCTION À PYTHON
2.2.1 Instructions de base
Caractères spéciaux

commentaire : # ceci est un commentaire

écriture sur plusieurs lignes : a\ Enter
-b
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 : a=7
suppression : del a
aectation multiple :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 (liste ordonnée),

set (ensemble), tuple (liste ordonnée non modiable), dict (dictionnaire), str (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 global ) pour les modier

lors de l'exécution d'une fonction [règle 4].

2.2. LEXIQUE 13

Exemple :

l i s t e =[1 ,2 ,3]
i =1
def fonction ( ) :
global i #nécessaire pour pouvoir modifier i [ règle 4]
del liste [0] #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

Entrée-Sortie

a g e=i n p u t ( " V o t r eâ g e ? " ) #age est une chaine de caractères

a g e=i n t ( a g e ) #transforme la chaine de caractères en un entier .
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 quitter ")
if l e t t r e==Q :
break
14 CHAPITRE 2. INTRODUCTION À PYTHON
continue

i =1
while i <10:
if i %3==0:
i +=2
continue #retour direct au while sans executer la suite
i +=1

Fonction

def a d d i t i o n ( a , b=2): #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 division (a , b ):
q u o t i e n t=a // b
r e s t e =a%b
return quotient , r e s t e #renvoie deux valeurs
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 a , b : a+b
f (1 ,3) # 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

création :MaChaine=str() ou bien MaChaine=""

aectation : MaChaine=" aBcD "

minuscule :
[Link]() #il s'agit méthode appliquée à MaChaine
#mais MaChaine n'est pas modifiée

majuscule : [Link]()
première lettre en majuscule : [Link]()
retirer les espaces au début et à la n : [Link]()
centrer dans un espace de 10 caractères : [Link](10)
justier à droite dans un espace de 10 caractères : [Link](10)
2.2. LEXIQUE 15

découper une chaine en liste :

MaChaine="1 2 3"
[Link](" ") #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)
ou bien "je m'appelle {prenom} {nom}".format(prenom="jean",nom="martin")
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
sélection d'une sous-chaine :

MaChaine[:4] #sélectionne les 4 premiers caractères (à partir de l'index 0)

longueur d'une chaine : len(MaChaine)
évaluation d'une chaine : a=eval("1+1") #a=2

Liste ordonnée

création : MaListe=list() ou bien MaListe=[]

aectation : MaListe=[1, 2, "trois"] #on peut lister des éléments de différents types
création d'une copie : MaCopie=list(MaListe)
ATTENTION si vous faites : MaCopie=MaListe les
: modications appliquées à MaCopie
s'appliqueront aussi à MaListe.
accession à un élément : MaListe[0] #1er élément indexé 0

modication d'un élément : MaListe[2]=3

ajout à la n :
[Link](4) #MaListe est directement modfiée
#il ne faut pas coder: MaListe=[Link](4)

insertion d'un élément : [Link](2,2.5) #insère 2.5 à la 2ème place (entre 2 et 3)

concaténation : [Link]([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
[Link](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) : [Link](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]
[Link](4) # [1, 2, 3, 4]
[Link]() #4

Ensemble

Liste sans élément redondant.

création : MonEnsemble=set()
aectation : 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

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 des [crochets].

création : MonDico=dict() 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

def fonction():
cas où l'élément est une fonction : print("Hello")
MonDico["f"]=fonction #sans les parenthèses

accession à un élément :
MonDico["cle"] #si la clé ne correspond à aucun élément
#on aura une exception de type KeyError
2.2. LEXIQUE 17

cas où l'élément est une fonction : MonDico["f"]() #avec les parenthèses

suppression d'un élément : del MonDico["cle"] #supprime la clé et l'élément associé
ou bien [Link]("cle")
parcours des clés : for cle in [Link]():
parcours des éléments : for element in [Link]():
parcours des clés et des éléments : for cle, element in [Link]():

Gestion des erreurs

try :
c=a / b #on t e s t e une operation à risque
assert c >0 #pour la suite du programme , on veut c>0
except NameError :
p r i n t ( "a ou b n ' est pas défini ")
except TypeError :
p r i n t ( "a ou b n ' est pas un nombre " )
except ZeroDivisionError :
p r i n t ( "b est nul " )
except AssertionError :
print (" le résultat n ' est pas positif ")
else :
print (" la division n 'a pas provoqué d ' erreur \
et donne bien un résultat 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 #on t e s t e une operation à risque
if c <=0: #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 )
except NameError :
p r i n t ( "a ou b n ' est pas défini ")
except TypeError :
p r i n t ( "a ou b n ' est pas un nombre " )
except ZeroDivisionError :
p r i n t ( "b est nul " )
except ValueError :
print (" i l y a un problème " )
else :
print (" la division n 'a pas provoqué d ' erreur \
et donne bien un résultat 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

[Link](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 [Link] #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
Dans l'éditeur de , créez un chier où vous insérez au début :

# −∗− coding : Latin −1−∗−

import os

Tapez votre code et insérez à la n :

os . system ( " pause " )

Sauvez le chier avec l'extension .py et lancez l'exécution (Menu Exécution/Exécution).

Si vous n'utilisez pas Spyder , prenez un éditeur type : 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 [Link]) an de les séparer du code principal (par exemple [Link]) qui
commencera par :

# −∗− coding : Latin −1 −∗−

import os
from MaBiblotheque import ∗

Insérez le code principal et terminez par :

os . system ( " pause " )

Pour tester une fonction (ex : test(2)) de [Link], ajoutez, à l'intérieur du chier
[Link] :

if __name__=="__main__" :
test (2)
os . system ( " pause " )

ainsi, la fonction test(2) ne sera pas exécutée lorsque vous appelez [Link] depuis
[Link]

Remarque :
Le code principal et les bibliothèques sont interprétés à la volée. Il faut donc que Python soit ins-
tallé. Pour créer un exécutable "stand-alone", utilisez un outil comme cx_Freeze (téléchargeable à :
[Link]
2.2. LEXIQUE 19

2.2.3 Lecture-écriture dans des chiers

se déplacer dans l'arborescence des répertoires :

import os
[Link]("C:/Documents and Settings")

ouvrir un chier en mode lecture (r pour read) : MonFichier1=open("[Link]","r")

lire l'intégralité d'un chier ouvert : contenu=[Link]()
créer un chier en mode écriture (w pour write) :

MonFichier2=open("[Link]","w") #si ce fichier existe déjà, il est écrasé

ouvrir un chier en mode écriture à la suite (a pour append) :

MonFichier3=open("[Link]","a")
écrire une chaine de caractères dans un chier : [Link]("Ecrire")
fermer un chier : [Link]()

Pour écrire des données en mode binaire (b pour binary) :

import pickle #b i b l i o t h è q u e pour l i r e et écrire n ' importe quel objet

n o t e s ={
" informatique " :20 ,
" physique " : 19 ,
" maths " : 18 ,
"S . I " : 17 ,
" arts 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 pickle #b i b l i o t h è q u e pour l i r e et écrire n ' importe quel objet

with open ( ' n o t e s . dat ' , ' rb ' ) 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
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
La bibliothèque est notamment utile pour gérer les problèmes d'algèbre linéaire (vecteur,
SciPy
matrice,. . .) ; pour le traitement du signal ; MatPlotLib pour les graphiques 2D et 3D (ainsi que
PyLab PyPlot
les sous-bibliothèques et MatLab R
pour les fonctions de ). L'intérêt de la bibliothèque
MatPlotLib est que la syntaxe est très proche de MatLab R SciLab
et donc de . Nous privilégierons
cette méthode pour les représentations graphiques par rapport au module Plotting de la bibliothèque
SymPy .

Dans toute la suite, nous importerons ces bibliothèques avec les mêmes conventions que Spyder , à
savoir :
import numpy as np
import scipy as sp
import matplotlib as mpl
import [Link] as plt
20 CHAPITRE 2. INTRODUCTION À PYTHON
from pylab import *

Vecteur - matrice

création : MonVecteur= [Link]([])

aectation :
vecteur en ligne : MonVecteurLigne=[Link]([1,2,3])
vecteur en colonne : MonVecteurColonne=[Link]([[1],[2],[3]])
matrice : MaMatrice=[Link]([[1,2,3],[4,5,6],[7,8,9]])
ou MaMatrix=[Link]([[1,2,3],[4,5,6],[7,8,9]])
[Link] permet d'appliquer des méthodes spéciques aux matrices ;
on peut passer de array à matrix par [Link](MaMatrice)

et réciproquement par [Link](MaMatrix) .

création automatique :
création d'un vecteur correspondant à progression arithmétique :
MonVecteurLigne=[Link](1,10,2) # (début,fin,incrément)
MonVecteurLigne=[Link](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 : [Link]((2,3))
création d'une matrice nulle de 2 lignes et 3 colonnes : [Link]((2,3))
création d'une matrice identité de dimension 3 : [Link](3,3)
création de la matrice m×n telle que M (i, j) = f (x(i), y(j)) ; ex : f (x, y) = x2 + 2.y 3 :

x = [Link](-5, 5, 0.25)
y = [Link](-5, 5, 0.25)
X, Y = [Link](x, y)
Z=[Link](X)+2*[Link](Y,3)
voir une application au Ÿ graphiques à 3 dimensions.
création d'une copie : MaCopie=[Link]() ou MaCopie=[Link](MonVecteur)
ATTENTION : si vous faites : MaCopie=MonVecteur les modications appliquées à MaCopie
s'appliqueront aussi à MonVecteur.
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
accession à une colonne : MaMatrice[:,2] #3ème colonne
modication d'un élément : MaMatrice[1,2]=10
suppression d'un élément :
[Link](MonVecteur,1) #supprime le 2eme élément (on indique la valeur de l'index)
concaténation : MonVecteur=[Link]((MonVecteur,[Link](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 : [Link](MaMatrice) #(NbreLignes,NbreColonnes)
reformatage d'une matrice :
MonVecteurColonne=[Link](size(MonVecteurLigne),1)
une méthode plus élégante en ajoutant une dimension pour transformer le vecteur en matrice :
MonVecteurColonne=MonVecteurLigne[:,[Link]]
2.2. LEXIQUE 21

si vous voulez un vecteur distinct, utilisez [Link](...)

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=[Link]([1,4,7]);
[Link](MonVecteur) # crée le vecteur [1,16,49]
[Link]([element**2 for element in MonVecteur if element%2==0]) # donne [16]
comparaison globale : v1=[Link]([1,2,3]);v2=[Link]([1,2,4]);np.array_equal(v1,v2) # False
comparaison terme à terme : v1=[Link]([1,2,3]);v2=[Link]([1,2,4]);v1==v2 # True True False
recherche dans un tableau :

f=lambda x: x<3
[Link](list(filter(f,MonVecteur))) #renvoie les éléments correspondants
tri d'un tableau :
[Link](MonVecteur) #[Link](MonVecteur)[::-1] pour le sens décroissant
passage d'un tableau à un ensemble (sans élément redondant) : unique(MonVecteurLigne)

somme des éléments d'un vecteur : [Link](MonVecteurLigne)

somme des lignes d'une matrice : [Link](MaMatrice,axis=0) #addition verticale
somme des colonnes d'une matrice : [Link](MaMatrice,axis=1) #addition horizontale
produit des éléments d'un vecteur : [Link](MonVecteurLigne)
produit scalaire de deux vecteurs : [Link](MonVecteur1,MonVecteur2)
produit vectoriel de deux vecteurs : [Link](MonVecteur1,MonVecteur2)
produit extérieur :
v1=[Link]([1,2,3]);v2=[Link]([4,5,6]);t=[Link](v1,v2)
#construction de la table t[i,j]=v1[i].v2[j]
inverse d'une matrice : [Link](MaMatrice)
transposé d'une matrice : [Link](MaMatrice)
transposé conjugué d'une matrice :
[Link]([Link](M))
avec le type matrix : [Link]()
multiplication d'une matrice :
[Link](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 :
[Link](MaMatrice,[Link](MaMatrice)) #multiplication matricielle par l'inverse
MaMatrice/MaMatrice #division élément par élément
résolution d'un système linéaire : [Link](MaMatrice,MonVecteur)

Polynôme

création à partir des coecients : MonPoly=np.poly1d([2,1,1]);print(MonPoly) pour 2.x2 + x + 1.

création à partir des racines : MonPoly=np.poly1d([Link]([1,1,2])) pour (x − 1)2 .(x − 2).
évaluation en x=1 MonPoly(1)
:

degré : [Link]
22 CHAPITRE 2. INTRODUCTION À PYTHON
dérivation : [Link](MonPoly)
primitive : [Link](MonPoly)#avec cte=0
racines : [Link](MonPoly)
régression linéaire :
x=[Link](0,1,10);y=[Link](0,2,10);
np.poly1d([Link](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

couleurs : "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 : "","-.",":"
sélectionner une fenêtre graphique :
MaFigure1=[Link]() # crée une fenêtre et la sélectionne
acher la fenêtre graphique : [Link]()
eacer la fenêtre graphique : [Link]() #clear figure
faire apparaître un quadrillage : [Link](True)
dénir les axes : [Link]([0, 5, 0, 10]) # forme([xmin,xmax,ymin,ymax])
tracer un point de coordonnées (1; 2), en forme de cercle, en rouge : [Link](1,2,"or")
tracer un nuage de points, en forme d'étoile :
[Link]([2,4,6],'*') # forme ([1,2,3,...],[y1,y2,y3,...])
[Link]([1,3], [2,4],'*') #forme ([x1,x2],[y1,y2])
tracer un segment entre les points (1; 2) et (3; 4) :
[Link]([1,3], [2,4]) #forme ([x1,x2],[y1,y2])
2
tracer la fonction f (x) = x + 2.x + 3 pour x ∈ [−1, 3] :

x=[Link](-1,3,100) #génère des 100 pts dans l'intervalle [-1,3]

[Link](x,x**2+2*x+3)
[Link]('abscisse')
[Link]('ordonnée')
[Link]('titre')
[Link]()
ou bien à partir de SymPy
from sympy import symbols
from [Link] import plot
x = symbols('x')
plot(x**2+2*x+3, (x, -1, 3))
2.2. LEXIQUE 23

tracer les deux fonctions f (x) = cos(x) et g(x) = sin(x) sur la même gure :

x=[Link](0,2*pi,100) # génère 100 points dans l'intervalle [0,[Link]]

[Link](x,[Link](x),x,[Link](x))
axis("tight") #adaptation automatique de l'échelle (auto-scale)
ou bien :

x=[Link](0,2*pi,100)
[Link](x,sin(x),label='sin')
[Link](x,cos(x),label='cos')
[Link]()
[Link]()
ou bien encore :

x=[Link](0,2*pi,100) # génère 100 points dans l'intervalle [0,[Link]]

f,=[Link](x,[Link](x)) #liste dont le premier élément est f
g,=[Link](x,[Link](x)) #idem avec g
[Link]([f, g], ["cosinus", "sinus"]) #à mettre dans l'ordre
[Link]()

tracer les deux fonctions f (x) = cos(x) et g(x) = sin(x) sur deux gures l'une en dessous de l'autre :

x=[Link](0,2*pi,100) # génère 100 points dans l'intervalle [0,[Link]]

[Link](1) # figure 1
[Link](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)
[Link](x,[Link](x))
[Link](212) # même grille, 2eme sous-figure
[Link](x,[Link](x))
[Link]()
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=[Link](1,3,10)
[Link]()
[Link](x,x**2)
[Link]()

tracer la courbe paramétrée x = sin(t), y(t) = cos(t), z(t) = 2.t sur un graphique à 3 dimensions :

from mpl_toolkits.mplot3d import Axes3D

fig = [Link]()
ax = [Link](projection='3d')
t=linspace(0,6*pi,100);
x=[Link](t)
y=[Link](t)
z=2*t
[Link](x,y,z)
[Link]()
24 CHAPITRE 2. INTRODUCTION À PYTHON
tracer z = x2 + 2.y 3 sur un graphique à 3 dimensions :

from mpl_toolkits.mplot3d import Axes3D

fig = [Link]()
ax = [Link](projection='3d')
ax.set_xlim3d(-1,1)
ax.set_ylim3d(-1,1)
x=[Link](-1,1,100)
y=[Link](-1,1,100)
X, Y = meshgrid(x,y)
Z=[Link](X)+2*[Link](Y,3)
surf = ax.plot_surface(X,Y,Z)
[Link]()

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 *

Commencez par : x=symbols("x")
y=symbols("y")

évaluer numériquement : [Link]() #valeur numérique de pi

développer une expression : expand((x+y)**3)
simplier une expression : simplify((x+x*y)/x)
calculer une limite : limit(sin(x)/x, x, 0) limit(1/x, x, oo) #oo=infini
dériver une expression : diff(cos(2*x), x) diff(cos(2*x), x,2) #dérivée seconde
intégrer une expression :
integrate(sin(x), x)
integrate(x**3, (x, -1, 1)) #en précisant les bornes
développer en série de Taylor : series(cos(x), x,0,3) #en x=0 à l'ordre 3
résoudre une équation=0 : solve(x**4+2*x-1, x)

résoudre un système : solve([2*x+5*y-2,4*x-7*y-8],[x,y])

factoriser un polynôme : factor(x**4+4*x**3+6*x**2+4*x+1)

résoudre une équation diérentielle : f=Function("f");dsolve(diff(f(x),x, 2)+f(x),f(x))
2.2. LEXIQUE 25

Calcul numérique

trouver une racine par dichotomie (ex : x = − cos x pour x ∈ [−π, π]) :

import [Link]
f=lambda x:x+cos(x)
[Link](f,-pi,pi) #f,xmin,xmax
R2
calculer une intégrale (ex :
x=1
x2 .dx) :

import [Link]
derivee=lambda x:x**2
resultat,erreur=[Link](derivee,1,2) #derivee,xmin,xmax
er df
résoudre une équation diérentielle du 1 ordre (ex :
dt = −5.f (t) avec f (0) = 10) :

import [Link]
derivee=lambda f,t: -5*f
f0=10
t=linspace(0,2,100)
f_numerique=[Link](derivee,f0,t)
[Link](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)

 x(0) = 1
dy
dt = 2.x(t).y(t) + 4.z(t) − 5.x(t).y(t)
avec y(0) = 2
 dz
dt = 3.x(t) + 5.x(t).y(t) − 4.z(t)
z(0) = 3


import numpy as np
import [Link] as plt
from [Link] 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 = [Link](0, 1., 1000)

# résolution du système
soln = odeint(equadiff, coords0, t)
x = soln[:, 0]; y = soln[:, 1]; z = soln[:, 2]

# graphique
[Link]()
[Link](t,x,t,y,t,z)
axis([0,1,0,5])
26 CHAPITRE 2. INTRODUCTION À PYTHON
résoudre une équation diérentielle du second ordre
 dz0 ⇒ transformer 0 en système du premier ordre

d2 z 0 dz = −g z (0) = 0
ex : 2 = −g ⇒ on pose z = dt et l'on a :
dt avec
d t dz
dt = z 0 (t) z(0) = 10

import numpy as np
import [Link] as plt
from [Link] 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 = [Link](0, 2., 1000)

# résolution du système
soln = odeint(equadiff, coords0, t)
z = soln[:, 0]
vz = soln[:, 1]

# graphique
[Link]()
[Link](t,z)
axis([0,2,0,10])
prendre le gradient d'un champ scalaire

from mpl_toolkits.mplot3d import Axes3D

import [Link] 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
[Link]()
2.2. LEXIQUE 27

prendre le Laplacien d'un champ scalaire

from mpl_toolkits.mplot3d import Axes3D

import [Link] as plt
from pylab import *
import numpy as np
from scipy import ndimage
gabarit = [Link]([[0, 1, 0],[1, -4, 1], [0, 1, 0]])
x = [Link](-3, 3, 100)
y = [Link](-3, 3, 100)
X, Y = meshgrid(x, y)
F = exp(-(X**2+Y**2))
Laplace = [Link](F, gabarit)/(x[1]-x[0])**2
fig = [Link]()
ax = [Link](projection='3d')
surf= ax.plot_surface(X,Y,Laplace)
[Link]()