Comment rejoindre DataFrames dans Pandas Python?

Pandas DataFrame est une structure de données bidimensionnelle (2D) qui est alignée dans un format tabulaire. Ces dataframes peuvent être combinés à l'aide de différentes méthodes telles que Concat (), Merge () et des jointures. Les Pandas ont des performances élevées et des opérations de jointure à complexe qui ressemblent à la base de données relationnelle SQL. À l'aide de la fonction de fusion, les opérations de jointure peuvent être implémentées entre les objets DataFrames.

Nous explorerons les utilisations de la fonction de fusion, de la fonction concat et des différents types d'opérations de jointures à Pandas Python dans cet article. Tous les exemples seront exécutés via l'éditeur PyCharm. Commençons par les détails!

Utilisation de la fonction de fusion

La fonction de base couramment utilisée de la fonction Merge () est donnée:

PD.fusionner (df_obj1, df_obj2, comment = 'inner', on = non, left_on = aucun, droit_on = aucun)

Expliquons les détails des paramètres:

Les deux premiers df_obj1 et df_obj2 Les arguments sont les noms des objets ou des tables DataFrame.

Le "comment"Le paramètre est utilisé pour différents types d'opérations de jointure telles que« gauche, droite, extérieure et intérieure ». La fonction de fusion utilise l'opération de jointure «intérieure» par défaut.

L'argument "sur" contient le nom de colonne sur lequel l'opération de jointure est effectuée. Cette colonne doit être présente dans les deux objets DataFrame.

Dans les arguments "Left_on" et "droite". Le "droit_on" est le nom de la colonne utilisée comme clé de la bonne dataframe.

Pour développer le concept de jointure de DataFrames, nous avons pris deux objets de dataframe - le produit et le client. Les détails suivants sont présents dans le produit DataFrame:

produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)

Le Client DataFrame contient les détails suivants:

Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)

Rejoignez des dataframes sur une clé

Nous pouvons facilement trouver des produits vendus en ligne et les clients qui les ont achetés. Ainsi, sur la base d'une clé «Product_id», nous avons effectué une opération de jointure intérieure sur les deux dataframes comme suit:

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
«City»: [«Lahore», «Islamabad», «Faisalabad», «Karachi», «Karachi», «Islamabad», «Rawalpindi», «Islamabad»,
'Lahore']
)
Imprimer (PD.fusion (produit, client, on = 'product_id'))

La sortie suivante s'affiche sur la fenêtre après avoir exécuté le code ci-dessus:

Si les colonnes sont différentes dans les deux dataframes, écrivez explicitement le nom de chaque colonne par les arguments Left_on et Right_on comme suit:

Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
«City»: [«Lahore», «Islamabad», «Faisalabad», «Karachi», «Karachi», «Islamabad», «Rawalpindi», «Islamabad»,
'Lahore']
)
Imprimer (PD.fusionner (produit, client, Left_on = 'product_name', droite_on = 'product_purchased')))

La sortie suivante s'affichera à l'écran:

Rejoignez des dataframes en utilisant comment l'argument

Dans les exemples suivants, nous expliquerons quatre types d'opérations de jointures sur Pandas DataFrames:

• Jointure interne
• Jointure extérieure
• Joint gauche
• À droite

Se joindre à l'intérieur dans les pandas

Nous pouvons effectuer une jointure intérieure sur plusieurs clés. Pour afficher plus de détails sur les ventes de produits, prenez Product_id, Seller_City à partir du produit DataFrame et Product_id, et «Customer_City» du client DataFrame pour constater que le vendeur ou le client appartient à la même ville. Implémentez les lignes de code suivantes:

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)
Imprimer (PD.fusionner (produit, client, comment = 'inner', left_on = ['product_id', 'seller_city'], droit_on = ['product_id', 'customer_city']))))

Le résultat suivant s'affiche dans la fenêtre après avoir exécuté le code ci-dessus:

Rejoings complet / extérieur à Pandas

Les jointures externes renvoient à la fois les valeurs de données de données à droite et à gauche, qui ont soit des correspondances. Donc, pour implémenter la jointure extérieure, définissez l'argument «comment» comme extérieur. Modifions l'exemple ci-dessus en utilisant le concept de jointure externe. Dans le code ci-dessous, il renverra toutes les valeurs des données de données gauche et droite.

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)
Imprimer (PD.fusion (produit, client, on = 'product_id', comment = 'extérieur')))

Définir l'argument de l'indicateur comme «vrai» s. Vous remarquerez que la nouvelle colonne "_merge" est ajoutée à la fin.

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)
Imprimer (PD.fusion (produit, client, on = 'product_id', comment = 'extérieur', indicateur = true))

Comme vous pouvez le voir dans la capture d'écran ci-dessous, les valeurs de la colonne de fusion expliquent quelle ligne appartient à quel dataframe.

À gauche rejoindre Pandas

La gauche à gauche n'afficher que les lignes du dataframe gauche. Il est similaire à la jointure extérieure. Alors, modifiez la valeur de l'argument «comment» avec «gauche». Essayez le code suivant pour implémenter l'idée de gauche à gauche:

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)
Imprimer (PD.fusion (produit, client, on = 'product_id', comment = 'gauche')))

Right Rejoignez-vous dans Pandas

La jointure de droite maintient toutes les bonnes lignes de données de données à droite avec les lignes qui sont également communes dans le dataframe gauche. Dans ce cas, l'argument «comment» est défini comme la «bonne» valeur. Exécutez le code suivant pour implémenter le bon concept de jointure:

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)
Imprimer (PD.fusion (produit, client, on = 'product_id', comment = 'droit')))

Dans la capture d'écran suivante, vous pouvez voir le résultat après avoir exécuté le code ci-dessus:

Jointure de DataFrames à l'aide de la fonction concat ()

Deux dataframes peuvent être joints à l'aide de la fonction Concat. La syntaxe de base de la fonction de concaténation est donnée ci-dessous:

PD.concat ([df_obj1, df_obj_2]))

Deux objets DataFrames passeront comme arguments.

Rejoignons à la fois le produit DataFrames et le client via la fonction Concat. Exécutez les lignes de code suivantes pour rejoindre deux dataframes:

# Importer la bibliothèque Pandas
Importer des pandas en tant que PD
produit = PD.Trame de données(
'Product_id': [101,102,103,104,105,106,107],
«Product_name»: [«casque», «sac», «chaussures», «smartphone», «Brush de dents», «montre de bracelets», «ordinateur portable»],
«Catégorie»: [«électronique», «mode», «mode», «électronique», «épicerie», «mode», «électronique»],
'Prix': [300.0,1000.50 2000.0,21999.0 145.0,1500.0,90999.0],
«Seller_City»: [«Islamabad», «Lahore», «Karachi», «Rawalpindi», «Islamabad», «Karachi», «Faisalabad»]
)
Client = PD.Trame de données(
'Id': [1,2,3,4,5,6,7,8,9],
'Customer_name': ['Sara', 'Sana', 'Ali', 'Raees', 'Mahwish', 'Umar', 'Mirha', 'Asif', 'Maria'],
«Âge»: [20,21,15,10,31,52,15,18,16],
'Product_id': [101,0,106,0,103,104,0,0,107],
«Product_purchased»: [«casque», «na», «montre de bracelets», «na», «chaussures», «smartphone», «na», «na», «ordinateur portable»],
'Customer_City': ['Lahore', 'Islamabad', 'Faisalabad', 'Karachi', 'Karachi', 'Islamabad', 'Rawalpindi', 'Islamabad',
'Lahore']
)
Imprimer (PD.concat ([produit, client]))

Conclusion:

Dans cet article, nous avons discuté de la mise en œuvre de la fonction Merge (), des fonctions concat () et de l'opération à Pandas Python. En utilisant les méthodes ci-dessus, vous pouvez facilement rejoindre deux dataframes et appris. Comment mettre en œuvre les opérations de jointure «intérieure, extérieure, gauche et droite» dans Pandas. Espérons que ce tutoriel vous guidera dans la mise en œuvre des opérations de jointure sur différents types de dataframes. Veuillez nous faire part de vos difficultés en cas d'erreur.