Importer une base de données au format SQL
Importer une base de données au format CSV
Importer une base de données au format xlsx
Importer des données à partir d'un fichier au format json
Créer une base de données au format SQL
Créer une base de données au format CSV
Créer une base de données au format xlsx
Modifier une base de données au format SQL
Modifier une base de données au format CSV
Modifier une base de données au format xlsx
Créer un DataFrame à partir d'un dictionnaire
Créer un DataFrame à partir d'une liste
Afficher un aperçu des premières lignes d'un DataFrame
Sélectionner une colonne par son nom
Sélectionner un élément à partir de l'index de sa ligne et du nom de sa colonne
Sélectionner des lignes et des colonnes
Filtrer des lignes par leur contenu
Ajouter des titres / labels aux colonnes et aux lignes
Régressions et courbes de tendance avec Koala
Etudier des séquences biologiques avec Genopy
Convertir des fichiers .edi (anagene) en fichiers fasta
Rechercher et afficher des séquences
Afficher les tables du code génétique
Comparer des séquences: alignement par paires
Comparer des séquences: alignement multiple (clustal)
Afficher et sauvegarder une matrice de distances
Tracer un arbre phylogénétique à partir d'une matrice de distances
Tracer un arbre phylogénétique à partir d'une liste de séquences
Faire un graphique "simple" avec une seule courbe
Faire un graphique avec plusieurs courbes
Mise en page de plusieurs graphiques: réaliser un subplot
Utiliser matplotlib.plyplot avec Jupyter Notebook
...
Datation absolue avec chrono.py
Calculer et représenter le déplacement des plaques lithosphériques avec Pandas et Basemap
Corrélation UV mélanome - Approche épidémiologique avec Pandas GeoPandas et Koala
Les structures conditionnelles if elif else
Manipuler les chaines de caractères str
Utiliser le module time de python
Les modules os, glob, shutil et subprocess
Utiliser le module json de python
Lire et ecrire un fichier avec python
>>> import pandas as pd
>>> import numpy as np
>>> s = pd.Series([2,4,6,8])
>>> s
0 2
1 4
2 6
3 8
dtype: int64
>>> s = pd.Series([2,4,6,8], name="gogo", dtype="float", index=list("abcd"))
>>> s
a 2.0
b 4.0
c 6.0
d 8.0
Name: gogo, dtype: float64
>>> s.name = "toto"
>>> s.index = list("ABCD")
>>> s
A 2.0
B 4.0
C 6.0
D 8.0
Name: toto, dtype: float64
>>> s2 = s.astype(‘int64’) # ou s.astype(int) ou s.astype(float)...
>>> s2
0 2
1 4
2 6
3 8
Name: toto, dtype: int64
A partir d’un dictionnaire {label : valeur} :
>>> a = pd.Series({"a":2,"b":4,"c":6,"d":8})
>>> a
0 2
1 4
2 6
3 8
dtype: int64
A partir d’un Ndarray:
>>> b = pd.Series(np.arange(2,10,2))
>>> b
0 2
1 4
2 6
3 8
dtype: int32
>>> s
A 2.0
B 4.0
C 6.0
D 8.0
Name: toto, dtype: float64
>>> s[0]
2.0
>>> s.iloc[0]
2.0
>>> s.A
2.0
>>> s.loc["A"]
2.0
>>> s
A 2
B 4
C 6
D 8
Name: toto, dtype: int64
>>> s.A = 45
>>> s.B = 'gogo'
>>> s.C = 6.9
>>> s.iloc[3] = "bobo"
>>> s
A 45
B gogo
C 6.9
D bobo
Name: toto, dtype: object
>>> s
A 2.0
B 4.0
C 6.0
D 8.0
Name: toto, dtype: float64
>>> f = s*2
>>> f
A 4.0
B 8.0
C 12.0
D 16.0
Name: toto, dtype: float64
>> z = pd.Series(list("wxyz"))
>>> z
0 w
1 x
2 y
3 z
dtype: object
>>> s
A 2.0
B 4.0
C 6.0
D 8.0
Name: toto, dtype: float64
>>> x = s.append(z, ignore_index=True)
>>> x
0 2
1 4
2 6
3 8
4 w
5 x
6 y
7 z
dtype: object
Il existe de très nombreuses façons de créer un DataFrame... en voici 4
>>> d = {"nom":("Diatta", "Sane", "Diouf"), "prenom":("Robert", "Jean", "Albert")}
>>> df = pd.DataFrame(d)
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> n = np.array((("Diatta", "Robert"),("Sane", "Jean"),("Diouf", "Albert")))
>>> n
array([['Diatta', 'Robert'],
['Sane', 'Jean'],
['Diouf', 'Albert']], dtype='<U6')
>>> df = pd.DataFrame(n, columns=("nom","prenom"))
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> t = [('Diatta', 'Robert'), ('Sane', 'Jean'), ('Diouf', 'Albert')]
>>> t
[('Diatta', 'Robert'), ('Sane', 'Jean'), ('Diouf', 'Albert')]
>>> df = pd.DataFrame(t, columns=("nom","prenom"))
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> a = pd.Series(("Diatta","Robert"))
>>> b = pd.Series(("Sane","Jean"))
>>> c = pd.Series(("Diouf","Albert"))
>>> a
0 Diatta
1 Robert
dtype: object
>>> df = pd.DataFrame([a,b,c])
>>> df
0 1
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df.columns = ("nom", "prenom")
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
Ou
>>> n = pd.Series(["Diatta","Sane","Diouf"])
>>> p = pd.Series(["Robert","Jean","Albert"])
>>> n
0 Diatta
1 Sane
2 Diouf
dtype: object
>>> p
0 Robert
1 Jean
2 Albert
dtype: object
>>> df = pd.DataFrame([n,p])
>>> df
0 1 2
0 Diatta Sane Diouf
1 Robert Jean Albert
>>> df = df.T
>>> df
0 1
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df.columns = ("Nom","Prenom")
>>> df
Nom Prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
Il faut alors préciser son path ou son url. Dans l'exemple ci dessous on utilise un fichier json hébérgé à l'URL suivante: https://ipfs.io/ipfs/QmfD7A6kpeWYuJMVoNey2GTeNphGg4F8cdXEhWq61Q9shn.
>>> df = pd.read_json("https://ipfs.io/ipfs/QmfD7A6kpeWYuJMVoNey2GTeNphGg4F8cdXEhWq61Q9shn")
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> df.head()
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
On ne voit pas la différence car mon DataFrame ne fait que trois lignes... mais c’est bien pratique quand on a un DataFrame de 3000 lignes. De plus il est possible de passer le nombre de lignes désiré en argument de head().
On crée un DataFrame:
>>> d = {'nom': ('Diop', 'Diallo', 'Diouf', 'Sane'), 'prenom': ('Alpha', 'Alpha', 'Alpha', 'Jean'), 'age': (30, 37, 28, 42)}
>>> df = pd.DataFrame(d)
>>> df
nom prenom age
0 Diop Alpha 30
1 Diallo Alpha 37
2 Diouf Alpha 28
3 Sane Jean 42
Filtrer des lignes ayant pour nom Diallo:
>>> diallo = df[(df.nom == "Diallo")]
>>> diallo
nom prenom age
1 Diallo Alpha 37
Équivalent à:
>>> df.query('nom == "Diallo"')
Filtrer des lignes ayant pour prénom Alpha et un âge supérieur à 29:
>>> alpha_29 = df[(df.prenom == "Alpha") & (df.age > 29)]
>>> alpha_29
nom prenom age
0 Diop Alpha 30
1 Diallo Alpha 37
Équivalent à:
>>> df.query('prenom == "Alpha" and age > 29')
Filtrer des lignes ayant pour nom Sane ou un âge inférieur à 30:
>>> sane_30 = df[(df.nom == "Sane") | (df.age < 30)]
>>> sane_30
nom prenom age
2 Diouf Alpha 28
3 Sane Jean 42
Équivalent à:
>>> df.query('nom == "Sane" or age < 30')
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> n = df.nom
>>> type(n)
<class 'pandas.core.series.Series'>
>>> n
0 Diatta
1 Sane
2 Diouf
Name: nom, dtype: object
>>> df["nom"]
0 Diatta
1 Sane
2 Diouf
Name: nom, dtype: object
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> df.nom[1]
'Sane'
Sélection de toutes les lignes de la colonne d’index 0 incluse jusqu’à la colonne d’index 1 exclue:
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> w = df.iloc[:, :1]
>>> w
nom
0 Diatta
1 Sane
2 Diouf
>>> type(w)
<class 'pandas.core.frame.DataFrame'>
Vous remarquerez que iloc retourne un DataFrame
Sélection de toutes les colonnes de la ligne d’index 1 incluse jusqu’à la ligne d’index 2 exclue:
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> df.iloc[1:2]
nom prenom mail
1 Sane Jean jean@hotmail.com
Sélectionner des colonnes entières:
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> df.loc[:,["nom","mail"]]
nom mail
0 Diatta rob@hotmail.fr
1 Sane jean@hotmail.com
2 Diouf bebert@gmail.com
>>> df.loc[["nom","mail"]]
nom mail
0 Diatta rob@hotmail.fr
1 Sane jean@hotmail.com
2 Diouf bebert@gmail.com
Sélectionner des lignes (n’ayant pas de labels): les index des lignes sont alors considérés comme des labels. Les index initiaux et finaux sont alors inclus dans le retour.
>>> df
nom prenom mail
0 Diatta Robert rob@hotmail.fr
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
>>> df.loc[1:2]
nom prenom mail
1 Sane Jean jean@hotmail.com
2 Diouf Albert bebert@gmail.com
Ajoutons des labels de lignes:
>>> df.index = list("abc")
>>> df
nom prenom mail
a Diatta Robert rob@hotmail.fr
b Sane Jean jean@hotmail.com
c Diouf Albert bebert@gmail.com
Sélection de la ligne b incluse à c incluse:
>>> df.loc["b":"c"]
nom prenom mail
b Sane Jean jean@hotmail.com
c Diouf Albert bebert@gmail.com
Sélection des colonnes nom et mail pour les lignes b incluse à c incluse:
>>> df.loc["b":"c",["nom","mail"]]
nom mail
b Sane jean@hotmail.com
c Diouf bebert@gmail.com
Sélectionner les lignes a et c des colonnes nom et mail
>>> df.loc[[0,2],["nom","mail"]]
nom mail
a Diatta robert@hotmail.fr
c Diouf bebert@hotmail.com
On peut toujours sélectionner par les index avec iloc si on le souhaite:
>>> df.iloc[1:2]
nom prenom mail
b Sane Jean jean@hotmail.com
>>> df.iloc[1:3]
nom prenom mail
b Sane Jean jean@hotmail.com
c Diouf Albert bebert@gmail.com
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df.T
0 1 2
nom Diatta Sane Diouf
prenom Robert Jean Albert
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df.columns
Index(['nom', 'prenom'], dtype='object')
>>> df.columns = ("colA","colB")
>>> df
colA colB
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df.index
RangeIndex(start=0, stop=3, step=1)
>>> df.index = list("abc")
>>> df
colA colB
a Diatta Robert
b Sane Jean
c Diouf Albert
>>> df
colA colB
a Diatta Robert
b Sane Jean
c Diouf Albert
>>> df["colC"] = (34,21,45)
>>> df
colA colB colC
a Diatta Robert 34
b Sane Jean 21
c Diouf Albert 45
>>> df
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> m
mail
0 robert@hotmail.fr
1 jean@gmail.com
2 bebert@hotmail.com
>>> pd.concat([df,m],axis=1)
nom prenom mail
0 Diatta Robert robert@hotmail.fr
1 Sane Jean jean@gmail.com
2 Diouf Albert bebert@hotmail.com
>>> raw = pd.DataFrame([("Dupond","Serge")], columns=("colA","colB"))
>>> raw
colA colB
0 Dupond Serge
>>> df
colA colB
a Diatta Robert
b Sane Jean
c Diouf Albert
>>> df2 = df.append(raw)
>>> df2
colA colB
a Diatta Robert
b Sane Jean
c Diouf Albert
0 Dupond Serge
>>> df3 = df.append(raw, ignore_index=True)
>>> df3
colA colB
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
3 Dupond Serge
Il existe de très nombreuses autres méthodes pour concatener des DataFrame... Doc officielle
>>> df
colA colB colC
a Diatta Robert 34
b Sane Jean 21
c Diouf Albert 45
>>> df2 = df.drop(["colC"], axis=1)
>>> df2
colA colB
a Diatta Robert
b Sane Jean
c Diouf Albert
>>> df
colA colB colC
a Diatta Robert 34
b Sane Jean 21
c Diouf Albert 45
>>> df3 = df.drop(columns=["colC"])
>>> df3
colA colB
a Diatta Robert
b Sane Jean
c Diouf Albert
>>> df
colA colB colC
a Diatta Robert 34
b Sane Jean 21
c Diouf Albert 45
>>> df2 = df.drop(["a"])
>>> df2
colA colB colC
b Sane Jean 21
c Diouf Albert 45
>>> import pandas as pd
>>> from sqlite3 import *
>>> import pandas as pd
>>> from sqlite3 import *
>>> conn = connect("base.db")
On peut aussi se connecter de la même façon à une base SQL en plaçant son URL en argument de connect.
>>> conn = connect("https://domaine/base.db")
On peut éventuellement commencer par récupérer les noms des tables:
>>> liste_tables = pd.read_sql_query("select name from sqlite_master where type = 'table'", conn)
>>> liste_tables
name
0 users
Ma base de données contient ici une seule table nommée users.
Puis envoyer une requête SQL pour récupérer le contenu d’une table
>>> users = pd.read_sql_query("select * from users", conn)
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
Commencez par importer les modules et créer un objet conn:
>>> import pandas as pd
>>> from sqlite3 import *
>>> conn = connect("base.db")
Vous pouvez créer un DataFrame vide ou contenant déjà des lignes
>>> df = pd.DataFrame({"nom":("Admi", "Diatta", "Sane"), "mail":("admi@gmail.com", "robert@hotmail.com", "jean@hotmail.fr"), "level":(2,1,1)})
>>> df
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
Convertir le DataFrame en table sql:
>>> df.to_sql("users", conn, index=False)
En utilisant une commande sql:
>>> cur = conn.cursor()
>>> cur.execute("insert into users(nom, mail, level) values('Diouf', 'dio@yahoo.com', 1)")
<sqlite3.Cursor object at 0x73590d60>
>>> users = pd.read_sql_query("select * from users", conn)
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
3 Diouf dio@yahoo.com 1
En modifiant le DataFrame et en remplaçant l’ancienne table par le nouveau DataFrame:
>>> users = pd.read_sql_query("select * from users", conn)
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
>>> raw = pd.DataFrame({"nom":("Samb",), "mail":("samba@gmail.com",), "level":(3,)})
>>> users = users.append(raw, ignore_index=True)
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
3 Samb samba@gmail.com 3
>>> users.to_sql("users", conn, index=False, if_exists="replace")
>>> df = pd.DataFrame({"nom":("Admi", "Diatta", "Sane"), "mail":("admi@gmail.com", "robert@hotmail.com", "jean@hotmail.fr"), "level":(2,1,1)})
>>> df
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
>>> df.to_csv("mycsv", index=False)
>>> users = pd.read_csv("mycsv")
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
On peut aussi passer l'URL du CSV en argument à la place de son path
>>> users = pd.read_csv("mycsv")
>>> raw = pd.DataFrame({"nom":("Samb",), "mail":("samba@gmail.com",), "level":(3,)})
>>> users = users.append(raw, ignore_index=True)
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
3 Samb samba@gmail.com 3
>>> users.to_csv("mycsv", index=False)
>>> users2 = pd.read_csv("mycsv")
>>> users2
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
3 Samb samba@gmail.com 3
>>> df
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
>>> df.to_excel("mybase.xlsx", sheet_name = "Modou")
>>> users = pd.read_excel("mybase.xlsx")
>>> users
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
>>> df1 = pd.DataFrame({"nom":("Admi", "Diatta", "Sane"), "mail":("admi@gmail.com", "robert@hotmail.com", "jean@hotmail.fr"), "level":(2,1,1)})
>>> df2 = pd.DataFrame({"nom":("Diatta", "Sane", "Diouf"), "prenom":("Robert", "Jean", "Albert")})
>>> writer = pd.ExcelWriter('gogo.xlsx')
>>> df1.to_excel(writer,'feuille 1')
>>> df2.to_excel(writer,'feuille 2')
>>> writer.save()
Récupérer la feuille 1: feuille d’index 0 retournée par défaut:
>>> table1 = pd.read_excel("gogo.xlsx")
>>> table1
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
Récupérer la feuille 2 (feuille d’index 1):
>>> table2 = pd.read_excel("gogo.xlsx", sheet_name = 1)
>>> table2
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> table2 = pd.read_excel("gogo.xlsx", sheet_name = "feuille 2")
>>> table2
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
Récupérer les feuilles 0 et 1 (on obtient un dictionnaire de feuilles):
>>> tables = pd.read_excel("gogo.xlsx", sheet_name = [0,1])
>>> tables
OrderedDict([(0, nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1), (1, nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert)])
Récupérer toutes les feuilles (on obtient un dicitionnaire de feuilles):
>>> tables = pd.read_excel("gogo.xlsx", sheet_name = None)
>>> tables
OrderedDict([('feuille 1', nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1), ('feuille 2', nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert)])
>>> tables.keys()
odict_keys(['feuille 1', 'feuille 2'])
>>> tables["feuille 1"]
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
>>> tables["feuille 2"]
nom prenom
0 Diatta Robert
1 Sane Jean
2 Diouf Albert
>>> df
nom mail level
0 Admi admi@gmail.com 2
1 Diatta robert@hotmail.com 1
2 Sane jean@hotmail.fr 1
>>> df.to_json()
'{"nom":{"0":"Admi","1":"Diatta","2":"Sane"},"mail":{"0":"admi@gmail.com","1":"robert@hotmail.com","2":"jean@hotmail.fr"},"level":{"0":2,"1":1,"2":1}}'
>>> df.to_json("myjson.js") # le json est enregistré dans le fichier myjson.js
>>> pd.set_option('display.max_colwidth', -1) # c'est pour ne pas couper les phrases trops longues
>>> html = df.to_html()
Par conventions, on les importe toujours de la manière suivante:
import numpy as np
import matplotlib.pyplot as plt
On peut utiliser des listes "classiques":
x = [0,1,2,3,4]
y = [23,31,45,78]
Les deux listes doivent évidemment être de même longueur !
On peut aussi utiliser des array à une dimension avec numpy:
x = np.arange(10)
y = 2*x + 5
plt.close()
plt.plot(x, y, "-*b", markersize=8, label="nom de la courbe")
Vous disposez alors d’un objet "plt" qui vous permet d’agir sur votre plot (y compris dans le shell après l’affichage du plot)
De nombreuses options sont possibles pour les "marker":
Options de ligne: "-" continue, "--" tirets
Options de marker: *, +, o, ^
Options de couleur : b: bleu, k: noir, r: rouge, g: vert...
Pour faire un nuage de points (donc sans ligne), n’utilisez pas d’option de ligne, exemple: "+r"
plt.xlabel("titre des abscisses", fontsize=8)
plt.ylabel("titre des ordonnées", fontsize=8)
plt.legend(loc='best', fontsize=8)
L’argument loc="best" permet de placer automatiquement la légende au meilleur endroit (c’est à dire là où elle ne va pas chevaucher une courbe)
plt.title("titre du graphique", fontsize=8)
plt.text(2,8,"j'ecris ici si je veux !", fontsize=8)
Le texte serra ajouté aux coordonnées x=2 , y=8
plt.xlim(0,10)
plt.ylim(0,25)
Ou équivalent :
plt.axis([0,10,0,25])
plt.show()
Même après avoir affiché le graphique, l’objet plt est toujours actif, il est encore possible de modifier le graphique (y compris dans le shell), pour voir les modifications apportées, il faut ré afficher le graphique plt.show()
plt.savefig("mon_graphique.png")
Le format par défaut est .png, mais il est possible de choisir un autre format de sauvegarde:
plt.savefig("mon_graphique.pdf", format = "pdf")
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(10)
y = 2*x + 5
plt.close()
plt.plot(x, y, "-*b", markersize=8, label="nom de la courbe")
plt.xlabel("titre des abscisses", fontsize=8)
plt.ylabel("titre des ordonnées", fontsize=8)
plt.legend(loc='best', fontsize=8)
plt.title("titre du graphique", fontsize=8)
plt.text(2,8,"j'ecris ici si je veux !", fontsize=8)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(10)
plt.close()
plt.plot(x, 2*x, "-*b", markersize=8, label="nom de la courbe 1")
plt.plot(x, 2*x + 5, "-ok", markersize=8, label="nom de la courbe 2")
plt.plot(x, x**2, "-+r", markersize=8, label="nom de la courbe 3")
plt.xlabel("titre des abscisses", fontsize=8)
plt.ylabel("titre des ordonnées", fontsize=8)
plt.legend(loc='best', fontsize=8)
plt.title("titre du graphique", fontsize=8)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(10)
y1 = 2*x
y2 = x**2
y3 = x**3
y4 = 3*x + 6
y5 = x**0.5
plt.close()
plt.figure(1)
g1 = plt.subplot(221)
plt.plot(x, y1, '-^k', label='courbe1', markersize=5)
plt.title('titre 1', fontsize=10)
plt.xlabel("X",fontsize=10)
plt.ylabel("Y1",fontsize=10)
plt.legend(fontsize=10)
g2 = plt.subplot(222)
plt.plot(x, y2, '-*b', label='courbe2', markersize=5)
plt.title('titre 2', fontsize=10)
plt.xlabel("X",fontsize=10)
plt.ylabel("Y2",fontsize=10)
plt.legend(fontsize=10)
g3 = plt.subplot(223)
plt.plot(x, y3, '--or', label='courbe3', markersize=5)
plt.title('titre 3', fontsize=10)
plt.xlabel("X",fontsize=10)
plt.ylabel("Y3",fontsize=10)
plt.legend(fontsize=10)
g4 = plt.subplot(224)
plt.plot(x, y4, '-+g', label='courbe4', markersize=5)
plt.plot(x, y5, '--^y', label='courbe5', markersize=5)
plt.title('titre 4', fontsize=10)
plt.xlabel("X",fontsize=10)
plt.ylabel("Y4",fontsize=10)
plt.legend(fontsize=10)
plt.tight_layout()
plt.show()
Chaque subplot possède une position exemple 223, ce qui correspond au 3° graphique dans une figure de 2 lignes et 2 colonnes.
Pour faire 2 graphiques superposés, utilisez les positions 211 (2 lignes, 1 colonne, graphique 1) et 212 (2 lignes, 1 colonne, graphique 2)
Pour faire 2 graphiques alignés, utilisez les positions 121 et 122
Après l’affichage, on conserve un accès sur chaque plt.subplot que l’on peut modifier, exemple:
g1.xlim(0,20)
Il faut ensuite re afficher le graphique plt.show() pour voir les modifications.
Si vous êtes un Ayatollah de la console GNU Linux et que vous n’avez pas d’interface graphique (sans dekstop), vous allez générer une belle erreur en tentant de créer un objet plt !
Pour éviter cela, il faut importer matplotlib de la manière suivante:
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
Évidement vous ne pourrez pas faire de plt.show(), mais vous pourrez tout de même sauvegarder votre graphique avec plt.savefig("mon_graphique.png")