Comment débuter avec Python Une selection d`instructions

Comment débuter avec Python
"Mon choix" d'une version et d'un environnement. Cas d'un PC sous windows (nul n'est parfait)
Version de python "de base" : Installation : http://www.python.org/download/releases/
A ce jour pas de décision de prise au niveau CPGE national. Personnellement j'ai installé python 3.2.3 avec bibliothèques
numpy et matplotlib (cf plus loin). Il semblerait que la version 2.7 soit préférée à la 3.2 pour débuter cette réforme. En effet la
version 2.7 antérieure dispose de nombreuses bibliothèques.
Abréviation dans ce poly : Pour les deux versions j'utilise v2 ou v3 pour les distinguer.
Choix d'un IDE : IDLE fournit avec Python. Sinon ils sont nombreux, iep, pythonwin, spyder dans winpython.
Astuce : Avec IDLE. Créer un raccourci sur son bureau (ou vous voulez), puis bouton droit/propriétés et c'est là qu'on
paramètre le dossier par défaut de IDLE mais aussi du shell associé. (suis je clair ?)
Bibliothèques de fonctions numpy et matplotlib.
numpy " numeric python" . Installation : www.numpy.org
Obligatoire pour pouvoir faire des calculs même les plus simples.
Remarques : On peut tout de même utiliser math de "python de base" pour débuter sans numpy.
matplotlib " mat de matlab ? " Installation : www.matplotlib.org
Bibliothèque pour faire des graphiques 2D (et projections 3D), on peut tout faire en 2D avec matplolib mais demande de
l'investissement. Intérêt pour un utilisateur d'un autre logiciel graphique ?
Aide pour Python de base :
Aide depuis Python "rustique" mais parfois efficace :
>>>dir(bibliotheque ou objet)
# liste attributs et méthode ou fonctions. Il faut avoir importé la biblio avant.
>>>help(nom de fonction)
# renvoie dans le shell une notice de la fonction !
Aide aussi par menu dans IDLE.
Sur internet :
Internet cf différents liens après surtout pour numpy et matplotlib.
Fsincere
$$ celui de l ups
Sinon joyeux foutoir.
Les livres : Sur python "de base", ils sont assez nombreux. Sur numpy matplotlib aucun en français à ma connaissance.
Une pub sur un livre sous licence GPL téléchargeable gratuitement :
Un choix tout intégré. Toujours sous windows
Si vous ne souhaitez pas installer Python mais juste tester, il existe WinPython. C'est un package contenant python2.7, numpy
matplotlib, scypi , et l'IDE spyder. Ce package ne demande pas d'installation. Précisément il se décompresse dans un dossier
de votre choix (une clé USB peut convenir) et il n'y a pas d'installation proprement dite donc c'est transportable (suis je clair ?)
Critique personnelle : De mémoire décompressé ça pèse 800 méga, et au démarrage c'est lent. De plus pour débuter je préfère
l'IDE IDLE plus sobre.
Une selection d'instructions algorithmiques
Je propose ici une sélection suffisante pour le niveau de ce document et qui se traduit facilement dans les langages Python,
Scilab, Turbo Pascal, Maple etc....
Les commentaires
Ils sont neutres (non interprétés par le programme) faits pour nous les humains, ils permettent d'annoter l'algorithme pour
faciliter sa compréhension. J'utilise le symbole # suivi du commentaire. C'est le cas en Python en Maple.
Les entrées sorties
La majorité des algorithmes utilisent des données entrées par l'utilisateur de l'algorithme, et renvoient un résultat sous forme
d'affichage. Ces notions d'entrée/sortie ont des traductions très différentes suivant les langages. Par exemple Les commandes
3
input et print en Python. input n'existe pas en Maple. L'objet fonction plus évolué gère efficacement le problème des entrées
sorties.
Dans les algorithmes j'utilise si nécessaire les mots entrer ( .....) , et afficher( .... )
Affectation
L'affectation consiste à affecter une (des) valeur(s) à une variable.
En algorithmique elle se note : nom de la variable ← valeur
ou
valeur  nom de la variable
Remarque : Principe de fonctionnement de : nom de la variable ← valeur
Le membre de droite est évalué si nécessaire, et la variable dont le nom est indiqué à gauche reçoit le résultat de cette
évaluation.
exemple 1
exemple 2
b←2
b←2
a←b
b ← b + 1 # un tube en informatique
La variable a, reçoit la valeur 2.
La variable b reçoit 3
Booléens, fonctions booléennes
On appelle ensemble des booléens l'ensemble B = {Vrai, Faux} = { True, False }. On appelle fonction booléenne toute
anglais
fonction à valeur dans B. Vous connaissez plusieurs fonctions booléennes pratiquées de façon usuelle :
non , et, ou , ou exclusif (fromage ou dessert) ce sont des fonctions définies sur B ou B×B à valeur dans B.
Vous connaissez aussi les fonctions booléennes >, <, =, ≤, ≥, ≠. Par exemple (2 < 3) vaut Vrai, (3 ≠ 3) vaut Faux.
Blocs d'instructions
Instructions conditionnelles
condition représente une expression à valeur booléenne.
La plus classique, la plus élémentaire, la plus générale.
si condition
groupe d instructions1
sinon
groupe d'instructions2
si condition
groupe d instructions
si condition1
groupe d'instructions
si condition2
groupe d'instructions
si condition3
groupe d'instructions
sinon
groupe d'instructions
Remarques : J'ai indenté (ou décalé) mais groupes d'instruction vous allez vite comprendre pourquoi.
Signification pour la classique : si condition vaut Vraie le groupe d'instructions1 est effectué si condition vaut Faux c'est le
groupe d'instructions2 qui est effectué.
exemple Voici un algorithme bien connu.
entrer ( x )
# la valeur entrée est affectée à x
si x  0 alors
afficher (x) # Affiche le contenu de x pas la lettre x
sinon
afficher (– x) # idem affiche le contenu de – x
fin de si
Blocs d'instruction de type Boucles
Boucles conditionnelles
condition représente une expression à valeur booléenne.
4
tant que condition faire
groupe d'instructions
fin de faire
Signification : si condition vaut Vraie, on effectue le groupe d'instructions, on revient à condition, si elle est encore vraie, on
effectue le groupe d'instructions, et ceci tant que condition est vraie. Ca "boucle" tant que condition reste vraie.
Attention : Il est donc indispensable qu'à un moment le groupe d'instructions modifie la valeur de condition, sinon la boucle
tourne sans fin, un grand classique dans l'art du bug !
Boucles du type compteur
Indice est une liste de valeurs, une séquence de valeurs, en gros un ensemble ordonné. La aussi je m'adapte à Python.
pour compteur variant dans Indice faire
groupe d'instructions
fin de faire
Signification : la variable compteur va recevoir successivement toutes les valeurs de Indice, et à chaque fois le groupe
d'instructions est effectué
Exemple : Que renvoie cet algorithme ?
S←0
i ←0
tant que ( i ≤ 10 ) faire
S← S+i
i ←i+1
fin de faire
afficher ( S )
Exemple : Que renvoie cet algorithme ?
S←0
pour i variant de 1 à 10 faire
S←S+i
fin de faire
afficher (S)
Algorithmique et traduction Python
Remarques : Pas de difficulté majeure à traduire les instructions algorithmiques en Python.
Principe élémentaire de fonctionnement de Python.
Remarques : Au 01/01/2013 j'utilise la version 3.2.3 de python et l'interface IDLE pour Pythoner.
Dans la fenêtre "Python shell" le prompt >>> attend un calcul à effectuer, il le renvoie par retour chariot.
Bien entendu vous souhaiterez écrire des scripts (des programmes) dans un fichier. Pour cela vous pouvez utiliser tout éditeur
de fichier texte indépendant de Python pour écrire ces scripts de commandes. Il faut alors les enregistrer avec l'extension .py.
Vous pouvez par exemple utiliser notpad pour écrire des scripts de commandes python. Fun fun !
Pour les exécuter il suffit depuis IDLE de taper F5 .
Remarques : Par double clic sur un .py, il est exécuté par Python dans une fenêtre dos, fenêtre dos qui se ferme tout de suite je
crois bien donc souci.
Affectation
En Python, l'affectation est représentée par =
nom de la variable = valeur
exemples :
>>> x = 1 # La variable x reçoit la valeur 1.
Puis >>> y = x + 1 # la variable y reçoit 2.
>>> x = 1
>>> x = x + 1
>>> x # au final x reçoit 2
5
Python n'est pas un langage de calcul formel (pas exactement voir sympy par exemple). Il ne peut pas affecter à une variable
une expression d'une autre variable non affectée.
Affectations multiples
>>> a, b, c = 1, 2, 3
>>> a, b, c = c, b, a # Que valent a, b, c ?
Remarques : Voir plus loin le bel exemple de Fibonnacci.
Abréviations d'affectations classiques
>>> a = a + 1 peut se noter >>> a += 1
Remarque non débutant : Cette 2eme syntaxe est interprétée plus efficacement par python c'est l'incrémentation. Bien entendu
l'éviter pour débuter, fait économiser 1 caractère et ça me perd.
Restart : Célèbre commande Maple existe dans le menu de Python shell.
Type des données affectées aux variables. Opérations élémentaires.
C'est un point essentiel d'ou sa longueur. Bien comprendre les types des données que l'on manipule est indispensable à la
compréhension, l'utilisation, la fabrication de programmes en Python.
Exemple : Si un élève confond un vecteur v ∈ 3 et un scalaire λ ∈ , le professeur de mathématiques que je suis est fâché,
plutôt désespéré. Python lui Bugue sans crier, problème de type !
Remarques : Dans le shell la commande type(donnée) renvoie le type d'une donnée (on peut aussi dire sa classe). Forcer par
print(type(donnée) ) dans un script.
Remarques : En Python le typage est dynamique. Vous affectez ce que vous voulez à une variable il se débrouille. Autrement
dit pas besoin de préciser le type de la variable avant d'affecter. C'est très pratique.
Type Booleen
True False
# respecter la majuscule.
>>> type(True) # renvoie <class 'bool'>
Opérations sur les booléens
or, not, and, ^ (le xor le ou exclusif. Merci pour les maths la notation ^ vraiment merci )
== (l'égalité doit se distinguer du = de l'affectation), != ( le ≠ ) , <, >, <= ( le  ), >= ( le  )
Remarque :
>>> a = 2
>>> a == 2
# Signifie l'affectation de 2 à la variable a.
# représente la valeur booléenne vraie si a = 2, fausse si a ≠ 2
Exemples : Qu'affiche Python dans ces cas :
>>> True and not(False) == True ^ False
>>> a= True
>>> b = False >>> print( not(a) or b )
>>> a = True >>> b = True >>> print (a and not(b) ) or not(a) )
>>> 10 ^ 2
# renvoie 8 .
2
Réponse : 2^10 = 10
^ 1010
2
= 1000
2
= 8 qui a compris ?
Type entier
>>>type(5)
#renvoie <class 'int'>
Remarques : Il y a une évolution entre v2 et v3 la dernière accepte les entiers longs.
Opérations sur les entiers
+ , *, , ** (l'exposant, pas ^ rappel ) , / , // (c'est le quotient de la division euclidienne, la aussi évolution de v2 à v3), % (le reste
de la division euclidienne dit aussi modulo)
Type réel
>>> type(3.14) # renvoie < class 'float'>
6
Opérations sur les réels
+, *, ** (l'exposant) , / , mais aussi // et % qui fonctionnent sur les réels ( Olé Olé ! Osé Osé ?)
Exemple : Pour le moins surprenant et déstabilisant. Origine la liste info2013. Celui ci est la pour mettre en garde sur l'usage du
type 'float' .
>>> a=1/2 – 2/5
>>> a
# renvoie 0.09999999999999998
# bien entendu ça fait 1/10 soit 0.1
Remarques : Pourquoi une erreur sur un exemple si simple ? Réponse de la liste : Cela vient du fait que 1/5 a un
développement infini en base deux. Dépasse le débutant que je suis.
Type complexe (nombre complexe)
Remarques : Sans doute à partir de v3, pas testé v2. Je n'utilise pas ce type dans l'exposé.
Le nombre complexe noté  en math, j en physique se note en Python 1j (original !)
>>> type(1+1j*2)
# renvoie <class 'complex'>
Remarques : Il peut paraître étonnant que Python "de base" qui "ne connait pas" les fonctions réelles sin, exp connaisse les
complexes.
Opérations sur les complexes
+ , *, , ** (l'exposant il accepte l'exposant. Rien compris à ce jour) , / , abs (le module).
Par contre // et % il n'en veut pas ( can't mod complexe number. ouf ? )
Type chaine de caractères
C'est déjà un type de données composites. "Séquences" ou collections ordonnées d'éléments. Il se prête donc bien aux boucles
de type compteur. Une chaine de caractère se note : ' les caractères de votre choix '
type( ' toto ' )
# renvoie <class 'string' >
Opérations sur les chaines de caractère
Nombreuses, données de type composées. Si a et b sont deux chaines de caractère :
a+b
# concaténation de a e t b
2*a
# doublage de a...... c'est à dire a + a
a[i]
# renvoie le caractère d'indice i dans la chaine. Attention ça commence à zéro dans Python, il va falloir s'y faire.
Exemples : >>> a = 'toto'
>>> b = 'tata'
Que renvoie >>> a+2*b
>>> a + 2
>>> a + '2'
Réponse pour : >>> a+2 # bug on ne peut pas concaténer a et 2 qui est du type int. Vous suivez !
Type listes
Une liste est une collection d'objets écrite sou la forme [ objet1, objet2, ......, objetn ] . Je ne résiste pas à dire une séquence
entre crochets, 17 ans de Maple derrière. La notion de séquence n'est pas très claire en Python.
>>> type([4,5,'toto',3.5,True])
#renvoie <class 'list' >
Remarques : Vous avez remarquez que j'ai mis dans ma liste des objets de type différent et que Python ne râle pas. Une liste
peut même contenir des listes.
>>>> a=[[1,2],[3,4]]
# on peut toujours rêver qu'il la comprenne comme matrice 2x2 c'est un rêve hélas.
Opérations sur les listes
Innombrables ! On peut tout faire même se que l'on n'imagine pas ! Citons des opérations élémentaires.
Si L1 et L2 sont deux listes
L1 + L2
# concaténation de L1 et L2
2*L1
# Il comprend L1 + L1. En aucun cas multiplication par 2 sur les éléments de L1. Mais comment va t on faire
pour la multiplication scalaire sur les vecteurs ? Et les lois d'algèbre alors ! Réponse numpy bien entendu.
7
L1[i]
L1[i]='toto'
[]
# extraction du terme d'indicie i de L1 . La aussi commence à zéro.
# modification de l'élément d'indice i prenant la valeur 'toto'
# est la liste vide. Peut servir dans de l'initialisation.
Exemple décevant ?
>>>ma=[[1,2],[3,4]]
>>> 2*ma
# renvoie [[1, 2], [3, 4], [1, 2], [3, 4]]. C'est bien 2 fois la liste ma il a raison.
Remarques : On peut appliquer toute sorte de méthodes à une liste Python étant orienté objet cf plus loin.
Conversion de types. Autres types
En vrac :
1 – Le type 'tuple' . Explication Wikipedia Les objets tuple (ou n-uplet) sont des listes non mutables d'objets hétérogènes.
>>> a = 1,2,3
>>> type(a)
# renvoie <class 'tuple'>
Cela me gène un peu pas de [ ] dans ce cas. C'est pour moi une séquence étant fortement conditionné par Maple.
2 – Il y a d'autres types en Python. Voir la page bien faite de Wikipedia par exemple.
3 – La conversion de certains types est possible. Typiquement si j'ai '1' , int('1') convertit en 1.
Plus évolué : ord('x') convertir le caractère x en la valeur de l'octet écrit en base 10 (vous avez compris ?)
chr(12) fera le contraire écrire le caractère (si c'est possible à afficher !) dont l'octet vaut 12 en base 10.
4 – En tant que matheux ou physiciens on aimerait que les listes se comportent comme des matrices ou vecteurs. Pour cela
nous allons plus loin utiliser numpy et son type array.
Blocs d'instruction
En python les limites des blocs d'instructions sont définies par l'indentation, la mise en page.
Instructions conditionnelles
La plus classique, la plus élémentaire, la plus générale.
if condition :
groupe d instructions
else :
groupe d'instruction
if condition:
groupe d instructions
if condition :
groupe d'instructions
elif :
groupe d'instructions
elif :
groupe d'instructions
else :
groupe d'instructions
Blocs d'instruction de type boucles
Boucles conditionnelles
Boucles de type compteur
while condition:
groupe d'instructions
for i in Indice
groupe d'instructions
La mystérieuse et très utilisée fonction range : range(n) créait "la séquence" d'indices 0,1,....., n – 1. Elle permet donc de
traduire l'instruction très employée : pour i variant de 0 à n – 1.
Pourquoi mystérieuse ? Je n'ai toujours pas compris le type de range(n). En Python v2.7 c'est une liste, en v3.2 cela devient
mystérieux pour le débutant que je suis !
Exemple : A l'aide d'une boucle compteur et la multi affectation créaient la suite de Fibonacci.
Les fonctions
J'ai déjà utilisé range( ), abs( ). Elles sont essentielles. Bien entendu on peut créer des scripts sans utiliser les fonctions.
8
Syntaxes
# Plutôt procédure ou sous programmme
def nom_fonction (sequence de paramètres) :
global a,b,c # par défaut locales
groupe d'instructions
# Plutôt fonction
def nom_fonction (sequence de paramètres) :
global a,b,c # par défaut locales
groupe d'instructions
return valeur
Remarques : . Maple a un sens des fonctions proche des maths. En python on préférera éventuellement parler de procédure ou
sous programme.
Remarques : Erreur dans le bouquin de G Swinnenn qui parle pour les paramètres d'entrée de liste. Je m'aperçois à nouveau
que cette notion de séquence est peut modélisée en Python.
Paramètres d'entrée, variables locales, variables globales
Paramètres d'entrées : On peut modifier la valeur d'un paramètre d'entrée dans le bloc d'instructions d'une fonction. Pour
comparaison pas possible en Maple, possible en Turbo Pascal.
Variables locales, globales : Pas clair pour moi à ce jour, je m'explique (cf exemple plus loin) :
Soit a une variable affectée dans votre session (srcipt).
Si a n'est pas déclarée dans votre fonction mais affectée à une valeur, alors elle est considérée comme locale (par défaut). Vous
avez alors deux variables a portant le même nom mais différentes. C'est l'intérêt des variables locales pour éviter les conflits.
Si a est déclarée globale dans votre fonction. Elle est vue par la fonction comme la variable a extérieure et modifie donc cette
variable.
Enfin le cas qui me gêne, si a n'est pas déclarée dans votre fonction elle peut être utilisée par celle ci sans être modifiable. La la
procédure la reconnait comme celle de la session.
Voici un exemple: # De vrais fonctions et problème de gestion des variables.
a=10
def essai1(n):
def essai2(n):
a=2
global a
n=a+n
a=2
return n
n=a+n
return n
# Après exécution a vaut 10
# Après exécution a vaut 2
def essai3(n):
n=a+n
return n
# Est ce une bonne idée qu'il autorise ?
Remarques : Python ne semble pas accepter local a. local notion par défaut exclusivement ?
Recursivité
Une définition de la récursivité (risquée pour un non informaticien) : Une fonction peut s'appeler elle même dans sa
construction.
Exemple : Fibonacci récursif, en comparaison avec la multi affectation + boucle vue avant.
def fibo(n):
if n==0 or n==1:
return 1
else:
return fibo(n – 1)+fibo(n – 2)
Python Programmation Orientée Objet "POO"
Partie en travaux
Python est un langage de programmation orienté objet. Il n'est pas nécessaire ici de maitriser cette notion, la comprendre un
peu semble important pour mieux comprendre la syntaxe.
A ce jour je ne sais rien de la programmation orientée objet. Voici juste un peu de vocabulaire :
Nous manipulons en python des objets.
9
La classe d'un objet : Un objet appartient à une classe on dit que c'est une instance de sa classe.
>>> type(objet) # renvoie sa classe, on comprend mieux les <class, 'type' > vu précédemment pour les types.
Les Attributs et méthodes pour un objet :
>>> dir(objet) # renvoie la liste de ses méthodes et attributs.
Les méthodes pour un objet sont les fonctions applicables à cet objet.
Les attributs pour un objet sont les variables liées à cet objet.
Un exemple, simple et puissant à la fois, de manipulation d'objet :
>>> x=[5,7,12,4,1]
# création d'un objet liste. C'est donc une instance de la classe list.
# j'aurai pu débuter par x=list() qui créait un objet vide de la classe list puis compléter son
# contenu. Ceci serait lourd et maladroit ici.
>>> dir(x)
# listing des méthodes et attributs disponibles pour cet objet.
>>> x.sort()
# Application de la méthode sort() qui ordonne x. Attention l'objet x a était modifié par
cette méthode.
>>> x.__doc__
# attribut __doc__ variable d'information sur x.
>>> x.append(123)
# méthode append(123) ajoute la valeur 123 en fin de la liste x. Idem, l'objet x modifé.
Remarques : Je n'aurai pas le temps de progresser sur ce point mais en écrivant ce résumé il me semble indispensable d'ajouter
cette compétence sans doute à un niveau 2.
Bibliothèque Numpy
Définition Wikipedia : NumPy est une extension du langage de programmation Python, destinée à manipuler des matrices ou
tableaux multidimensionnels ainsi que des fonctions mathématiques opérant sur ces tableaux.
Remarques : Vous trouverez souvent dans les documentations la notion de "ndarray" c'est à dire tableaux de dimension n.
Installation : www.numpy.org # dépend de votre choix d'environnement
Documentation pour débuter :
http://scipy-lectures.github.com/index.html ou si vous préférez le format pdf
http://scipy-lectures.github.com/_downloads/PythonScientific-simple.pdf
Importation dans une session : >>> import numpy as np
# créait un alias.
# on doit pouvoir faire >>> from numpy import * # mais est ce une bonne chose ?
# Vous pouvez faire à titre d'introduction >>>dir(np) # puis par exemple >>>dir(np.matrix)
Exemples de manipulation du type array de numpy. Bienvenue aux "nd_array"
import numpy as np
import matplotlib.pyplot as plt # juste pour la dernier exemple.
Tableau de dimension 1. "1d_array" .
Tableau de dimension 2. "2d_array"
a=np.array([1,2,3,4,5,6,12]) # vecteur ligne
print(a)
print(a.ndim) # dimension de a
print(len(a)) # nombre d'éléments de a
print(a.shape) # ?
print(a[0]) # premier élément de a
print(a[-1]) # dernier élément de a (cyclique)
print(a[:4]) # les éléments à partir du rang 4
print(a[1:6:2]) # les éléments du rang 1 à 6 par pas de 2
b=np.array([[1,2,3],[4,5,6]]) # matrice 2×3
print(b)
print(b.ndim) # dimension de b
print(len(b)) # nombre d'éléments de b
print(b.shape) # ?
print(b[0,1]) # Elément 1ere ligne 2eme colonne.
print(b[-1,2]) # Element dernière ligne 3eme colonne.
print(b[:,2]) # 3eme colonne
print(b[1,:]) # 2eme ligne
# si on veut un vecteur colonne on peut transposer a avec a.T ou transpose(a).
# on peut aussi construire un vecteur colonne va=np.array([[1],[2],[3],..,[12]])
Tableau dans la 2x3x3eme dimension ou un "2x3x3d_array" ouah !
C'est en fait le cas classique de manipulation d image par RGB. J'anticipe ici matplotlib.pyplot
c=np.array([[[.1,.2,.3],[.1,.2,.3],[.1,.22,.33]],[[.1,.12,.13],[.4,.5,.6],[1.,1.,1.]]])
plt.imshow(c)
10
plt.show() # c'est beau non ?
Calculs sur les array
ma=np.array([[1,2,3],[4,5,6]])
v=np.array([1,2,3])
vv=np.array([[1],[2],[3]])
print(ma+2)
print(2*ma)
print(ma+ma)
print(ma.T)
print(ma*ma)
print(ma.dot(vv))
# matrice 2x3
#vecteur ligne
# vecteur colonne
# ajout de 2 à tous les termes
# multiplication scalaire enfin comme en math !
# addition matricielle ouf !
# Transpose ma, aussi np.transpose(ma)
# multiplication termes à termes peu habitués en math.
# multiplication matricielle
np.meshgrid
Cette commande de numpy joue un rôle important pour la fabrication de certaines images ou pour faire une représentation 2d d'une surface.
Si x et y sont deux 1d –array meshgrid(x,y) va créer une "grille de valeurs" relatives à ces deux vecteurs. C'est à dire l'ensemble de tous les
couples possibles d'une valeur de x avec une valeur de y. Voici un copié collé de l'aide en ligne relativement bien faite grâce à
help(np.meshgrid) (après avoir fait l'alias bien entendu).
>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7])
>>> X
>>> Y
array([[1, 2, 3],
array([[4, 4, 4],
[1, 2, 3],
[5, 5, 5],
[1, 2, 3],
[6, 6, 6],
[1, 2, 3]])
[7, 7, 7]])
`meshgrid` is very useful to evaluate functions on a grid.
Remarques : Ainsi si vous prenez une valeur de X avec une valeur de Y de même indices vous avez tous ces couples.
Bibliothèque Maplotlib.pyplot
Créateur John Hunter (1968-2012)
Définition wikipedia : matplotlib is a plotting library for the Python programming language and its NumPy numerical
mathematics extension. [...] There is also a procedural "pylab" interface based on a state machine (like OpenGL), designed to
closely resemble that of MATLAB. Matplotlib was written and maintained primarily by John Hunter, and is distributed under a
BSD-style license. Currently, matplotlib 1.2 has support for Python versions 2.7 through 3.2. Matplotlib 1.2 is the first version
of matplotlib to support Python 3.x. The package pylab combines pyplot with NumPy into a single namespace.
Installation : matplotlib.org. Prendre la version cohérente avec votre version de Python. La aussi l'installation dépend du choix
d'environnement.
Documentations pour débuter :
http://matplotlib.free.fr/ # En français
Le même document que pour numpy http://scipy-lectures.github.com/index.html
ou si vous préférez le format pdf http://scipy-lectures.github.com/_downloads/PythonScientific-simple.pdf
Importation dans une session : Nous utilisons essentiellement la bibliothèque matplotlib.pyplot.
>>> import matplotlib.pyplot as plt
# création d'un alias pour faciliter l'utilisation
# A titre d'introduction vous pouvez faire
>>> dir(plt)
# donne déjà un aperçu de la bibliothèque pyplot.
Documentations pour confirmer : Sans hésiter consulter le site matplotlib.org et télécharger la documentation de référence en
pdf sur ce même site. Plus de 1000 pages. Il est à mon avis necessaire d'avoir investit dans la notion de "POO" avant.
figure (optionnel)
Permet de paramétrer la (les) fenêtre(s) graphique(s). Par défaut il s'en sort très bien. Inutile pour cet exposé.
Exemple : plt.figure(figsize=(8,6),dpi=80) # c'est en inch en pouces.
subplot (optionnel)
Permet de mettre dans une même fenêtre différents graphiques, précisément de partitionner la fenêtre graphique.
Exemple: plt.subplot(2,2,3) # Partition 2 lignes 2 colonnes 3eme zone de la partition.
11
Remarques : pyplot comprend aussi (223) à la place de (2,2,3)
Remarques : la commande axes fait un peu la même chose mais en plus général, les différents graphiques pouvant se
superposer. Exemple : Inclure dans un graphique un autre graphique.
plot (notre objectif)
Voici quelques commandes de plot. Un objectif possible étant de traiter l'exemple 6 cf plus loin.
la commande plot dans sa version basique :
>>> plt.plot( x, y ) # x, y sont des 1d-array ou des listes. Trace le nuage de points M[i](x[i],y[i]) avec i = len(x) = ln(y).
Nous utiliserons souvent y = f(x) ou f opère sur les réels. Python fait automatiquement l'opération sur chaque opérande de x.
Apelle t on cela le mapping ?
Remarques : Si vous autre objectif est de tracer un nuage de points M[i,j] (x[i], y[j]) vous utiliserez np.meshgrid et plt.scatter,
cf plus loin.
>>> plt.plot( x ) # x est un 1d-array ou une liste. Il considère x comme une suite de valeurs, il trace alors le nuage de points
M[i] (i, x[i]).
Un peu de mise en forme du graphique . Pyplot comprend Latex . Toutes ses commandes sont optionnelles.
plt.xlabel(' votre texte ')
plt.ylabel(' votre texte ')
plt.title(' votre texte ')
plt.axis([xmin,xmax,ymin,ymax])
plt.xticks( liste1,liste2) # liste1 liste des valeurs des graduations ou 1d_array, liste2 optionnel les valeurs sur graduation. Par
défaut les mêmes que liste1.
plt.yticks(liste1,liste2)
plt.grid(True ou False la valeur par défaut # affiche ou pas la grille relative aux graduations
plt.text( 'votre texte')
Pour les physiciens et chimistes modification des échelles :
plt.loglog()
# Echelle logarithmique pour les deux axes
$$ je n'arrive plus à trouver le semi logarithmique pas plt.xlog $$
Quelques options, non nécessaires car valeurs par défauts, que l'on peut définir dans le plot.
linestyle = '–' # définit le style du tracé liant les points du nuage . linestyle=' ' permet de ne pas relier le nuage de points.
linewidth= # épaisseur de line "en points" c'est à dire relatif à votre figure sa taille et son dpi.
marker= 'o' # le symbole représentant les points du nuage de points.
markersize= # la taille du symbole toujours "en points".
color='red' # la couleur du tracé. pyplot sait manipuler toutes les couleurs (RGB etc ...).
Remarques : je ne peux ici proposer toutes les valeurs possibles de options elles sont trop nombreuses, plusieurs dizaines de
style pour linestyle, marker.
Et enfin ne pas oublier :
>>> plt.show() # Il y a ici un bug avec IDLE. La fenêtre graphique est sensée être dynamique en python, c'est à dire que l'on
peut ajouter des commandes dans le shell celle ci est mise à jour. Plante sous IDLE, j'y suis arrivé avec spyder.
Autre type de graphiques
Je suppose les alias np et plt créés.
plt.scatter . scatter "aime bien" meshgrid . Un exemple élémentaire :
>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7]) >>> plt.scatter(X,Y)
>>>plt.show()
Remarques : plt.plot(X,Y) sort un graphique bien décevant (la droite x = 2) ce qui m'étonne, j'attendais une erreur.
plt.hist . utilisé dans l'exemple qu'elle heure est il.
Graphiques 3d avec matplotlib : La boite à outils mpl_toolkits.mplot3d
Remarques : Pour débuter j'importe ici "seulement" la bibliothèque Axes3D de mpl_toolkits.mplot3d.
12
Exemple: Voici un exemple, le plus simple possible, pour tracer une surface définie par z = f (x,y). J'ai pris un exemple sur
matplotlib.org puis nettoyé au maximum ses options. Voici le script (donc sans >>>)
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
# creation d un objet figure
ax = fig.gca(projection='3d')
# sans doute l'étape clé : Option projection='3d' de gca( ).
# On trouve aussi pour débuter la commande add_subplot(111, projection='3d' )
X = np.arange(-5, 5, 0.25)
# Création d une grille en x,y grâce à np.arange, puis meshgrid
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
# Evaluation de (x,y)  x2 + y2 sur la grille.
Z = np.sin(R)
#Evaluation de sin(R). On aurait pu faire d'un coup.
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, linewidth=1.0, antialiased=True)
# Commande plot_surface( ) du nuage de points (X,Y,Z). J'ai choisi de tracer les "lignes" qui aident à visualiser la surface.
ax.set_zlim3d(-1, 1)
# contrôle de la fenêtre z ∈ [-1,1]
plt.show()
# bien entendu sinon vous allez être déçus.
13