Comment réaliser efficacement un produit cartésien (CROSS JOIN) avec Pandas DataFrames ?

Produit cartésien performant (CROSS JOIN) avec Pandas

Dans le domaine de la manipulation de données, le produit cartésien, ou CROSS JOIN, est une opération précieuse qui combine deux ou plus de DataFrames sur une base un-à-un ou plusieurs-à-plusieurs. Cette opération étend l'ensemble de données d'origine en créant de nouvelles lignes pour toutes les combinaisons possibles d'éléments à partir des DataFrames d'entrée.

Énoncé du problème

Étant donné deux DataFrames avec des indices uniques :

left = pd.DataFrame({'col1': ['A', 'B', 'C'], 'col2': [1, 2, 3]})
right = pd.DataFrame({'col1': ['X', 'Y', 'Z'], 'col2': [20, 30, 50]})

Le but est de trouver la méthode la plus efficace pour calculer le produit cartésien de ces DataFrames, ce qui donne ce qui suit sortie :

  col1_x  col2_x col1_y  col2_y
0      A       1      X      20
1      A       1      Y      30
2      A       1      Z      50
3      B       2      X      20
4      B       2      Y      30
5      B       2      Z      50
6      C       3      X      20
7      C       3      Y      30
8      C       3      Z      50

Solutions optimales

Méthode 1 : Colonne de clé temporaire

Une approche consiste à attribuer temporairement une colonne « clé » avec un valeur commune aux deux DataFrames :

left.assign(key=1).merge(right.assign(key=1), on='key').drop('key', 1)

Cette méthode utilise la fusion pour effectuer une JOIN plusieurs-à-plusieurs sur la colonne "clé".

Méthode 2 : produit cartésien NumPy

Pour les DataFrames plus grands, une solution performante consiste à utiliser l'implémentation du produit cartésien de NumPy :

def cartesian_product(*arrays):
    la = len(arrays)
    dtype = np.result_type(*arrays)
    arr = np.empty([len(a) for a in arrays] + [la], dtype=dtype)
    for i, a in enumerate(np.ix_(*arrays)):
        arr[...,i] = a
    return arr.reshape(-1, la)  

Cette fonction génère toutes les combinaisons possibles d'éléments à partir de l'entrée tableaux.

Méthode 3 : CROSS JOIN généralisée

La solution généralisée fonctionne sur des DataFrames avec des indices non uniques ou mixtes :

def cartesian_product_generalized(left, right):
    la, lb = len(left), len(right)
    idx = cartesian_product(np.ogrid[:la], np.ogrid[:lb])
    return pd.DataFrame(
        np.column_stack([left.values[idx[:,0]], right.values[idx[:,1]]]))

Ceci La méthode réindexe les DataFrames en fonction du produit cartésien de leurs indices.

Amélioré Solutions

Méthode 4 : CROSS JOIN simplifiée

Une solution simplifiée supplémentaire est possible pour deux DataFrames avec des types non mixtes :

def cartesian_product_simplified(left, right):
    la, lb = len(left), len(right)
    ia2, ib2 = np.broadcast_arrays(*np.ogrid[:la,:lb])

    return pd.DataFrame(
        np.column_stack([left.values[ia2.ravel()], right.values[ib2.ravel()]]))

Ceci La méthode utilise la diffusion et l'ogrid de NumPy pour générer le produit cartésien des DataFrames indices.

Comparaison des performances

Les performances de ces solutions varient en fonction de la taille et de la complexité de l'ensemble de données. Le benchmark suivant fournit une comparaison relative de leur temps d'exécution :

# ... (Benchmarking code not included here)

Les résultats indiquent que la méthode cartesian_product basée sur NumPy surpasse les autres solutions dans la plupart des cas, d'autant plus que la taille des DataFrames augmente.

Conclusion

En tirant parti des techniques présentées, les analystes de données peuvent réaliser efficacement des produits cartésiens sur des DataFrames, une opération fondamentale pour la manipulation de données. et l'agrandissement. Ces méthodes permettent des performances optimales même sur des ensembles de données volumineux ou complexes, permettant une exploration et une analyse efficaces des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!