Retrouvez toutes les fiches de cours téléchargeables au format pdf en cliquant sur les liens suivants :

• Fiche n° 1 : Algorithme en langage naturel
• Fiche n° 2 : Les variables
• Fiche n° 2 bis : Les listes
• Fiche n° 3 : Les fonctions
• Fiche n° 3 bis : Mathématiques et programmation
• Fiche n° 4 : Les instructions conditionnelles
• Fiche n° 5 : Les boucles bornées
• Fiche n° 6 : Les boucles non bornées

1

Coefficients binomiaux ★☆☆

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

On souhaite écrire une fonction qui renvoie les coefficients binomiaux $\left(\genfrac{}{}{0ex}{}{n}{k}\right)$. Plusieurs pistes sont envisageables, mais on choisit l’utilisation de la formule $\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\frac{n!}{k!(n-k)!}$ pour cet exercice.

1. Compléter la fonction factorielle pour qu’elle renvoie $n!$, pour tout entier naturel $n$.
2. Compléter la fonction coefficient qui renvoie $\left(\genfrac{}{}{0ex}{}{n}{k}\right)$ lorsque $n$ est un entier naturel et $k$ un entier naturel inférieur ou égal à $n$.

def factorielle(n):
  fac = ...
  for i in range(..., ...):
    fac = fac*i
  return out
 
def coefficient(n, k):
  return ...//...

2

Coefficients binomiaux ★☆☆

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

Comme l’exercice précédent, on souhaite écrire une fonction qui renvoie les coefficients binomiaux $\left(\genfrac{}{}{0ex}{}{n}{k}\right)$ en utilisant la formule $\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\frac{n!}{k!(n-k)!}$.
Voici une version un peu différente des deux fonctions de l’exercice précédent qui permet de calculer les coefficients binomiaux.
Expliquer en quoi cette version est plus efficace que celle de l’exercice précédent.
.

def arrangement(n, k):
  out = 1
  for i in range(n, n-k, -1):
    out = out*i
  return out
 
def factorielle(n):
  return arrangement(n, n)
 
def coefficient(n, k):
  return arrangement(n, k)//(factorielle(k))

3

Loi binomiale ★★★

→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 4 : Les instructions conditionnelles

Soient $n\in \mathbb{N}$ et $p\in [0;1]$. On cherche à déterminer la valeur de $k$ pour laquelle $\text{P}(\text{X}=k)$ est maximale lorsque $\text{X}$ est une variable aléatoire suivant une loi binomiale de paramètre $n$ et $p$.

1. Compléter la fonction factorielle ci-après qui prend en paramètre un nombre entier positif et qui renvoie sa factorielle.

2. Compléter la fonction probabilite ci-après qui prend en paramètres $n$ et $p$ et renvoie la probabilité $\text{P}(\text{X}=k)$.

3. Compléter la fonction maximum qui prend en paramètre une liste et qui renvoie l’indice (c’est-à-dire la position dans la liste) du plus grand élément de la liste.

4. Trouver la valeur de $k$ pour laquelle $\text{P}(\text{X}=k)$ est maximale dans chacun des cas suivants :

• $n=7$ et $p=0,5$ ;
  
• $n=8$ et $p=0,05$ ;
  
• $n=6$ et $p=0,95$.
  

def factorielle(n):
  fac = 1
  for i in range (1, n + 1):
    ...
  return fac

def probabilite(n, p, k):
  return ...

def maximum(liste):
  reponse = 0
  i = 0
  while i < len(liste):
    if ...
      reponse = i
    i = i + 1
  return reponse

proba = [probabilite(7, 0.5, k) for k in range(8)]
print(proba)
print(maximum(proba))

4

Triangle de Pascal ★★★

Écrire un fonction triangle_Pascal prenant en paramètre un entier naturel $n$ et renvoyant les $n+1$ premières lignes du triangle de Pascal sous forme de liste de listes. Ainsi, triangle_Pascal(3) doit renvoyer [[1],[1,1],[1,2,1],[1,3,3,1]].

Indications :

• Il n’est pas obligatoire d’utiliser la fonction factorielle. Le cas échéant, on pourra utiliser la fonction factorielle écrite dans un des exercices précédents ou bien directement celle du module math de Python.
• La fonction triangle_Pascal pourra faire appel à d’autres fonctions si nécessaire.

5

Espérance d’une variable aléatoire ★☆☆

→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 5 : Les boucles bornées

On considère une variable aléatoire $\text{X}$ définie par sa loi de probabilité.


Écrire une fonction esperance prenant en paramètres les deux listes $[x_1,x_2,\dots ,x_n]$ et $[p_1,p_2,\dots ,p_n]$ et renvoyant l’espérance de $\text{X}$.

6

Variance d’une variable aléatoire ★☆☆

→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 5 : Les boucles bornées

On considère une variable aléatoire $\text{X}$ définie par sa loi de probabilité.


1. Énoncer le théorème de König-Huygens.


2. Écrire une fonction variance prenant en paramètres les deux listes $[x_1,x_2,\dots ,x_n]$ et $[p_1,p_2,\dots ,p_n]$ et renvoyant la variance de $\text{X}$.
On pourra utiliser la fonction esperance construite dans l’exercice précédent.

7

Bienaymé-Tchebychev ★☆☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 3 bis : Mathématiques et programmation

Compléter la fonction ci-dessous qui affiche l’inégalité de Bienaymé-Tchebychev.

def bienayme_tchebychev(E, V, a):
  borne_inf = ...
  borne_sup = ...
  proba = ...
  print("La probabilité que X ne soit pas comprise entre", borne_inf, " et ", borne_sup, "est inférieure ou égale à ", proba)

8

Simuler $\text{N}$ échantillons de taille $n$ ★★★

On considère une pièce truquée dont la probabilité d’obtenir Pile est égale à $0,4$.

1. On lance $n$ fois cette pièce truquée et on s’intéresse au nombre moyen de piles obtenus (pour $n\ne 0$).
a. Quelle est la valeur théorique de la moyenne obtenue sur un nombre de lancers suffisamment grand ? Justifier que l’écart-type moyen s’écrit $\frac{\sigma }{\sqrt{n}}$ avec $\sigma =\sqrt{0,24}$.

b. Compléter la fonction UneSimulation suivante qui calcule la moyenne obtenue lorsque le nombre de lancers $n$ est donné en argument.

from random import*
from math import*

def UneSimulation(n):
  Pile = 0
  for i in ...:
    if random() ...:
      Pile = Pile + 1
  return ...

c. Faire plusieurs tests avec $n=100$ puis plusieurs tests avec $n=1000$. Les moyennes obtenues sont-elles cohérentes avec la moyenne théorique ?

2. On décide à présent d’effectuer $N$ simulations de $n$ lancers de cette pièce. Pour chaque simulation, on note la moyenne obtenue et on obtient donc une liste de $N$ valeurs (chacune correspondant à la moyenne d’une seule simulation de $n$ lancers).

a. Compléter la fonction NSimulations qui renvoie cette liste de valeurs pour des simulations d’échantillons de taille $n$ (on pensera évidemment à utiliser la fonction UneSimulation). Faire plusieurs tests avec $N=1000$ et $n=1000$.

b. Compléter la fonction moyenne qui donne la moyenne des nombres de la liste obtenue avec l’exemple précédent.

def NSimulation(N, n):
  i = 0
  Valeurs = []
  for i in range(...):
    ...
  return(Valeurs)

def moyenne(L):
  m = 0
  l = len(L)
  for i in range(...) :
    m = m + ...
  m = ...
  return(...)

3. On rappelle que, pour une série statistique de valeurs $\left(x_i\right)$ ($i$ est un entier entre $1$ et $n$) et de moyenne $\overline{x}$, on calcule l’écart-type $s$ de la façon suivante : $s=\sqrt{V}$ où $V=\frac{1}{n}\sum _{i=1}^n{\left(x_i-\overline{x}\right)}^2$.

a. Compléter la fonction EcartType qui prend en argument une liste de nombres et qui renvoie l’écart-type de cette liste.

def EcartType(L):
  m = moyenne(...)
  l = len(L)
  V = 0
  s = 0
  for i in range(l):
    V = V + ...
    V = V/l
  s = ...
  return(s)

b. Utiliser alors cette fonction pour calculer l’écart-type de $N$ simulations de $n$ lancers de la pièce en prenant $N=1000$ et $n=1000$.

c. Comparer le résultat obtenu avec l’écart-type moyen théorique de la question 1.a. lorsque $n=1000$.

4. Pour finir, parmi les $N$ échantillons, on souhaite calculer la proportion de ceux dont l’écart entre la moyenne observée et la moyenne théorique est inférieur ou égal à $\frac{k\sigma }{\sqrt{n}}$ avec $k=1$, $k=2$ puis $k=3$. Compléter la fonction ecart et la tester plusieurs fois avec $N=1000$ et $n=1000$. Pour chaque valeur de $k$, autour de quelle valeur semble se stabiliser la fonction ecart ?

def ecart(N,n, coef) :
  prop = 0
  L = ...
  ecartmax = coef * sqrt(...) / sqrt(...)
  for j in range(...) :
    if abs(... - 0.6) <= ... :
      prop = ...
  prop = ...
  return(...)

print(ecart(1000,1000, 1))
print(ecart(1000,1000, 2))
print(ecart(1000,1000, 3))