Comment puis-je réaliser efficacement un produit cartésien (jointure croisée) de Pandas DataFrames ?

Produit cartésien performant (CROSS JOIN) avec Pandas

Dans Pandas, calculer le produit cartésien (jointure croisée) de deux DataFrames peut être un opération essentielle. Bien que l'astuce JOIN plusieurs-à-plusieurs fonctionne raisonnablement pour les DataFrames plus petits, les performances se dégradent avec des données plus volumineuses.

Implémentation rapide à l'aide de NumPy

Une implémentation plus rapide utilise NumPy pour 1D Calculs de produits cartésiens :

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)  

Solutions généralisées pour différents DataFrames

L'astuce ci-dessus fonctionne pour les DataFrames avec des types scalaires non mixtes. Pour les types mixtes, utilisez à vos propres risques.

• Généralisation à des dataframes indexées uniques :

  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]]]))

  Copier après la connexion
• Gestion Indices non uniques :
  La solution ci-dessus peut être étendue pour fonctionner avec des indices non uniques indices.

• Plusieurs DataFrames :
  Plusieurs DataFrames peuvent être combinés à l'aide de :

  def cartesian_product_multi(*dfs):
      idx = cartesian_product(*[np.ogrid[:len(df)] for df in dfs])
      return pd.DataFrame(
          np.column_stack([df.values[idx[:,i]] for i,df in enumerate(dfs)]))

  Copier après la connexion

Solution simplifiée pour deux DataFrames

Lorsqu'il s'agit de seulement deux DataFrames, une approche plus simple peut être utilisée :

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()]]))

Comparaison des performances

L'analyse comparative des solutions a montré que le cartesian_product_generalized basé sur NumPy est le plus rapide, suivi de cartesian_product_simplified pour deux DataFrames.

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!