Optimisation des performances de Pandas
Pandas est un outil d'analyse de données très puissant, mais lorsque les jeux de données deviennent volumineux, des goulots d'étranglement de performance sont souvent rencontrés.
Pour améliorer l'efficacité de Pandas lors du traitement de données à grande échelle, il est nécessaire de comprendre et d'appliquer certaines techniques d'optimisation des performances.
L'optimisation des performances de Pandas implique plusieurs aspects, notamment l'optimisation des types de données, l'évitement des boucles inutiles, l'utilisation d'opérations vectorisées, l'optimisation des index et le chargement de grands jeux de données par blocs.
Ci-dessous, nous allons présenter en détail plusieurs méthodes d'optimisation des performances de Pandas.
Utiliser des types de données appropriés
Types de données dans Pandas (dtype) affectent directement l'utilisation de la mémoire et la vitesse de calcul. Choisir des types de données appropriés peut réduire considérablement l'utilisation de la mémoire et accélérer les calculs.
1. Utiliser des types numériques appropriés
Le type numérique par défaut de Pandas estint64etfloat64, mais pour la plupart des données, cela peut gaspiller de la mémoire. Vous pouvez utiliser des types plus petits, tels queint8, int16, float32etc.
| Méthode | Description |
|---|---|
astype() |
Utilisé pour convertir le type de données d'une colonne |
downcast |
Convertir le type de données vers un type inférieur, par exemple, convertirint64convertir vers un type inférieurint32ouint16 |
Exemple
# Données d'exemple
df = pd.DataFrame({'A': [100, 200, 300, 400], 'B': [1000, 2000, 3000, 4000]})
# Convertir les types de données des colonnes en types de données plus petits
df['A'] = df['A'].astype('int16')
df['B'] = df['B'].astype('int32')
print(df.dtypes)
Sortie :
A int16 B int32 dtype: object
2. Utiliser pour les données de type caractèrecategorytype
Pour les colonnes de chaînes avec des valeurs répétées, vous pouvez utilisercategorytype pour réduire la consommation de mémoire.categoryLe type stocke des index entiers en mémoire plutôt que les chaînes de caractères elles-mêmes.
Exemple
df = pd.DataFrame({'Category': ['A', 'B', 'A', 'C', 'B', 'A']})
# Utiliser le type category
df['Category'] = df['Category'].astype('category')
print(df.dtypes)
Sortie :
Category category dtype: object
Utilisez des opérations vectorisées au lieu de boucles
L'un des plus grands avantages de Pandas est sa capacité à utiliser des opérations vectorisées pour des calculs par lots rapides. Dans Pandas, essayez d'éviter les boucles Python natives et d'utiliser les fonctions intégrées de Pandas, qui peuvent tirer parti des optimisations sous-jacentes pour des calculs rapides.
Exemple
# Données d'exemple
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]})
# Utiliser des opérations vectorisées, éviter les boucles
df['C'] = df['A'] + df['B']
print(df)
Sortie :
A B C 0 1 5 6 1 2 6 8 2 3 7 10 3 4 8 12
Par rapport au traitement des données ligne par ligne, l'utilisation des opérations vectorisées de Pandas peut considérablement améliorer la vitesse de calcul.
3. Utiliserapply()etapplymap()Optimisation
Pandas fournitapply()etapplymap()les méthodes, qui permettent d'appliquer des fonctions par ligne ou par colonne dans un DataFrame, et qui sont plus efficaces que les boucles.
Exemple
df['D'] = df['A'].apply(lambda x: x ** 2)
print(df)
Sortie :
A B C D 0 1 5 6 1 1 2 6 8 4 2 3 7 10 9 3 4 8 12 16
apply()Il est adapté au traitement de données unidimensionnelles,applymap()tandis qu'il applique une fonction à chaque élément d'un DataFrame et convient aux données bidimensionnelles.
Exemple
df = df.applymap(lambda x: x * 10)
print(df)
Sortie :
A B C D 0 10 50 60 10 1 20 60 80 40 2 30 70 100 90 3 40 80 120 160
Utiliser des index appropriés
Les index Pandas peuvent améliorer la vitesse de recherche des données, en particulier lorsque plusieurs recherches ou fusions de données sont nécessaires, et les index peuvent considérablement améliorer l'efficacité. Pour les grands ensembles de données, garantir des index appropriés et réduire les opérations inutiles sur les index peut améliorer les performances.
Exemple
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]})
df.set_index('A', inplace=True)
# Recherche rapide via l'index
print(df.loc[2])
Sortie :
B 6 Name: 2, dtype: int64
Charger de grands ensembles de données par morceaux
Lorsque l'ensemble de données est trop volumineux, le charger en entier peut consommer beaucoup de mémoire et peut même provoquer un débordement de mémoire. Dans ce cas, vous pouvez réduire la pression sur la mémoire en lisant les données par morceaux.
Pandas fournitchunksizeparamètre, qui permet de charger les données par morceaux lors de la lecture de fichiers CSV ou Excel.
Exemple
chunksize = 10000
for chunk in pd.read_csv('large_file.csv', chunksize=chunksize):
# Traiter chaque bloc de données
process(chunk)
Dask et Vaex sont deux bibliothèques capables de gérer des jeux de données plus grands que la mémoire. Elles sont compatibles avec Pandas, prennent en charge le multithreading et le calcul distribué, et peuvent traiter efficacement de très grands jeux de données.
Exemple
# Utiliser Dask pour lire un grand jeu de données
df = dd.read_csv('large_file.csv')
# Effectuer des opérations de calcul
df.groupby('category').sum().compute()
VianumbaAccélérer le calcul
numbaest un compilateur JIT qui peut accélérer le code Python. En accélérant le code de traitement des données, les performances peuvent être considérablement améliorées. En particulier pour les opérations gourmandes en calcul telles que les boucles et les calculs numériques,numbacela peut considérablement augmenter la vitesse.
Exemple
import pandas as pd
# Exemple de fonction
@numba.jit
def calculate_square(x):
return x ** 2
# Utiliser numba pour accélérer le calcul
df = pd.DataFrame({'A': [1, 2, 3, 4]})
df['B'] = df['A'].apply(calculate_square)
print(df)
Éviter l'affectation chaînée
L'affectation chaînée est l'un des pièges de performance courants dans Pandas. Elle peut provoquer des effets de bord inutiles et ralentit généralement l'exécution. Il est préférable d'utiliser une affectation explicite et d'éviter les affectations multiples sur la même ligne.
Exemple
df['A'][df['A'] > 2] = 0
# Méthode d'affectation correcte :
df.loc[df['A'] > 2, 'A'] = 0
Optimiser les opérations de fusion
Lors de la fusion de plusieurs DataFrames, utilisezmerge()ouconcat()vous devez veiller à optimiser l'opération de fusion, en particulier lors du traitement de grands ensembles de données. Vous pouvez utiliseronethowle paramètre pour spécifier explicitement la méthode de fusion et éviter les calculs inutiles.
Exemple
# Utilisez une méthode de fusion appropriée
df1 = pd.DataFrame({'ID': [1, 2, 3], 'Value': ['A', 'B', 'C']})
df2 = pd.DataFrame({'ID': [1, 2, 3], 'Value': ['X', 'Y', 'Z']})
# Utilisez le paramètre on pour fusionner
merged_df = pd.merge(df1, df2, on='ID', how='inner')
print(merged_df)
Sortie :
ID Value_x Value_y 0 1 A X 1 2 B Y 2 3 C ZAutres extensions