Python

La fonction txt2list ci-dessous vous permet d’importer un fichier texte contenant des colonnes de valeurs numériques séparées par une tabulation pour le convertir en une liste de listes (chaque sous-liste étant une colonne). Elle permet d’importer des valeurs générées par un tableur vers un programme écrit en Python, en passant par l’intermédiaire d’un fichier texte via un copier/coller.

• La virgule en tant que séparateur décimal est transformée en point (si le séparateur décimal est déjà un point, pas de problème).
• Une ligne qui contient des lettres (ligne de titre par exemple) sera supprimée.
• Une ligne vide sera également supprimée.
• L’emplacement du fichier (la variable adresse) doit être noté avec des slashs (/), pas des anti-slashs (\). Par exemple :
  C:/Users/eleve/desktop/mon_fichier.txt
  Pour trouver l’emplacement exact de votre fichier, regardez ses propriétés et copier/coller son emplacement, sans oublier de rajouter le nom du fichier ainsi que son extension.

		def txt2list(adresse):
			with open(adresse,'r') as fichier: lignes = fichier.read()
			lignes = lignes.replace(",",'.').replace('\t',',').split('\n')
			lignes = list(filter(lambda x: x!="", lignes))
			lignes = list(filter(lambda x : not any(i.isalpha() for i in x), lignes))
			for i, ligne in enumerate(lignes): lignes[i] = ligne.split(',')
			colonnes = len(lignes[0])
			liste=[]
			for i in range(colonnes): liste.append([])
			for ligne in lignes:
				for i in range(colonnes): liste[i].append(float(ligne[i]))
			return liste
	

Voici le code minimum pour représenter un graphique si on dispose de deux listes de valeurs $*x*$ et $*y*$.

import matplotlib.pyplot as plt
x = []
y = []
plt.plot(x, y, 'bo', ms = 10)
plt.show()

Pour ce qui est de l’apparence de la courbe ou des points (ici, bo – b pour blue, o pour symboliser un point), il y a plein de possibilités. Voici le format le plus basique : il est formé de 2 ou 3 caractères. Un pour la couleur, un pour le style de marqueur et un pour le style de ligne.

• Couleurs : r, g, b, k (black), w (white), c (cyan), m (magenta), y (yellow)
• Marqueur : o, x, +, s (square). Si vous ne mettez rien, il n’y aura aucun marqueur.
• Ligne : - (continue), -- (tirets), : (pointillées). Si vous ne mettez rien, il n’y aura pas de ligne.

Consultez cette page pour en savoir plus.

✋ si vos listes $*x*$ et $*y*$ n’ont pas la même taille, cela va générer une erreur.

Il y a également quelques commandes pour contrôler l’apparence de votre graphique. Elles sont optionnelles. En voici quelques unes :

plt.xlim(min, max)	  # limites axe x
plt.ylim(min, max)	  # limites axe y
plt.title("Titre")	  # titre du graphique
plt.grid(True)	      # quadrillage
plt.axis('equal')	  # repère orthonormé
plt.xlabel('label x') # nommer l’axe x
plt.ylabel('label y') # nommer l’axe y

# pour plus d’options sur l’apparence de votre courbe
plt.plot(x, y, color = 'b', marker='o', linestyle='', ms = 10)

Pour tracer un vecteur qui part du point ($*x_0*$ ; $*y_0*$) et dont les coordonnées sont ($*X*$ ;$*Y*$)

import matplotlib.pyplot as plt
plt.arrow(x0, y0, X, Y, length_includes_head=True, head_width=0.05, color='black')
plt.show()

length_includes_head=True veut dire… je crois que c’est clair, non ? 😊

head_width gère l’épaisseur de la flèche. Faites des essais pour trouver celle qui vous convient.

Pour en savoir plus sur l’objet arrow du sous-module pyplot de matplotlib, vous pouvez consulter cette page.

Pour représenter deux grandeurs $*y_1*$ et $*y_2*$ complètement différentes mais dépendant d’une même abscisse $*x*$. $*y_1*$ correspond à l’axe d’ordonnées de gauche, et $*y_2*$ celui de droite.

import matplotlib.pyplot as plt

fig, axe1 = plt.subplots()

axe1.set_xlabel('label x')
axe1.set_ylabel('label y1', color='b')
# axe1.set_ylim(min, max)
for valeur in axe1.get_yticklabels() :
    valeur.set_color('b') # couleur graduation gauche

axe2 = axe1.twinx()
axe2.set_ylabel('label y2', color='r')
# axe2.set_ylim(min, max)
for valeur in axe2.get_yticklabels():
    valeur.set_color('r') # couleur graduation droite

axe1.plot(x, y1, 'bo', ms=5)
axe2.plot(x, y2, 'ro', ms=5)
# si on veut ajouter y3 connecté à l’axe 2
# axe2.plot(x, y3, 'go', ms=5)
plt.show()

import matplotlib.pyplot as plt

n1 = 10
n2 = 2
n3 = 7
n4 = 3
x=range(4)

# Si vous avez besoin de fixer la taille de l’axe y
axes = plt.gca() # on capture les axes
axes.set_ylim(valeur_min, valeur_max)

plt.bar( 				# graphique barres
    x, 					# abscisses
    [n1, n2, n3, n4],	# ordonnées
    width = 0.5,		# largeur des barres
    color = ['blue', 'green', 'red', 'yellow'] # couleurs des barres, dans l’ordre
)
# Pour légender l’axe des abscisses
plt.xticks(x, ('val 1', 'val 2', 'val 3', 'val 4') )

plt.show()

Une manière assez simple de faire des animations… 😊

L’idée est de faire une boucle qui trace un graphique à chaque fois puis qui met en pause l’affichage. Au début de la boucle, il faut effacer le graphique précédent

		import matplotlib.pyplot as plt
		for i in range(10) :	# animation de 10 images
			plt.cla()			# efface le graphique précédent

			# (ici vous tracez votre graphique)

			plt.pause(0.2) # attend 0.2 seconde puis
						   # affiche le graphique suivant.

		plt.show()
	

import scipy.stats as sst

x = [...]
y = [...]

a,b,r,p,err = sst.linregress(x,y)

a et b sont le coefficient directeur et l’ordonnée à l’origine du modèle affine.
r est le coefficient de détermination (à élever au carré pour avoir le $*R^2*$ d’Excel)

Vous pouvez à present tracer la droite modélisée ($*y_m = ax+b*$) et faire figurer les éléments importants ($*a*$, $*b*$ et $*R^2*$) sur votre graphique en y ajoutant du texte.

ym = [a*i + b for i in x]

text = f"y = {a:.2e}·x + {b:.2e} \n R² = {r**2:.4f}"
# pour les vieilles version de Python (≤ 3.6)
# text = "y = {:.2e}·x + {:.2e} \n R² = {:.4f}".format(a,b,r**2)

plt.plot(x, ym)
plt.text (0.15,0.85, text, transform=plt.gca().transAxes)
# place le coin haut-gauche du texte à 15 % depuis la gauche
# et 85 % depuis le bas