Physique & Chimie au lycée

Cours de physique-chimie pour les classes de 1ère et Terminale

Sommaire
SP-1 ES-1
SP-T ES-T
3e SNT
Divers Annales

Python

Vous trouverez dans cette rubrique quelques tutos sur l’usage de Python dans le cadre de la SPC.

Bases de Python
Python en ligne sur repl.it.
La création d’un compte est nécessaire pour pouvoir ex­ploi­ter toutes les fonction­nalités (notamment la création de graphiques via Matplolit).
Noms de couleurs pour de beaux graphiques.

Importer des colonnes de valeurs

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
	

Graphique simple

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)

Vecteur

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.

Graphique avec deux axes d’ordonnées

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()

Graphique en barres verticales


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()

Graphique animé

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()
	

Droite de tendance

Vous voulez modéliser une série de points de coordonnées $*x*$ et $*y*$ par une fonction affine. Python peut le faire (bien sûr).
L’outil le plus efficace pour ce faire est la fonction linregress() du module scipy.stats.

scipy.stats n’est pas nécessairement installé par défaut. Tout depend de votre distribution de Python.
Si vous ne l’avez pas, voir les conseils sur scipy.org.

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