Python

[Wissam]

Bon, comme beaucoup de monde j'essaie de me mettre à python.

J'ai regardé les capsules vidéo de David Latouche sur le site PhyChim (académie de versailles) qui sont très bien (d'ailleurs il y en a aussi sur Arduino, que je vous conseil) et maintenant je tente de faire quelques petits scripts pour m'entrainer.

Ce sujet a pour vocation de proposer des scripts, plus ou moins aboutis en précisant leurs intérêt pour un prof, pour son cours, pour un élève... et éventuellement de demander de l'aide si il ne fonctionne pas )

[Wissam]

J'essaie d'écrire un script permettant de tracer un graphique à l'aide de valeur expérimentales, la régression linéaire qui va avec et de faire apparaitre dans une fenêtre l'équation de la droite

L'intérêt, outre l'entrainement est d'avoir un script permettant de tracer rapidement un graphique expérimental et de l'exporter en pdf pour le distribuer aux élèves, le mettre dans une présentation etc...

J'utilise les bibliothèques matplotlib et numpy pour le tracer de la courbe et la modélisation.

Mais je ne parviens pas à afficher de manière satisfaisante l'équation de la droite (dans la légende par exemple c'est vraiment moche).

J'importe donc le module (ou bibliothèque, je ne suis pas certains de saisir la différence) Tkinter qui permet de créer des interfaces graphique, notamment des fenêtre.

Le bout de code que j'ajoute fonctionne quand je l'utilise tout seul: j'obtient une fenêtre avec écris ce que je veux. Mais dans le scripts ci-dessous, je n'ai pas la fenêtre qui s'affiche...

Si quelqu'un a une idée...

Voici le script en question:


import matplotlib.pyplot as plt
import numpy as np
from tkinter import *


# Données expérimentales

x = [0.5, 1, 2, 3, 4, 5]
y = [0.080, 0.14, 0.29, 0.42, 0.57, 0.73]
p = np.polyfit(x,y,1)
f = np.poly1d(p)

# Tracer de la courbe
print (p)
print (f)

listeX= []
listeY = []
for i in np.arange(1, 7, 0.05):
listeX.append(i)
listeY.append(f(i))

plt.plot(listeX, listeY, label="modelisation")
plt.plot(x, y, "go--", label='Courbe experimentale')
plt.legend()
plt.xlabel("c (mg/L)")
plt.ylabel("A_660")
plt.show()

# Création de la fenêtre principale (main window)
Mafenetre = Tk()

# Création d'un widget Label (texte 'Bonjour tout le monde !')
Label1 = Label(Mafenetre,text="Hello World!")

# Positionnement du widget avec la méthode pack()
Label1.pack()


# Lancement du gestionnaire d'événements
Mafenetre.mainloop()


PS: oui, on pourrait le faire avec Excel mais c'est quand même plus cool avec Python.

[philippe]

voilà une version qui permet de tracer la caractéristique d'une résistance , si ça peut t'aider.

import matplotlib.pyplot as plt
import numpy as np

U=[0,1,2,3,4,5]
I=[0,0.002,0.004,0.006,0.008,0.01]
U=np.array(U)
I=np.array(I)
plt.xlabel("I (A)")
plt.ylabel("U (V)")
plt.title("caractéristique du dipôle")
plt.scatter(I,U,marker='+',s=50)
modele=np.polyfit(I,U,1)
plt.plot(I,modele[0]*I+modele[1],color='red')
print(modele)
plt.show()

[fredok]

Bonjour, cela peut peut-être vous aider

Code: Tout sélectionner

import matplotlib.pyplot as plt
import numpy as np
import traceback

def f_plot(x,y,titre='Courbe sans titre!!!',xlabel='pas de nom',ylabel='pas de nom',ortho='auto',style='xkcd',label=None):
    """
    fonction qui retourne un graphique
    Arguments:
        * x (série numpy): série absisse
        * y (série numpy ou list de série numpy): séries des ordonnées
        * titre (str): titre du tracé - Defaut 'Courbe sans titre!!!'
        * xlabel (str): nom de l'axe des absisses - Defaut 'pas de nom'
        * ylabel (str): nom de l'axe des ordonnées - Defaut 'pas de nom'
        * ortho (str): 'ortho' pour que le graphique soit orthonormal (utile pour tracer des trajectoire)
        * style: 'XKCD' pour un style xkcd - défaut = ''
        * label (list(str)) : est une liste des labels des ordonnées y - Attention, il doit y avoir autant d'éléments dans label que d'ordonnées - défaut = None
   
    Exemple : Soient y1, y2 et t des séries numpy de taille identique, pour tracer y1=f(t) et y2=f(t)
            > plot(t,y=[y1,y2],titre='y1=f(t) et y2=f(t)',label=['y1=f(t)','y2=f(t)'])
    """
    if isinstance(y,np.ndarray):
        y=[y]
    if style.upper()=='XKCD':
        plt.xkcd()
    else:
        plt.rcdefaults()
    for i,elem in enumerate(y):
        lab = f"courbe n°{i} - {label[i]}" if isinstance(label,list) else f"courbe n°{i}"
        plt.plot(x,elem,label=lab)
    plt.title(titre)
    if ortho == 'ortho':
        plt.axis('equal')
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)
    plt.grid(True, lw=0.5, zorder=0)
    plt.legend()
    return plt.show()

def regression(x,y,ym='--',degre=1,plot=False,**d):
    """
    Permet de modéliser x en fonction de y par un polynome de degré 'degre'
    Arguments:
     x,y (série numpy)
     degre = 0 ou 1 ou 2
     plot (bool) : True => Une courbe est affichée - Défaut = False
     **d (dict) : dictionnaires des arguments de f_plot()
    """
    (_,_,_,text)=traceback.extract_stack()[-2]
    a = 'regression('
    def_name = text[text.find(a)+len(a):].split(',')
    x_name,y_name = def_name[0],def_name[1]
    if degre != 1 and degre !=2 and degre != 0:
        degre = 1
    resultat = np.polyfit(x,y,degre)
    p=np.poly1d(resultat,variable=x_name)
    print(f'meilleur modèle de degré {degre} entre {x_name} et {y_name} est :')
    print(y_name+'=')
    print(p)
    if plot:
        ym = np.poly1d(resultat)(x)
        f_plot(x=x,y=[y,ym],**d)

C = [0.5, 1, 2, 3, 4, 5]
A = [0.080, 0.14, 0.29, 0.42, 0.57, 0.73]
regression(C,A,degre=1,plot=True,xlabel = 'c mg/L',ylabel = 'A',style = 'xkcd',label=["Exp","Modélisation"])



Avec f_plot() pour tracer des courbes (avec matplotlib) car le pense qu'il n'est pas utile à l'élève de taper

Code: Tout sélectionner

plt.plot(listeX, listeY, label="modelisation")
plt.plot(x, y, "go--", label='Courbe experimentale')
plt.legend()
plt.xlabel("c (mg/L)")
plt.ylabel("A_660")
plt.show()


mais plutôt de se demander ce que l'on doit mettre en x, en y, le titre, le nom des axes etc....
Et regression() pour modéliser
taper help(f_plot) .. pour l'aide

[fredok]

Bonjour,
en rajoutant la ligne 'return np.poly1d(resultat)(x)' à la fin de la fonction regression, le programme peut s'écrire

Code: Tout sélectionner

.......
C = [0.5, 1, 2, 3, 4, 5]
A = [0.080, 0.14, 0.29, 0.42, 0.57, 0.73]
A_mod = regression(C,A,degre=1)
f_plot(x=C,y=[A,A_mod],xlabel='C mg/L',ylabel='A',label=['A exp = f(C)','A modélisé = f(C)'])



[Wissam]

Philippe,

je ne suis pas certains de comprendre l'intérêt d'utiliser le type array au lieu d'une liste.

Sinon j'ai essayé de tracer le graphique en affichant la fenêtre avec l'équation en utilisant ton script, mais le problème est le même : je vois le graphique, mais pas de fenêtre avec l'équation de la modélisation ...

[Wissam]

En pièce jointe l'activité que je fais faire cette année à mes élèves de seconde et de première pour les familiariser avec python et l'usage qu'on en fait en physique.

Le but est qu'ils manipulent un peu le script (également en pièce jointe) que je leur ferai utiliser à chaque fois qu'il faudra tracer un graphique en TP.

La notice qui va avec est très largement inspirée de celle du Magnard de seconde.