loi_binomiale.py

import random, math
import tkinter

# Paramètres de la loi binomiale:
n = 100
p = 0.2

# Une série correspond à n tirages.
nb_series = 1000

# Formules et notations:
esperance = n*p
variance = n*p*(1-p)
ecart_type = math.sqrt(variance)

# Mise en place de la fenêtre graphique:
w, h = 600, 400
root = tkinter.Tk()
root.title('Lien loi binomiale - loi normale')
canvas = tkinter.Canvas(root, width=w, height=h)
canvas.pack()

def to_canvas(x1, y1, x2, y2, offset):
    # in canvas, y=0 is at the top
    return (x1 * coef_x + w/2 + offset - 2, h - y1 * coef_y,
            x2 * coef_x + w/2 + offset + 2, h - y2 * coef_y)

def barre(x, y, color, offset):
    if not y:
        return
    x1, x2 = x, x
    y1, y2 = 0, y
    canvas.create_rectangle(to_canvas(x1, y1, x2, y2, offset),
                            width=0, fill=color)

def fact(n):
    if n:
        return n*fact(n-1)
    else:
        return 1

def nice_exit(event=None):
    root.destroy()
    exit()

root.bind('q', nice_exit)

# Tirages:
decompte_succes = [0] * (n + 1)
for serie in range(nb_series):
    nb_succes = 0
    for tirage in range(n):
        if random.random() <= p:
            nb_succes = nb_succes + 1
    decompte_succes[nb_succes] = decompte_succes[nb_succes] + 1
coef_x = int(10000000000/n**4)
coef_y = int(20/(max(decompte_succes)/nb_series))

# Tracé:
for nb_succes in range(n + 1):
    # Centrage et réduction:
    t = (nb_succes - esperance)/ecart_type
    freq = decompte_succes[nb_succes]/nb_series
    # Correction de la fréquence pour garder une aire totale de 1:
    freq_corrigee = freq * ecart_type
    barre(t, freq_corrigee, 'red', 0)
    # Loi binomiale:
    proba_theorique = fact(n)/(fact(nb_succes)*fact(n - nb_succes))*(p**(nb_succes))*((1-p)**(n - nb_succes))
    proba_corrigee = proba_theorique * ecart_type
    barre(t, proba_corrigee, 'green', 4)
    # Densité de Laplace-Gauss:
    phi_t = (1/math.sqrt(2*math.pi))*(2.718**(-(t**2)/2))
    barre(t, phi_t, 'blue', 8)

root.mainloop()