Fonctionnalités avancées de Pandas

Pandas fournit des fonctions extrêmement puissantes de manipulation de données, adaptées à des tâches complexes telles que le nettoyage, l'analyse, l'agrégation et le traitement de séries temporelles. Maîtriser les fonctionnalités avancées de Pandas peut grandement améliorer l'efficacité du traitement et de l'analyse des données.

1. Fusion et jointure de données

Pandas fournit plusieurs méthodes pour fusionner et concaténer différents DataFrames, telles quemerge()、concat()etjoin(). Ces méthodes sont souvent utilisées pour gérer plusieurs jeux de données et des tâches de fusion complexes.

1. merge()— Jointure de type base de données

merge()la méthode permet de fusionner deux DataFrames en fonction de certaines colonnes, similaire à l'opération SQLJOINopération. Elle prend en charge les jointures internes, les jointures externes, les jointures à gauche et les jointures à droite.

Parameters Description
left DataFrame de gauche
right DataFrame de droite
how Méthode de fusion, prend en charge'inner', 'outer', 'left', 'right'
on Nom(s) de colonne pour la jointure (si les noms de colonnes diffèrent des deux côtés, vous pouvez utiliserleft_onetright_on）
left_on Colonne(s) dans le DataFrame de gauche sur lesquelles effectuer la jointure
right_on Colonne(s) dans le DataFrame de droite sur lesquelles effectuer la jointure
suffixes Ajouter des suffixes pour distinguer les noms de colonnes en double

Exemple

import pandas as pd

# Données d'exemple
left = pd.DataFrame({'ID': [1, 2, 3], 'Name': ['Alice', 'Bob', 'Charlie']})
right = pd.DataFrame({'ID': [1, 2, 4], 'Age': [24, 27, 22]})

# Utiliser merge pour une jointure interne
result = pd.merge(left, right, on='ID', how='inner')
print(result)

Sortie :

   ID     Name  Age
0   1    Alice   24
1   2      Bob   27

2. concat()— Concaténation le long d'un axe

concat()Il est utilisé pour concaténer plusieurs DataFrames le long d'un axe spécifié (lignes ou colonnes), couramment utilisé pour la fusion par lignes (concaténation verticale) ou la fusion par colonnes (concaténation horizontale).

Parameters Description
objs Liste des DataFrames à concaténer
axis Axe de concaténation,0indique une fusion par lignes,1indique la fusion par colonnes
ignore_index Indique s'il faut ignorer l'index et régénérer l'index (la valeur par défaut estFalse）
keys Fournir un index hiérarchique pour les objets concaténés

Exemple

import pandas as pd

# Données d'exemple
df1 = pd.DataFrame({'A': [1, 2, 3]})
df2 = pd.DataFrame({'A': [4, 5, 6]})

# Concaténation par lignes
result = pd.concat([df1, df2], axis=0, ignore_index=True)
print(result)

Sortie :

   A
0  1
1  2
2  3
3  4
4  5
5  6

3. join()— Jointure basée sur l'index

join()méthode est une opération de jointure simplifiée dans Pandas, couramment utilisée pour joindre plusieurs DataFrames en fonction de l'index.

Parameters Description
other Un autre DataFrame à joindre
how Méthode de fusion, prend en charge'left', 'right', 'outer', 'inner'
on Colonne de jointure à utiliser, par défaut l'index

Exemple

import pandas as pd

# Données d'exemple
left = pd.DataFrame({'A': [1, 2, 3]}, index=[1, 2, 3])
right = pd.DataFrame({'B': [4, 5, 6]}, index=[1, 2, 4])

# Utiliser join pour effectuer une jointure
result = left.join(right, how='inner')
print(result)

Sortie :

   A  B
1  1  4
2  2  5

2. Tableaux croisés dynamiques et tabulations croisées

Pandas fournitpivot_table()méthode pour créer des tableaux croisés dynamiques, etcrosstab()méthode pour calculer des tabulations croisées. Les tableaux croisés dynamiques et les tabulations croisées conviennent bien à la synthèse et à la réorganisation des données.

1. pivot_table()— Création de tableaux croisés dynamiques

Parameters Description
data Données d'entrée
values Colonne à synthétiser
index Colonne à utiliser comme index de ligne
columns Colonne à utiliser comme index de colonne
aggfunc Fonction d'agrégation, la valeur par défaut estmean, peut êtresum, countwait
fill_value Remplir les valeurs manquantes

Exemple

import pandas as pd

# Données d'exemple
data = {'Date': ['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04'],
        'Category': ['A', 'B', 'A', 'B'],
        'Sales': [100, 150, 200, 250]}
df = pd.DataFrame(data)

# Créer un tableau croisé dynamique
pivot_table = pd.pivot_table(df, values='Sales', index='Date', columns='Category', aggfunc='sum', fill_value=0)
print(pivot_table)

Sortie :

Category         A    B
Date                    
2024-01-01     100    0
2024-01-02       0  150
2024-01-03     200    0
2024-01-04       0  250

2. crosstab()— Création de tableaux croisés

Parameters Description
index Étiquettes de ligne
columns Étiquettes de colonne
values Données utilisées pour le calcul (facultatif)
aggfunc Fonction d'agrégation, par défautcount

Exemple

import pandas as pd

# Données d'exemple
data = {'Category': ['A', 'B', 'A', 'B', 'A', 'B'],
        'Region': ['North', 'South', 'North', 'South', 'West', 'East']}
df = pd.DataFrame(data)

# Créer un tableau croisé
cross_table = pd.crosstab(df['Category'], df['Region'])
print(cross_table)

Sortie :

Region    East  North  South  West
Category                         
A           0      2      0     1
B           1      0      1     0

3. Application de fonctions personnalisées

Pandas offre plusieurs façons d'appliquer des fonctions personnalisées pour le nettoyage et la transformation des données.

1. apply()— Application de fonctions à un DataFrame ou une Series

apply()méthode permet d'appliquer des fonctions personnalisées sur DataFrame ou Series, en prenant en charge les opérations sur les lignes ou les colonnes.

Parameters Description
func Fonction à appliquer
axis La valeur par défaut est0, indique une application par colonne ;1indique une application par ligne
raw Indique s'il faut transmettre les données d'origine (la valeur par défaut estFalse）
result_type Définir le type de sortie, tel queexpand, reduce, broadcast

Exemple

import pandas as pd

# Données d'exemple
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40]})

# Définir une fonction personnalisée
def custom_func(x):
    return x * 2

# Appliquer la fonction sur les colonnes
df['A'] = df['A'].apply(custom_func)
print(df)

Sortie :

   A   B
0  2  10
1  4  20
2  6  30
3  8  40

2. applymap()— Application d’une fonction à l’ensemble du DataFrame

applymap()Cela ne peut s’appliquer qu’à un DataFrame, et cela agit sur chaque élément du DataFrame.

Parameters Description
func Fonction à appliquer

Exemple

import pandas as pd

# Données d'exemple
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# Appliquer une fonction personnalisée au DataFrame
df = df.applymap(lambda x: x ** 2)
print(df)

Sortie :

   A  B
0  1  16
1  4  25
2  9  36

3. map()— Application d’une fonction à une Series

map()Vous pouvez appliquer une fonction ou une correspondance à chaque élément d’une Series.

Parameters Description
arg Fonction, dictionnaire ou Series à appliquer

Exemple

import pandas as pd

# Données d'exemple
df = pd.DataFrame({'A': ['cat', 'dog', 'rabbit']})

# Utiliser un dictionnaire pour la correspondance
df['A'] = df['A'].map({'cat': 'kitten', 'dog': 'puppy'})
print(df)

Sortie :

       A
0  kitten
1   puppy
2     NaN

4. Opérations de regroupement et d'agrégation

Dans Pandas, lagroupby()méthode est très puissante et peut être utilisée pour l'agrégation groupée, la transformation de données et le filtrage de données. Grâce àgroupby(), vous pouvez regrouper les données selon certaines conditions et effectuer des opérations d'agrégation telles que la somme, la moyenne, le comptage, etc.

1. groupby()— Regroupement de données

Parameters Description
by Regrouper par quelle colonne ou index
axis Axe de regroupement, la valeur par défaut est0, c'est-à-dire un regroupement par lignes
level Regrouper par le niveau de l'index (applicable à MultiIndex)

Exemple

import pandas as pd

# Données d'exemple
df = pd.DataFrame({
    'Category': ['A', 'B', 'A', 'B', 'A', 'B'],
    'Valeur': [10, 20, 30, 40, 50, 60]
})

# Regrouper par la colonne Category et calculer la somme pour chaque groupe
grouped = df.groupby('Category')['Value'].sum()
print(grouped)

Sortie :

Category
A    90
B    120
Name: Value, dtype: int64

2. Opérations d'agrégation (agg()）

agg()Utilisé pour effectuer des opérations d'agrégation complexes ; plusieurs fonctions peuvent être transmises pour calculer plusieurs valeurs agrégées en même temps.

Parameters Description
func Fonction d'agrégation, peut être une chaîne de caractères ou une fonction personnalisée

Exemple

import pandas as pd

# Données d'exemple
df = pd.DataFrame({
    'Category': ['A', 'B', 'A', 'B', 'A', 'B'],
    'Valeur': [10, 20, 30, 40, 50, 60]
})

# Utiliser agg() pour effectuer plusieurs opérations d'agrégation
grouped = df.groupby('Category')['Value'].agg([sum, min, max])
print(grouped)

Sortie :

          sum  min  max
Category                
A          90   10   50
B         120   20   60

5. Traitement des séries temporelles

Pandas offre de puissantes capacités de traitement de séries temporelles, notamment l'analyse de dates, la conversion de fréquences, la génération de plages de dates, les opérations sur fenêtres temporelles, etc.

1. date_range()— Génération de séries temporelles

Paramètre Description
start Date de début
end Date de fin
periods Nombre de points temporels générés
freq Fréquence (par ex.,Dsignifie des jours,Hsignifie des heures, etc.)

Exemple

import pandas as pd

# Générer une série temporelle
date_range = pd.date_range(start='2024-01-01', periods=5, freq='D')
print(date_range)

Sortie :

DatetimeIndex(['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05'], dtype='datetime64[ns]', freq='D')

2. Décalages de date et d'heure

Utilisationpd.Timedelta()vous pouvez effectuer des opérations d'addition et de soustraction de temps.

Exemple

import pandas as pd

# Décalage de date
date = pd.to_datetime('2024-01-01')
new_date = date + pd.Timedelta(days=10)
print(new_date)

Sortie :

2024-01-11 00:00:00

3. Opérations sur fenêtres temporelles (Rolling, Expanding)

Utilisationrolling()etexpanding()méthodes pour effectuer des opérations de fenêtre glissante et expansive, couramment utilisées dans des calculs tels que les moyennes mobiles dans les séries temporelles.

Méthode Description
rolling() Calculer des opérations de fenêtre glissante, couramment utilisées pour les moyennes mobiles, etc.
expanding() Calculer des opérations de fenêtre expansive, valeurs cumulées

Exemple

import pandas as pd

# Exemple de données
df = pd.DataFrame({'Value': [10, 20, 30, 40, 50]})

# Calculer la moyenne mobile sur 3 jours
df['Rolling_Mean'] = df['Value'].rolling(window=3).mean()
print(df)

Sortie :

   Value  Rolling_Mean
0     10            NaN
1     20            NaN
2     30     20.000000
3     40     30.000000
4     50     40.000000

6. Gestion des valeurs manquantes

Pandas fournit plusieurs méthodes pour gérer les valeurs manquantes (telles que NaN). Les opérations courantes incluent le remplissage des valeurs manquantes, la suppression des valeurs manquantes, etc.

Méthode Description
isna() Vérifier les valeurs manquantes, renvoyer des valeurs booléennes
fillna() Remplir les valeurs manquantes
dropna() Supprimer les lignes ou colonnes contenant des valeurs manquantes

Exemple

import pandas as pd
import numpy as np

# Exemple de données
df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, 7, 8]
})

# Remplir les valeurs manquantes
df_filled = df.fillna(0)
print(df_filled)

Sortie :

   A  B
0  1  5
1  2  0
2  0  7
3  4  8

7. MultiIndex

Pandas offre la fonctionnalité MultiIndex, qui permet de gérer des structures de données complexes dans DataFrame ou Series et qui est particulièrement adaptée aux données hiérarchiques. Avec MultiIndex, nous pouvons effectuer des opérations telles que le regroupement, la sélection, le découpage et l'agrégation de données.

1. Création d'un MultiIndex

Peut être créé à l'aide depd.MultiIndex.from_tuples()、pd.MultiIndex.from_product()ouset_index()méthodes pour créer un MultiIndex.

Méthode 1 :pd.MultiIndex.from_tuples()

Utilisez des tuples pour créer un MultiIndex, où chaque tuple correspond à un niveau d'index.

Paramètre Description
tuples Chaque tuple correspond à une valeur d'index
names Nom de chaque niveau d'index (facultatif)

Exemple

import pandas as pd

# Créer des tuples
index_tuples = [('A', 1), ('A', 2), ('B', 1), ('B', 2)]

# Créer un MultiIndex
multi_index = pd.MultiIndex.from_tuples(index_tuples, names=['Letter', 'Number'])

# Créer un DataFrame
df = pd.DataFrame({'Value': [10, 20, 30, 40]}, index=multi_index)
print(df)

Sortie :

               Value
Letter Number       
A      1          10
       2          20
B      1          30
       2          40

Méthode 2 : pd.MultiIndex.from_product()

Utilisez le produit cartésien de plusieurs listes pour créer un MultiIndex, adapté aux cas avec de nombreuses dimensions de données.

Paramètre Description
iterables Plusieurs listes ou tableaux
names Nom de chaque niveau d'index (facultatif)

Exemple

import pandas as pd

# Créer plusieurs listes
index_values = [['A', 'B'], [1, 2]]

# Créer un MultiIndex
multi_index = pd.MultiIndex.from_product(index_values, names=['Letter', 'Number'])

# Créer un DataFrame
df = pd.DataFrame({'Value': [10, 20, 30, 40]}, index=multi_index)
print(df)

Sortie :

               Value
Letter Number       
A      1          10
       2          20
B      1          30
       2          40

Méthode 3 : Utilisation deset_index()Création d'un MultiIndex

set_index()La méthode peut convertir les colonnes d'un DataFrame en un MultiIndex, ce qui permet de créer un MultiIndex à partir de données existantes.

Paramètre Description
keys Noms de colonnes utilisés comme index (peut être une seule colonne ou plusieurs colonnes)

Exemple

import pandas as pd

# Exemple de données
data = {
    'Letter': ['A', 'A', 'B', 'B'],
    'Number': [1, 2, 1, 2],
    'Valeur': [10, 20, 30, 40]
}

df = pd.DataFrame(data)

# Définir le MultiIndex
df.set_index(['Letter', 'Number'], inplace=True)
print(df)

Sortie :

               Value
Letter Number       
A      1          10
       2          20
B      1          30
       2          40

2. Opérations sur MultiIndex

1. Accès aux données MultiIndex

Les données sont accessibles via une indexation hiérarchique. En utilisantloc[]ouxs()(section transversale) facilite la sélection des données.

Utilisationloc[]pour sélectionner des données :

Exemple

import pandas as pd

# Exemple de données
data = {
    'Letter': ['A', 'A', 'B', 'B'],
    'Number': [1, 2, 1, 2],
    'Valeur': [10, 20, 30, 40]
}

df = pd.DataFrame(data)

# Définir le MultiIndex
df.set_index(['Letter', 'Number'], inplace=True)

# Sélectionner la catégorie 'A', toutes les données où 'Number' est 1
print(df.loc['A', 1])

Sortie :

Value    10
Name: (A, 1), dtype: int64

Utilisationxs()pour obtenir des données transversales :

xs()La méthode peut sélectionner des tranches à des niveaux spécifiés dans un MultiIndex.

Exemple

# Utiliser xs pour obtenir toutes les données où 'Number' vaut 1
print(df.xs(1, level='Number'))

Sortie :

        Value
Letter       
A          10
B          30

2. Découpage d'un MultiIndex

Pandas prend en charge les opérations de découpage sur un MultiIndex, permettant de sélectionner différents sous-ensembles par niveau d'index.

Exemple

# Sélectionner toutes les données où Letter est 'A'
print(df.loc['A'])

Sortie :

        Value
Number       
1          10
2          20

3. Tri d'un MultiIndex

La méthode de Pandassort_index()prend en charge le tri d'un MultiIndex.

Exemple

# Trier par MultiIndex
df_sorted = df.sort_index(level=['Letter', 'Number'], ascending=[True, False])
print(df_sorted)

Sortie :

               Value
Letter Number       
A      2          20
       1          10
B      2          40
       1          30

4. Opérations d'agrégation

MultiIndex combiné avecgroupby()peut effectuer de puissantes opérations d'agrégation, adaptées à l'analyse statistique de données complexes.

Exemple

# Utiliser groupby pour agréger sur MultiIndex
df_grouped = df.groupby(['Letter', 'Number']).sum()
print(df_grouped)

Sortie :

               Value
Letter Number       
A      1          10
       2          20
B      1          30
       2          40

5. Réinitialisation de l'index

Vous pouvez utiliser lareset_index()méthode pour réinitialiser le MultiIndex en colonnes régulières.

Exemple

# Réinitialiser l'index
df_reset = df.reset_index()
print(df_reset)

Sortie :

  Letter  Number  Value
0      A       1     10
1      A       2     20
2      B       1     30
3      B       2     40

6. Valeurs manquantes dans un MultiIndex

Les valeurs manquantes dans un MultiIndex peuvent être gérées à l'aide defillna()oudropna()similaire à un index standard.

Exemple

# Introduire des valeurs manquantes dans les données d'exemple
data = {
    'Letter': ['A', 'A', 'B', 'B'],
    'Number': [1, 2, 1, 2],
    'Value': [10, None, 30, 40]
}

df = pd.DataFrame(data)
df.set_index(['Letter', 'Number'], inplace=True)

# Remplir les valeurs manquantes
df_filled = df.fillna(0)
print(df_filled)

Sortie :

               Value
Letter Number       
A      1          10
       2           0
B      1          30
       2          40
Autres extensions