madamasterclass.com
Manipulation de tables avec la bibliothèque Pandas
Dans ce cours, nous allons explorer la manipulation de tables avec la bibliothèque Pandas. Nous découvrirons comment importer et traiter des fichiers CSV, manipuler les DataFrames et Series, effectuer des interrogations et tris, créer de nouveaux champs, et fusionner des tables pour l'analyse de données.
Pandas est la bibliothèque Python de référence pour l'analyse et la manipulation de données structurées. Elle offre des structures de données puissantes et des outils flexibles pour transformer, nettoyer et analyser vos données de manière efficace.
Éducation
pip install pandasimport pandas as pdpd.read_csv() avec de nombreuses options
import pandas as pd
# Lecture basique d'un fichier CSV
df = pd.read_csv('donnees.csv')
# Avec options avancées
df = pd.read_csv('donnees.csv',
sep=';', # Séparateur personnalisé
encoding='utf-8', # Encodage des caractères
index_col=0, # Première colonne comme index
na_values=['N/A', 'NULL', '']) # Valeurs manquantes
# Aperçu rapide des données
print(df.head()) # 5 premières lignes
print(df.info()) # Informations sur les colonnes
print(df.describe()) # Statistiques descriptives
pd.read_csv() détecte automatiquement la plupart des formats CSV
| Structure | Création | Accès aux données |
|---|---|---|
| Series | pd.Series([1,2,3]) |
series[0] ou series['label'] |
| DataFrame | pd.DataFrame(dict) |
df['colonne'] ou df.colonne |
# Création d'une Series
ages = pd.Series([25, 30, 35], index=['Alice', 'Bob', 'Charlie'])
print(ages['Alice']) # 25
# Création d'un DataFrame
data = {
'nom': ['Alice', 'Bob', 'Charlie'],
'age': [25, 30, 35],
'ville': ['Paris', 'Lyon', 'Marseille']
}
df = pd.DataFrame(data)
# Accès aux données
print(df['nom']) # Colonne complète (Series)
print(df[['nom', 'age']]) # Plusieurs colonnes (DataFrame)
print(df.loc[0]) # Ligne par index de position
print(df.iloc[0]) # Ligne par position numérique
query() pour des filtres complexes&, |, ~
# Filtrage simple
jeunes = df[df['age'] < 30]
parisiens = df[df['ville'] == 'Paris']
# Filtres multiples
adultes_parisiens = df[(df['age'] >= 25) & (df['ville'] == 'Paris')]
# Méthode query() - plus lisible
resultats = df.query('age >= 25 and ville == "Paris"')
resultats = df.query('nom in ["Alice", "Bob"]')
# Filtrage par texte
df_filtré = df[df['nom'].str.contains('Al')] # Noms contenant "Al"
df_filtré = df[df['nom'].str.startswith('A')] # Noms commençant par "A"
# Valeurs manquantes
sans_na = df[df['age'].notna()] # Lignes sans valeurs manquantes
avec_na = df[df['age'].isna()] # Lignes avec valeurs manquantes
df.query() pour des conditions complexes - c'est plus lisible !
| Méthode | Utilisation | Exemple |
|---|---|---|
sort_values() |
Tri par valeurs | df.sort_values('age') |
sort_index() |
Tri par index | df.sort_index() |
nlargest() |
N plus grandes valeurs | df.nlargest(3, 'age') |
nsmallest() |
N plus petites valeurs | df.nsmallest(2, 'age') |
# Tri simple par une colonne
df_trié = df.sort_values('age') # Croissant
df_trié = df.sort_values('age', ascending=False) # Décroissant
# Tri multiple
df_trié = df.sort_values(['ville', 'age'], ascending=[True, False])
# Tri avec gestion des valeurs manquantes
df_trié = df.sort_values('age', na_position='first') # NaN en premier
# Tri par index
df_trié = df.sort_index() # Par index de ligne
df_trié = df.sort_index(axis=1) # Par nom de colonne
# Top/Bottom N
top3_ages = df.nlargest(3, 'age') # 3 plus âgés
bottom2_ages = df.nsmallest(2, 'age') # 2 plus jeunes
apply() et map()
# Création de colonnes par calcul direct
df['age_double'] = df['age'] * 2
df['nom_complet'] = df['prenom'] + ' ' + df['nom']
# Colonnes conditionnelles
df['categorie_age'] = df['age'].apply(lambda x: 'Jeune' if x < 30 else 'Senior')
# Avec np.where pour des conditions multiples
import numpy as np
df['generation'] = np.where(df['age'] < 25, 'Gen Z',
np.where(df['age'] < 40, 'Millenial', 'Gen X'))
# Application de fonctions personnalisées
def categoriser_age(age):
if age < 18:
return 'Mineur'
elif age < 65:
return 'Actif'
else:
return 'Retraité'
df['statut'] = df['age'].apply(categoriser_age)
# Transformation de colonnes existantes
df['nom_majuscule'] = df['nom'].str.upper()
df['ville_code'] = df['ville'].str[:3].str.upper() # 3 premières lettres
apply() quand c'est possible !
merge() : Jointures SQL-like (inner, left, right, outer)concat() : Concaténation de DataFramesjoin() : Jointure sur l'index| Type de jointure | Description | Paramètre |
|---|---|---|
| Inner | Valeurs communes uniquement | how='inner' |
| Left | Toutes les lignes du DataFrame gauche | how='left' |
| Right | Toutes les lignes du DataFrame droit | how='right' |
| Outer | Union de toutes les lignes | how='outer' |
# Exemple de données pour la fusion
employes = pd.DataFrame({
'id': [1, 2, 3],
'nom': ['Alice', 'Bob', 'Charlie'],
'departement_id': [10, 20, 10]
})
departements = pd.DataFrame({
'id': [10, 20, 30],
'nom_dept': ['IT', 'RH', 'Finance']
})
# Fusion par clé commune
fusion = pd.merge(employes, departements,
left_on='departement_id',
right_on='id',
how='inner')
# Fusion avec suffixes pour colonnes en conflit
fusion = pd.merge(employes, departements,
left_on='departement_id',
right_on='id',
suffixes=('_emp', '_dept'))
# Concaténation verticale (empiler)
df_total = pd.concat([df1, df2], ignore_index=True)
# Concaténation horizontale (côte à côte)
df_large = pd.concat([df1, df2], axis=1)
groupby() pour analyses par groupepivot_table() pour tableaux croisés dynamiquesagg() pour calculs multiples
# Groupement et agrégation
stats_ville = df.groupby('ville')['age'].agg(['mean', 'max', 'count'])
stats_ville = df.groupby('ville').agg({
'age': ['mean', 'max'],
'salaire': 'sum'
})
# Tableau croisé dynamique
pivot = df.pivot_table(values='salaire',
index='ville',
columns='departement',
aggfunc='mean')
# Suppression de doublons
df_unique = df.drop_duplicates(subset=['nom', 'age'])
# Gestion des valeurs manquantes
df_clean = df.dropna() # Supprime les lignes avec NaN
df_filled = df.fillna(0) # Remplace NaN par 0
df_filled = df.fillna(method='forward') # Propagation vers l'avant
# Échantillonnage
echantillon = df.sample(n=100) # 100 lignes aléatoires
echantillon = df.sample(frac=0.1) # 10% des données
| Format | Méthode | Exemple |
|---|---|---|
| CSV | to_csv() |
df.to_csv('resultat.csv') |
| Excel | to_excel() |
df.to_excel('resultat.xlsx') |
| JSON | to_json() |
df.to_json('resultat.json') |
| Pickle | to_pickle() |
df.to_pickle('resultat.pkl') |
head(), info(), describe()query() pour des filtres lisibles et complexesmerge() est votre ami pour joindre des tablesPandas est un outil extraordinairement puissant pour la manipulation et l'analyse de données en Python. Sa syntaxe intuitive et ses nombreuses fonctionnalités en font l'outil de choix des data scientists et analystes. Maîtriser les DataFrames, les techniques de filtrage, de tri, de transformation et de fusion vous permettra de traiter efficacement la plupart des tâches d'analyse de données. L'investissement dans l'apprentissage de Pandas se révèle rapidement rentable par la productivité qu'il apporte dans vos projets d'analyse.
Vous disposez d'un fichier CSV contenant des informations sur des étudiants avec les colonnes : nom, age, note_maths, note_francais, ville.
1. Créez un DataFrame pandas avec ces données (5 étudiants minimum).
2. Calculez la moyenne générale de chaque étudiant.
3. Affichez les étudiants ayant une moyenne supérieure à 12.
4. Triez le DataFrame par ordre décroissant de moyenne.
import pandas as pd
# 1. Création du DataFrame
data = {
'nom': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
'age': [18, 19, 17, 18, 19],
'note_maths': [15, 12, 18, 14, 11],
'note_francais': [13, 16, 14, 17, 15],
'ville': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon']
}
df = pd.DataFrame(data)
# 2. Calcul de la moyenne générale
df['moyenne'] = (df['note_maths'] + df['note_francais']) / 2
# 3. Étudiants avec moyenne > 12
etudiants_reussis = df[df['moyenne'] > 12]
print(etudiants_reussis)
# 4. Tri par ordre décroissant de moyenne
df_trie = df.sort_values('moyenne', ascending=False)
print(df_trie)
Vous avez deux fichiers CSV : "commandes.csv" (id_commande, id_client, montant, date) et "clients.csv" (id_client, nom, email, ville).
1. Chargez les deux fichiers dans des DataFrames.
2. Effectuez une jointure interne pour obtenir les commandes avec les informations clients.
3. Calculez le montant total des commandes par ville.
4. Trouvez le client ayant dépensé le plus d'argent.
import pandas as pd
# 1. Chargement des fichiers (exemple de création des DataFrames)
commandes = pd.DataFrame({
'id_commande': [1, 2, 3, 4, 5],
'id_client': [101, 102, 101, 103, 102],
'montant': [250, 180, 300, 150, 220],
'date': ['2024-01-15', '2024-01-16', '2024-01-17', '2024-01-18', '2024-01-19']
})
clients = pd.DataFrame({
'id_client': [101, 102, 103],
'nom': ['Alice Martin', 'Bob Dupont', 'Charlie Blanc'],
'email': ['alice@email.com', 'bob@email.com', 'charlie@email.com'],
'ville': ['Paris', 'Lyon', 'Marseille']
})
# 2. Jointure interne
commandes_clients = pd.merge(commandes, clients, on='id_client', how='inner')
print(commandes_clients)
# 3. Montant total par ville
montant_par_ville = commandes_clients.groupby('ville')['montant'].sum()
print(montant_par_ville)
# 4. Client ayant le plus dépensé
depenses_par_client = commandes_clients.groupby(['id_client', 'nom'])['montant'].sum()
client_max = depenses_par_client.idxmax()
print(f"Client ayant le plus dépensé: {client_max[1]} avec {depenses_par_client.max()}€")
Manipulez un dataset de ventes avec les colonnes : produit, categorie, prix, quantite, date_vente, vendeur.
1. Chargez le fichier et affichez les informations de base (shape, dtypes, describe).
2. Créez une colonne "chiffre_affaires" (prix × quantité).
3. Trouvez les 3 produits les plus vendus en quantité.
4. Calculez le chiffre d'affaires moyen par catégorie et par mois.
5. Identifiez les vendeurs dont le CA est supérieur à la médiane.
import pandas as pd
import numpy as np
# Création d'un dataset exemple
np.random.seed(42)
data = {
'produit': ['Laptop', 'Souris', 'Clavier', 'Écran', 'Tablet'] * 20,
'categorie': ['Informatique', 'Accessoire', 'Accessoire', 'Informatique', 'Informatique'] * 20,
'prix': np.random.uniform(10, 1000, 100),
'quantite': np.random.randint(1, 20, 100),
'date_vente': pd.date_range('2024-01-01', periods=100, freq='D'),
'vendeur': np.random.choice(['Alice', 'Bob', 'Charlie'], 100)
}
df = pd.DataFrame(data)
# 1. Informations de base
print("Shape:", df.shape)
print("Types:", df.dtypes)
print("Statistiques:", df.describe())
# 2. Création colonne chiffre_affaires
df['chiffre_affaires'] = df['prix'] * df['quantite']
# 3. Top 3 produits les plus vendus
top_produits = df.groupby('produit')['quantite'].sum().sort_values(ascending=False).head(3)
print("Top 3 produits:", top_produits)
# 4. CA moyen par catégorie et par mois
df['mois'] = df['date_vente'].dt.to_period('M')
ca_cat_mois = df.groupby(['categorie', 'mois'])['chiffre_affaires'].mean()
print("CA moyen par catégorie/mois:", ca_cat_mois)
# 5. Vendeurs avec CA > médiane
ca_vendeurs = df.groupby('vendeur')['chiffre_affaires'].sum()
mediane_ca = ca_vendeurs.median()
vendeurs_sup_mediane = ca_vendeurs[ca_vendeurs > mediane_ca]
print("Vendeurs CA > médiane:", vendeurs_sup_mediane)
Travaillez avec des Series pandas pour analyser des données météorologiques.
1. Créez une Series de températures pour 30 jours avec un index de dates.
2. Calculez la température moyenne, min et max.
3. Identifiez les jours où la température était supérieure à la moyenne.
4. Créez une nouvelle Series avec les températures en Fahrenheit.
5. Fusionnez les deux Series dans un DataFrame.
import pandas as pd
import numpy as np
# 1. Création de la Series températures
dates = pd.date_range('2024-01-01', periods=30, freq='D')
np.random.seed(42)
temperatures_celsius = pd.Series(
np.random.normal(15, 8, 30), # Moyenne 15°C, écart-type 8
index=dates,
name='temp_celsius'
)
# 2. Statistiques descriptives
print(f"Température moyenne: {temperatures_celsius.mean():.2f}°C")
print(f"Température min: {temperatures_celsius.min():.2f}°C")
print(f"Température max: {temperatures_celsius.max():.2f}°C")
# 3. Jours avec température > moyenne
jours_chauds = temperatures_celsius[temperatures_celsius > temperatures_celsius.mean()]
print(f"Nombre de jours chauds: {len(jours_chauds)}")
print("Jours chauds:", jours_chauds.index.date)
# 4. Conversion en Fahrenheit
temperatures_fahrenheit = temperatures_celsius * 9/5 + 32
temperatures_fahrenheit.name = 'temp_fahrenheit'
# 5. Fusion dans un DataFrame
df_temperatures = pd.DataFrame({
'celsius': temperatures_celsius,
'fahrenheit': temperatures_fahrenheit
})
print(df_temperatures.head())
Analysez un dataset complexe de logs d'un site web avec les colonnes : timestamp, ip, page, user_agent, status_code, response_time.
1. Chargez le fichier et convertissez la colonne timestamp en datetime.
2. Filtrez les logs pour ne garder que les codes de statut 200 et 404.
3. Calculez le temps de réponse moyen par page.
4. Identifiez les heures de pointe (plus de trafic) en regroupant par heure.
5. Créez un tableau croisé dynamique montrant le nombre de requêtes par page et par code de statut.
6. Exportez les résultats dans un nouveau fichier CSV.
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
# Création d'un dataset exemple de logs
np.random.seed(42)
start_date = datetime(2024, 1, 1)
timestamps = [start_date + timedelta(minutes=x) for x in range(1000)]
data = {
'timestamp': timestamps,
'ip': [f"192.168.1.{np.random.randint(1, 255)}" for _ in range(1000)],
'page': np.random.choice(['/home', '/about', '/contact', '/products', '/login'], 1000),
'user_agent': np.random.choice(['Chrome', 'Firefox', 'Safari', 'Edge'], 1000),
'status_code': np.random.choice([200, 404, 500], 1000, p=[0.8, 0.15, 0.05]),
'response_time': np.random.uniform(0.1, 2.0, 1000)
}
df = pd.DataFrame(data)
# 1. Conversion timestamp en datetime (déjà fait dans cet exemple)
df['timestamp'] = pd.to_datetime(df['timestamp'])
print("Dataset chargé avec", len(df), "lignes")
# 2. Filtrage des codes de statut 200 et 404
df_filtered = df[df['status_code'].isin([200, 404])]
print(f"Après filtrage: {len(df_filtered)} lignes")
# 3. Temps de réponse moyen par page
temps_reponse_page = df_filtered.groupby('page')['response_time'].mean().sort_values(ascending=False)
print("Temps de réponse moyen par page:")
print(temps_reponse_page)
# 4. Heures de pointe
df_filtered['heure'] = df_filtered['timestamp'].dt.hour
trafic_par_heure = df_filtered.groupby('heure').size().sort_values(ascending=False)
print("Heures de pointe (top 5):")
print(trafic_par_heure.head())
# 5. Tableau croisé dynamique
pivot_table = pd.crosstab(df_filtered['page'], df_filtered['status_code'], margins=True)
print("Tableau croisé dynamique - Requêtes par page et statut:")
print(pivot_table)
# 6. Export des résultats
# Sauvegarde du dataset filtré
df_filtered.to_csv('logs_filtered.csv', index=False)
# Sauvegarde des analyses
analyses = {
'page': temps_reponse_page.index,
'temps_reponse_moyen': temps_reponse_page.values
}
pd.DataFrame(analyses).to_csv('analyse_temps_reponse.csv', index=False)
print("Analyses exportées vers les fichiers CSV")
Vous travaillez pour une bibliothèque municipale qui souhaite analyser ses prêts de livres. Le fichier CSV contient : titre, auteur, genre, date_emprunt, date_retour, emprunteur.
1. Créez un DataFrame avec ces données (10 livres minimum).
2. Calculez la durée moyenne d'emprunt par genre.
3. Affichez les 3 livres les plus empruntés.
4. Identifiez les emprunteurs en retard (date_retour dépassée).
import pandas as pd
from datetime import datetime, timedelta
# 1. Création du DataFrame
data = {
'titre': ['1984', 'Le Seigneur des Anneaux', 'Harry Potter', 'Dune', 'Fondation',
'Le Petit Prince', 'Gatsby le Magnifique', 'Orgueil et Préjugés', 'Beloved', 'L\'Étranger'],
'auteur': ['George Orwell', 'J.R.R. Tolkien', 'J.K. Rowling', 'Frank Herbert', 'Isaac Asimov',
'Antoine de Saint-Exupéry', 'F. Scott Fitzgerald', 'Jane Austen', 'Toni Morrison', 'Albert Camus'],
'genre': ['Science-Fiction', 'Fantasy', 'Fantasy', 'Science-Fiction', 'Science-Fiction',
'Littérature', 'Littérature', 'Littérature', 'Littérature', 'Littérature'],
'date_emprunt': [datetime(2024,1,5), datetime(2024,1,10), datetime(2024,1,15),
datetime(2024,2,1), datetime(2024,2,5), datetime(2024,2,10),
datetime(2024,2,15), datetime(2024,3,1), datetime(2024,3,5), datetime(2024,3,10)],
'date_retour': [datetime(2024,1,19), datetime(2024,1,24), datetime(2024,1,30),
datetime(2024,2,15), datetime(2024,2,20), datetime(2024,2,25),
datetime(2024,3,1), datetime(2024,3,15), datetime(2024,3,20), datetime(2024,3,25)],
'emprunteur': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Alice', 'Bob', 'Charlie', 'Diana', 'Eve']
}
df = pd.DataFrame(data)
# 2. Durée moyenne d'emprunt par genre
df['duree'] = (df['date_retour'] - df['date_emprunt']).dt.days
print(df.groupby('genre')['duree'].mean())
# 3. Livres les plus empruntés (simulation avec données fictives)
print(df['titre'].value_counts().head(3))
# 4. Emprunteurs en retard (aujourd'hui = 2024-03-15)
aujourdhui = datetime(2024,3,15)
retards = df[df['date_retour'] < aujourdhui]
print("Retards:", retards[['titre', 'emprunteur']])
Vous analysez les données d'une application de fitness. Deux fichiers : "utilisateurs.csv" (id, nom, age, sexe, ville) et "activites.csv" (id_activite, id_utilisateur, type, duree, calories, date).
1. Chargez les deux fichiers dans des DataFrames.
2. Fusionnez-les pour obtenir les activités avec les infos utilisateurs.
3. Calculez les calories moyennes dépensées par type d'activité et par sexe.
4. Trouvez les 3 villes les plus actives (plus de minutes d'activité).
import pandas as pd
import numpy as np
# 1. Création des DataFrames (exemple)
utilisateurs = pd.DataFrame({
'id': [1, 2, 3, 4, 5],
'nom': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
'age': [25, 30, 35, 28, 32],
'sexe': ['F', 'M', 'M', 'F', 'F'],
'ville': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon']
})
activites = pd.DataFrame({
'id_activite': range(1, 21),
'id_utilisateur': np.random.choice([1,2,3,4,5], 20),
'type': np.random.choice(['Course', 'Natation', 'Vélo', 'Yoga'], 20),
'duree': np.random.randint(15, 120, 20),
'calories': np.random.randint(100, 500, 20),
'date': pd.date_range('2024-01-01', periods=20)
})
# 2. Fusion des données
df = pd.merge(activites, utilisateurs, left_on='id_utilisateur', right_on='id')
# 3. Calories moyennes par type et sexe
print(df.pivot_table(values='calories', index='type', columns='sexe', aggfunc='mean'))
# 4. Villes les plus actives
villes_actives = df.groupby('ville')['duree'].sum().sort_values(ascending=False).head(3)
print("Villes les plus actives:", villes_actives)
Vous gérez un restaurant et souhaitez analyser les commandes. Le dataset contient : id_commande, plat, prix, quantite, heure, serveur, satisfaction.
1. Chargez les données et vérifiez les valeurs manquantes.
2. Calculez le chiffre d'affaires par serveur.
3. Identifiez le plat le plus rentable (CA total).
4. Analysez la satisfaction moyenne par heure de service.
5. Exportez un rapport par serveur avec leur CA et satisfaction moyenne.
import pandas as pd
import numpy as np
# Création du dataset
np.random.seed(42)
plats = ['Steak', 'Salade', 'Pizza', 'Pâtes', 'Poisson', 'Dessert']
data = {
'id_commande': range(1, 101),
'plat': np.random.choice(plats, 100),
'prix': np.random.uniform(5, 25, 100),
'quantite': np.random.randint(1, 4, 100),
'heure': np.random.choice(['12h', '13h', '19h', '20h', '21h'], 100),
'serveur': np.random.choice(['Alice', 'Bob', 'Charlie'], 100),
'satisfaction': np.random.randint(1, 6, 100) # 1-5 étoiles
}
df = pd.DataFrame(data)
# 1. Vérification valeurs manquantes
print("Valeurs manquantes:", df.isnull().sum())
# 2. CA par serveur
df['CA'] = df['prix'] * df['quantite']
ca_serveur = df.groupby('serveur')['CA'].sum()
print("CA par serveur:", ca_serveur)
# 3. Plat le plus rentable
ca_plat = df.groupby('plat')['CA'].sum().sort_values(ascending=False)
print("Plat le plus rentable:", ca_plat.idxmax(), "avec", ca_plat.max(), "€")
# 4. Satisfaction par heure
print(df.groupby('heure')['satisfaction'].mean())
# 5. Rapport par serveur
rapport = df.groupby('serveur').agg({'CA': 'sum', 'satisfaction': 'mean'})
rapport.to_csv('rapport_serveurs.csv')
print("Rapport exporté")
Vous analysez des données de capteurs IoT mesurant la qualité de l'air avec : timestamp, device_id, pm25, pm10, temperature, humidity.
1. Créez une Series pandas pour les mesures de pm25 avec index temporel.
2. Calculez les statistiques descriptives (moyenne, max, min).
3. Identifiez les pics de pollution (pm25 > 35).
4. Visualisez la corrélation entre température et pollution.
5. Exportez les jours critiques (pm25 > seuil) dans un nouveau CSV.
import pandas as pd
import numpy as np
# 1. Création des données
dates = pd.date_range('2024-01-01', periods=100, freq='H')
pm25 = pd.Series(
np.random.normal(25, 10, 100).clip(0), # Moyenne 25, min 0
index=dates,
name='pm25'
)
# 2. Statistiques
print("Moyenne:", pm25.mean())
print("Max:", pm25.max())
print("Min:", pm25.min())
# 3. Pics de pollution
pics = pm25[pm25 > 35]
print(f"{len(pics)} pics de pollution détectés")
# 4. Corrélation (avec données simulées)
temperature = pd.Series(np.random.normal(20, 5, 100), index=dates)
print("Corrélation:", pm25.corr(temperature))
# 5. Export jours critiques
df_air = pd.DataFrame({'pm25': pm25, 'temperature': temperature})
df_air['jour'] = df_air.index.date
jours_critiques = df_air[df_air['pm25'] > 35].groupby('jour').mean()
jours_critiques.to_csv('jours_critiques.csv')
Vous travaillez sur des données de transactions bancaires avec : transaction_id, client_id, montant, type, date, fraude (booléen).
1. Chargez les données et convertissez la date.
2. Analysez la répartition des types de transaction.
3. Calculez le montant moyen des transactions frauduleuses vs normales.
4. Identifiez les clients avec le plus de transactions frauduleuses.
5. Créez une visualisation du montant total par jour.
6. Exportez une liste des clients suspects à investiguer.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Création du dataset
np.random.seed(42)
data = {
'transaction_id': range(1, 1001),
'client_id': np.random.choice(['C100', 'C101', 'C102', 'C103', 'C104'], 1000),
'montant': np.random.exponential(100, 1000).round(2),
'type': np.random.choice(['Virement', 'Retrait', 'Paiement', 'Dépôt'], 1000),
'date': pd.date_range('2024-01-01', periods=1000, freq='H'),
'fraude': np.random.choice([True, False], 1000, p=[0.05, 0.95])
}
df = pd.DataFrame(data)
# 1. Conversion date (déjà fait ici)
print(df.info())
# 2. Répartition des types
print(df['type'].value_counts())
# 3. Montant moyen
print(df.groupby('fraude')['montant'].mean())
# 4. Clients suspects
clients_suspects = df[df['fraude']].groupby('client_id').size().sort_values(ascending=False)
print("Clients suspects:", clients_suspects)
# 5. Visualisation
df['jour'] = df['date'].dt.date
montant_jour = df.groupby('jour')['montant'].sum()
montant_jour.plot(title='Montant total par jour')
plt.show()
# 6. Export clients suspects
clients_suspects.to_csv('clients_suspects.csv', header=['nb_fraudes'])
Explorez comment l'art et la philosophie s'entrelacent pour questionner notre perception de la réalité et de l'esthétique.
Read more.Plongez dans les débats philosophiques sur la liberté, ses implications éthiques et les défis contemporains qui l'entourent.
Read more.Découvrez les différentes approches philosophiques de la vérité et comment elles influencent notre compréhension du monde.
Read more.
