🐼 Pandas et 🤖 Scikit-learn

💡 Introduction à l'analyse de données

📊 Pour votre TP2, vous allez devoir manipuler des données réelles :

📥 Charger des ensembles de données à partir de fichiers CSV.
🧹 Nettoyer et prétraiter les données pour les rendre exploitables.
🔍 Analyser les données pour en extraire des informations pertinentes.
📈 Visualiser les données à l'aide de graphiques.
🤖 Utiliser des techniques d’apprentissage automatique pour construire des modèles prédictifs.

🧠 Cela nécessite une bonne compréhension des concepts et des outils d’analyse de données.

🔬 L’analyse de données est un processus essentiel qui consiste à examiner, nettoyer, transformer et modéliser des données dans le but de découvrir des informations utiles, informer des conclusions et soutenir la prise de décision.

🧰 Bibliothèques Python couramment utilisées pour l’analyse de données :

🐼 Pandas : pour la manipulation et l’analyse de données, offrant des structures de type DataFrame.
🔢 NumPy : pour le calcul scientifique et les opérations sur des tableaux multidimensionnels.
🤖 Scikit-learn : pour l’apprentissage automatique et la modélisation prédictive.
🧠 Keras et TensorFlow : pour le développement de modèles d’apprentissage profond (deep learning).
🎨 Matplotlib et Seaborn : pour la visualisation de données.
… et bien d’autres selon les besoins !

🧩 Vous connaissez déjà :

🎨 Matplotlib pour la visualisation
🔢 NumPy pour les calculs numériques

📅 Cette semaine, nous allons apprendre à utiliser deux nouvelles bibliothèques essentielles pour votre TP2 : 🐼 Pandas et 🤖 Scikit-learn.
👉 La semaine prochaine, nous aborderons les concepts d’intelligence artificielle et d’apprentissage profond (deep learning).

Introduction à 🐼 Pandas

Pandas est une bibliothèque Python essentielle pour la manipulation et l'analyse de données.
Elle offre des structures de données flexibles et performantes, telles que les DataFrames, qui facilitent le traitement des données tabulaires.

Le DataFrame

Le DataFrame est la structure de données principale de Pandas. Il s'agit d'une table bidimensionnelle, similaire à une feuille de calcul Excel, où les données sont organisées en lignes et en colonnes. Chaque colonne peut contenir des types de données différents (nombres, chaînes de caractères, dates, etc.).

On peut créer un DataFrame à partir de diverses sources de données, telles que des fichiers CSV, des bases de données SQL, ou même des dictionnaires Python.

Création d'un DataFrame à partir d'un dictionnaire

Voici un exemple simple de création d'un DataFrame à partir d'un dictionnaire :

import pandas as pd

# Création d'un DataFrame à partir d'un dictionnaire
data = {'Nom': ['Alice', 'Bob', 'Charlie'],
        'Âge': [25, 30, 35],
        'Ville': ['Paris', 'Lyon', 'Marseille']}
df = pd.DataFrame(data)

# Affichage du DataFrame
print(df)

Cela produira le DataFrame suivant :

       Nom  Âge      Ville
  Alice   25      Paris
    Bob   30       Lyon
Charlie   35  Marseille

Les clés du dictionnaire deviennent les noms des colonnes, et chaque liste associée à une clé devient une colonne de données.
La première ligne représente les en-têtes des colonnes.
La première colonne (0, 1, 2) est l'index par défaut des lignes suivantes.
Chacune de ces lignes représente un enregistrement (une personne dans cet exemple).

Lire un fichier CSV avec Pandas

Le fichier tips_dataset.csv contient des données sur les pourboires donnés dans un restaurant, avec les colonnes suivantes : le montant total de la facture, le pourboire, le sexe du serveur, si le client est fumeur, le jour de la semaine, le moment de la journée (dîner/lunch ou souper/dinner) et la taille du groupe :

total_bill,tip,sex,smoker,day,time,size
16.99,1.01,Female,No,Sun,Dinner,2
10.34,1.66,Male,No,Sun,Dinner,3
21.01,3.5,Male,No,Sun,Dinner,3
23.68,3.31,Male,No,Sun,Dinner,2
...

Si vous le téléchargez et le placez dans votre projet Pycharm, vous pouvez le lire avec Pandas comme ceci :

import pandas as pd

# Lire le fichier CSV dans un DataFrame
df = pd.read_csv('tips_dataset.csv')  # la variable df contiendra un DataFrame

# Afficher les premières lignes du DataFrame
print(df.head())

Cela produira un DataFrame qui ressemble à ceci (seules les 5 premières lignes sont affichées) :

   total_bill   tip     sex smoker  day    time  size
     16.99  1.01  Female     No  Sun  Dinner     2
     10.34  1.66    Male     No  Sun  Dinner     3
     21.01  3.50    Male     No  Sun  Dinner     3
     23.68  3.31    Male     No  Sun  Dinner     2
     24.59  3.61  Female     No  Sun  Dinner     4

Nous utiliserons ces données pour illustrer diverses opérations avec Pandas.

Chargez-les et expérimentez par vous-même ! 🎯

Ajuster l’affichage des DataFrames dans la console

Si votre DataFrame a trop de colonnes ou du contenu trop long, il se peut que certaines colonnes soient remplacées par des ...
Dans ce cas, ajoutez ces 2 instructions juste après vos importations en haut de votre script :

import pandas as pd
# Permet d'afficher entièrement le contenu des colonnes, sans limite de longueur
pd.set_option('display.max_colwidth', None)
# Empêche Pandas d'étendre l'affichage du DataFrame sur plusieurs lignes (si possible)
pd.set_option('display.expand_frame_repr', False)

👀 Explorer sommairement les données

Une fois vos données chargées dans un DataFrame (ici nommé df), vous pouvez effectuer une grande variété d’opérations.
L'une des premières opérations consiste généralement à explorer les données afin de découvrir les colonnes, leur format, etc.

# Afficher les 5 premières lignes du DataFrame
print(df.head())

# Afficher les 20 premières lignes du DataFrame
print(df.head(20))

# Afficher les informations sur les colonnes et les types de données
df.info()

# Afficher les noms des colonnes uniquement sous forme d'une liste de string
print(df.columns.to_list())

# Afficher le nombre de lignes dans le DataFrame
print(len(df))

# Afficher des statistiques descriptives (moyenne, min, max, etc.)
print(df.describe())

Remarquez que toutes ces opérations ne modifient pas le DataFrame original df.
Elles retournent des informations ou des nouveaux objets basés sur le contenu de df, mais df lui-même reste inchangé.
Seule la méthode df.info() affiche des informations sur le DataFrame sans retourner un nouvel objet, donc on n'a pas besoin de faire print(df.info()).

La dernière commande df.describe() permet d’obtenir sous forme d'un DataFrame un résumé statistique rapide des colonnes numériques du DataFrame, incluant des mesures telles que la moyenne (mean), l’écart-type (std), les valeurs minimales (min) et maximales (max), ainsi que les quartiles (25%, 50%, 75%) :

       total_bill         tip        size
count  244.000000  244.000000  244.000000
mean    19.785943    2.998279    2.569672
std      8.902412    1.383638    0.951100
min      3.070000    1.000000    1.000000
25%     13.347500    2.000000    2.000000
50%     17.795000    2.900000    2.000000
75%     24.127500    3.562500    3.000000
max     50.810000   10.000000    6.000000

🔍 Filtrer les données

Il est possible de créer un nouveau DataFrame en filtrant des lignes.
Par exemple, on peut filtrer pour ne conserver que :

# les lignes où le pourboire est supérieur à 5
df_filtre1 = df[df["tip"] > 5]
print(df_filtre1)

# les lignes où le jour est "Sun" et le temps est "Dinner"
df_filtre2 = df[(df["day"] == "Sun") & (df["time"] == "Dinner")]
print(df_filtre2)

# les lignes où le jour contient la chaîne de caractère "u"
# (ceci limite les résultats aux jours : Sun et Thur)
df_filtre3 = df[df["day"].str.contains("u")]
print(df_filtre3)

# les lignes où le serveur est une femme et le pourboire est supérieur à 3
df_filtre4 = df[(df["sex"] == "Female") & (df["tip"] > 3)]
print(df_filtre4)

# les lignes où la longueur de la chaîne dans la colonne "day" est supérieure à 3
df_filtre5 = df[df["day"].str.len() > 3]
print(df_filtre5)

# les lignes où le jour est dans une liste de valeur souhaitées
liste_journees_a_conserver = ["Fri", "Sat"]
df_filtre6 = df[df["day"].isin(liste_journees_a_conserver)]
print(df_filtre6)

Attention

Toutes ces opérations (et celles qui suivent) ne modifient pas le DataFrame original df.
Elles renvoient un nouveau DataFrame basé sur les critères spécifiés.

Il est cependant possible de stocker le résultat dans une nouvelle variable (si nécessaire) :

df_filtered = df[df["tip"] > 5]

df_filtered contiendra alors un nouveau DataFrame avec uniquement les lignes où le pourboire est supérieur à 5.

📈 Trier et ordonner les données

Il est possible de créer un nouveau DataFrame trié sur une ou plusieurs colonnes :

# Trier par montant total de la facture (total_bill) en ordre croissant
df_trie1 = df.sort_values(by="total_bill")
print(df_trie1)

# Trier par pourboire (tip) en ordre décroissant
df_trie2 = df.sort_values(by="tip", ascending=False)
print(df_trie2)

# Trier par jour puis par montant total de la facture
df_trie3 = df.sort_values(by=["day", "total_bill"])
print(df_trie3)

Combinaison des opérations

Il est possible de chaîner les opérations. Par exemple, on peut filtrer les données, puis les trier immédiatement. Cela peut se faire en deux instructions séparées, tout comme il est possible de le faire en une seule ligne!

# Création de 2 DataFrames contenant les mêmes lignes
# (les données de la fin de semaine triées en ordre du montant total de la facture)

# Version détaillée (en 2 étapes)
df_version1 = df[df["day"].isin(["Sun","Sat"])]
df_version1 = df_version1.sort_values(by="total_bill")
print(df_version1)

# Version compacte (en 1 seule instruction : "Method Chaining")
df_version2 = df[df["day"].isin(["Sun","Sat"])].sort_values(by="total_bill")
print(df_version2)

Débogage

Lorsque vous combinez plusieurs opérations, il peut être complexe d'identifier la source d'une erreur. Le débogage est souvent plus simple en décomposant les instructions sur des lignes distinctes. Cela permet de vérifier l'état du DataFrame après chaque transformation.

Performance : filtrer avant de trier!

En programmation, on applique souvent le principe de réduction précoce (early filtering) : plus tôt on réduit la taille du jeu de données, plus les opérations suivantes seront fluides et performantes. Par conséquent, commencez toujours par filtrer vos données avant de les trier.

🎯 Sélectionner des colonnes et des lignes

Nous avons vu comment filtrer des lignes en fonction de critères spécifiques.
Voyons maintenant comment sélectionner des colonnes ou des lignes spécifiques d'un DataFrame.

Il est possible de créer un NOUVEAU DataFrame à partir d'un DataFrame existant en ne conservant que certaines colonnes ou certaines lignes.

📌 Sélection de colonnes

Pour sélectionner plusieurs colonnes, on utilise une liste de noms de colonnes :

colonnes_a_conserver = ["total_bill", "tip", "day"]
df_plusieurs_colonnes = df[colonnes_a_conserver]
print(df_plusieurs_colonnes)

On peut aussi le faire directement (attention aux doubles crochets [[...]]) :

df_plusieurs_colonnes = df[["total_bill", "tip", "day"]]
print(df_plusieurs_colonnes)

📌 Sélection de lignes

On peut sélectionner des lignes avec différentes méthodes :

# Créer un nouveau DataFrame avec les 10 premières lignes
df_debut = df.head(10)
print(df_debut)

# Créer un DataFrame avec un intervalle de lignes (index 3 à 9)
df_plage_lignes = df.iloc[3:10]
print(df_plage_lignes)

# Créer un DataFrame avec des lignes spécifiques (index 0, 5 et 10)
df_lignes_specifiques = df.iloc[[0, 5, 10]]
print(df_lignes_specifiques)

📌 Sélection d'une seule colonne ou d'une seule ligne

On peut aussi sélectionner une seule colonne ou une seule ligne.

👉 Dans ce cas, le résultat n’est plus un DataFrame, mais une Series.

Une Series est une structure de données à une dimension, semblable à une liste, mais avec des index (étiquettes).

# Une seule colonne → Series
serie_total_bill = df["total_bill"]
print(serie_total_bill)

# Une seule ligne → Series
serie_une_ligne = df.iloc[3]
print(serie_une_ligne)

⚠️ Piège important

Le type retourné dépend de comment on sélectionne, pas seulement du nombre d’éléments :

df.iloc[3]     # → Series
df.iloc[[3]]   # → DataFrame

df["total_bill"]     # → Series
df[["total_bill"]]   # → DataFrame

👉 Les crochets simples vs doubles changent tout !

💡 Observations importantes

Prenez le temps d'observer le contenu affiché dans la console.

Le DataFrame :
- 2 dimensions (lignes + colonnes)
- Colonnes affichées en haut
- Index à gauche
La Series :
- 1 dimension
- Une liste de valeurs avec des index
- 👉 Deux cas courants :
  - Vous avez sélectionné une seule colonne (df["total_bill"])
  - Vous avez sélectionné une seule ligne (df.iloc[3])

⚙️ Méthodes

Certaines méthodes sont communes aux DataFrames et aux Series (mean(), sort_values(), etc.), mais d'autres sont spécifiques à chacun.

👉 En cas de doute :

type(variable)

🔁 Parcourir un DataFrame et une Series

On peut parcourir les lignes d'un DataFrame avec iterrows() et une boucle for :

import pandas as pd

# Création d'un DataFrame
df = pd.DataFrame({
    'Nom': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35]
})

for index, row in df.iterrows():
    print(f"Index : {index}, Nom : {row['Nom']}, Age : {row['Age']}")

Pour une Series, c’est comme une liste :

for x in df["Nom"]:  # (la sélection d'une seule colonne d'une DataFrame génère une Series)
    print(f"Nom : {x}")

🔍 Accéder à une valeur précise

La méthode loc permet d’accéder à une valeur précise, à l'intersection d'une ligne et d'une colonne spécifiées d'un DataFrame.

Par exemple, cette instruction produira le DataFrame ci-dessous :

# Résumé statistique
desc = df.describe()
print(desc)

       total_bill         tip        size
count  244.000000  244.000000  244.000000
mean    19.785943    2.998279    2.569672
std      8.902412    1.383638    0.951100
min      3.070000    1.000000    1.000000
25%     13.347500    2.000000    2.000000
50%     17.795000    2.900000    2.000000
75%     24.127500    3.562500    3.000000
max     50.810000   10.000000    6.000000

Il est possible de récupérer la valeur à l'intersection de la ligne mean et de la colonne tip comme ceci :

# Extraire la moyenne ('mean') de la colonne 'tip'
mean_tip = desc.loc['mean', 'tip']
print("Moyenne de tip :", mean_tip) # 2.998279

🧮 Créer de nouvelles colonnes

Parfois, dans un DataFrame, on veut créer une nouvelle colonne, en effectuant un calcul ou une transformation à partir d'une ou plusieurs colonnes existantes.
Par exemple, on peut ajouter, au DataFrame df contenant les données sur les pourboires, de nouvelles colonnes :

# Ajouter une colonne pour le pourcentage de pourboire
df["tip_percentage"] = (df["tip"] / df["total_bill"]) * 100

# Ajouter une colonne indiquant si la journée fait partie de la fin de semaine
df["is_weekend"] = df['day'].isin(['Sun', 'Sat'])

# Ajouter une colonne indiquant si le moment du repas est "Dinner"
df["is_dinner"] = df["time"] == "Dinner"

# Ajouter une colonne indiquant si les pourboires sont supérieurs à 5$
df["is_generous"] = df["tip"] > 5

Cela ajoute 4 nouvelles colonnes au DataFrame :

tip_percentage : calcul du pourcentage de pourboire par rapport au montant total de la facture (float)
is_weekend : indique si la journée fait partie de la fin de semaine ou pas (bool)
is_dinner : indique si le moment du repas est "Dinner" ou pas (bool)
is_generous indique si le pourboire est supérieur à 5$ ou pas (bool)

Les nouvelles colonnes créées peuvent servir dans des opérations, par exemple :

# Afficher uniquement les lignes où la colonne 'is_generous' est égale à True,
# conserver uniquement les colonnes 'total_bill', 'tip', 'tip_percentage', 'day' et 'is_weekend',
# trier ces lignes par ordre croissant de pourboire ('tip'),
# puis afficher les 10 premières lignes du résultat.
colonnes_a_afficher = ["total_bill", "tip", "tip_percentage", "day", "is_weekend"]
print(df[df["is_generous"] == True][colonnes_a_afficher].sort_values(by="tip").head(10))

On peut ici observer le contenu des nouvelles colonnes tip_percentage et is_weekend :

     total_bill   tip  tip_percentage   day  is_weekend
     29.93  5.07       16.939526   Sun        True
     29.85  5.14       17.219430   Sun        True
      7.25  5.15       71.034483   Sun        True
     25.89  5.16       19.930475   Sat        True
      34.83  5.17       14.843526  Thur       False
      34.81  5.20       14.938236   Sun        True
      30.40  5.60       18.421053   Sun        True
     23.33  5.65       24.217745   Sun        True
      24.71  5.85       23.674626  Thur       False
     29.03  5.92       20.392697   Sat        True

🔁 Mapper une valeur à l'aide d'un dictionnaire

Imaginons que nous avons le DataFrame suivant représentant la valeur du Bitcoin et de certains altcoins :

df = pd.DataFrame({
    "symbole": ["BTC", "ETH", "SOL", "ADA", "XRP", "DOT"],
    "valeur_courante" : [94406.0, 3101.57, 137.55,0.4854, 2.22, 2.80]
})

Et le dictionnaire suivant contenant le nom correspondant à chaque symbole :

dict_symboles_noms = {
    "BTC": "Bitcoin",
    "ETH": "Ethereum",
    "SOL": "Solana",
    "ADA": "Cardano",
    "XRP": "Ripple",
    "DOT": "Polkadot"
}

Il est possible de créer une nouvelle colonne dans notre DataFrame contenant le nom en utilisant la méthode map() :

df["nom"] = df["symbole"].map(dict_symboles_noms)
print(df.head())

Notre DataFrame contient maintenant une nouvelle colonne nom avec le nom complet de chaque crypto-monnaie :

  symbole  valeur_courante       nom
   BTC       94406.0000   Bitcoin
   ETH        3101.5700  Ethereum
   SOL         137.5500    Solana
   ADA           0.4854   Cardano
   XRP           2.2200    Ripple

En résumé, dans cet exemple, la méthode map() :

regarde chaque valeur de la colonne symbole ;
cherche la clé correspondante dans le dictionnaire dict_symboles_noms ;
renvoie une colonne avec les valeurs correspondantes.

🧠 Statistiques sur les Séries

Les Series possèdent plusieurs méthodes permettant de calculer rapidement des statistiques. Par exemple :

# Moyenne du pourboire
tip_moyen = df["tip"].mean()
print(tip_moyen) # affiche 2.99827868852459

Parmi les méthodes les plus utilisées sur les séries, on retrouve les suivantes :

mean() → moyenne
sum() → somme
min() → minimum
max() → maximum
first() → premier élément
last() → dernier élément

count() → nombre d’éléments
nunique() → nombre de valeurs uniques (sans répétition)
unique() → liste des valeurs uniques (sans répétition)
std() → écart-type
var() → variance
median() → médiane

Séries - Lister les différentes valeurs sans répétition

Si vous souhaitez connaître la liste des valeurs distinctes présentes dans une colonne, vous pouvez utiliser la fonction unique() sur une série.
L'exemple ci-dessous identifie tous les jours de la semaine représentés dans le jeu de données. On peut constater l'absence de données dans le jeu de données pour lundi, mardi et mercredi.

# Récupérer les valeurs uniques de la colonne "day"
jours_uniques = df["day"].unique()

# Récupérer le nombre de valeurs différentes
nb_valeurs_differentes = df["day"].nunique()

print(jours_uniques)            # Affichage : ['Sun' 'Sat' 'Thur' 'Fri']
print(nb_valeurs_differentes)   # Affichage : 4

Il est à noter que la méthode nunique()ne compte pas les valeurs manquantes (NaN), alors que la méthode unique() les inclut dans la liste des valeurs uniques.

GroupBy - Regroupement et calcul de statistiques

La méthode groupby() rend possible le calcul de statistiques basées sur des regroupements. Par exemple, si on souhaite connaître la moyenne des pourboires par jour, nous pouvons exécuter le code suivant :

# Moyenne du pourboire par jour
tip_par_jour = df.groupby("day")["tip"].mean()
print(tip_par_jour)

Cela produira une Series similaire à :

day
Fri     2.734737
Sat     2.993103
Sun     3.255132
Thur    2.771452
Name: tip, dtype: float64

On voit que c'est plus payant le dimanche ! 😉
Il aurait été possible de remplacer mean() par n'importe quelle autre méthode mentionnée plus haut (statistiques sur les séries).

Remarquez la dernière ligne : Name: tip, dtype: float64
Cela indique que le résultat est une Series (et non un DataFrame) contenant les moyennes des pourboires (tip) par jour, dont le type est un float (float64).
La colonne utilisée pour le regroupement (day) est devenue l'index de cette série.

Bien comprendre ce que fait un groupby

C'est l'équivalent de lancer un petit algorithme en trois étapes :

Étape #1 : SPLIT (Séparer)
- Pandas parcourt la colonne spécifiée (ex: day) et isole les lignes dans des compartiments distincts.
- Il crée un "tiroir" pour le samedi, un pour le dimanche, etc.
Étape #2 : APPLY (Appliquer)
- On applique une fonction mathématique sur chaque tiroir indépendamment.
- Par exemple, on calcule la moyenne (mean()) des factures uniquement pour le samedi, puis uniquement pour le dimanche.
Étape #3 : COMBINE (Combiner)
- Pandas récupère les résultats de chaque groupe et les combine pour produire un nouvel objet Pandas de synthèse (Series ou DataFrame, selon l’opération effectuée).

Ce qui se passe techniquement?

Les lignes disparaissent : On ne parle plus de facture 4 ou la facture 12, on parle plutôt des regroupements (des tiroirs).
Les étiquettes changent : La colonne qui a servi au regroupement (day) n'est plus une simple colonne, elle devient l'index de votre nouvelle Series.
La réduction : Si vous aviez 100 lignes pour le samedi, elles sont maintenant résumées en une seule ligne.

Calculer plusieurs statistiques en même temps
Il est possible de calculer plusieurs statistiques en même temps en passant la méthode agg().
Cette méthode s'attend à recevoir une liste de string contenant le nom des fonctions statistiques. Par exemple :

# Moyenne et somme du pourboire par jour
df_somme_et_moyenne_tip_par_jour = df.groupby("day")["tip"].agg(['mean', 'sum'])
print(df_somme_et_moyenne_tip_par_jour)

Cela produira un DataFrame similaire à :

          mean     sum
day
Fri   2.734737   51.96
Sat   2.993103  260.40
Sun   3.255132  247.39
Thur  2.771452  171.83

Chacune des statistiques calculées possède sa propre colonne.

Regardons maintenant un exemple couvrant l'étendu des pouvoirs de la méthode groupby :

df_groupby_ultime = df.groupby(["sex","day"])[["tip", "total_bill"]].agg(['min', 'max', 'mean', 'count'])
print(df_groupby_ultime)

Cela produira un DataFrame similaire à :

              tip                        total_bill
              min    max      mean count        min    max       mean count
sex    day
Female Fri   1.00   4.30  2.781111     9       5.75  22.75  14.145556     9
       Sat   1.00   6.50  2.801786    28       3.07  44.30  19.680357    28
       Sun   1.01   5.20  3.367222    18       9.60  35.26  19.872222    18
       Thur  1.25   5.17  2.575625    32       8.35  43.11  16.715312    32
Male   Fri   1.50   4.73  2.693000    10       8.58  40.17  19.857000    10
       Sat   1.00  10.00  3.083898    59       7.74  50.81  20.802542    59
       Sun   1.32   6.50  3.220345    58       7.25  48.17  21.887241    58
       Thur  1.44   6.70  2.980333    30       7.51  41.19  18.714667    30

Décomposons l'instruction pour bien comprendre chaque opération :

groupby(["sex","day"])
- Regroupement basé sur les valeurs distinctes de plusieurs colonnes (sex et day)
- 2 valeurs distinctes trouvées pour la colonne sex
- 4 valeurs distinctes trouvées pour la colonne day
- Donc 2 x 4 = 8 regroupements, le DataFrame possède une ligne par regroupement
[["tip", "total_bill"]]
- Le calcul des statistiques doit se faire sur plusieurs colonnes
- ATTENTION : étant donné qu'il y a plusieurs colonnes, les doubles [[ ]] sont nécessaires
agg(['min', 'max', 'mean', 'count'])
- Plusieurs fonctions statistiques appliquées sur chacune des colonnes
- 4 fonctions statistiques x 2 colonnes = 8 colonnes contenant des statistiques

🔍 GroupBy — Explorer les groupes

Après un groupby(), on peut obtenir différentes informations sur les groupes créés.

groupe_par_jour = df.groupby("day")

📌 Nombre de groupes

print(f"Nombre de groupes : {len(groupe_par_jour)}")
# Exemple : 4 (Fri, Sat, Sun, Thur)

👉 len(...) donne le nombre de groupes distincts.

📌 Noms des groupes (méthode directe)

print(list(groupe_par_jour.groups.keys()))

👉 Résultat :

['Fri', 'Sat', 'Sun', 'Thur']

📌 Noms des groupes après une opération

Lorsqu’on applique une opération comme mean(), les noms des groupes deviennent l’index du résultat :

tip_par_jour = df.groupby("day")["tip"].mean()
print(tip_par_jour.index.to_list())

👉 Résultat :

['Fri', 'Sat', 'Sun', 'Thur']

💡 À retenir

len(groupby) → nombre de groupes
groupby.groups.keys() → noms des groupes
.index après une opération → noms des groupes

📋 Tables de pivot

Une table de pivot, générée avec la méthode pivot_table(), permet de créer un tableau de synthèse à partir d’un DataFrame. On y choisit généralement :

la valeur à résumer (values)
le regroupement des lignes (index)
le regroupement des colonnes (columns)
la fonction statistique à appliquer (aggfunc)

C’est un peu comme un groupby(), mais avec une présentation souvent plus pratique pour comparer plusieurs groupes en même temps.

Par exemple, si on veut calculer le pourboire moyen selon la taille du groupe et selon qu’on est en semaine ou en fin de semaine :

df["is_weekend"] = df["day"].isin(["Sun", "Sat"])

df_pivot = df.pivot_table(
    values="tip",          # la valeur à résumer
    index="size",          # regroupement des lignes
    columns="is_weekend",  # regroupement des colonnes
    aggfunc="mean"         # fonction statistique à appliquer
)

print(df_pivot)

On obtiendra un DataFrame de synthèse (pivot table) :

is_weekend     False     True
size
         1.875000  1.000000
         2.492969  2.644457
         2.754000  3.490000
         4.303333  4.102903
         5.000000  3.785000
         5.300000  5.000000

les lignes correspondent à size
les colonnes correspondent à is_weekend
les cellules contiennent la moyenne des pourboires

👉 Ici, par exemple, la fin de semaine, les groupes de 3 personnes ont donné, en moyenne, un pourboire de 3,49 $.

Ce type de tableau est particulièrement utile avant une visualisation, car il organise déjà les données dans une forme facile à tracer.

🧹 Nettoyage de données

La qualité des données est aussi cruciale que la précision d'une pesée en chimie.
Le nettoyage de données est l'étape qui sépare un graphique illisible d'une conclusion scientifique solide.
Cette étape est généralement réalisée avant les analyses importantes ou la modélisation.

Pourquoi nettoyer ses données?
👉 Le principe du Garbage In, Garbage Out (Déchets en entrée, déchets en sortie)
Si les données de base sont erronées, les calculs de moyenne, d'écart-type ou les régressions linéaires seront faussés.

On nettoie pour :

Éviter les erreurs de calcul : Les valeurs manquantes (NaN, Not a Number) peuvent compliquer les calculs, produire des résultats incomplets ou empêcher certaines opérations.
Assurer la précision : Éliminer les doublons ou les valeurs aberrantes (ex : un capteur de température qui indique 500°C dans un frigo).
Faciliter la visualisation : Un point "fantôme" à zéro peut écraser l'échelle du graphique et masquer la tendance réelle.

🗑️ Nettoyage - Supprimer les lignes incomplètes

On utilise cette approche quand on veut un jeu de données "parfait" où chaque ligne est complète sans valeur manquante.

df_propre = df.dropna()

⚠️ Attention : cette approche est radicale !
Si une seule donnée d'une ligne est manquante (même dans une colonne peu importante), la ligne complète est supprimée.

🧹 Supprimer les lignes uniquement si une donnée est manquante

Utile lorsqu'une ligne est inutilisable seulement si une donnée critique (ex : la variable dépendante) est manquante.

# On supprime la ligne seulement si 'COLONNE_A' ou 'COLONNE_B' est manquant
df_propre = df.dropna(subset=['COLONNE_A', 'COLONNE_B'])

Cela permet de conserver des lignes où des informations secondaires seraient absentes, sans affecter les calculs.

🧹 Supprimer les doublons

Cette fonction élimine les lignes qui sont des copies exactes d'autres lignes.
C'est fréquent lors de la fusion de plusieurs fichiers de résultats.

df_propre = df.drop_duplicates()

Remplacer les valeurs manquantes

Au lieu de supprimer une ligne, on peut remplacer un NaN par une valeur.
⚠️ Cette valeur doit être choisie avec soin et avoir du sens dans le contexte.

df['MA_COLONNE'] = df['MA_COLONNE'].fillna(0)

Note : en statistiques, on remplace parfois les valeurs manquantes par la moyenne de la colonne.

Corriger un type de données

Parfois, Pandas importe des chiffres en les considérant comme du texte (souvent à cause d'une virgule ou d'une unité mal placée).

On peut alors forcer le type :

df['MA_COLONNE'] = df['MA_COLONNE'].astype(float)

⚠️ Cette conversion fonctionne seulement si toutes les valeurs peuvent être converties en nombres.

🔄 Transformer les données

Le nettoyage peut aussi passer par la création de nouvelles colonnes basées sur des calculs ou des transformations.

📊 Visualisation rapide (avec Matplotlib intégré)

Pandas s'intègre avec Matplotlib pour générer rapidement des graphiques à partir des données d'un DataFrame :

import pandas as pd
import matplotlib.pyplot as plt

# Lire le fichier CSV dans un DataFrame
df = pd.read_csv('tips_dataset.csv')

# Ajouter une colonne pour le pourcentage de pourboire
df["tip_percentage"] = (df["tip"] / df["total_bill"]) * 100

# Histogramme du pourcentage de pourboire
df["tip_percentage"].hist(  # Histogramme de la colonne "tip_percentage" (axe des x)
    bins=20                 # Diviser l'axe des x en 20 intervalles égaux (20 "bins")
)
plt.title("Distribution du pourcentage de pourboire")
plt.xlabel("Pourcentage de pourboire")
plt.ylabel("Fréquence")
plt.grid(axis='both', linestyle='--', linewidth=0.5)
plt.show()

# Boîte à moustaches du pourcentage de pourboire par jour
df.boxplot(
    column="tip_percentage", # Axe des y
    by="day"                 # Axe des x (regroupement)
)
plt.title("Pourcentage de pourboire par jour")
plt.suptitle("")  # Supprimer le titre autogénéré apparaisant en haut de notre titre
                  # (il indique le regroupement réalisé)
plt.xlabel("Jour")
plt.ylabel("Pourcentage de pourboire")
plt.grid(axis='both', linestyle='--', linewidth=0.5)
plt.show()

📊 Visualisation avec taille de point proportionnelle à une (3e) variable

Voici un graphique montrant la relation entre le montant total de la facture (total_bill), le pourboire (tip) et la taille du groupe (size). Le montant total est sur l'axe X, le pourboire sur l'axe Y, et la taille du groupe est représentée pas la grosseur du point :

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv('tips_dataset.csv')

plt.scatter(
    x=df["total_bill"],   # Axe des x
    y=df["tip"],          # Axe des y
    s=df["size"] * 20,    # Taille des points (fois un facteur de 20 pour les rendre plus visibles)
    alpha=0.5             # Opacité des points
)

plt.xlabel("Montant total de la facture ($)")
plt.ylabel("Pourboire ($)")
plt.title("Pourboire en fonction du montant total de la facture\n(taille proportionnelle à la taille du groupe)")
plt.grid(axis='both', linestyle='--', linewidth=0.5)

plt.show()

Visualisation avec courbes regroupées selon une (3e) variable catégorielle

Et voici un graphique montrant la relation entre le pourboire (tip) et la taille du groupe (size), selon qu'on est la semaine ou la fin de semaine, en utilisant la fonction pivot_table() de Pandas pour réorganiser les données :

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv('tips_dataset.csv')

# Ajouter une colonne indiquant si la journée fait partie de la fin de semaine (True/False)
df["is_weekend"] = df['day'].isin(['Sun', 'Sat'])

# Créer un tableau croisé dynamique (pivot table) pour calculer le pourboire (tip) moyen (mean)
# par taille de groupe (size) et par type de jour (is_weekend)
df_pivot = df.pivot_table(
    values="tip",          # Axe des y
    index="size",          # Axe des x (1er regroupement)
    columns="is_weekend",  # Courbes   (2e regroupement)
    aggfunc='mean'         # Fonction d'agrégation à appliquer (ici la moyenne)
)

# Tracer les courbes de ce nouveau tableau croisé
df_pivot.plot(marker='o') # (marker='o' si on veut ajouter des points sur les lignes)

plt.xlabel("Taille du groupe")
plt.ylabel("Pourboire moyen ($)")
plt.title("Pourboire moyen en fonction de la taille du groupe\n(par jour de la semaine)")
plt.grid(axis='both', linestyle='--', linewidth=0.5)

# Changer les étiquettes de is_weekend dans la légende
plt.legend(title='Jour de la semaine', labels=['Jour de semaine', 'Fin de semaine'])

plt.show()

🤖 Introduction à Scikit-learn

Scikit-learn est une bibliothèque Python utilisée pour faire de l’apprentissage automatique (machine learning).
Elle permet de créer des modèles capables de détecter des relations dans les données afin de faire des prédictions.

On retrouve principalement trois types d’algorithmes :

Classification → classer des éléments (ex : ceci est une photo de chat, ceci est une photo de chien)
Régression → prédire une valeur numérique (ex : combien de Bixi seront empruntés demain)
Clustering → regrouper des données similaires (ex : identifier des groupes de clients avec des comportements semblables)

🧠 Concepts clés

Modèle : algorithme qui apprend à partir des données
Prétraitement des données : préparer les données (normaliser, encoder, nettoyer)
Évaluation des modèles : mesurer la qualité des prédictions
Pipeline : enchaîner plusieurs étapes automatiquement

👉 Cette semaine, nous allons nous concentrer sur des modèles simples de régression, en lien avec la visualisation des données.

🚗 Démonstration : Consommation d’essence et caractéristiques des voitures

Nous utiliserons le jeu de données classique Auto MPG (Miles per Gallon) pour explorer la relation entre la consommation d’essence (mpg) et des variables comme le poids (weight) ou le nombre de cylindres (cylinders).

Ce jeu de données (dataset) est très vintage (années 70-80), mais reste un excellent exemple pédagogique.
Vous pouvez le télécharger ici : mpg_dataset.csv

🧰 Chargement du jeu de données

import pandas as pd

# Chargement du jeu de données
df = pd.read_csv('mpg_dataset.csv')

# Aperçu
print(df.head())
df.info()

    mpg  cylinders  displacement  ...  model_year  origin                       name
0  18.0          8         307.0  ...          70     usa  chevrolet chevelle malibu
1  15.0          8         350.0  ...          70     usa          buick skylark 320
2  18.0          8         318.0  ...          70     usa         plymouth satellite
3  16.0          8         304.0  ...          70     usa              amc rebel sst
4  17.0          8         302.0  ...          70     usa                ford torino

[5 rows x 9 columns]

RangeIndex: 398 entries, 0 to 397
Data columns (total 9 columns):
 #   Column        Non-Null Count  Dtype
---  ------        --------------  -----
 0   mpg           398 non-null    float64
 1   cylinders     398 non-null    int64
 2   displacement  398 non-null    float64
 3   horsepower    392 non-null    float64
 4   weight        398 non-null    int64
 5   acceleration  398 non-null    float64
 6   model_year    398 non-null    int64
 7   origin        398 non-null    object
 8   name          398 non-null    object
dtypes: float64(4), int64(3), object(2)
memory usage: 28.1+ KB

Ce jeu de données contient 398 entrées (voitures) avec les 9 colonnes suivantes :

mpg : consommation en miles par gallon
cylinders : nombre de cylindres
displacement : cylindrée en pouces cubes
horsepower : puissance en chevaux
weight : poids en livres
acceleration : temps d’accélération de 0 à 60 mph
model_year : année du modèle
origin : pays d’origine (usa, europe, japan)
name : nom du modèle

Ce qui nous intéresse ici, c’est de voir comment certaines caractéristiques (ex. poids, cylindres) influencent la consommation (mpg, première colonne).

🔍 Exploration rapide

Regroupons les voitures par nombre de cylindres et calculons la moyenne de consommation pour chaque groupe :

# Moyenne de la consommation par nombre de cylindres
print(df.groupby("cylinders")["mpg"].mean())

cylinders
  20.550000
  29.286765
  27.366667
  19.985714
  14.963107
Name: mpg, dtype: float64

💡 On observe une relation inverse : à l'exception des petits 3-cylindres, on dirait que plus il y a de cylindres, plus la mesure de consommation (mpg) diminue. 🤔
C'est plutôt logique : plus une voiture a de cylindres, plus elle consomme d’essence (donc moins elle parcourt de miles par gallon). Mais c'est un peu mélangeant, car on est plutôt habitué à penser à l'envers, soit en litres consommés aux 100 km (L/100km), où une consommation plus faible est donc meilleure.

👉 Nous allons donc créer une nouvelle colonne l_par_100km pour convertir mpg en litres aux 100 km :

# Conversion mpg -> L/100km
df["l_par_100km"] = 235.214583 / df["mpg"]

Refaisons le même calcul avec cette nouvelle colonne :

print(df.groupby("cylinders")["l_par_100km"].mean())

cylinders
  11.578018
   8.333277
   9.103094
  12.106109
  16.235661
Name: l_par_100km, dtype: float64

Visualisons maintenant la relation entre le poids (weight) et la consommation (l_par_100km) avec un graphique de dispersion (scatter plot) :

# Visualisation simple
import matplotlib.pyplot as plt

plt.scatter(df["weight"], df["l_par_100km"], alpha=0.6)

plt.xlabel("Poids du véhicule (lbs)")
plt.ylabel("Consommation d'essence (L/100km)")
plt.title("Consommation d'essence en fonction du poids du véhicule")

plt.show()

💬 On observe une tendance claire : plus le poids du véhicule augmente, plus la consommation en litres aux 100 km augmente également. Cela confirme notre intuition que les voitures plus lourdes consomment plus d’essence.

🧮 Régression linéaire simple (Scikit-learn)

Nous allons modéliser cette relation avec une régression linéaire (LinearRegression).

Préparons d'abord les données :

# Suppression des lignes contenant des valeurs manquantes
# (on regarde seulement les colonnes utilisées : l_par_100km et weight)
df = df.dropna(subset=["l_par_100km", "weight"])

# Préparation des variables
X = df[["weight"]]            # variables explicatives (celles utilisées pour prédire y)
y = df["l_par_100km"]         # variable cible         (celle que l'on veut prédire)

Il est très important de bien comprendre ici la structure de X et y :

X est un DataFrame à 2 dimensions (double [ et double ]) même si une seule colonne : il doit toujours être en 2D pour Scikit-learn.
y est une Series (1D) contenant les valeurs cibles.

Ici :

X est une matrice 2D de dimensions (n_samples, n_features) où n_samples est le nombre de voitures et n_features est 1 (le poids).
y est un vecteur 1D de longueur n_samples contenant les valeurs de consommation (l_par_100km).

Plus précisément, comme on a 398 voitures, X aura une forme (398, 1) et y aura une forme (398,) :

print(X)

     weight
    3504
    3693
    3436
    3433
    3449
..      ...
  2790
  2130
  2295
  2625
  2720

[398 rows x 1 columns]

print(y)

    13.067477
    15.680972
    13.067477
    14.700911
    13.836152
         ...
   8.711651
   5.345786
   7.350456
   8.400521
   7.587567
Name: l_par_100km, Length: 398, dtype: float64

Entraînons maintenant le modèle de régression linéaire :

from sklearn.linear_model import LinearRegression

# On crée un modèle linéaire :
model = LinearRegression()

# Le modèle va essayer de trouver la "meilleure droite" qui représente la relation entre X et y.
# 👉 On "entraîne" le modèle :
model = model.fit(X, y)

# ⚠️ ici, le score est calculé sur les données d'entraînement :
print("Score R² :", model.score(X, y))
print("Coefficient :", model.coef_[0])
print("Intercept :", model.intercept_)

Score R² : 0.7836118983544517
Coefficient : 0.0040789144329788085
Intercept : -0.9030520509041988

Un score R² de 0.78 indique que le modèle explique environ 78% de la variance observée dans la consommation (l_par_100km) en fonction du poids
- R² indique que le modèle explique bien la relation observée (très bon).
- Un score R² = 1 : Le modèle explique parfaitement la variance des données (Parfait)
- Un score 0.7 ≤ R² < 1 : Le modèle explique bien la variance, mais pas parfaitement (Très bon)
- Un score 0.5 ≤ R² < 0.7 : Le modèle explique une partie significative de la variance (Acceptable)
- Un score 0.3 ≤ R² < 0.5 : Le modèle a une faible capacité explicative (Médiocre)
- Un score 0 ≤ R² < 0.3 : Le modèle explique très peu de la variance (Faible)
- Un score R² = 0 : Le modèle n'explique rien du tout (Inutile)
- Un score R² < 0 : Le modèle est pire qu'une simple moyenne (régression non pertinente) (Mauvais)
Le coefficient positif (0.00408) confirme que la relation est directe : plus le poids augmente, plus la consommation (L/100km) augmente :
- Coefficient positif : la variable cible augmente quand la variable explicative augmente.
- Coefficient négatif : la variable cible diminue quand la variable explicative augmente.
- Coefficient proche de zéro : la variable explicative a peu ou pas d’effet.
La relation entre le poids et la consommation peut donc être modélisée par la formule de la droite de régression suivante :

\text{l\_par\_100km} \quad = \quad 0.00408 \times \text{weight} - 0.903

(où 0.00408 est la valeur du coefficient et -0.903 est la valeur intercept)

📈 Visualisation de la régression

La méthode model.predict() permet d'obtenir les valeurs cibles prédites par le modèle (à l'aide de la formule).

# On calcule les valeurs prédites par le modèle pour chaque poids
y_pred = model.predict(X)

plt.scatter(X, y, label="Données réelles", alpha=0.6)

# On ajoute la droite de régression :
plt.plot(X, y_pred, color="red", label="Régression linéaire")

plt.xlabel("Poids du véhicule (lbs)")
plt.ylabel("Consommation d'essence (L/100km)")
plt.title("Régression linéaire : Poids vs Consommation")
plt.legend()

plt.show()

💬 On obtient une droite de tendance montrant clairement la relation linéaire entre le poids et la consommation :

Les points bleus représentent les données réelles (poids vs consommation).
La ligne rouge est la droite de régression linéaire ajustée par le modèle.

Visualisation des cylindres

Colorons les points en fonction du nombre de cylindres pour voir si on peut observer une tendance supplémentaire :

# pour chaque nombre de cylindres :
for cyl in [8, 6, 5, 4, 3]:
    # on crée un dataframe filtré pour ce nombre de cylindres :
    subset = df[df["cylinders"] == cyl]
    # puis on trace les points correspondants :
    plt.scatter(subset["weight"], subset["l_par_100km"], alpha=0.6, label=f"{cyl} cylindres")

plt.xlabel("Poids du véhicule (lbs)")
plt.ylabel("Consommation d'essence (L/100km)")
plt.title("Consommation en fonction du poids selon le nombre de cylindres")
plt.legend()

plt.show()

💬 On observe que les voitures avec plus de cylindres (ex. 8 cylindres) ont tendance à être plus lourdes et à consommer plus d’essence, ce qui confirme notre analyse précédente.

⚙️ Régression multiple

On peut facilement ajouter d’autres variables (ex. nombre de cylindres, puissance) :

# Suppression des lignes contenant des valeurs manquantes
# (seulement pour les colonnes utilisées dans le modèle)
df = df.dropna(subset=["l_par_100km", "weight", "cylinders", "horsepower"])

# Préparation des variables :
# X → variables explicatives (plusieurs colonnes → modèle multiple)
# y → variable cible (ce qu'on veut prédire)
X = df[["weight", "cylinders", "horsepower"]]
y = df["l_par_100km"]

# On crée un modèle linéaire :
model = LinearRegression()

# Le modèle va essayer de trouver la "meilleure combinaison" de ces variables pour prédire y.
# 👉 On "entraîne" le modèle :
model.fit(X, y)

# ⚠️ ici, le score est calculé sur les données d'entraînement :
print("Score R² :", model.score(X, y))
print("Coefficients :", model.coef_)
print("Intercept :", model.intercept_)

Coefficients : [0.00229432 0.2757425  0.03284566]
Score R² : 0.8176921365228299
Intercept : -0.5232093212414135

Le score R² a augmenté à 0.82, indiquant que l’ajout de ces deux variables supplémentaires améliore la capacité du modèle à expliquer la variance de la consommation.
La relation reste positive pour le poids et le nombre de cylindres, et la puissance a aussi un effet positif sur la consommation.
La formule de la régression multiple est donc :

\text{l\_par\_100km} \quad = \quad 0.00229 \times \text{weight} \quad + \quad 0.2757 \times \text{cylinders} \quad + \quad 0.03285 \times \text{horsepower} \quad - \quad 0.5232

(où 0.00229, 0.2757 et 0.03285 sont les valeurs des coefficients des variables explicatives et -0.5232 est la valeur intercept)

🧠 À retenir

Objectif	Outil
Charger et explorer les données	🐼 Pandas
Visualiser les relations	📊 Matplotlib
Modéliser une tendance	🤖 Scikit-learn (ex : LinearRegression)

🎯 Au prochain cours, nous verrons comment utiliser Scikit-learn pour des tâches plus avancées, notamment l'apprentissage machine (machine learning) et l'apprentissage profond (deep learning).

Pour favoriser une progression efficace, ce cours adopte une approche de classe inversée. Ce modèle déplace l'acquisition théorique hors de la classe pour transformer les heures de rencontre en véritables séances d'application pratique.

À la maison (Exploration et Appropriation) : Vous êtes le maître de votre rythme. Ces activités vous permettent de découvrir les nouveaux concepts et tester les exemples au moment où vous êtes le plus concentré. Si une notion vous semble obscure, n'hésitez pas à poser des questions à votre prof au fur et à mesure.
En classe (Application et Consolidation) : Le temps en présentiel est une ressource précieuse. Nous l'utilisons pour nous attaquer aux défis plus complexes et aux exercices de programmation qui demandent une mobilisation active de vos connaissances. C’est le moment idéal pour obtenir une rétroaction immédiate, collaborer avec vos pairs et bénéficier de l'accompagnement de votre enseignant au moment où vous en avez le plus besoin.

🏠 Activités à faire à la maison
🏫 Activités à faire en classe

🧠 Auto-validation des connaissances

Ce formulaire sert à vérifier votre compréhension des éléments les plus importants de la rencontre R11. Ne faites ce questionnaire que lorsque vous vous sentez en très bonne maîtrise de la matière. En classe, dès votre arrivée, vous aurez un questionnaire très similaire, évalué sommativement, à compléter sans accès à aucune documentation.

attention

Ne pas remplir le formulaire diminue fortement vos chances de réussir l’évaluation sommative en début de rencontre.
Assurez-vous de bien comprendre toutes les notions derrière chaque question.

✏️ Exercices de compréhension

Exercice - Écrire du code sans PyCharm

Sur papier, sans ordinateur, écrivez un code demandant à l'utilisateur de saisir un nombre.
Tant que le nombre saisi est positif, le programme redemande de saisir un nouveau nombre.
Lorsqu'un nombre saisi est négatif, le programme affiche tous les nombres saisis ainsi que leur somme.
Le programme prend alors fin.

Exemple d'exécution

Saisir un nombre : 20
Saisir un nombre : 50
Saisir un nombre : 10
Saisir un nombre : -5
Nombres saisis : [20, 50, 10, -5]
Somme : 75

Validez votre réponse à l'aide de Pycharm.

🔨 Exercices de création

Exercice - groupby et moyenne

Téléchargez le fichier tips_dataset.csv et utilisez 🐼 Pandas pour :

Charger les données dans un DataFrame.
Afficher les 10 premières lignes.
Calculer et afficher la moyenne du pourboire (tip) :
1. pour les clients fumeurs et non-fumeurs,
2. par jour de la semaine,
3. par temps (dîner/lunch),
4. par taille de groupe.

Résultats attendus :

smoker
No     2.991854
Yes    3.008710
Name: tip, dtype: float64

day
Fri     2.734737
Sat     2.993103
Sun     3.255132
Thur    2.771452
Name: tip, dtype: float64

time
Dinner    3.102670
Lunch     2.728088
Name: tip, dtype: float64

size
  1.437500
  2.582308
  3.393158
  4.135405
  4.028000
  5.225000
Name: tip, dtype: float64

Quelle(s) variable(s) semble(nt) influencer le plus le montant du pourboire ?
Quelle(s) variable(s) semble(nt) n'avoir aucun impact ?

Exercice - Visualisation : Pourboire par personne

Toujours avec le même jeu de données, créez une nouvelle colonne tip_par_person qui calcule le pourboire par personne (i.e. tip divisé par size). Ensuite, affichez les 5 premières lignes du DataFrame modifié.

Résultat attendu :

   total_bill   tip     sex smoker  day    time  size  tip_par_person
     16.99  1.01  Female     No  Sun  Dinner     2        0.505000
     10.34  1.66    Male     No  Sun  Dinner     3        0.553333
     21.01  3.50    Male     No  Sun  Dinner     3        1.166667
     23.68  3.31    Male     No  Sun  Dinner     2        1.655000
     24.59  3.61  Female     No  Sun  Dinner     4        0.902500

Ensuite, générez ces 2 graphiques :

un histogramme de cette nouvelle colonne tip_par_person pour visualiser la distribution des pourboires par personne en 20 intervalles égaux .
un boxplot de tip_par_person regroupé par taille de groupe (size) pour voir comment le pourboire par personne varie en fonction de la taille du groupe.

Résultats attendus :

Voyez-vous des tendances intéressantes ?

Exercice - Visualisation : Consommation d'essence

Téléchargez le fichier mpg_dataset.csv.
Dans un nouveau script :

Chargez les données dans un DataFrame.
Créez une nouvelle colonne l_par_100km en convertissant mpg en litres aux 100 km (au besoin, revoir l'onglet Scikit-learn).
Générez ces 2 graphiques :

Voyez-vous des tendances intéressantes ?

Exercice - Analyse : Modèles de véhicules

Toujours avec le fichier mpg_dataset.csv.
Dans un nouveau script, vous devez :

Charger les données dans un DataFrame.
Créer des nouveaux DataFrames à partir du DataFrame de départ vous permettant d'obtenir ces informations :
1. Les modèles japonais ayant une accélération de 19.4 et plus.
2. Les 5 voitures avec le plus de horsepower.
3. Le nombre de voitures japonaises avec un poid supérieur à 2500.
Présenter les résultats de ces DataFrames exactement comme ci-dessous :

Résultats attendus

Les modèles japonais ayant une accélération de 19.4 et plus :
    - toyota corolla 1200
    - mazda glc deluxe
    - datsun 210 mpg

Les 5 voitures avec le plus de horsepower :
    - horsepower : 230.0 - pontiac grand prix
    - horsepower : 225.0 - buick electra 225 custom
    - horsepower : 225.0 - pontiac catalina
    - horsepower : 225.0 - buick estate wagon (sw)
    - horsepower : 220.0 - chevrolet impala

Le nombre de voitures japonaises avec un poid supérieur à 2500 : 17

Indices

Pour l'affichage des résultats, consultez la section "Parcourir un DataFrame et une Series" de cet onglet.

Exercice - Analyse : Prix Turing

Téléchargez le fichier Téléchargez le fichier Turing.csv.

Placez-le dans le même dossier que votre script Python.
Il contient tous les gagnants du Prix Turing.

Dans un nouveau script, vous devez :

Charger les données dans un DataFrame.
Créer des nouveaux DataFrames à partir du DataFrame de départ vous permettant d'obtenir ces informations :
1. Nombre total de lauréats.
2. Lauréats avec 'intelligence' dans la contribution.
3. Années avec 3 lauréats ou plus.
Présenter les résultats de ces DataFrames exactement comme ci-dessous :

Résultat attendu :

Nombre total de lauréats : 79

Lauréats avec 'intelligence' dans la contribution :
    - Marvin Minsky
    - Allen Newell
    - Herbert A. Simon
    - Raj Reddy

Années avec 3 lauréats ou plus :
    - 2002
    - 2007
    - 2018

Indices
La dernière question d'analyse est la plus compliquée, voici quelques indices :

regrouper les données par années et utilisez la fonction statistique permettant de compter le nombre d'éléments;
filtrer ensuite le DataFrame pour n'obtenir que les lignes dont au moins une colonne contient une valeur de 3 ou plus ;
parcourir le DataFrame et utilisez l'index pour l'affichage.

Exercice - Régression linéaire simple et visualisation

Utilisez 🤖 Scikit-learn pour créer un modèle de régression linéaire simple qui prédit la consommation l_par_100km en fonction de la puissance (horsepower).

Affichez le score R², le coefficient et l'intercept du modèle :

Score R² : 0.7306976406434581
Coefficient : 0.08691820578815233
Intercept : 2.168240692150743

Ensuite, générez ce graphique de dispersion avec la droite de régression linéaire :

🎯 Solutions des exercices

Un solutionnaire possible pour chaque exercice est disponible en format vidéo avec des explications. Vous pouvez vous en servir pour comparer votre solution avec une solution possible jugée optimale et vous débloquer après un long moment bloqué sur un exercice (ex. 20 minutes) et après avoir utilisé le dégogueur pour essayer par vous-même de trouver le problème.

attention

Il est tout à fait normal que certains problèmes demandent du temps, de la réflexion, et parfois même un peu de frustration. C’est précisément dans ces moments d’effort que l’apprentissage s’ancre réellement.

Consulter un solutionnaire avant d’avoir tenté l’exercice par soi-même, ou le parcourir trop rapidement, revient à court-circuiter le processus d’apprentissage. Ce n’est pas simplement contre-productif, c’est pédagogiquement désastreux.

En sautant l’étape de la réflexion personnelle, on prive son cerveau de l’occasion de construire des connexions durables. Et à force de répéter ce réflexe, on risque de passer à côté des compétences essentielles, ce qui peut mener à des échecs plus tard, même si tout semble facile sur le moment. Alors oui, prenez le temps. L’erreur fait partie du jeu. C’est en cherchant, en tâtonnant, en doutant, qu’on devient réellement compétent. Le solutionnaire doit être un outil de validation, pas un raccourci.

🔨 Solution des exercices de création :

📌 Sélection de colonnes​

📌 Sélection de lignes​

📌 Sélection d'une seule colonne ou d'une seule ligne​

⚠️ Piège important​

💡 Observations importantes​

⚙️ Méthodes​

📌 Nombre de groupes​

📌 Noms des groupes (méthode directe)​

📌 Noms des groupes après une opération​

💡 À retenir​

🧠 Concepts clés​

🧰 Chargement du jeu de données​

🧠 Auto-validation des connaissances​

✏️ Exercices de compréhension​

Exemple d'exécution​

🔨 Exercices de création​

Résultats attendus​

Résultat attendu :​

🎯 Solutions des exercices

📌 Sélection de colonnes

📌 Sélection de lignes

📌 Sélection d'une seule colonne ou d'une seule ligne

⚠️ Piège important

💡 Observations importantes

⚙️ Méthodes

📌 Nombre de groupes

📌 Noms des groupes (méthode directe)

📌 Noms des groupes après une opération

💡 À retenir

🧠 Concepts clés

🧰 Chargement du jeu de données

🧠 Auto-validation des connaissances

✏️ Exercices de compréhension

Exemple d'exécution

🔨 Exercices de création

Résultats attendus

Résultat attendu :