Python 19 : Création de graphiques avec pyplot
Cette partie vous montrera comment parvenir à afficher des graphiques, que les données soient des données expérimentales ou des fonctions mathématiques.
1 - Installation de matplotlib
Il faut falloir installer matplotlib, si ce n'est pas déjà fait.
Pour vérifier si vous l'avez déjà installé, il suffit d'ouvrir la console Python de IDLE et de taper :
>>> import matplotlib
Si vous n'avez pas de message d'erreur, c'est que c'est bon.
Sinon, il va falloir penser à l'installer. Si Python et ses scripts ne sont pas dans votre variable système Path, il faut ouvrir votre console et aller dans le répertoire Scripts de Python qui contient le fichier pip.py.
Si vous ne savez pas comment on peut faire cela, utiliser le tutoriel ci-dessous.
Une fois que vous avez rajouté le chemin d'accès dans Path ou que vous avez réussi à atteindre le dossier depuis la console avec des commandes change dir (cd) multiples, il suffit de lancer l'installation :
C:\Users\ho\pip install matplotlib
Si vous voulez connaitre les bibliothèques déjà installées, il suffit de taper :
C:\Users\ho\pip freeze
Vous aurez alors la liste des bibliothèques supplémentaires installées ainsi que leurs versions.
2 - Module pyplot de matplotlib
Nous allons maintenant pouvoir commencer à tracer des choses.
Pour cela, nous allons importer l'un des modules contenant dans matplotlib : pyplot, py pour Python, plot pour tracer.
Pour ne pas à avoir à noter pyplot. à chaque fois que nous allons utiliser l'une des méthodes et fonctions du module, nous allons utiliser un alias lors de l'importation. L'alias courant est plt.
01° Utiliser le code suivant pour tracer votre premier graphique.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
x = [ 0,1,2,3,4,5,6,7,8,9,10 ]
y = [ i*i for i in x ]
print(x)
print(y)
plt.plot(x,y)
plt.show()
Rappel : un ensemble de données séparées par des virgules et entourées par des crochets [ ] est une liste.
Vous devriez obtenir quelque chose proche de ceci :
Quelques explications :
#!/usr/bin/env python: On précise que le fichier est un fichier Python.# -*- coding: utf-8 -*-: On déclare que l'encodage du fichier .py est l'UTF-8. Pensez à le faire réellement si vous enregistrez le fichier avec Notepad++.from matplotlib import pyplot as plt: On importe pyplot sous l'alias pltx = [ 0,1,2,3,4,5,6,7,8,9,10 ]: On crée une liste nommée x qui contient les valeurs des points sur l'axe x.y = [i*i for i in x]: C'est nouveau : on crée une liste à partir d'une autre : pour chaque valeur i contenue dans la liste x, on place i² dans la liste y.print(x): purement pédagogique : on affiche la liste x.print(y): purement pédagogoqie : on affiche la liste y.plt.plot(x,y): on crée un graphique où le premier argument (x) est l'abscisse et le deuxième argument (y) est l'ordonnée.plt.show(): on affiche le graphique qu'on a crée juste au dessus.
02° Placer # devant la dernière ligne pour prouver son utilité. # transforme cette instruction en commentaire.
03° Utiliser les boutons situés sous le graphique. Vous devriez voir qu'on peut zoomer, enregistrer le graphique directement dans un format image...
Pas mal pour quelques lignes de codes non ?
La documentation officielle de pyplot se trouve ici http://matplotlib.org/api/pyplot_summary.html.
Le but ici n'est pas de voir tout ce qu'on peut faire avec pyplot mais bien d'en présenter les grandes lignes uniquement.
La documentation sur plot se trouve facilement dans la liste : http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot.
04° Utiliser la documentation pour afficher une courbe rouge composée de pointillés.
...CORRECTION...
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
x = [ 0,1,2,3,4,5,6,7,8,9,10 ]
y = [ i*i for i in x ]
print(x)
print(y)
plt.plot(x,y, 'r--')
plt.show()
Jusqu'à présent, on crée des graphiques en fournissant une liste pour les x et les y. Mais on peut également simplement fournir une seule liste. Regardons ce que cela donne.
05° Utiliser successivement les deux codes suivants où on ne donne que y. Pourquoi est-ce que ça marche pour le premier mais pas pour le second ?
Premier cas :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
x = [0,1,2,3,4,5,6,7,8,9,10]
y = [ i*i for i in x ]
plt.plot(y, 'k+')
plt.show()
Donne :
Deuxième cas :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
x = [10,11,12,13,14,15,16,17,18,19,20]
y = [ i*i for i in x ]
plt.plot(y, 'k+')
plt.show()
Donne :
Si vous n'avez pas vu l'information dans la documentation, le fait de n'envoyer qu'une seule liste crée un graphique où l'abscisse correspond juste au numéro de l'élément de la liste.
Ainsi, le premier élement porte l'élément 0, le suivant 1... Dans le premier cas, x est également une liste variant de 0 à 10, ça ne pose pas de problème.
Par contre, pour le deuxième cas, les valeurs réelles de x varient de 10 à 20. Mais, comme on ne donne que y, Python place la première valeur de y à une abscisse de 0, la seconde à 2 ... Pour avoir les bonnes valeurs en abscisse, il faut envoyer x également à votre fonction plot>.#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
x = [10,11,12,13,14,15,16,17,18,19,20]
y = [ i*i for i in x ]
plt.plot(x,y, 'k+')
plt.show()
Voyons maintenant les deux types de diagrammes à barres.
Les diagrammes à barres à l'aide de hist. Cela permet de créer des historigrammes : on range les données dans un nombre précis de catégories et on affiche le total de chaque catégorie.
Nous allons créer un programme qui crée une liste z au hasard.
Rappel : Une courte description du module random se trouve dans l'activité Python-Canvas de ce site. Ici la fonction choice renvoie simplement l'un des éléments de la liste au hasard. Ainsi avec le code suivant valeur contiendra (au hasard) un nombre de 1 à 6 :
valeurs = [1,2,3,4,5,6]
valeur = random.choice(valeurs)
06° Analyser le code suivant pour comprendre ce qu'il faut. L'Utiliser puis augmenter le nombre de tirage du dé 6 pour montrer que la répartition entre les différentes possibilités s'uniformise avec un très grand nombre de lancés.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import random
valeurs = [1,2,3,4,5,6]
z = [random.choice(valeurs) for i in range(10)]
plt.hist(z, bins=6, range = (1,6))
plt.show()
On tire 10 dés à 6 faces (10d6)
Si on lance un million de D6 :
Les diagrammes à barres à l'aide de bar().
Cette fonction permet de tracer des diagrammes à barres à l'aide de deux listes ou tableaux x et y. Le premier contient les valeurs des abscisses x[i] et le second la hauteur y[i] de la barre correspondante.
On peut régler la largeur des barres à l'aide de width.
07° Utiliser le code suivant qui génére une liste x commençant à 10, et une liste y comprenant des valeurs entières tirées au hasard entre 0 et 100.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import random
x = [i for i in range(10,30,2)]
y = [random.randint(0,100) for i in x]
print(x)
print(y)
plt.bar(x,y,width=1)
plt.show()
Exemple 1 dont on donne les valeurs contenues dans les listes x et y :
Exemple 2 dont on donne les valeurs contenues dans les listes x et y :
08° Regardons ce qui se passe si on lance deux fois plot à la suite l'un de l'autre.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
x = [0,1,2,3,4,5,6,7,8,9,10]
y = [i*i for i in x]
y2 = [i**3 for i in x]
print(x)
print(y)
print(y2)
plt.plot(x,y)
plt.plot(x,y2)
plt.show()
Il nous reste à voir ou revoir quelques dernières fonctions permettant de modifier les axes et de rajouter des informations sur les axes par exemple.
| Pour rajouter un TITRE |
plt.title("Mon titre") |
| Pour rajouter un LABEL sur l'axe x |
plt.xlabel("Label sur cet axe") On notera que x n'est pas le nom de la série mais bien le nom de la fonction. Comme il s'agit de l'abscisse, le créateur de la fonction a utilisé x. |
| Pour rajouter un LABEL sur l'axe y |
plt.ylabel("Label sur cet axe") On notera que y n'est pas le nom de la série mais bien le nom de la fonction. Comme il s'agit de l'ordonnée, le créateur de la fonction a utilisé y. |
| Pour définir la largeur et la couleur de l'axe des abscisses |
plt.axhline(linewidth=1,color="r") Ici, on crée un axe Ox rouge de largeur 1. |
| Pour définir la largeur et la couleur de l'axe des ordonnées |
plt.axvline(linewidth=2,color="g") Ici, on crée un axe Oy vert de largeur 2. |
| Pour gérer les valeurs minimales et maximales des axes x et y |
plt.axis([ xmin, xmax, ymin, ymax ]) Il faut donc faire attention à l'ordre des arguments transmis. |
| Pour imposer un repère orthonormé |
plt.axis('equal') |
| Pour choisir les graduations sur l'axe des abscisses |
plt.xticks([0,1,2,3,4,5]) |
| Pour choisir les graduations sur l'axe des ordonnés |
plt.yticks([0,1,2,3,4,5]) |
| Pour fermer le graphique |
plt.close() |
09° Utilisez les indications ci-dessus pour tracer la fonction f(x)= 4x² - 10 x + 2 sur l'intervalle [-10;+10].
Une proposition de correction :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
def ma_fonction(x):
return(4*(x**2)-10*x+2)
x = [i/10 for i in range(-100,101,1)]
y = [ma_fonction(i) for i in x]
plt.plot(x,y)
plt.title("Représentation de f(x)")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.yticks([0,100,200,500])
plt.show()
3 - Module math
Comme nous traçons des graphiques, autant parler des fonctions mathématiques qui vous permettront de demander à Python d'utiliser quelques fonctions mathématiques.
Il faut pour cela importer le module math à l'aide par exemple de import math.
Voilà les noms des fonctions (informatiques) permettant de trouver la valeur des fonctions mathématiques.
10° Utiliser pyplot pour afficher les deux premières fonctions ci-dessous.
La racine carrée de x : math.sqrt(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction(x) :
return(math.sqrt(x))
x = [i/100 for i in range(0,1001,1)]
y = [ma_fonction(i) for i in x]
plt.plot(x,y)
plt.title("Racine carrée de x")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.show()
La partie entière de x : math.floor(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction(x) :
return(math.floor(x))
x = [i/100 for i in range(-1000,1001,1)]
y = [ma_fonction(i) for i in x]
plt.plot(x,y)
plt.title("Partie entière de x")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.show()
La valeur absolue |x| de x : math.fabs(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction(x) :
return(math.fabs(x))
x = [i/100 for i in range(-1000,1001,1)]
y = [ma_fonction(i) for i in x]
plt.plot(x,y)
plt.title("Valeur absolue de x")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.show()
Le factoriel x! de x : math.factorial(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction(x) :
return(math.factorial(x))
x = [i/100 for i in range(100,500,1)]
y = [ma_fonction(math.floor(i)) for i in x]
plt.plot(x,y)
plt.title("Factorielle de x")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.xticks([1,2,3,4,5])
plt.show()
L'exponentielle ex de x : math.exp(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction(x) :
return(math.exp(x))
x = [i/100 for i in range(-1000,1001,1)]
y = [ma_fonction(i) for i in x]
plt.plot(x,y)
plt.title("Exponentielle de x")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.show()
Le logarithme népérien ln(x) de x : math.log(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction(x) :
return(math.log(x))
x = [i/100 for i in range(1,1001,1)]
y = [ma_fonction(i) for i in x]
plt.plot(x,y)
plt.title("Logarithme (népérien) de x")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.show()
Les fonctions trigonométriques portent un nom assez explicite pour ne pas rentrer dans les détails :
math.cos(x)etmath.acos(x).math.sin(x)etmath.asin(x).math.tan(x)etmath.atan(x).
Par contre, attention : x est l'angle défini en radians. Pour convertir des degrés en radians, il faut utiliser math.radians(angle_en_degre).
De la même façon, transformer un angle en radians en degrés nécessite math.degrees(angle_en_radians).
Si vous cherchez pi, il faut utiliser math.pi.Au passage, la constante de Neper e = exp(1) se note math.e.
On remarquera que le calcul étant numérique, Python gère mal les discontinuités.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction1(x) :
return(math.sin(x))
def ma_fonction2(x) :
return(math.cos(x))
def ma_fonction3(x) :
return(math.tan(x))
x = [i/100 for i in range(0,36100,1)]
y = [ma_fonction1(math.radians(i)) for i in x]
y2 = [ma_fonction2(math.radians(i)) for i in x]
y3 = [ma_fonction3(math.radians(i)) for i in x]
plt.plot(x,y,'b')
plt.plot(x,y2,'g')
plt.plot(x,y3,'r')
plt.title("sin(x) en bleu, cos(x) en vert et tan(x) en rouge")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.axis([0,360,-3,3])
plt.show()
Le cosinus hyperbolique de x : math.cosh(x).
Le sinus hyperbolique de x : math.sinh(x).
La tangente hyperbolique de x : math.tanh(x).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib import pyplot as plt
import math
def ma_fonction1(x) :
return(math.sinh(x))
def ma_fonction2(x) :
return(math.cosh(x))
def ma_fonction3(x) :
return(math.tanh(x))
x = [i/100 for i in range(-1000,1001,1)]
y = [ma_fonction1(i) for i in x]
y2 = [ma_fonction2(i) for i in x]
y3 = [ma_fonction3(i) for i in x]
plt.plot(x,y,'b')
plt.plot(x,y2,'g')
plt.plot(x,y3,'r')
plt.title("sinh(x) en bleu, cosh(x) en vert et tanh(x) en rouge")
plt.xlabel("Abscisse x")
plt.ylabel("Ordonnée y")
plt.axis([-10,10,-10,10])
plt.show()
4 - Rappel et compléments sur les listes
1 - lecture des éléments d'une liste
Qu'est qu'une liste ? C'est une suite ordonnée et modifiable (mutable) d'objets ou variables quelconques.
Les éléments d'une liste sont séparés par des virgules et la définition de la liste commence avec [ et s'arrête avec ].
maListe = [1,'a',45.2,"bonjour",'b'] crée une liste de 5 éléments contenant l'integer 1, le char a, le float 45.2, le string bonjour et le char b.
Si on veut afficher une liste, print(maListe) fonctionne.
>>> maListe = [1,'a',45.2,"bonjour",'b']
>>> print(maListe)
[1,'a',45.2,'bonjour','b']
Si on veut connaitre le nombre d'éléments dans une liste, len(maListe) fonctionne.
>>> maListe = [1,'a',45.2,"bonjour",'b']
>>> len(maListe)
5
Si on veut accéder à l'un des éléments d'une liste, on tapera maListe[2], mais attention le premier élément est l'élément 0.
Si on demande print(maListe[2]) avec maListe = [1,'a',45.2,"bonjour",'b'], on obtient :
>>> maListe = [1,'a',45.2,"bonjour",'b']
>>> maListe = [2]
45.2
Si on veut accéder à un ensemble d'éléments d'une liste, on tapera ma_liste[1:4], et on aura les éléments 1,2 et 3 (car cela veut dire qu'on commence à l'élément 1 et qu'on s'arrête avant le 4.).
Si on demande print(ma_liste[1:4]) avec ma_liste = [1, 'a', 45.2,"bonjour", 'b'], on obtient :
>>> maListe = [1,'a',45.2,"bonjour",'b']
>>> print( ma_liste[1:4] )
['a',45.2,'bonjour']
Pour parcourir une liste, il suffit d'utiliser un for.
for element in maListe :
print(element)
Et on obtient alors
1
a
45.2
bonjour
b
Nous avons également vu qu'on peut utiliser plutôt une boucle for numérique :
for numero in range(len(maListe)) :
print(maListe[numero])
2 - Rajouter ou supprimer des élément dans les listes
Nous avions vu comment rajouter des éléments dans une liste avec la méthode append qui rajoute des éléments en fin de liste.
>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> a.append('4')
>>> a
[1, 2, 3, '4']
>>> b = [7,8,9]
>>> a.append(b)
>>> a
[1, 2, 3, '4', [7, 8, 9]]
Cette méthode append permet donc de considérer les listes comme des piles de livres : on rajoute les éléments au dessus des derniers éléments.
Voyons d'autres manières de rajouter des éléments dans une liste.
Pour rajouter des éléments à une liste, on peut également utiliser un simple + entre deux listes. Attention néanmoins : on crée alors une nouvelle liste qui n'aura pas la même adresse/référence/id que la précédente contrairement à l'utilisation de la méthode append. Comme la liste est mutable, c'est même plutôt une façon de faire à éviter SAUF si vous voulez clairement créer une nouvelle liste à partir d'une autre liste.
Si on utilise maListe = maListe + ['nouveau'] avec maListe = [1,'a',45.2,"bonjour",'b'], on obtient également :
>>> maListe = [1,'a',45.2,"bonjour",'b']
>>> maListe = maListe + ['nouveau']
>>> print(maListe)
['a',45.2,'bonjour','b','nouveau']
Par contre, cette fois, on a recréé une liste qui porte le même nom : ce n'est pas la même liste au niveau de son id.
Si on veut rajouter un élément à une position particulière d'index i dans la liste, on utilise maListe.insert(i,x) où x est l'élément à rajouter et i l'index dans la liste.
>>> maListe = [1,'a',45.2,"bonjour",'b']
>>> maListe.insert(1,'nouveau')
>>> print(maListe)
[1,'nouveau','a',45.2,'bonjour','b']
Souvenez-vous que l'index du premier élément est 0, pas 1.
Si i dépasse l'index maximum, x sera juste ajouté en fin de liste, comme avec un append.
Si on veut supprimer un élément x, on utilise maListe.remove(x) où x est l'élément à supprimer dans la liste.
Si on utilise maListe.remove('nouveau') avec maListe = [1,'nouveau','a',45.2,"bonjour",'b','nouveau'], on obtient :
>>> maListe = [1,'nouveau','a',45.2,"bonjour",'b','nouveau']
>>> maListe.remove('nouveau')
[1,'a',45.2,"bonjour",'b','nouveau']
On remarquera donc qu'elle ne supprime que le premier élément 'nouveau' rencontré. S'il y en a d'autres, il faudra faire d'autres remove.
Attention, si l'élément n'est pas présent dans la liste, la méthode va lever une exception de type valueError. Il faudra donc utiliser un while et un try pour supprimer tous les éléments identiques.
Justement, si on veut connaitre le nombre de fois qu'un élément x apparait dans une liste, on utilise maListe.count(x) où x est l'élément à surveiller dans la liste.
Si on utilise maListe.count('nouveau') avec maListe = [1,'nouveau','a',45.2,"bonjour",'b','nouveau'], on obtient :
>>> maListe = [1,'nouveau','a',45.2,"bonjour",'b','nouveau']
>>> maListe.count('nouveau')
2
Enfin, deux méthodes qui sont pratiques et un peu l'inverse l'une de l'autre :
Si on utilise maListe.sort(), on ordonne les éléments de la liste maListe.
Exemple 1:
>>> maListe = ['un','deux','trois','quatre']
>>> maListe.sort()
>>> maListe
['deux', 'quatre', 'trois', 'un']
Exemple 2:
>>> maListe = [5,1,3,2]
>>> maListe.sort()
>>> maListe
[1, 2, 3, 5]
Exemple 3: mélange d'int et de str
>>> maListe = ['un','deux','trois','quatre',5,1,3,2]
>>> maListe.sort()
TypeError: '<' not supported between instances of 'int' and 'str'
Donc attention : ce n'est pas une méthode miracle : elle doit pouvoir sélectionner et trier les éléments de type différents entre eux. Si elle ne sait pas faire, ça ne fonctionnera pas.
L'inverse, c'est la fonction shuffle : cette fonction du module random va mélanger les éléments de la liste et les répartir au hasard...
>>> import random as random
>>> maListe = ['un','deux','trois','quatre',5,1,3,2]
>>> random.shuffle(maListe)
>>> maListe
['trois', 'un', 'deux', 2, 1, 'quatre', 3, 5]
Pratique non ?
3 - Recherche du max, du min et de la valeur moyenne
Nous voulons faire des calculs avec les données récoltées.
Pour trouver la valeur maximale dans une liste purement numérique, on utilise max(liste).
Pour trouver la valeur minimale dans une liste purement numérique, on utilise min(liste).
Pour trouver la somme des éléments d'une liste, on utilise sum(liste).
Voilà un exemple des cas précédents et un moyen de calculer une valeur moyenne du coup.
>>> liste = [1,3,5,2,4]
>>> max(liste)
5
>>> min(liste)
1
>>> sum(liste)
15
>>> len(liste)
5
>>> valeur_moyenne = sum(liste)/len(liste)
>>> valeur_moyenne
3.0
>>>
5 - Interaction entre Python et un tableur
Ce que nous venons de créer n'a rien d'extraordinaire. Les tableurs peuvent faire la même chose sans aucun problème. La force de Python vient surtout de ce qu'on peut faire en plus : gérer les données avec un code, en mettre certaines de côté, faire des interfaces, ect ...
Or, il existe un moyen simple de faire communiquer votre tableur préféré et votre programme Python. Il existe un format particulier de fichier texte, prévu pour enregistrer les données des tableurs en suivant une codification simple :
Dans un fichier csv, les données d'une ligne sont écrites sur une ligne unique et sont séparées par des points-virgules.
Csv veut dire comma-separated values.
A titre d'exemple, voici une copie d'écran d'un tableur contenant les données issues d'une acquisition vidéo visualisant une voiture en mouvement : on a le temps correspondant à l'image, la position horizontale x et la position verticale y de la voiture.
En faisant ENREGISTRER SOUS et en sélectionnant csv, vous allez obtenir un fichier texte que vous pourrez ouvrir avec le tableur, avec un lecteur de fichier texte basique ou Notepad++ par exemple. Que contient-il ? Ceci :
t(s);x(m);y(m)
0,000;0,001;-0,001
0,100;0,061;0,000
0,200;0,139;-0,001
0,300;0,227;-0,002
0,400;0,318;-0,001
0,500;0,412;-0,001
0,600;0,506;-0,002
0,700;0,600;-0,001
0,800;0,688;-0,002
0,900;0,774;-0,003
1,000;0,855;-0,002
1,100;0,935;-0,004
1,200;1,019;-0,007
1,300;1,105;-0,009
1,400;1,194;-0,011
1,500;1,283;-0,012
1,600;1,371;-0,014
Comme on peut le voir chaque ligne du tableur correspond à une ligne du fichier texte. Et chaque donnée-colonne est séparée des autres par un point-virgule.
11° Créer des données dans le tableur que vous voulez. Les données seront bien présentées en colonne comme dans l'exemple présenté. La première ligne doit contenir les intitulés des données placées en dessous. Enregister les données en csv sous le nom "essai_csv.csv".
Bien, nous avons réussi à créer un fichier csv avec le tableur. Comment parvenir à récupérer les données de "essai_csv.csv" dans Python ?
C'est un fichier texte. On peut donc y accéder avec les méthodes open(), read(), readlines() ou readline() classiques. Il existe un module Python qui fait beaucoup de choses avec ces fichiers. Le module csv justement. On l'importe avec import csv. Nous le détaillerons pas ici car nous n'allons utilisé qu'un décodage basique des informations et les outils basiques seront suffisants. Cela nous permettra de faire quelques révisions d'ailleurs.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
obj_fichier = open("essai_csv.csv","r",encoding='utf-8')
while 1 : # La condition est donc toujours True
ligne = obj_fichier.readline() # On tente de lire la ligne
if not(ligne) : # Si ligne n'existe pas, elle contient False
break # On sort de la boucle
else: # Sinon, c'est que ligne contient quelque chose
print(ligne, end='') # Pour supprimer le passage à la ligne automatique
obj_fichier.close()
input("Appuyez sur ENTREE")
12° Tester ce code pour vérifier qu'il fonctionne bien.
Bon, le désavantage de cette méthode est que si un problème survient lors de la lecture, le programme va planter et le fichier sera mal refermé. Et là, il est possible que les données soient perdues, corrompues.
Nous allons compliquer les choses en présentant la méthode usuelle : on associe un open avec un opérateur with. Cette méthode garantit la fermeture correcte des fichiers en cas d'erreurs.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
with open("essai_csv.csv","r",encoding='utf-8') as obj_fichier :
while 1 : # La condition est donc toujours True
ligne = obj_fichier.readline() # On tente de lire la ligne
if not(ligne) : # Si ligne n'existe pas, elle contient False
break # On sort de la boucle
else: # Sinon, c'est que ligne contient quelque chose
print(ligne, end='') # Pour supprimer le passage à la ligne automatique
obj_fichier.close()
input("Appuyez sur ENTREE")
13° Tester la version avec le with pour voir qu'il fournit la même chose tant que tout va bien.
Il nous reste à stocker les données pour pouvoir en faire quelque chose. Nous allons les stocker dans deux listes nommées t,x. Nous n'y stockerons que les valeurs, les intitulés de la première ligne seront stockés ailleurs. Les informations sur y ne seront pas importées dans notre programme pour vous montrer qu'on peut limiter l'importation aux données voulues.
14° Lancer pour comprendre ce que fait le programme suivant :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
t = [] # Création d'une liste vide
x = [] # Création d'une liste vide
with open("essai_csv.csv","r",encoding='utf-8') as obj_fichier :
while 1 : # La condition est donc toujours True
ligne = obj_fichier.readline() # On tente de lire la ligne
if not(ligne) : # Si ligne n'existe pas, elle contient False
break # On sort de la boucle
else: # Sinon, c'est que ligne contient quelque chose
ligne.replace('\n','') # On supprime le passage à la ligne finale de chaque ligne
elements = ligne.split(';') # On crée une liste contenant les valeurs de chaque ligne
for element in elements :
print(element)
obj_fichier.close()
input("Appuyez sur ENTREE")
15° Voici la dernière étape de ce mini-projet : après être parvenu à lire le fichier csv, nous récupérons les intitulés de la première ligne et nous mettons le reste dans deux listes t et x :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
t = [] # Création d'une liste vide
x = [] # Création d'une liste vide
with open("essai_csv.csv","r",encoding='utf-8') as obj_fichier :
print("On affiche les listes contenant les lignes du .csv")
compteur = 0
while 1 : # La condition est donc toujours True
ligne = obj_fichier.readline() # On tente de lire la ligne
if not(ligne) : # Si ligne n'existe pas, elle contient False
break # On sort de la boucle
else: # Sinon, c'est que ligne contient quelque chose
ligne.replace('\n','') # On supprime le passage à la ligne finale de chaque ligne
elements = ligne.split(';') # On crée une liste contenant les valeurs de chaque ligne
print(elements)
if compteur == 0 :
grandeur_abscisse = elements[0]
grandeur_ordonnee = elements[1]
else:
t.append(elements[0])
x.append(elements[1])
compteur += 1
obj_fichier.close()
print("\nOn affiche la liste contenant les temps")
print(t)
print("\nOn affiche la liste contenant les positions")
print(x)
input("Appuyez sur ENTREE")
Avec mes données, cela donne :
On affiche les listes contenant les lignes du .csv
['t(s)', 'x(m)', 'y(m)\n']
['0,000', '0,001', '-0,001\n']
['0,100', '0,061', '0,000\n']
['0,200', '0,139', '-0,001\n']
['0,300', '0,227', '-0,002\n']
['0,400', '0,318', '-0,001\n']
['0,500', '0,412', '-0,001\n']
['0,600', '0,506', '-0,002\n']
['0,700', '0,600', '-0,001\n']
['0,800', '0,688', '-0,002\n']
['0,900', '0,774', '-0,003\n']
['1,000', '0,855', '-0,002\n']
['1,100', '0,935', '-0,004\n']
['1,200', '1,019', '-0,007\n']
['1,300', '1,105', '-0,009\n']
['1,400', '1,194', '-0,011\n']
['1,500', '1,283', '-0,012\n']
['1,600', '1,371', '-0,014\n']
On affiche la liste contenant les temps
['0,000', '0,100', '0,200', '0,300', '0,400', '0,500', '0,600', '0,700', '0,800', '0,900', '1,000', '1,100', '1,200', '1,300', '1,400', '1,500', '1,600']
On affiche la liste contenant les positions
['0,001', '0,061', '0,139', '0,227', '0,318', '0,412', '0,506', '0,600', '0,688', '0,774', '0,855', '0,935', '1,019', '1,105', '1,194', '1,283', '1,371']
Appuyez sur ENTREE
6 - Mini-projet
Utilisons nos connaissances pour exploiter les données fournies par l'analyse de la position de la voiture.
16° Les données stockées dans x et t sont des strings pour l'instant. Modifier le programme à l'aide de la fonction float(string) pour transformer les données en nombres réels.
17° Afficher le graphique de la position en fonction du temps.
Il nous reste à exploiter les données : nous allons tenter de trouver la vitesse instantanée.
Comment ? Et bien la vitesse v2 sur l'image 2 est égale à v2 = (x3-x1) / (t3-t1)
18° Calculer la vitesse sur les images possibles, c'est à dire celles où on dispose des valeurs précédentes et des valeurs suivantes en x et t.
19° Tracer la vitesse en fonction du temps.
20° Enregistrer le tout dans un nouveau fichier csv nommé "vitesse.csv".
Nous voilà à la fin de cette activité. Vous pourrez aller voir le module csv par la suite. Nous verrons qu'on peut également utiliser des tableaux de données plutôt que des listes, à l'aide du module numpy.