Sondage et intervalle de confiance

Dans cette leçon nous réalisons un sondage après la sortie d'un film dans différentes villes pour mesurer le taux de satisfaction. On voudrait estimer la probabilité qu'une personne prise au hasard apprécie le film.

Dans chaque ville on interroge 100 personnes et on collecte leurs réponses dans une liste.

1
Dans les leçons précédentes nous avons vu comment créer une liste de manière explicite en indiquant ses éléments. Par exemple L = [1,2,3]. C'est ce qu'on appelle définir une liste en extension.

Mais lorsque la liste contient beaucoup d'éléments comme dans notre cas, procéder de cette manière n'est pas réaliste.

À la place, on peut définir une liste en décrivant une propriété ou un calcul sur chacun de ses éléments avec une nouvelle syntaxe. Par exemple :
```
>>> [i ** 2 for i in range(3)]
[0, 1, 4]
```
Le code précédent crée une liste contenant i ** 2 pour chaque i allant de 0 à 2. Cette formule est interprétée par Python en [0 ** 2, 1 ** 2, 2 ** 2] qui donne finalement la liste [0, 1, 4]

Autrement dit, on a les trois premiers carrés d'entiers. Comme d'habitude la variable i aurait pu être nommée différemment. Autre exemple :
```
>>> [2 * n for n in range(5)]
[0, 2, 4, 6, 8]
```
De cette manière on crée une liste contenant les cinq premiers nombres pairs. En effet le for n in range(5) nous donne une séquence de cinq nombres, et pour chacun de ces nombres n on ajoute 2 * n dans la liste.

Dans la console crée une liste en compréhension, de sorte qu'elle contiennent les dix premiers cubes d'entiers à partir de zéro.
Solution

La liste doit contenir dix nombres en partant de zéro donc on utilise for n in range(10) et comme on veut des cubes, pour chaque n on ajoute n ** 3 dans la liste :
```
>>> [n ** 3 for n in range(10)]
[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
```
2
On peut également utiliser un appel de fonction dans la formule. Par exemple pour simuler dix lancers d'un dé à six face, on peut faire :
```
from random import randint
L = [randint(1,6) for n in range(10)]
```
De cette manière on a une liste de longueur 10 dont chaque élément est un entier aléatoire compris entre 1 et 6.

J'ai défini une fonction sondage qui renvoie lorsqu'on l'appelle un entier 0 ou 1 avec une certaine probabilité. Cette fonction ne prend pas d'argument et permet de modéliser la réponse donnée par un individu lors du sondage : 0 si la personne n'a pas aimé le film, 1 si la personne a apprécié le film.

Dans l'éditeur crée une liste L1 en compréhension qui représente les réponses données par 100 personnes au sondage.
Solution

Il nous faut une liste de longueur 100 donc on utilise for n in range(100) et chaque élément de la liste doit être la réponse d'une personne au sondage donc un appel de la fonction sondage :
```
L1 = [sondage() for n in range(100)]
```
3
Pour savoir ce qu'ont pensé les gens dans cette ville tu peux afficher la liste dans la console. Il faudrait compter la proportion de 1 pour avoir le taux de gens qui ont apprécié le film.

Les listes ont justement la capacité de compter le nombre d'occurrences d'une valeur grâce à la méthode count. Par exemple pour compter le nombre de 0 d'une liste L on peut faire :
```
L.count(0)
```
Combien de personnes ont apprécié le film dans cette ville ? Saisi l'expression dans la console pour avoir la réponse.
Solution

Il faut compter le nombre de 1 de la liste L1 :
```
>>> L1.count(1)
62
```
Donc dans mon cas il y 62% de gens qui ont apprécié le film
4
Nous allons reproduire ce sondage dans une vingtaine de villes en France pour déterminer dans chacune de ces villes la proportion de personnes qui apprécient le film.

Pour cela une liste L initialement vide permet de stocker le taux de satisfaction des gens à chaque sondage. Et une boucle for permet de réaliser le sondage dans chacune des vingts ville.

Il reste à calculer et stocker le taux de satisfaction dans chacune de ces villes. Défini dans la boucle for et sous la variable L1 une variable taux qui calcul le taux de satisfaction dans cette ville. C'est-à-dire le nombre de gens qui ont aimé par rapport à la taille de la liste.

Ensuite ajoute ce nombre à la liste L en utilisant une méthode spécifique aux listes. À la fin de la boucle, la liste L doit contenir 20 éléments
Solution

On commence par définir la variable taux sous la variable L1

Cette variable représente le taux de satisfaction dans la ville donc il faut compter le nombre de 1 de la liste L1 et diviser par la taille de la liste. Soit L1.count(1) / len(L1)

Ensuite on ajoute ce nombre à la liste L à l'aide de la méthode append en faisant L.append(taux)
```
L = []

for ville in range(20):
	L1 = [sondage() for n in range(100)]
	taux = L1.count(1) / len(L1)
	L.append(taux)
```
5
Si tu affiches la liste L dans la console tu vas observer des fluctuations du taux de satisfaction d'une ville à l'autre. Comme attendu !

Pour faire notre estimation on va se baser sur le taux moyen. Autrement dit on veut calculer une moyenne des valeurs de L. Mais on ne va pas recoder la fonction moyenne, on va faire plus simple.

En Python il y a une fonction sum qui comme son nom l'indique, calcule la somme des éléments. Elle prend une liste en argument. Par exemple
```
>>> sum([1,2,3])
6
```
Défini en dehors de la boucle for une variable taux_moyen qui calcule la moyenne des éléments de L en utilisant la fonction sum. Affiche ensuite cette variable à l'aide de print
Solution

Il faut définir une variable taux_moyen. Cette variable doit être définie après la boucle for, autrement la liste L est encore vide.

Ensuite on calcule la moyenne en sommant les éléments de L et en divisant par le nombre d'éléments de L, ce qui correspond à len(L) :
```
L = []

for ville in range(20):
	L1 = [sondage() for n in range(100)]
	taux = L1.count(1) / len(L1)
	L.append(taux)

taux_moyen = sum(L) / len(L)
print(taux_moyen)
```

En statistiques, il est fréquent de vouloir estimer une probabilité à partir d'une fréquence observée $f$ sur un échantillon. À cause des fluctuations on ne peut pas connaître précisément la probabilité. Mais on peut déterminer un intervalle dans lequel elle se trouve : $\left[f-\frac{1}{\sqrt{n}} ; f+\frac{1}{\sqrt{n}} \right]$ où $n$ est le nombre d'éléments de chaque échantillon.

Donc dans notre cas, si nous n'avions qu'un unique échantillon de taille 100 sur lequel le taux de satisfaction est de 60%, alors cette formule nous permet de dire que le taux réel de satisfaction est dans l'intervalle $\begin{aligned} &\left[0.6-\frac{1}{\sqrt{100}} ; 0.6+\frac{1}{\sqrt{100}} \right] \\ &=\left[ 0.6 + \frac{1}{10} ; 0.6+\frac{1}{10} \right] \\ &= [0.5 ; 0.7] \end{aligned}$

Et plus la taille de l'échantillon $n$ augmente, plus cet intervalle est petit, donc précis !