Vue d'ensemble de la connexion / combinaison de dataframe

Les DataFrames peuvent être concaténées et combinées dans Pandas.

Concaténation: opération pour connecter des DataFrames dans une certaine direction tels qu'ils sont
Combiner: opération pour se connecter en se référant à une clé spécifique

Concaténation DataFrame

Si l'index et la colonne correspondent

L'opération de connexion de DataFrames dans une certaine direction telle quelle est appelée concaténation. Concaténation de DataFrames avec des index ou des colonnes correspondants

axis=0 #En spécifiant cela, la liste sera connectée verticalement depuis le début.

De plus, si axis = 1 est spécifié, ils seront connectés horizontalement.

#Connecté verticalement
pandas.concat([Liste des DataFrames], axis=0)

#Connecté horizontalement
pandas.concat([Liste des DataFrames], axis=1)
#Lors de la concaténation horizontale, même si chaque DataFrame a la même colonne, il ne distingue pas
#Notez que les colonnes seront dupliquées car elles seront concaténées.

Lors de la connexion dans le sens vertical, connectez-vous dans la même colonne Lors de la concaténation horizontale, concaténez avec le même index.

Si l'index et la colonne ne correspondent pas

Le fait est que les lignes et les colonnes vides sont définies une fois avec NaN.

Pour plus d'informations Lors de la concaténation de DataFrames dont les index et les colonnes ne correspondent pas Les cellules avec NaN dans les lignes et les colonnes qui ne sont pas des index ou des colonnes communs sont automatiquement créées.

Même si les index et les colonnes ne correspondent pas, la méthode de concaténation est la même que si c'était le cas.

pandas.concat([Liste des DataFrames], axis=0) 
#Connectez-vous verticalement depuis le haut de la liste
# axis=Si 1 est spécifié, ils seront connectés horizontalement.

Spécification d'une étiquette lors de la concaténation

Puisque la concaténation relie les DataFrames sans les distinguer Il peut y avoir des étiquettes en double.

Par exemple, dans la concaténation de l'exemple 1 ci-dessous, «pomme», «orange», «banane» sont Vous pouvez voir qu'ils sont dupliqués sous forme d'étiquettes.

Dans ce cas, en ajoutant l'étiquette spécifiée par les clés à pd.concat () Vous pouvez éviter les étiquettes en double.

concat_df=pd.concat([df_data1,df_data2],axis=1,keys=["X", "Y"]) #Sertie de clés

Le bloc de données après la concaténation sera un index multiple qui utilise plusieurs étiquettes.

Dans le cas de l'exemple 2, vous pouvez voir que les nouvelles colonnes «X» et «Y» ont été ajoutées au-dessus des colonnes existantes. Dans ce cas, df ["X"] peut faire référence à la colonne intitulée "X". Vous pouvez vous référer à la colonne "apple" dans la colonne "X" en écrivant df ["X", "apple"].

Jointure DataFrame

Décrit la jointure. La jointure est également connue sous le nom de fusion. Join spécifie une colonne appelée Key Il s'agit d'une opération pour connecter les lignes avec la même valeur dans la clé de deux bases de données horizontalement.

Type d'obligation

Il existe deux méthodes principales d'assemblage, d'assemblage intérieur et d'assemblage extérieur. Rejoignez les deux DataFrames suivants dans la colonne "fruits".

Jointure interne

Les lignes qui n'ont pas de valeur commune dans la colonne Clé sont ignorées. Laissez également les autres lignes qui ont la même colonne et leurs valeurs ne correspondent pas Vous pouvez également spécifier de le supprimer. Vous pouvez voir que seules les données de colonne "fruits" communes des deux DataFrames restent.

Jointure externe

Certaines lignes n'ont pas de valeur commune dans la colonne Clé. Les éléments qui n'ont aucune valeur sont remplis avec NaN. Vous pouvez voir que NaN est inséré dans les données de direction de ligne de «kiwi» et «mangue».

Bases de la jointure interne how = "inner"

Essayons de combiner en interne deux DataFrames, df1 et df2.

pandas.merge(df1, df2, on= "Colonne clé", how="inner")

Dans ce cas, df1 est déplacé vers la gauche Les lignes dont les valeurs ne correspondent pas dans la colonne Clé sont ignorées.

En outre, les colonnes communes autres que la colonne Clé dont les valeurs ne correspondent pas sont laissées. La colonne qui appartenait au DataFrame sur la gauche est _x La colonne qui appartenait au côté droit a _y comme suffixe. Sauf indication contraire, l'index DataFrame n'est pas impliqué dans le processus.

Bases des jointures externes how = "external"

Examinons deux DataFrames, df1 et df2.

pandas.merge(df1, df2, on="Colonne clé", how="outer")

Dans ce cas, la ligne où df1 est déplacé vers la gauche et les valeurs ne correspondent pas dans la colonne Clé Les éléments sans valeur résiduelle sont remplis de NaN.

En outre, les colonnes communes avec des valeurs non concordantes autres que la colonne Clé sont laissées. La colonne qui appartenait au DataFrame sur la gauche est _x, La colonne qui appartenait au côté droit a _y comme suffixe. Sauf indication contraire, l'index DataFrame n'est pas impliqué dans le processus.

Combinez des colonnes qui n'ont pas le même nom que Key

Des deux DataFrames Order_df (à gauche), un avec les informations de commande Supposons que l'autre soit customer_df (à droite) avec les informations client.

Dans les informations de commande, la colonne indiquant l'ID du client acheteur est "customer_id". Dans les informations client, la colonne indiquant l'identifiant du client est "id".

Les colonnes des colonnes auxquelles vous souhaitez correspondre ne correspondent pas.

Dans ce cas, en spécifiant la colonne que vous souhaitez utiliser comme clé Vous pouvez combiner des colonnes de DataFrames avec différentes colonnes en correspondance.

pandas.merge(DF gauche,DF droit, left_on="DF gaucheのカラム", right_on="Colonne DF droite", how="Méthode d'adhésion")

Rejoindre avec index comme clé

Lorsque la clé utilisée pour joindre des DataFrames est un index Spécifiez l'index au lieu de spécifier les colonnes du DataFrame.

left_index=True #Index DF gauche

right_index=True #Index de DF à droite

import pandas as pd

#Informations sur la commande
order_df = pd.DataFrame([[1000, 2546, 103],
                         [1001, 4352, 101],
                         [1002, 342, 101],
                         [1003, 1192, 102]],
                         columns=["id", "item_id", "customer_id"])
#Informations client
customer_df = pd.DataFrame([["Tanaka"],
                           ["Suzuki"],
                           ["Kato"]],
                           columns=["name"])
customer_df.index = [101, 102, 103] #Modifiez la valeur d'index ici

# order_df et client_Combinez df avec l'ID client pour la clé et la commande_Remplaçant en df
order_df = pd.merge(order_df, customer_df, left_on="customer_id", right_index=True, how="inner")
# right_index=Vrai et client_Joint la même ligne que id.

print(order_df)

#production
    id  item_id  customer_id    name
0  1000     2546          103    Kato
1  1001     4352          101  Tanaka
2  1002      342          101  Tanaka
3  1003     1192          102  Suzuki

#production(customer_df.sans index, comment="outer"dans le cas de)

       id  item_id  customer_id    name
0  1000.0   2546.0          103     NaN
1  1001.0   4352.0          101     NaN
2  1002.0    342.0          101     NaN
3  1003.0   1192.0          102     NaN
3     NaN      NaN            0  Tanaka
3     NaN      NaN            1  Suzuki
3     NaN      NaN            2    Kato

Analyse des données à l'aide de DataFrame

Obtenez quelques lignes

Lorsque la quantité de données à traiter est énorme, les données de sortie sont limitées.

df.head() #Renvoie un DataFrame contenant uniquement les 5 premières lignes.

df.tail() #Renvoie un DataFrame contenant uniquement les 5 dernières lignes.

Si vous spécifiez une valeur entière comme argument, ce sera pour n'importe quel nombre de lignes au début ou à la fin. Vous pouvez obtenir un DataFrame. Les méthodes head () et tail () peuvent également être utilisées avec des variables de type Series.

Appliquer le traitement des calculs

Si vous passez Series ou DataFrame à la fonction fournie par NumPy Le traitement des calculs peut être appliqué à tous les éléments.

Si vous passez un DataFrame à une fonction qui reçoit un tableau NumPy Le processus de calcul est effectué collectivement pour chaque colonne.

En outre, Pandas prend en charge la diffusion comme NumPy. Utilisez l'expression régulière "+ - * /" pour calculer entre Pandas et entre Pandas et entiers. Peut être traité.

Obtenez des statistiques récapitulatives

Statistiques récapitulatives: ensemble d'informations statistiques telles que les valeurs moyennes, maximales et minimales pour chaque colonne.

Lorsque la variable de type DataFrame est df

df.describe() 
#Inclut le nombre df par colonne, la moyenne, l'écart type, le minimum, le quadrant, le maximum, etc.
#Renvoie un DataFrame.

Notez que les statistiques récapitulatives affichées varient en fonction du type de données. En outre, les lignes et les éléments peuvent être obtenus en utilisant loc et at ensemble.

Le nom de la statistique récapitulative est utilisé pour l'index du DataFrame obtenu.

import numpy as np
import pandas as pd

np.random.seed(0)
columns = ["apple", "orange", "banana", "strawberry", "kiwifruit"]

#Générer DataFrame et ajouter des colonnes
df = pd.DataFrame()
for column in columns:
    df[column] = np.random.choice(range(1, 11), 10)
df.index = range(1, 11)

#Des statistiques récapitulatives de DF"mean", "max", "min"Sortez df_Remplaçant dans des.
df_des = df.describe().loc[["mean","max","min"]]
# df.describe()Renvoie uniquement un Dataframe, vous devez donc le spécifier avec loc.


print(df_des)
#production
      apple  orange  banana  strawberry  kiwifruit
mean    5.1     6.9     5.6         4.1        5.3
max    10.0     9.0    10.0         9.0       10.0
min     1.0     2.0     1.0         1.0        1.0

Trouvez la différence entre les lignes ou les colonnes d'un DataFrame

L'opération pour trouver la différence entre les lignes est une fonction particulièrement utilisée dans l'analyse de séries chronologiques. Lorsque la variable de type DataFrame est df

df.diff() #Renvoie un DataFrame qui calcule la différence entre les lignes ou les colonnes.

df.diff(periods=Espacement des lignes ou des colonnes, axis=Direction de l'axe)
# periods=Peut être omis
#Si le premier argument est positif, la différence par rapport à la ligne précédente est calculée, et si elle est négative, la différence par rapport à la ligne suivante est calculée.
#Lorsque l'axe est à 0, il est dans le sens de la ligne et lorsqu'il est à 1, il est dans le sens de la colonne.

import numpy as np
import pandas as pd

np.random.seed(0)
columns = ["apple", "orange", "banana", "strawberry", "kiwifruit"]

#Générer DataFrame et ajouter des colonnes
df = pd.DataFrame()
for column in columns:
    df[column] = np.random.choice(range(1, 11), 10)
df.index = range(1, 11)

#Pour chaque ligne de df, df le DataFrame qui a calculé la différence par rapport à la ligne après 2 lignes_Remplacez diff.
df_diff = df.diff(periods="-2",axis=0)
#Ou df_diff = df.diff(-2, axis=0)

#df et df_Vérifiez le contenu du traitement en comparant les données de diff.
print(df)
print()
print(df_diff)

#production
apple  orange  banana  strawberry  kiwifruit
1       6       8       6           3         10
2       1       7      10           4         10
3       4       9       9           9          1
4       4       9      10           2          5
5       8       2       5           4          8
6      10       7       4           4          4
7       4       8       1           4          3
8       6       8       4           8          8
9       3       9       6           1          3
10      5       2       1           2          1

    apple  orange  banana  strawberry  kiwifruit
1     2.0    -1.0    -3.0        -6.0        9.0
2    -3.0    -2.0     0.0         2.0        5.0
3    -4.0     7.0     4.0         5.0       -7.0
4    -6.0     2.0     6.0        -2.0        1.0
5     4.0    -6.0     4.0         0.0        5.0
6     4.0    -1.0     0.0        -4.0       -4.0
7     1.0    -1.0    -5.0         3.0        0.0
8     1.0     6.0     3.0         6.0        7.0
9     NaN     NaN     NaN         NaN        NaN
10    NaN     NaN     NaN         NaN        NaN

Regroupement

Pour les bases de données et les DataFrames Agrégation de lignes avec la même valeur pour une colonne particulière C'est ce qu'on appelle le regroupement.