Python >> Tutoriel Python >  >> Python Tag >> Pandas

Comment fonctionne Pandas Concat ?

Le pandas.concat( ) combine les données de plusieurs séries et/ou DataFrames rapidement et de manière intuitive. C'est l'une des opérations de gestion de données les plus élémentaires utilisées dans Pandas. En général, nous tirons quelques conclusions des données en les analysant. La confiance dans nos conclusions augmente à mesure que nous incluons plus de variables ou de métadonnées sur nos données. Ceci est réalisé en combinant des données provenant d'une variété de sources de données différentes. Les objets Pandas de base, les séries et les DataFrames sont créés en gardant à l'esprit ces opérations relationnelles. Par exemple, pd.concat([df1, df2]) concatène deux DataFrames df1 , df2 ensemble horizontalement et aboutit à un nouveau DataFrame.

Pandas concatène deux DataFrames ou plus

Le cas d'utilisation le plus important et le plus largement utilisé de Pandas concat - pd.concat( ) est de concaténer des DataFrames.

Par exemple, lorsque vous achetez un nouveau smartphone, vous souhaitez souvent comparer les spécifications et le prix des téléphones. Cela vous fait prendre une décision éclairée. Une telle comparaison peut être consultée ci-dessous à titre d'exemple sur le site Web d'Amazon pour les téléphones OnePlus récents.

Dans l'image ci-dessus, les données de quatre smartphones différents sont concaténées avec leurs fonctionnalités sous forme d'index.

Construisons deux DataFrames et combinons-les pour voir comment cela fonctionne.

>>> import pandas as pd
>>> df1 = pd.DataFrame(
...             {"Key": ["A", "B", "A", "C"], "C1":[1, 2, 3, 4], "C2": [10, 20, 30, 40]})
>>> df1.index = ["L1", "L2", "L3", "L4"]
>>> print(df1)
   Key  C1  C2
L1   A   1  10
L2   B   2  20
L3   A   3  30
L4   C   4  40
>>> df2 = pd.DataFrame(
...             {"Key": ["A", "B", "C", "D"], "C3": [100, 200, 300, 400]})
>>> df2.index = ["R1", "R2", "R3", "R4"]
>>> print(df2)
   Key   C3
R1   A  100
R2   B  200
R3   C  300
R4   D  400

De la documentation officielle Pandas de Pandas concat ;

Les deux principaux arguments utilisés dans pandas.concat( ) de l'image ci-dessus sont,

  • objs – Une séquence d'objets Series et/ou DataFrame
  • axe – Axe le long duquel objs sont concaténés

Sur les deux arguments, objs reste constant. Mais, en fonction de la valeur de l'axe, l'opération de concaténation diffère. Les valeurs possibles de l'axe sont,

  • axis = 0 – Concaténer ou empiler les DataFrames sur les lignes
  • axis = 1 – Concaténer ou empiler les DataFrames le long des colonnes

Rappelez-vous ce axis fonctionnalité d'argument, car elle est présente dans de nombreuses autres fonctions Pandas. Voyons-les en action en utilisant les Dataframes créés ci-dessus.

1. Concaténation rangée par ligne (axe =0 / 'index')

>>> df3 = pd.concat([df1, df2], axis=0)
>>> print(df3)
   Key   C1    C2     C3
L1   A  1.0  10.0    NaN
L2   B  2.0  20.0    NaN
L3   A  3.0  30.0    NaN
L4   C  4.0  40.0    NaN
R1   A  NaN   NaN  100.0
R2   B  NaN   NaN  200.0
R3   C  NaN   NaN  300.0
R4   D  NaN   NaN  400.0
>>> df3_dash = pd.concat([df1, df2])
>>> print(df3_dash)
   Key   C1    C2     C3
L1   A  1.0  10.0    NaN
L2   B  2.0  20.0    NaN
L3   A  3.0  30.0    NaN
L4   C  4.0  40.0    NaN
R1   A  NaN   NaN  100.0
R2   B  NaN   NaN  200.0
R3   C  NaN   NaN  300.0
R4   D  NaN   NaN  400.0
>>> print(len(df3) == len(df1) + len(df2))
True

N'importe quel nombre de DataFrames peut être donné dans le premier argument qui a une liste de DataFrames comme [df1, df2, df3, ..., dfn] .

Quelques observations à partir des résultats ci-dessus :

  • Notez les sorties de df3 et df3_dash sont identiques. Ainsi, nous n'avons pas besoin de mentionner explicitement l'axe lorsque nous voulons concaténer les lignes.
  • Le nombre de lignes dans le DataFrame de sortie =Nombre total de lignes dans tous les DataFrames d'entrée.
  • Les colonnes du DataFrame de sortie =Combinaison de colonnes distinctes de tous les DataFrames d'entrée.
  • Des colonnes uniques sont présentes dans les DataFrames d'entrée. Les valeurs correspondantes aux étiquettes de ligne des différents DataFrames d'entrée sont remplies avec NaN s (Pas un nombre - valeurs manquantes) dans le DataFrame de sortie.

Visualisons le processus ci-dessus dans l'animation suivante :

2. Concaténation par colonne (axe =1 / 'colonnes')

>>> df3 = pd.concat([df1, df2], axis=1)
>>> print(df3)
    Key   C1    C2  Key     C3
L1    A  1.0  10.0  NaN    NaN
L2    B  2.0  20.0  NaN    NaN
L3    A  3.0  30.0  NaN    NaN
L4    C  4.0  40.0  NaN    NaN
R1  NaN  NaN   NaN    A  100.0
R2  NaN  NaN   NaN    B  200.0
R3  NaN  NaN   NaN    C  300.0
R4  NaN  NaN   NaN    D  400.0
>>> print("The unique row indexes of df1 and df2:", '\n\t', df1.index.append(df2.index).unique())
The unique row indexes of df1 and df2:
       Index(['L1', 'L2', 'L3', 'L4', 'R1', 'R2', 'R3', 'R4'], dtype='object')
>>> print("The row indexes of df3:", "\n\t", df3.index)
The row indexes of df3:
       Index(['L1', 'L2', 'L3', 'L4', 'R1', 'R2', 'R3', 'R4'], dtype='object')
>>> print("The column indexes of df1 and df2:", "\n\t", df1.columns.append(df2.columns))
The column indexes of df1 and df2:
       Index(['Key', 'C1', 'C2', 'Key', 'C3'], dtype='object')
>>> print("The column indexes of df3:", "\n\t", df3.columns)
The column indexes of df3:
       Index(['Key', 'C1', 'C2', 'Key', 'C3'], dtype='object')

Quelques observations à partir des résultats ci-dessus :

  • Les DataFrames sont concaténés côte à côte.
  • Les colonnes dans le DataFrame de sortie =Total des colonnes dans tous les DataFrames d'entrée.
  • Lignes dans le DataFrame de sortie =Lignes uniques dans tous les DataFrames d'entrée.
  • Des lignes uniques sont présentes dans tous les DataFrames d'entrée. Les valeurs correspondantes aux étiquettes de colonne des différents DataFrames d'entrée sont remplies avec NaN s (Pas un nombre - valeurs manquantes) dans le DataFrame de sortie.

Visualisons le processus ci-dessus dans l'animation suivante :

Colonnes Pandas Concat

Veuillez consulter le tableau de comparaison initial des téléphones OnePlus sur le site Web d'Amazon. Une colonne de ce tableau constitue toutes les spécifications d'un smartphone donné. Toutes les spécifications équivalentes (étiquettes de ligne) de toutes les variétés (téléphones - étiquettes de colonne) sont concaténées en colonnes pour former le tableau de comparaison final.

Ainsi, pour concaténer des colonnes, nous devrions avoir les mêmes index de ligne. Dans Pandas, la structure de données Series est exactement conçue pour représenter les colonnes et leur combinaison forme la structure de données DataFrame.

Construisons deux séries et concaténons-les sous forme de colonnes pour former un DataFrame résultant.

>>> ser1 = pd.Series([10, 20, 30, 40], name='C1')
>>> ser2 = pd.Series([100, 200, 300, 400], name='C2')
>>> print("Series 1:", "\n", ser1, "\n\n", "Series 2:", "\n",  ser2)
Series 1:
0    10
1    20
2    30
3    40
Name: C1, dtype: int64

Series 2:
0    100
1    200
2    300
3    400
Name: C2, dtype: int64
>>> df = pd.concat([ser1, ser2], axis=1)
>>> print("DataFrame:", "\n", df)
DataFrame:
   C1   C2
0  10  100
1  20  200
2  30  300
3  40  400

Pandas Concat MultiIndex

Considérons un cas d'utilisation où nous avons des données météorologiques horaires pendant 4 heures sur deux villes. Les données dont nous disposons ne sont que la température (degC) et la vitesse du vent (km/h). Une façon de stocker leurs données est de les stocker dans différents DataFrames par ville. Cela peut être fait de la manière suivante,

>>> Date_Hourly = pd.date_range(start = '2020-11-20', periods = 4, freq = 'H')
>>> df_city1 = pd.DataFrame(
...                  {"temp(degC)": [27, 24, 22, 20],
...                   "windspeed(kmph)": [18, 17, 17, 18]},
...                  index = Date_Hourly
...             )
>>> df_city2 = pd.DataFrame(
...                  {"temp(degC)": [30, 33, 33, 34],
...                   "windspeed(kmph)": [23, 25, 27, 30]},
...                  index = Date_Hourly
...             )
>>> print("Weather Data of City 1:", "\n", df_city1)
Weather Data of City 1:
                      temp(degC)  windspeed(kmph)
2020-11-20 00:00:00          27               18
2020-11-20 01:00:00          24               17
2020-11-20 02:00:00          22               17
2020-11-20 03:00:00          20               18
>>> print("Weather Data of City 2:", "\n", df_city2)
Weather Data of City 2:
                      temp(degC)  windspeed(kmph)
2020-11-20 00:00:00          30               23
2020-11-20 01:00:00          33               25
2020-11-20 02:00:00          33               27
2020-11-20 03:00:00          34               30

Maintenant, nous pourrions vouloir collecter les données de deux villes dans un DataFrame pour une analyse plus facile. Les clés MultiIndex servent d'identificateurs pour spécifier la source des données. Ceci peut être réalisé par concaténation MultiIndex.

La concaténation multi-index se fait de deux manières ;

1. Concaténation rangée par ligne (axe =0 / 'index')

>>> df_concat_rowwise = pd.concat([df_city1, df_city2], axis=0, keys=['City1', 'City2'])
>>> print("Row-Wise Multi-Index Concatenation:", "\n", df_concat_rowwise)
Row-Wise Multi-Index Concatenation:
                            temp(degC)  windspeed(kmph)
City1 2020-11-20 00:00:00          27               18
      2020-11-20 01:00:00          24               17
      2020-11-20 02:00:00          22               17
      2020-11-20 03:00:00          20               18
City2 2020-11-20 00:00:00          30               23
      2020-11-20 01:00:00          33               25
      2020-11-20 02:00:00          33               27
      2020-11-20 03:00:00          34               30

2. Concaténation par colonne (axe =1 / 'colonnes')

>>> df_concat_rowwise = pd.concat([df_city1, df_city2], axis=1, keys=['City1', 'City2']) >>> print("Column-Wise Multi-Index Concatenation:", "\n", df_concat_colwise)
Column-Wise Multi-Index Concatenation:
                          City1                      City2               
                    temp(degC) windspeed(kmph) temp(degC) windspeed(kmph)
2020-11-20 00:00:00         27              18         30              23
2020-11-20 01:00:00         24              17         33              25
2020-11-20 02:00:00         22              17         33              27
2020-11-20 03:00:00         20              18         34              30

La même chose peut être obtenue pour de nombreuses villes. Après concaténation, toutes les données sont dans un seul DataFrame. Cela nous permet d'analyser efficacement la météo au lieu d'aller chercher des données à partir de plusieurs sources.

Pandas concat vs append

Concaténation le long des lignes (axis = 0 ) est très courant. Si vous observez le scénario de données météorologiques après chaque heure, les données sont ajoutées dans la ligne suivante. Donc, à cette fin, une méthode appelée append( ) est construit au-dessus de DataFrame pour ajouter un autre DataFrame par ligne. Cela vous permet d'obtenir les mêmes résultats que pd.concat( ) avec quelques frappes.

Il peut être implémenté comme suit,

>>> df1 = pd.DataFrame({'C1': ['A', 'B', 'C', 'D']})
>>> df2 = pd.DataFrame({'C1': ['E', 'F', 'G', 'H']})
>>> print("DataFrame 1:", "\n", df1)
DataFrame 1:
  C1
0  A
1  B
2  C
3  D
>>> print("DataFrame 2:", "\n", df2)
DataFrame 2:
  C1
0  E
1  F
2  G
3  H
>>> pd.concat([df1, df2])
  C1
0  A
1  B
2  C
3  D
0  E
1  F
2  G
3  H
>>> df1.append(df2)
  C1
0  A
1  B
2  C
3  D
0  E
1  F
2  G
3  H

Vous pouvez observer ci-dessus les mêmes résultats pour pd.concat([df1, df2]) et df1.append(df2) .

Pandas concat lent

Chaque fois que nous effectuons une opération de concaténation, cela crée un nouveau DataFrame. La concaténation DataFrame fonctionne comme une opération de jointure SQL. Ainsi, l'index du DataFrame de sortie est d'abord formé par une opération de jointure. La résolution de toutes les incompatibilités entre les index des DataFrames d'entrée le ralentit. Dans certains scénarios, les index peuvent ne pas être importants. Dans de tels cas, nous pouvons ignorer les index pour accélérer l'opération de concat.

Ignorer l'index se fait de la manière suivante,

>>> df = pd.DataFrame({'C1': [10, 20, 30, 40]}, index=['R1', 'R2', 'R3', 'R4'])
>>> df
    C1
R1  10
R2  20
R3  30
R4  40
>>> df.reset_index(drop=True)
   C1
0  10
1  20
2  30
3  40

Avec concat , toutes les autres fonctions de Pandas sont exécutées en utilisant un seul cœur dans le processeur. Les opérations sur des ensembles de données plus petits s'exécutent de manière transparente. Au fur et à mesure que la taille de l'ensemble de données augmente, les fonctions de Pandas commencent à s'étrangler car elles n'effectuent qu'une seule opération à la fois.

Modin est le package python créé pour accélérer l'exécution des fonctions Pandas. Il répartit la charge de calcul sur tous les cœurs disponibles. Pour ce faire, il fragmente le DatFrame et exécute la fonction sur des fragments DataFrame dans d'autres cœurs en parallèle. Veuillez consulter cet article pour le connaître en détail.