= Graphiques =

La bibliothèque standard de Python ne permet pas de manipuler des images, ni de dessiner des graphes de fonctions par exemple.
Pour ça, il faut installer des bibliothèques supplémentaires.

Le module `matplotlib` est la solution habituelle pour les graphes de fonctions, les nuages de points, les histogrammes, etc.
Il est intégré à la distribution `scipy` qui rassemble tout le nécessaire pour le calcul scientique.
On trouve tout ça par défaut dans EduPython, Anaconda, etc.

Si ce n’est pas intallé dans votre établissement, vous pouvez le demander : il ne faut pas s’en priver.

== Les bases ==

On va utiliser la surcouche `pylab`, qui réunit le module `numpy` (pour travailler efficacement sur des tableaux de nombres)
et `matplotlib.pyplot` (pour générer les graphiques).

La règle: on dessine avec `plot`, on affiche avec `show`.

{{{#!highlight python
from pylab import *
plot(0,0,'ob') # on trace le point de coordonnées (0,0) comme un rond ('o') bleu ('b')
show()
}}}

Magnifique, non ?

Pour dessiner une courbe au lieu d’un point, il suffit de donner la liste des abscisses et celle des ordonnées.

Par exemple :
{{{#!highlight python
from pylab import * # fournit aussi les mêmes fonctions que math
def dessine_cercle(nb_segments):
	lx = []
	ly = []
	for i in range(nb_segments+1):
		lx = lx + [cos(2*i*pi/nb_segments)]
		ly = ly + [sin(2*i*pi/nb_segments)]
	plot(lx,ly,'b')
	show()
}}}

C’est un peu fastidieux, mais on peut faire mieux, grâce au système
de calcul matriciel de `numpy`, façon Matlab.

== Générer des tableaux de coordonnées ==

{{{#!highlight python
def dessine_cercle(nb_segments):
    theta = linspace(0,2*pi,nb_segments+1)
    x = cos(theta)
    y = sin(theta)
    plot(x,y,'b')
    show()
}}}
Ici `theta` est un tableau `numpy`, contenant `nb_segments+1` valeurs uniformément réparties de 0 à 2π,
et on applique les fonctions `cos` et `sin` case par case, grâce aux versions ''adhoc'' 
fournies par le module.

On peut aussi générer un tableau en donnant un pas plutôt qu’un nombre de valeurs :
{{{#!highlight python
x = arange(-pi,pi,.1) # de -π à π, tous les 0,1.
plot(x,sin(x))
show()
}}}

Il est important d’utiliser les fonctions `sin`, `cos`, etc. en provenance de `pylab` plutôt que 
du module `math`: ces dernières ne sauraient quoi faire d’un tableau.
De fait, on a choisi d’importer `pylab` sous le nom `pl` pour bien distinguer les choses.
On aurait aussi bien pu faire `from pylab import *` en classe: il faut juste faire attention
de ne pas importer les valeurs du module `math` après.

On peut également appliquer les opérations usuelles
(`+`, `-`, `*`, etc.) car le type des tableaux de `pylab` sait les gérer.

Par exemple:
{{{#!highlight python
x = arange(-1,1,.1)
plot(x, x*x+1)
xlabel('x')
ylabel('f(x)=x²+1')
title('Le graphe de la fonction x ↦ x²+1')
show()
}}}

== Un exemple d’application ==

{{{#!highlight py3
from random import randint
from pylab import plot, show, bar

def tirage_des(n):
    "Renvoie un tuple de `n` entiers entre 1 et 6, tirés au hasard."
    return (randint(1,6) for i in range(n))

def somme(l):
    "Renvoie la somme des éléments de `l`."
    s = 0
    for x in l:
        s = s+x
    return s

def compte(l,x):
    "Renvoie le nombre d’occurrences de `x` dans `l`."
    nb = 0
    for y in l:
        if x == y:
            nb = nb+1
    return nb

def affiche_fréquence_sommes(d,n):
    "Affiche le graphe des fréquences des sommes obtenues en lançant `n` fois `d` dés."
    tirages = [tirage_des(d) for i in range(n)]
    sommes = [somme(t) for t in tirages]
    valeurs = range(min(sommes),max(sommes)+1)
    fréquences = [compte(sommes,v)/n for v in valeurs]
    plot(valeurs, fréquences)
    show()
}}}

Bien d’autres choses sont possibles : le réseau regorge de ressources sur le sujet.

On peut par exemple se reporter aux 
[[http://revue.sesamath.net/spip.php?article1110|activités conçues par Hubert Raymondaud publiées sur MathémaTICE]].