Python interface graphique et boucle

Fermé
-
Bonjour,

J'aimerai vous solliciter pour cet exercice vu mon niveau de débutant.

L'essentiel de cet exercice vise à la représentation graphique d'un modèle d'évolution de population selon différents scénarios.
Pierre François Verhulst a proposé vers 1840 un modèle d'évolution de population
basé sur la suite logistique.
Le modèle peut être décrit par une formule de récurrence :

v=pt+((k-pt)/k)*r*p

Où pt et pt+1 la population aux temps t et t+1.
K la capacité maximale de l'écosystème
r un coefficient représentant le taux de reproduction de l'espèce
Le but de l'exercice est d'écrire un programme python qui calcule la population en
fonction du temps. Le programme doit demander à l'utilisateur les valeurs de la population initiale p0, de la capacité maximale de l'écosystème K et du taux de reproduction r, ainsi que le nombre de pas pour lesquels l'utilisateur souhaite effectuer le calcul. Les valeurs calculées des couples (temps, population) doivent être sauvegardées dans des variables, enregistrées dans un fichier et affichées.

Première étape
Une interface graphique doit permettre d'afficher l'évolution de la population en
fonction du temps (sous forme de points, ou de ligne). Le programme doit calculer les étendues des valeurs à afficher dans les deux axes, puis effectuer une mise à l'échelle en fonction de la taille du canvas créé et enfin afficher les points correspondant aux différents couples (temps, population) calculés. Une amélioration de l'interface consiste à prévoir des cases à remplir où l'utilisateur renseignera les paramètres et un bouton d'exécution des calculs. Testez votre programme avec r=1 ; p0=100 ; K=500 et calculez jusque t=500.

Deuxième étape
Des exécutions du programme doivent être effectuées avec différents paramètres pour vérifier le bon fonctionnement du programme à l'aide des points suivants :
1) Influence de la valeur de population initiale (différentes valeurs de p0 pour les
mêmes K et r)
2) Influence de la capacité maximale K (différents K pour les mêmes p0 et r)
3) Influence du taux de reproduction, notamment ces 5 valeurs de r : -0,5 ; 0,5 ;
1,8 ; 2,3 ; 2,8
Pour chacun de ces trois cas, il faudra que le programme affiche superposées les
courbes de différents p0 , K et r. À vous d'organiser l'interface qui permet d'effectuer cet affichage de manière conviviale.


Solution:

from tkinter import *


mafen1=Tk()
mafen1.title("capacité de reprodcution")


saisie_ut=StringVar()
resultat1=StringVar()

def lire1():
saisie=case_entree.get()
global k
try:
nombre=float(saisie)
k=nombre*1
resultat1.set(str(k))
mafen1.destroy()



except:
if("," in saisie):
resultat1.set(". comme sépar.decimal")
else:
resultat1.set("Entrez un nombre")

return


def clavier1(touche):

lire1()
return


case_entree=Entry(mafen1,textvariable=saisie_ut)
case_entree.bind
case_entree.pack()

case_sortie=Label(mafen1,textvariable=resultat1)
case_sortie.pack()

valider=Button(mafen1,text="sauvegarder",command=lire1)
valider.pack()

mafen1.mainloop()

# deuxième variable population intiale

mafen2=Tk()
mafen2.title("population initiale")


population_ut=StringVar()
resultat2=StringVar()

def lire2():
population=case_entree.get()
global p
try:
nombre=float(population)
p=nombre
resultat2.set(str(p))
resultat2.set(str(p))
mafen2.destroy()


except:
if("," in population):
resultat2.set(". comme sépar.decimal")
else:
resultat2.set("Entrez un nombre")


return

def clavier2(touche):
lire2()
return


case_entree=Entry(mafen2,textvariable=population_ut)
case_entree.bind

case_entree.pack()


case_sortie=Label(mafen2,textvariable=resultat2)
case_sortie.pack()


valider=Button(mafen2,text="sauvegarder",command=lire2)
valider.pack()

mafen2.mainloop()


# troisième variable taux de reproduction

mafen3=Tk()
mafen3.title("taux de reproduction")


reproduction_ut=StringVar()
resultat3=StringVar()

def lire3():
reproduction=case_entree.get()
global r
try:
nombre=float(reproduction)
r=nombre
resultat3.set(str(r))
mafen3.destroy()

except:
if("," in reproduction):
resultat3.set(". comme sépar.decimal")
else:
resultat3.set("Entrez un nombre")

return


def clavier3(touche):
lire3()
return

case_entree=Entry(mafen3,textvariable=reproduction_ut)
case_entree.bind
case_entree.pack()

case_sortie=Label(mafen3,textvariable=resultat3)
case_sortie.pack()

valider=Button(mafen3,text="sauvegarder",command=lire3)
valider.pack()


mafen3.mainloop()



# quatrième variable caractérisant le pas

mafen4=Tk()
mafen4.title("le pas")

lepas_ut=StringVar()
resultat4=StringVar()

def lire4():

lepas=case_entree.get()
global lp
try:
nombre=int(lepas)
lp=nombre+1
resultat4.set(str(lp))
resultat4.set(str(lp))
mafen4.destroy()

except:
if("," in lepas):
resultat4.set(". comme sépar.decimal")
else:
resultat4.set("Entrez un nombre")

return


def clavier4(touche):
lire4()
return


case_entree=Entry(mafen4,textvariable=lepas_ut)
case_entree.bind

case_entree.pack()


case_sortie=Label(mafen4,textvariable=resultat4)
case_sortie.pack()


valider=Button(mafen4,text="sauvegarder",command=lire4)
valider.pack()


mafen4.mainloop()

# quatrième variable permettant de calculer

mafen5=Tk()
mafen5.title("operation")

operation_ut=StringVar()
resultat5=StringVar()

def calcul():
operation=case_entree.get()
try:

v=p+((k-p)/k)*r*p
resultat5.set(str(v))

except:
if("," in operation):
resultat5.set(". comme sépar.decimal")
else:
resultat5.set("Entrez un nombre")

return


def clavier5(touche):
lire5()
return

case_entree=Entry(mafen5,textvariable=operation_ut)
case_entree.bind

case_entree.pack()

case_sortie=Label(mafen5,textvariable=resultat5)
case_sortie.pack()

valider=Button(mafen5,text="Envoyer",command=calcul)
valider.pack()

mafen5.mainloop()

Pour mieux expliquer ce je fais, j'ai créé des fenêtres afin de pouvoir entrer les valeurs permettant de calculer mon modèle. Cependant, j'aurai souhaité plutôt mettre en place des cases en lieu et place des fenêtres pour n'avoir qu'une fenêtre en fin de compte.

1) Donc ma première question c'est comment regrouper dans une seule fenêtre les cases me permettant de calculer mon modèle?

2) ensuite pour tester mon programme, il m'a été demandé de tester les valeurs suivantes:
po=100
k=500
r=1
avec t allant jusqu'à 500

==> pour cette question, il me semble qu'il me faudra mettre en place une boucle, ce que je ne parviens pas à faire afin d'avoir les valeurs de population de 1 à 500 en vue d'obtenir la courbe.

En espérant avoir été plus précis, je vous remercie d'avoir pris le temps de vous intéresser à mon problème.