Programmation statistique automatisée

Programmation statistique automatisée : concepts clés en Python

Ce cours vous guide à travers les notions fondamentales de la programmation statistique avec NumPy et Pandas. Vous apprendrez à générer des séquences numériques, à manipuler des tirages aléatoires, à différencier les structures de données Pandas et à appliquer les opérations de regroupement, de jointure et de concaténation. Chaque section s’appuie sur les questions d’un quiz, offrant des explications détaillées et des exemples de code prêts à être reproduits.

1. Générer des séquences numériques avec NumPy

NumPy propose deux fonctions très utilisées pour créer des tableaux d’intervalles : np.arange et np.linspace. Bien qu’elles semblent similaires, elles diffèrent par le paramètre qu’elles fixent.

• np.arange(i, j, p) crée une séquence qui commence à i, s’arrête avant j et avance de p à chaque pas. Le pas p est explicite, ce qui rend la fonction idéale quand vous connaissez l’incrément souhaité.
• np.linspace(i, j, n) génère exactement n valeurs réparties uniformément entre i et j, incluant les deux bornes. Ici, le nombre de points n est le paramètre contrôlé, tandis que le pas est calculé automatiquement.

Exemple d’utilisation :

import numpy as np
# Pas de 0,5 entre 0 et 3
print(np.arange(0, 3, 0.5))
# 5 valeurs entre 0 et 3
print(np.linspace(0, 3, 5))

Résultat :

[0.  0.5 1.  1.5 2.  2.5]
[0.  0.75 1.5 2.25 3. ]

2. Tirages aléatoires avec np.random.randint

La fonction np.random.randint(low, high) renvoie un entier aléatoire compris entre low (inclus) et high (exclu). Ainsi, np.random.randint(5, 10) produit les entiers 5, 6, 7, 8 ou 9.

Illustration :

import numpy as np
samples = [np.random.randint(5, 10) for _ in range(10)]
print(samples)

Chaque exécution génère une liste d’entiers compris dans l’intervalle 5‑9. Cette règle d’inclusion/exclusion est cruciale pour éviter les erreurs de débordement dans les boucles ou les indexations.

3. Tirage avec remise (sampling with replacement)

Lorsque l’on effectue un tirage avec remise, l’élément sélectionné est replacé dans la population avant le tirage suivant. Cette méthode autorise donc la sélection multiple du même élément.

En Python, on peut simuler ce comportement avec random.choices :

import random
items = ['A', 'B', 'C']
# 5 tirages avec remise
print(random.choices(items, k=5))

Le résultat peut contenir plusieurs occurrences du même symbole, par exemple ['B', 'A', 'B', 'C', 'B']. En revanche, un tirage sans remise (ex. random.sample) ne permettrait pas de répéter un même élément.

4. Structures de données Pandas : Series vs DataFrame

Pandas propose deux objets principaux :

• Series : tableau unidimensionnel, similaire à une colonne d’une feuille de calcul. Chaque valeur possède un indice (label) qui peut être de n’importe quel type (int, str, datetime, …).
• DataFrame : collection de Series alignées sur le même index, formant ainsi une structure bidimensionnelle (lignes × colonnes). Un DataFrame peut contenir plusieurs types de données simultanément.

Exemple de création :

import pandas as pd
# Series simple
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
# DataFrame à partir de deux Series
df = pd.DataFrame({'val1': s, 'val2': [1, 2, 3]})
print(df)

Affichage :

   val1  val2
a    10     1
b    20     2
c    30     3

5. Sélectionner des lignes par position avec .iloc

Dans Pandas, deux méthodes permettent d’accéder aux données : .loc (par étiquette) et .iloc (par position entière). .iloc utilise des indices numériques, exactement comme le ferait le slicing de listes Python.

# Sélection des deux premières lignes
print(df.iloc[:2])
# Sélection de la ligne d’indice 1 et de la colonne "val2"
print(df.iloc[1, df.columns.get_loc('val2')])

Résultat :

   val1  val2
a    10     1
b    20     2
2

Utiliser .iloc est indispensable lorsqu’on travaille avec des index non numériques ou lorsqu’on veut garantir un accès basé sur la position réelle des lignes.

6. Regrouper et sommer les données avec groupby

Pour calculer un total (ou toute autre agrégation) par catégorie, la méthode groupby est la plus efficace. Elle crée des sous‑ensembles de données selon la clé spécifiée, puis applique une fonction d’agrégation comme sum(), mean(), etc.

# Exemple de tableau de ventes
sales = pd.DataFrame({
    'ville': ['Paris', 'Lyon', 'Paris', 'Lyon', 'Marseille'],
    'bénéfice': [100, 150, 200, 120, 80]
})
# Total du bénéfice par ville
total_par_ville = sales.groupby('ville')['bénéfice'].sum()
print(total_par_ville)

Résultat :

ville
Lyon          270
Marseille      80
Paris          300
Name: bénéfice, dtype: int64

Cette opération est largement utilisée pour les rapports financiers, l’analyse de trafic ou toute situation où l’on doit résumer des données par groupe.

7. Types de jointures : la jointure inner

Lorsque deux DataFrames sont fusionnés, la nature de la jointure détermine quelles lignes sont conservées. La jointure inner ne garde que les clés présentes dans les deux tables, éliminant ainsi les enregistrements orphelins.

df1 = pd.DataFrame({'id': [1, 2, 3], 'val1': ['A', 'B', 'C']})
df2 = pd.DataFrame({'id': [2, 3, 4], 'val2': ['X', 'Y', 'Z']})
inner = pd.merge(df1, df2, on='id', how='inner')
print(inner)

Résultat :

   id val1 val2
0   2    B    X
1   3    C    Y

Les lignes avec id=1 et id=4 sont exclues car elles n’apparaissent pas dans les deux DataFrames. Cette jointure est idéale lorsqu’on veut travailler uniquement sur les enregistrements compatibles.

8. Concatenation de DataFrames avec les mêmes colonnes

Concaténer deux DataFrames qui partagent les mêmes colonnes revient à empiler leurs lignes l’une après l’autre. La fonction pd.concat réalise cela rapidement, créant un nouveau DataFrame qui conserve l’ordre des lignes d’origine.

df_a = pd.DataFrame({'nom': ['Alice', 'Bob'], 'âge': [25, 30]})
df_b = pd.DataFrame({'nom': ['Charlie', 'Diane'], 'âge': [35, 28]})
combined = pd.concat([df_a, df_b], ignore_index=True)
print(combined)

Résultat :

       nom  âge
0    Alice   25
1      Bob   30
2  Charlie   35
3    Diane   28

Contrairement à une jointure, la concaténation ne combine pas les colonnes selon une clé ; elle se contente d’ajouter des lignes, ce qui est utile pour rassembler des jeux de données provenant de plusieurs fichiers ou sources.

9. Bonnes pratiques SEO pour les tutoriels Python

Pour que votre contenu soit bien référencé, respectez les recommandations suivantes :

• Utilisez des titres clairs contenant les mots‑clés principaux (ex. « np.arange vs np.linspace », « groupby Pandas »).
• Structurez le texte avec des balises sémantiques (<h2>, <h3>, <p>) afin que les moteurs de recherche comprennent la hiérarchie du contenu.
• Intégrez des extraits de code formatés en <pre><code> pour améliorer la lisibilité et encourager le partage sur les plateformes de développeurs.
• Ajoutez des liens internes vers d’autres articles liés (ex. « Manipulation de dates avec Pandas ») pour augmenter le temps de visite.
• Optimisez les méta‑descriptions (non affichées ici) en résumant le sujet en moins de 160 caractères, incluant les mots‑clés « NumPy », « Pandas », « analyse de données ».

En suivant ces principes, votre page gagnera en visibilité et attirera un public ciblé recherchant des réponses précises sur la programmation statistique automatisée.