Tracer des graphiques dans une

interface paramétrable Tkinter

Par Denis Hulo

Date de publication : 8 août 2024

Objectif : tracer les graphiques de la loi binomiale et de la loi normale dans une interface
Tkinter afin de montrer leur convergence.

Niveau requis : débutant

Commentez cet article : Commentez

 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

I - Introduction..............................................................................................................................................................3
II - Lois de probabilité..................................................................................................................................................3
II-A - Loi binomiale................................................................................................................................................. 3
II-B - Loi normale................................................................................................................................................... 3
III - Théorème de Moivre-Laplace............................................................................................................................... 3
IV - Implémentation en Python....................................................................................................................................4
IV-A - Fonctions de probabilité.............................................................................................................................. 4
IV-A-1 - Fonction de masse de la loi binomiale............................................................................................... 4
IV-A-2 - Fonction de densité de la loi normale................................................................................................ 5
IV-B - Représentation graphique : intégration du graphique dans une interface Tkinter....................................... 6
IV-C - Module Python...........................................................................................................................................10
V - Conclusion........................................................................................................................................................... 11
VI - Téléchargement.................................................................................................................................................. 11
VII - Remerciements.................................................................................................................................................. 11

-2-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

I - Introduction

Une loi binomiale peut être utilisée pour modéliser des situations simples de succès ou échec, un jeu de pile ou
face par exemple. Le calcul de sa fonction de masse devient rapidement fastidieux lorsque le nombre d'épreuves n
est grand, il est alors possible d'utiliser des approximations par d'autres lois de probabilité telle que la loi normale
et d'utiliser des tables de valeurs.

Après avoir défini ces lois de probabilité, on va ensuite montrer comment les représenter graphiquement en Python
à l'aide de la librairie matplotlib.

Enfin, on va créer une interface paramétrable Tkinter intégrant un graphique afin de montrer la convergence de loi
binomiale vers la loi normale conformément au théorème de Moivre-Laplace.

II - Lois de probabilité

II-A - Loi binomiale

D'après Wikipédia, la loi binomiale est une loi de probabilité discrète décrite par deux paramètres : n le nombre
d'expériences réalisées, et p la probabilité de succès. Pour chaque expérience appelée épreuve de Bernoulli, on
utilise une variable aléatoire qui prend la valeur 1 lors d'un succès et la valeur 0 sinon. La variable aléatoire, somme
de toutes ces variables aléatoires, compte le nombre de succès et suit une loi binomiale. Il est alors possible d'obtenir
la probabilité de k succès dans une répétition de n expériences :

II-B - Loi normale

La loi normale est une loi de probabilité continue qui dépend de deux paramètres : son espérance, un nombre réel
noté μ, et son écart-type, un nombre réel positif noté σ. La densité de probabilité de la loi normale d'espérance μ
et d'écart-type σ est donnée par :

Parmi les lois de probabilité, les lois normales prennent une place particulière grâce au théorème central limite. En
effet, elles correspondent au comportement, sous certaines conditions, d'une suite d'expériences aléatoires similaires
et indépendantes lorsque le nombre d'expériences est très élevé. Grâce à cette propriété, une loi normale permet
d'approcher d'autres lois comme la loi binomiale et ainsi de modéliser de nombreuses études scientifiques comme
des mesures d'erreurs ou des tests statistiques, en utilisant par exemple les tables de la loi normale centrée réduite.

III - Théorème de Moivre-Laplace

D'après Wikipédia, en théorie des probabilités, selon le théorème de Moivre-Laplace, si la variable Xn suit une loi
binomiale d'ordre n et de paramètre p ϵ [0, 1], alors la variable :

-3-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

converge en loi vers une loi normale centrée et réduite N(0, 1). Cette approximation est bonne en général pour np(1
− p) ≥ 10.

IV - Implémentation en Python

IV-A - Fonctions de probabilité

Les fonctions et les objets décrits par la suite sont issus du module [Link].

IV-A-1 - Fonction de masse de la loi binomiale

L'objet binom représente une variable aléatoire discrète suivant une loi binomiale qui est en fait une instance de la
classe rv_discrete avec ses différentes méthodes.

La fonction de masse de la loi binomiale [Link](x, n, p) peut être appelée comme ceci :

x = 10; n = 100; p = 0.5

val = [Link](x, n, p)

Traçons maintenant l'histogramme de la fonction avec la librairie matplotlib :

from [Link] import binom

import [Link] as plt
from math import sqrt

# nombre d'épreuves de Bernoulli

n = 80

# probabilité de succès
p = 0.5

# moyenne μ et écart-type σ de la loi binomiale

μ = n*p
σ = sqrt(n*p*(1-p))

# génère la séquence des x : 0 -> n-1

x = range(n)

# nom et dimension de la figure contenant le graphique

[Link](num="Figure : Loi binomiale", figsize=(8, 5), dpi=80)

# trace l'histogramme correspondant à la série de valeurs

[Link](x, [Link](x,n,p), color="blue")

# limites sur l'axe des x : [μ - 4σ, μ + 4σ]

[Link](μ - 4*σ, μ + 4*σ)

# limite inférieure sur l'axe des y

[Link](0)

[Link]("Histogramme de la loi binomiale B({0}, {1})".format(n,p))

# affiche le graphique
[Link]()

Le code affiche :

-4-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

Histogramme de la loi binomiale

IV-A-2 - Fonction de densité de la loi normale

L'objet norm représente une variable aléatoire continue suivant une loi normale qui est en fait une instance de la
classe rv_continuous avec ses différentes méthodes.

La fonction de densité de la loi normale [Link](x, loc=μ, scale=σ) d'espérance μ et d'écart-type σ peut être invoquée
comme ceci :

x = 10; μ = 50; σ = 5

val = [Link](x, loc=μ, scale=σ)

Traçons maintenant la courbe représentative de la fonction :

from [Link] import norm

import [Link] as plt
from math import sqrt

# nombre d'épreuves de Bernoulli

n = 80

# probabilité de succès
p = 0.5

# moyenne μ et écart-type σ de la loi normale

μ = n*p
σ = sqrt(n*p*(1-p))

# génère la séquence des x : 0 -> n-1

x = range(n)

# nom et dimension de la figure contenant le graphique

[Link](num="Figure : Loi normale", figsize=(8, 5), dpi=80)

-5-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

# trace la courbe correspondant à la série de valeurs

[Link](x, [Link](x,μ,σ), color="red")

# limites sur l'axe des x : [μ - 4σ, μ + 4σ]

[Link](μ - 4*σ, μ + 4*σ)

# limite inférieure sur l'axe des y

[Link](0)

[Link]("Courbe représentative de la loi normale N({0}, {1})".format(round(μ,2),round(σ**2,2)))

# affiche le graphique
[Link]()

Le code affiche :

Courbe de Gauss

IV-B - Représentation graphique : intégration du graphique dans une interface Tkinter

Nous allons maintenant créer une interface paramétrable avec Tkinter sur laquelle nous allons pouvoir choisir le
nombre d'expériences n et la probabilité de succès p de la loi binomiale, puis tracer le graphique des deux fonctions.

La classe [Link] permet de construire un widget Tk de niveau supérieur, qui est généralement la fenêtre principale
d'une application, et initialise un interpréteur Tcl pour ce widget. Chaque instance a son propre interpréteur Tcl associé.

Notre interface est ainsi construite à l'aide d'une classe fille InterfaceGraphique qui hérite de la classe mère [Link].
On peut alors utiliser les attributs et méthodes de cette classe mère :

-6-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

Héritage

Au moment de créer l'interface Tkinter, c'est-à-dire quand la classe InterfaceGraphique(Tk) est instanciée, on met à
jour les zones de texte, puis on trace les graphiques des deux fonctions :

from tkinter import *

from [Link] import Figure
from [Link].backend_tkagg import FigureCanvasTkAgg
from math import sqrt

class InterfaceGraphique(Tk):

def __init__(self, n, p, pmf, pdf):

# instantiation de la classe parente

Tk.__init__(self)

# conteneur vertical occupant tout le formulaire et destiné à contenir le widget à canvas

verticalPane = PanedWindow( self, orient=VERTICAL )

# conteneur horizontal placé en haut du formulaire pour les différents contrôles du

formulaire
horizontalPane = PanedWindow( verticalPane, orient=HORIZONTAL )

# création des labels et des zones de texte

lblNbreEpreuves = Label( horizontalPane, text = "Nombre d'épreuves (n) :")
[Link]= Text(horizontalPane, height = 1, width = 8)

lblProbaSucces = Label( horizontalPane, text = "Proba de succès (p) :")

[Link]= Text(horizontalPane, height = 1, width = 8)

lblMoyenne = Label( horizontalPane, text = "Moyenne (μ) :")

[Link]= Text(horizontalPane, height = 1, width = 8, bg="lightgray")

-7-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

lblEcartType = Label( horizontalPane, text = "Ecart-type (σ) :")

[Link] = Text(horizontalPane, height = 1, width = 8, bg="lightgray")

# création du bouton de commande pour générer le graphique sur l'interface Tkinter

btnTracer=Button( horizontalPane, text="Tracer", command=[Link],
width = 10)

# ajout des contrôles au conteneur horizontal

[Link]( lblNbreEpreuves )
[Link]( [Link] )

[Link]( lblProbaSucces )
[Link]( [Link] )

[Link]( lblMoyenne )
[Link]( [Link] )

[Link]( lblEcartType )
[Link]( [Link] )

[Link]( btnTracer )

# ajout du conteneur horizontal

[Link]( horizontalPane )
[Link](expand=True, fill='both')

# ajout de l'objet au conteneur vertical

[Link](expand=True, fill='both')

# saisie des valeurs par défaut dans les zones de texte

[Link](END,n)
[Link](END,p)

# moyenne μ et écart-type σ de la loi binomiale et de la normale

μ = n*p
σ = [Link](n*p*(1-p))

# mise à jour des zones de texte correspondantes

[Link](END,round(μ,2))
[Link](END,round(σ,2))

[Link] = pmf
[Link] = pdf

# trace le graphique
[Link](n, p, μ, σ)

def tracer(self, n, p, μ, σ, new_graph=False):

# méthode permettant de tracer les graphiques sur l'interface

# génère la séquence des x : 0 -> n-1

x = range(n)

# on crée la figure du graphique pour les 2 séries de valeurs

fig = Figure(figsize=(8, 5), dpi=96)
plt = fig.add_subplot(111)

# trace l'histogramme et la courbe correspondant aux 2 séries de valeurs

[Link](x, [Link](x,n,p), color="blue", label = "B({0}, {1})".format(n,p))
[Link](x, [Link](x,μ,σ), color="red", label = "N({0},
{1})".format(round(μ,2),round(σ**2,2)))

# limites sur l'axe des x : [μ - 4σ, μ + 4σ]

plt.set_xlim(μ - 4*σ, μ + 4*σ)

# limite inférieure sur l'axe des y

plt.set_ylim(0)

plt.set_title("Représentation graphique de la loi binomiale et de la loi normale")

-8-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

[Link]()

if new_graph:
[Link].get_tk_widget().pack_forget()

[Link] = FigureCanvasTkAgg(fig, master=self)

[Link].get_tk_widget().pack()

Un bouton de commande btnTracerClicked permet ensuite de tracer le graphique en fonction des choix de paramètres
n et p :

class InterfaceGraphique(Tk):

...

def btnTracerClicked(self):
# méthode qui s'exécute quand on clique sur le bouton de commande btnTracer

# copie du contenu des zones de texte dans des variables

n = int([Link]("1.0",'end-1c'))
p = float([Link]("1.0",'end-1c'))

# moyenne μ et écart-type σ de la loi binomiale et de la normale

μ = n*p
σ = [Link](n*p*(1-p))

# mise à jour des zones de texte correspondantes

[Link]("1.0",'end-1c')
[Link](END,round(μ,2))

[Link]("1.0",'end-1c')
[Link](END,round(σ,2))

# trace le graphique
[Link](n,p,μ,σ,True)

Testons maintenant notre interface graphique :

from [Link] import binom, norm

from interface_graphique import InterfaceGraphique

# nombre d'épreuves de Bernoulli

n = 80

# probabilité de succès
p = 0.5

# création de l'objet InterfaceGraphique avec les paramètres : n, p, [Link], [Link]

InterfaceGraphique = InterfaceGraphique(n, p, [Link], [Link])

# ajout d'un titre à la fenêtre Tkinter

interface_graphique.title("Interface graphique avec Tkinter")

# centre la fenêtre
[Link]('tk::PlaceWindow . center')

[Link]()

Le code affiche :

-9-
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

Interface Tkinter

Le graphique montre bien que la valeur en x de la fonction de densité de la loi normale

représente une bonne approximation de la valeur en x de la fonction de masse de la loi
binomiale pour n=80 et p=0.5.

IV-C - Module Python

On donne pour finir le code complet du module présent dans le fichier joint dossier_test.zip :

from [Link] import binom, norm

from math import sqrt
import [Link] as plt
from interface_graphique import InterfaceGraphique

print("I. Représentation graphique de la loi binomiale..\n")

# nombre d'épreuves de Bernoulli

n = 80

# probabilité de succès
p = 0.5

# moyenne μ et écart-type σ de la loi binomiale et de la normale

μ = n*p
σ = sqrt(n*p*(1-p))

# génère la séquence des x : 0 -> n-1

x = range(n)

# nom et dimension de la figure contenant le graphique

[Link](num="Figure : Loi binomiale", figsize=(8, 5), dpi=80)

# trace l'histogramme correspondant à la série de valeurs

[Link](x, [Link](x,n,p), color="teal")

# limites sur l'axe des x : [μ - 4σ, μ + 4σ]

- 10 -
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

[Link](μ - 4*σ, μ + 4*σ)

# limite inférieure sur l'axe des y

[Link](0)

[Link]("Histogramme de la loi binomiale B({0}, {1})".format(n,p))

# affiche le graphique
[Link]()

print("II. Représentation graphique de la loi normale..\n")

# nom et dimension de la figure contenant le graphique

[Link](num="Figure : Loi normale", figsize=(8, 5), dpi=80)

# trace la courbe correspondant à la série de valeurs

[Link](x, [Link](x,μ,σ), color="red")

# limites sur l'axe des x : [μ - 4σ, μ + 4σ]

[Link](μ - 4*σ, μ + 4*σ)

# limite inférieure sur l'axe des y

[Link](0)

[Link]("Courbe représentative de la loi normale N({0}, {1})".format(round(μ,2),round(σ**2,2)))

# affiche le graphique
[Link]()

print("III. Interface Tkinter : représentation graphique de la loi binomiale et de la loi

normale..")

# création de l'objet InterfaceGraphique avec les paramètres : n, p, [Link], [Link]

interface_graphique = InterfaceGraphique(n, p, [Link], [Link])

# ajout d'un titre à la fenêtre Tkinter

interface_graphique.title("Interface graphique avec Tkinter")

# centre la fenêtre
interface_graphique.eval('tk::PlaceWindow . center')

interface_graphique.mainloop()

V - Conclusion

Après avoir défini la loi binomiale et la loi normale, on a donc présenté le théorème de Moivre-Laplace comme un
cas particulier du théorème central limite.

On a pu ensuite montrer comment représenter graphiquement ces lois à l'aide de la librairie matplotlib, et comment
tracer leur graphique dans une interface Tkinter afin de vérifier que la loi binomiale converge bien vers la loi normale
quand n augmente.

VI - Téléchargement

Le dossier de test :

• interface_graphique.py : module contenant la classe InterfaceGraphique ;

• representation_graphique.py : module principal.

VII - Remerciements

Je tiens à remercier Malick pour le suivi de cet article, ainsi que f-leb pour sa relecture.

- 11 -
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Tracer des graphiques dans une interface paramétrable Tkinter par Denis Hulo

Sources

• [Link]
• [Link]
• [Link]
• [Link]
• [Link]
• [Link]
• [Link]

- 12 -
Copyright ® 2024 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse
de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]