– utiliser un générateur de nombres aléatoires entre 0 et 1 pour simuler une loi de Bernoulli de paramètre p ;
La loi de Bernoulli de paramètre p peut être simulée en coupant l’intervalle [0,1] en deux sous-intervalles, l’un de taille p, l’autre de taille 1−p :

– utiliser la notion de compteur ;
Lorsque l’on souhaite répéter un nombre donné de fois la même instruction ou le même bloc d’instructions, la commande for est la plus appropriée. Elle intègre un compteur, souvent appelé i (on peut lui donner le nom que l’on veut)
Admettons que l’on veuille répéter 7 fois la loi de Bernoulli de paramètre p ci-dessus. Voici ce que l’on peut faire.

Lorsque l’on souhaite répéter un certain nombre de fois, inconnu, la même instruction ou le même bloc d’instructions, la commande while est la plus appropriée et le plus souvent elle nécessite un compteur. On va répéter la loi de Bernoulli de paramètre p jusqu’à ce qu’elle ait rencontré 10 succès.

– utiliser le principe d’accumulateur pour calculer une somme, un produit.
On s’est servi de ce principe pour incrémenter le compteur ci-dessus, mais illustrons cela avec un calcul de somme, par exemple les carrés des nombres inférieurs à 10 :

Commentaires
– Les notions relatives aux types de variables et à l’affectation sont consolidées. Comme en classe de seconde, on utilise le symbole « ← » pour désigner l’affectation dans un algorithme écrit en langage naturel.
Python est un langage à typage dynamique, ce qui signifie que la valeur que l’on affecte à une variable définit son type. Le type du contenu d’une variable peut donc changer si on change sa valeur.
La fonction type()
Pour connaître le type d’une donnée ou d’une variable, il suffit d’utiliser la fonction type().

Le type int (entier)
Ce type est utilisé pour stocker un entier ( integer en anglais).

Le type float (flottant)
Ce type est utilisé pour stocker des nombres à virgule flottante ( floating point numbers en anglais). En français, on parle de flottant.

Le type str (chaîne de caractères)
Dans Python, une donnée de type str est une suite quelconque de caractères délimitée soit par des apostrophes, soit par des guillemets. str est l’abréviation de string, qui veut dire chaîne en français.

Le type list (liste)
Dans Python, on peut définir une liste comme une collection d’éléments séparés par des virgules, l’ensemble étant écrit entre crochets.

– identifier les entrées et les sorties d’une fonction ;
Prenons l’exemple de la loi de Bernoulli, on peut définir une fonction loi de Bernoulli de paramètre 0.7 :

Il n’y a pas d’entrée, et en sortie on obtient 1 si l’expérience est un succès, 0 sinon.
Si l’on veut définir une loi de Bernoulli de paramètre p (au lieu de 0.7), on prendra en entrée le paramètre p, la sortie étant la même que précédemment :

Si l’on veut répéter n fois l’expérience :

En entrée, on renseigne le nombre d’expériences n et la probabilité du succès p. En sortie, on récupère le nombre de succès.
– structurer un programme en ayant recours aux fonctions. (Ceci est illustré partout dans l’article, nous n’en dirons pas plus ...)
Commentaires
– L’accent est mis sur la programmation modulaire qui permet de découper une tâche complexe en tâches plus simples.
Prenons l’exemple du calcul de l’écart-type pour une liste de données, on peut programmer la fonction :

On peut aussi programmer les fonctions esperance et variance afin de les utiliser dans la fonction ecarttype et éventuellement de s’en servir par ailleurs :

– générer une liste (en extension, par ajouts successifs, en compréhension) ;
Une liste est une séquence modifiable. Un élément d’une liste peut être de n’importe quel type.

La liste vide :

Longueur d’une liste : fonction len

– manipuler des éléments d’une liste (ajouter, supprimer...) et leurs indices ;
Concaténation et multiplication
On concatène avec + :

On peut utiliser la concaténation pour insérer un terme à la fin de la liste, mais on préférera utiliser la méthode append :

On multiplie avec * :

Convertir avec la fonction list
On peut convertir n’importe quel itérable en liste :

Indexing et slicing
Les listes sont des séquences, elles sont donc indexables (les items sont repérés par un indice) et sliceables (on peut en extraire des tranches grâce à des plages d’indices). Comme d’habitude, l’indice du premier item est zéro :

Indices négatifs : Python numérote le dernier item avec -1, l’avant-dernier avec -2, et ainsi de suite :

Si on est obligé d’initialiser les termes dans le désordre, on commencera par créer une liste triviale.
Supposons par exemple qu’on veuille L de longueur 10, on écrira :

sans déclencher d’erreur.
Un peu de slicing :

On peut faire du slicing avec un pas (positif ou négatif) :

Remplacer une tranche par une autre
Dans une liste, on peut remplacer une tranche par une autre (il s’agit d’une mutation) :

On peut utiliser ce procédé pour changer un terme :

On peut utiliser cette méthode pour supprimer une tranche :

On peut utiliser ce procédé pour supprimer un terme d’indice connu :

On peut utiliser ce procédé pour insérer un élément où on veut :

On peut insérer une tranche :

Compréhension
En mathématiques (théorie des ensembles), l’axiome de compréhension est fondamental :
Axiome : Si E est un ensemble et P une propriété exprimée dans le langage de la théorie des ensembles, alors $\left\{x \in E | P\right\}$ est un ensemble.
Il est très courant en mathématiques de définir des ensembles en compréhension. L’ensemble des nombres pairs, par exemple est l’ensemble $\left\{n \in \mathbb{Z} | n\equiv 0 [2] \right\}$.
On peut avec Python définir des listes en compréhension (on dit aussi en intension avec un s) :

Y est la liste des carrés des nombres appartenant à X. On peut même ajouter une condition :

On peut redéfinir X à partir de X directement :

On peut imbriquer des listes en compréhension :

Fusionner
Soit L une liste de listes. On peut récupérer les items des listes de L en une seule instruction :

On peut utiliser cette technique pour effectuer des produits de listes :

Trier avec sort ou sorted (arguments reverse, key)
La fonction sorted et la méthode sort font la même chose : elles trient les items dans l’ordre croissant (par défaut). La fonction sorted prend n’importe quel itérable et retourne les items dans l’ordre, sous forme de liste :

La méthode sort s’applique à une liste et modifie cette liste :

Les deux, sort et sorted, acceptent les arguments reverse et key. L’argument reverse permet de trier dans l’ordre décroissant :

L’argument key permet de choisir la fonction avec laquelle on fera le tri. Si on veut trier selon la valeur absolue, on fera :

Très pratique avec des données complexes :

Instruction del (mot réservé)
Pour effacer un item selon son rang, ou une plage d’items :

Une autre syntaxe :

On peut utiliser del sur une plage d’indices :

Méthode index
Pour trouver l’indice d’un terme :

C’est l’index de la première occurrence du terme qui est renvoyé, si l’on veut l’index de la seconde occurrence, on peut démarrer la recherche plus loin :

Méthode count
Pour compter les occurrences d’un item :

Méthode remove
Pour supprimer une occurrence (ne supprime que la première occurrence) :

Méthode append
Pour insérer un terme à la fin :

Méthode insert
Pour insérer un terme où on veut :

Méthode extend
Pour étendre une liste par concaténation :

Méthode pop
Supprime le dernier terme et le retourne :

Fonction max
Retourne le plus grand élément :

Fonction min
Retourne le plus petit élément :

Méthode copy
Pour copier une liste dans une autre :

Méthode clear
Pour effacer le contenu d’une liste :

– itérer sur les éléments d’une liste.
Le type list est itérable
On peut itérer une liste :

Les listes supportent les tests x in list et x not in list.

Commentaires
– La génération des listes en compréhension et en extension est mise en lien avec la notion d’ensemble. Les conditions apparaissant dans les listes définies en compréhension permettent de travailler la logique.
– Afin d’éviter des confusions, il est recommandé de se limiter aux listes sans présenter d’autres types de collections.

– traiter un fichier contenant des données réelles pour en extraire de l’information et l’analyser ;
Nous utiliserons un gros fichier de données issu du site de l’INSEE, sur les communes de France métropolitaine et de Corse, débarrassé des données incomplètes (pour les DOM-TOM) :

Données sur les villes de France (Métropolitaine et Corse)

Nous traiterons ce fichier avec le module pandas qui est une librairie Python spécialisée dans l’analyse des données. Pour ma part, je l’utilise dans Spyder, mais cela est un détail à régler de votre côté ... Un objet de type « data frame » permet de réaliser de nombreuses opérations de filtrage, prétraitements, etc., préalables à la modélisation statistique.
Dans Spyder, on crée un fichier Python :

On obtient dans la console un extrait des données qui sont enregistrées dans 36568 lignes et 12 colonnes, des « ... » indiquent les « trous » présents dans cet affichage :

Par rapport au fichier original, la colonne des index des lignes a été rajoutée à gauche.
Il est possible d’afficher toutes les données grâce à l’explorateur de variables :

Structure DataFrame
Une matrice DataFrame correspond à une matrice individus-variables où les lignes correspondent à des observations, les colonnes à des attributs décrivant les individus. Concernant notre fichier « villes_virgule.csv » : la première ligne correspond aux noms des champs (des variables) ; à partir de la seconde ligne, nous disposons des valeurs pour chaque enregistrement (individu, ici une commune). Dans ce qui suit, nous chargeons le fichier de données et nous procédons à quelques vérifications.
Si l’on demande le type de data :

Voyons maintenant l’architecture de la structure DataFrame :

La ligne d’en-tête et la colonne d’index ne sont pas comptées.
Pour afficher l’en-tête de toutes les colonnes :

On a donc le numéro du département, le nom de la commune, le code postal, le nombre d’habitants en 2010, le nombre d’habitants en 1999, le nombre d’habitants en 2012, la densité, la surface, la longitude, la latitude, l’altitude minimum et l’altitude maximum.
On peut récupérer les données statistiques de base pour chacune des colonnes :

Certaines des données ont plus ou moins d’intérêt selon le contexte, ici par exemple count correspond au nombre de données pour chaque colonne c’est-à-dire 36568 ...
On peut alors demander plus précisément les données pour une colonne précise :

Si l’on demande le calcul explicite de la moyenne :

Ou la population totale en 2010 :

Le nombre de communes par département :

data[« dens »] est une liste, on peut donc lui appliquer toutes les méthodes des listes :

On peut accéder aux valeurs du DataFrame via des indices ou plages d’indice. La structure se comporte alors comme une matrice. La cellule en haut et à gauche est de coordonnées (0,0). Il y a différentes manières de le faire, l’utilisation de .iloc[,] constitue une des solutions les plus simples. N’oublions pas que Shape permet d’obtenir les dimensions (lignes et colonnes) du DataFrame :

Nous pouvons isoler les sous-ensembles d’observations répondant à des critères définis sur les champs. Nous utiliserons préférentiellement la méthode .loc[,] dans ce cadre. Par exemple si l’on veut toutes les données correspondant au code postal 34400 :

Si l’on veut les communes du Nord de l’Hérault :

pour visualiser l’évolution démographique des communes Héraultaises de plus de 10000 habitants en 1999 :

– réaliser un tableau croisé de données sur deux critères à partir de données brutes.

On utilisera un second fichier, plus approprié, qui répertorie, selon leur ville de résidence, la LV2 étudiée par des lycéens :

LV2 étudiée

On peut alors calculer les effectifs et les fréquences :

Et réaliser le tri croisé :

Ou avec la métode pivot_table(), qui donne exactement la même chose :

Le calcul d’un terme de rang donné d’une suite définie de manière explicite, c’est-à-dire à l’aide d’une fonction de n est quelque chose de très simple :

Si l’on veut simplement un terme de rang donné, il suffit d’utiliser la fonction u :

Regardons maintenant du côté des suites définies par récurrence. Prenons le cas d’une suite définie par $u_{n+1} = f(u_n)$ et de premier terme $u_{p}$ :

Après avoir défini la fonction $f$, qui calcule $u_{n+1}$ en fonction de $u_{n}$, on calcule à l’aide d’une boucle les termes d’indice compris entre début+1 et fin. Si l’on veut $u_{12}$ :

Étant donné que les suites arithmétiques et géométriques apparaissent dans le programme, il semble légitime de s’y intéresser particulièrement. On peut bien sûr utiliser la fonction suite_recurrente() (l’expression explicite de ces suites est au programme de Terminale) précédentes, il suffit d’écrire la relation de récurrence adéquate. Sinon, il est possible aussi de créer un outil spécifique qui prendrait en paramètres les rangs de début et de fin ainsi que le terme initial et la raison.

Utilisation :

A noter les petites différences avec les résultats attendus de l’ordre de $10^{-15}$ dues à la gestion des nombres décimaux (flottants) dans Python. Cela peut se régler en utilisant la fonction round().
Si la suite est définie de manière explicite et que l’on veut la somme des termes de rang compris entre debut et fin :

Utilisation :

Si la suite est définie de manière récurrente et que l’on veut la somme des termes de rang compris entre debut et fin avec $u_{debut} = u_p$ :

Utilisation :

Pour une suite déterminée de manière explicite :

Taper dans la console :

Pour une suite déterminée de manière récurrente :

Taper dans la console :

Pour une suite, définie de manière explicite, pour laquelle on cherche à partir de quel rang son terme devient supérieur à un seuil donné :

utilisation :

Le seuil de 1000 est dépassé au rang 74 avec $u_{74}=1008$.

Pour une suite, définie par récurrence, pour laquelle on cherche à partir de quel rang son terme devient supérieur à un seuil donné :

utilisation :

Le seuil de 1000 est dépassé au rang 6 avec $u_{6}=1336$.

Pour une suite, définie de manière explicite, pour laquelle on cherche à partir de quel rang son terme devient inférieur à un seuil donné :

utilisation :

La suite passe sous le seuil de 500 au rang 54 avec $u_{54}=481.6$.

Pour une suite, définie par récurrence, pour laquelle on cherche à partir de quel rang son terme devient inférieur à un seuil donné :

utilisation :

La suite passe sous le seuil de 250 au rang 10 avec $u_{11}\approx 69.77$.

Déterminer le rang à partir duquel les termes d’une suite sont supérieurs aux termes de même rang d’une autre suite avec deux suites définies par récurrence :

utilisation :

Déterminer le rang à partir duquel les termes d’une suite sont supérieurs aux termes de même rang d’une autre suite avec deux suites définies de manière implicite :

utilisation :

Cette méthode, classique, consiste, pour une fonction continue et monotone sur un intervalle [a ; b] dans lequel on sait trouver la solution de $f(x) = k$, à calculer $f(x)$, pour $x$ allant de a à b avec un pas de h, après avoir vérifié la croissance ou la décroissance de la fonction. Si f est croissante, « Tant Que » f(x) < k est vérifiée (On utilisera pour cela un While.), on calcule f(x). Dès que f(x) > k on arrête l’algorithme. Si f est décroissante, « Tant Que » f(x) > k est vérifiée, on calcule f(x). Dès que f(x) < k on arrête l’algorithme. On obtient un encadrement de longueur h de la solution
Il faut déterminer a et b, les bornes de l’intervalle dans lequel on va appliquer le balayage.
Fonction qui calcule cet encadrement, renvoyé dans un tuple, en fonction du nombre n de décimales souhaitées :
Cet algorithme détermine par balayage un encadrement de racine de 2 d’amplitude 10^(-n).

Utilisation : Compiler le fichier puis dans la console :

Le round permet ici de corriger quelques erreurs d’affichage des flottants [1].
Il est à noter que cet algorithme est très long à donner une réponse si n>=9.
On peut donc chercher à l’optimiser, par exemple en utilisant une boucle for qui va faire la même chose que le programme précédent mais pour h allant de 10^-1 à 10^-n en réduisant l’intervalle [a ; b] à chaque boucle.
C’est beaucoup plus rapide, jusqu’à n=16 où ça bogue, parce que les flottants (décimaux) ne sont affichés qu’avec 16 chiffres après la virgule.

Soit l’on se donne une telle liste soit on la génère aléatoirement, par exemple :

On obtient par exemple :

On peut alors déterminer différents sous-ensembles :

Sans le module Pandas
On peut partir de deux listes, ou d’une liste regroupant les deux listes, nous choisissons de générer cette liste aléatoirement dans le programme Python, en utilisant la méthode choice() pour tirer aléatoirement un élément d’une liste (ici dans les deux listes intitules), puis de traiter les données afin d’établir le tableau croisé :

La méthode index() cherche un élément dans la liste et renvoie son index. En termes simples, la méthode index() trouve un élément donné dans une liste et renvoie sa position, ce qui nous permet de les compter et d’établir le tableau des effectifs.
A noter que l’on crée la matrice a=[0,0,...,0]...[0,0,...,0] avec :

et non pas avec :

Plutôt qu’un long discours l’explication est dans le code ci-dessous :

Une petite mise en forme s’impose si l’on veut obtenir quelque chose de lisible (ceci n’a pas besoin d’être expliqué aux élèves, il s’agit de cosmétique ...).
Utilisation :

Pour obtenir les fréquences, on complète le code précédent avec :

Pour obtenir :

On a alors dans les colonnes « Total » les fréquences marginales :
– 17,78% des individus ont un niveau Collège.
– 48,89% des individus sont Mariés.
Avec le module Pandas
Sinon, on peut traiter un fichier csv qui contient ces données avec le module pandas qui est une librairie Python spécialisée dans l’analyse des données. Pour ma part, je l’utilise dans Spyder, mais cela est un détail à régler de votre côté ... Un objet de type « data frame » permet de réaliser de nombreuses opérations de filtrage, prétraitements, etc., préalables à la modélisation statistique.
Dans Spyder, on crée un fichier Python :

qui ouvre un fichier statut_niveau.csv qui contient les données, le voici :

Statut et niveau

On vérifie dans la console :

Et on demande le tableau croisé :

Avec les totaux par ligne et par colonne :

On peut obtenir le tableau des fréquences conditionnelles selon le niveau :

On lit ainsi que :
– « 50% des individus Célibataires ont un niveau Collège. » (fréquence conditionnelle)
– « 35,48% des individus Mariés ont un niveau Lycée . » (fréquence conditionnelle)
– « 40,35% desindividus ont un niveau Collège » (fréquence marginale)
On peut obtenir le tableau des fréquences conditionnelles selon le Statut :

On lit ainsi que :
– « 35,29% des individus ayant un niveau Lycée sont célibataires. » (fréquence conditionnelle)
– « 58,82% des individus ayant un niveau Supérieur sont mariés. » (fréquence conditionnelle)
– « 45,61% des individus sont célibataires. » (fréquence marginale)
Et enfin le tableau des fréquences :

Avec les totaux :

Où l’on retrouve les fréquences marginales dans la colonne et la ligne « All ».

Si l’on s’intéresse à des données numériques assez nombreuses, il peut être intéressant de croiser ces données par classes d’intervalles, avec le fichier ci-dessous :

taille et distance

On demande alors dans la console :