GVKun编程网logo

Python-pandas高性能笛卡尔积（CROSS JOIN）（python笛卡尔积算法）

33

以上就是给各位分享Python-pandas高性能笛卡尔积，其中也会对CROSSJOIN进行解释，同时本文还将给你拓展(转载)Mysql----Join用法(Innerjoin,Leftjoin,Ri

以上就是给各位分享Python-pandas高性能笛卡尔积，其中也会对CROSS JOIN进行解释，同时本文还将给你拓展(转载) Mysql----Join用法(Inner join,Left join,Right join, Cross join, Union模拟Full join)及---性能优化、2018.03.27 python pandas merge join 使用、dask - 合并/完整笛卡尔积 - 内存问题、Java 8中的流作为流的笛卡尔积（仅使用流）等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

Python-pandas高性能笛卡尔积（CROSS JOIN）（python笛卡尔积算法）

Python-pandas高性能笛卡尔积（CROSS JOIN）（python笛卡尔积算法）

给定两个简单的DataFrames；

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

这些框架的叉积可以计算出来，如下所示：

A       1      X      20A       1      Y      30A       1      Z      50B       2      X      20B       2      Y      30B       2      Z      50C       3      X      20C       3      Y      30C       3      Z      50

计算结果的最有效方法是什么？

答案1

小编典典

让我们从建立基准开始。解决此问题的最简单方法是使用临时“键”列：

def cartesian_product_basic(left, right):    return (       left.assign(key=1).merge(right.assign(key=1), on=''key'').drop(''key'', 1))cartesian_product_basic(left, right)  col1_x  col2_x col1_y  col2_y0      A       1      X      201      A       1      Y      302      A       1      Z      503      B       2      X      204      B       2      Y      305      B       2      Z      506      C       3      X      207      C       3      Y      308      C       3      Z      50

这是如何为两个DataFrame分配一个具有相同值（例如1）的临时“键”列的。merge然后对“键”执行多对多JOIN。

尽管多对多JOIN技巧适用于大小合理的DataFrame，但你会在较大数据上看到相对较低的性能。

更快的实现将需要NumPy。这是一些著名的一维笛卡尔积的NumPy实现。我们可以基于其中一些性能解决方案来获得所需的输出。但是，我最喜欢的是@senderle的第一个实现。

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)

通用化：对唯一或非唯一索引数据帧进行CROSS JOIN

免责声明

这些解决方案针对具有非混合标量dtype的DataFrames进行了优化。如果处理混合dtype，请自担风险！

此技巧适用于任何类型的DataFrame。我们使用上述方法计算DataFrames数字索引的笛卡尔积·，使用它来重新索引DataFrames，然后

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]]]))cartesian_product_generalized(left, right)   0  1  2   30  A  1  X  201  A  1  Y  302  A  1  Z  503  B  2  X  204  B  2  Y  305  B  2  Z  506  C  3  X  207  C  3  Y  308  C  3  Z  50np.array_equal(cartesian_product_generalized(left, right),               cartesian_product_basic(left, right))True

而且，沿着类似的路线，

left2 = left.copy()left2.index = [''s1'', ''s2'', ''s1'']right2 = right.copy()right2.index = [''x'', ''y'', ''y'']left2   col1  col2s1    A     1s2    B     2s1    C     3right2  col1  col2x    X    20y    Y    30y    Z    50np.array_equal(cartesian_product_generalized(left, right),               cartesian_product_basic(left2, right2))True

该解决方案可以推广到多个DataFrame。例如，

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)]))cartesian_product_multi(*[left, right, left]).head()   0  1  2   3  4  50  A  1  X  20  A  11  A  1  X  20  B  22  A  1  X  20  C  33  A  1  X  20  D  44  A  1  Y  30  A  1

进一步简化
cartesian_product当只处理两个 DataFrame 时，可能会出现一个不涉及@senderle的简单解决方案。使用np.broadcast_arrays，我们可以达到几乎相同的性能水平。

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()]]))np.array_equal(cartesian_product_simplified(left, right),               cartesian_product_basic(left2, right2))True

性能比较

在具有唯一索引的某些人为设计的DataFrame上对这些解决方案进行基准测试，

请注意，时间可能会根据你的设置，数据和cartesian_product适用的辅助功能选择而有所不同。

性能基准测试代码

这是时间脚本。上面定义了此处调用的所有功能。

from timeit import timeitimport pandas as pdimport matplotlib.pyplot as pltres = pd.DataFrame(       index=[''cartesian_product_basic'', ''cartesian_product_generalized'',               ''cartesian_product_multi'', ''cartesian_product_simplified''],       columns=[1, 10, 50, 100, 200, 300, 400, 500, 600, 800, 1000, 2000],       dtype=float)for f in res.index:     for c in res.columns:        # print(f,c)        left2 = pd.concat([left] * c, ignore_index=True)        right2 = pd.concat([right] * c, ignore_index=True)        stmt = ''{}(left2, right2)''.format(f)        setp = ''from __main__ import left2, right2, {}''.format(f)        res.at[f, c] = timeit(stmt, setp, number=5)ax = res.div(res.min()).T.plot(loglog=True) ax.set_xlabel("N"); ax.set_ylabel("time (relative)");plt.show()

(转载) Mysql----Join用法(Inner join,Left join,Right join, Cross join, Union模拟Full join)及---性能优化

(转载) Mysql----Join用法(Inner join,Left join,Right join, Cross join, Union模拟Full join)及---性能优化

http://blog.csdn.net/ochangwen/article/details/52346610

 

前期数据准备

CREATE TABLE  atable(
aID int( 1 ) AUTO_INCREMENT PRIMARY KEY ,
aNum char( 20 ));

CREATE TABLE btable(
bID int( 1 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
bName char( 20 ) );

INSERT INTO atable
VALUES ( 1, ''a20050111'' ) , ( 2, ''a20050112'' ) , ( 3, ''a20050113'' ) , ( 4, ''a20050114'' ) , ( 5, ''a20050115'' ) ;

INSERT INTO btable
VALUES ( 1, '' 2006032401'' ) , ( 2, ''2006032402'' ) , ( 3, ''2006032403'' ) , ( 4, ''2006032404'' ) , ( 8, ''2006032408'' ) ;

-------------------------------------------------------------------------------------------

atable:左表；btable:右表。
JOIN 按照功能大致分为如下三类：
  1).inner join(内连接,或等值连接)：取得两个表中存在连接匹配关系的记录。
  2).left  join(左连接)：取得左表（atable）完全记录，即是右表（btable）并无对应匹配记录。
  3).right join(右连接)：与 LEFT JOIN 相反，取得右表（btable）完全记录，即是左表（atable）并无匹配对应记录。
注意：mysql不支持Full join,不过可以通过 union 关键字来合并 left join 与 right join来模拟full join.

一、Inner join

  内连接，也叫等值连接，inner join产生同时符合A和B的一组数据。
  接下来给出一个列子用于解释下面几种分类。如下两个表(A,B)

 
  1. mysql> select * from atable  inner join btable  on atable.aid=btable.bid;  
  2. +-----+-----------+-----+-------------+  
  3. | aID | aNum      | bID | bName       |  
  4. +-----+-----------+-----+-------------+  
  5. |   1 | a20050111 |   1 |  2006032401 |  
  6. |   2 | a20050112 |   2 | 2006032402  |  
  7. |   3 | a20050113 |   3 | 2006032403  |  
  8. |   4 | a20050114 |   4 | 2006032404  |  
  9. +-----+-----------+-----+-------------+  

 

二、Left join

  left join,（或left outer join:在Mysql中两者等价，推荐使用left join.）左连接从左表(A)产生一套完整的记录,与匹配的记录(右表(B)) .如果没有匹配,右侧将包含null。

 

 
  1. mysql> select * from atable  left join btable  on atable.aid=btable.bid;  
  2. +-----+-----------+------+-------------+  
  3. | aID | aNum      | bID  | bName       |  
  4. +-----+-----------+------+-------------+  
  5. |   1 | a20050111 |    1 |  2006032401 |  
  6. |   2 | a20050112 |    2 | 2006032402  |  
  7. |   3 | a20050113 |    3 | 2006032403  |  
  8. |   4 | a20050114 |    4 | 2006032404  |  
  9. |   5 | a20050115 | NULL | NULL        |  
  10. +-----+-----------+------+-------------+  


------------------------------------------------------------------------------------------------------------

 

  2).如果想只从左表(A)中产生一套记录，但不包含右表(B)的记录，可以通过设置where语句来执行，如下

 

 
  1. mysql> select * from atable  left join btable  on atable.aid=btable.bid   
  2.     -> where atable.aid is  null or btable.bid is  null;  
  3. +-----+-----------+------+-------+  
  4. | aID | aNum      | bID  | bName |  
  5. +-----+-----------+------+-------+  
  6. |   5 | a20050115 | NULL | NULL  |  
  7. +-----+-----------+------+-------+  


-----------------------------------------------------------------------------------------

 

同理，还可以模拟inner join. 如下：


 

 
  1. mysql> select * from atable  left join btable  on atable.aid=btable.bid  where atable.aid is not null and btable.bid is not null;  
  2. +-----+-----------+------+-------------+  
  3. | aID | aNum      | bID  | bName       |  
  4. +-----+-----------+------+-------------+  
  5. |   1 | a20050111 |    1 |  2006032401 |  
  6. |   2 | a20050112 |    2 | 2006032402  |  
  7. |   3 | a20050113 |    3 | 2006032403  |  
  8. |   4 | a20050114 |    4 | 2006032404  |  
  9. +-----+-----------+------+-------------+  

------------------------------------------------------------------------------------------

 

三、Right join

  同Left join

 

  1. mysql> select * from atable  right join btable  on atable.aid=btable.bid;  
  2. +------+-----------+-----+-------------+  
  3. | aID  | aNum      | bID | bName       |  
  4. +------+-----------+-----+-------------+  
  5. |    1 | a20050111 |   1 |  2006032401 |  
  6. |    2 | a20050112 |   2 | 2006032402  |  
  7. |    3 | a20050113 |   3 | 2006032403  |  
  8. |    4 | a20050114 |   4 | 2006032404  |  
  9. | NULL | NULL      |   8 | 2006032408  |  
  10. +------+-----------+-----+-------------+  

 

四、差集

 

 
  1. mysql> select * from atable  left join btable  on atable.aid=btable.bid    
  2.     -> where btable.bid is null  
  3.     -> union  
  4.     -> select * from atable right join btable on atable.aid=btable.bid  
  5.     -> where atable.aid is null;  
  6. +------+-----------+------+------------+  
  7. | aID  | aNum      | bID  | bName      |  
  8. +------+-----------+------+------------+  
  9. |    5 | a20050115 | NULL | NULL       |  
  10. | NULL | NULL      |    8 | 2006032408 |  
  11. +------+-----------+------+------------+  


-----------------------------------------------------------------------------------

 

五.Cross join

  交叉连接，得到的结果是两个表的乘积，即笛卡尔积

    笛卡尔（Descartes）乘积又叫直积。假设集合A={a,b}，集合B={0,1,2}，则两个集合的笛卡尔积为{(a,0),(a,1),(a,2),(b,0),(b,1), (b,2)}。可以扩展到多个集合的情况。类似的例子有，如果A表示某学校学生的集合，B表示该学校所有课程的集合，则A与B的笛卡尔积表示所有可能的选课情况。

 

 
  1. mysql> select * from atable cross join btable;  
  2. +-----+-----------+-----+-------------+  
  3. | aID | aNum      | bID | bName       |  
  4. +-----+-----------+-----+-------------+  
  5. |   1 | a20050111 |   1 |  2006032401 |  
  6. |   2 | a20050112 |   1 |  2006032401 |  
  7. |   3 | a20050113 |   1 |  2006032401 |  
  8. |   4 | a20050114 |   1 |  2006032401 |  
  9. |   5 | a20050115 |   1 |  2006032401 |  
  10. |   1 | a20050111 |   2 | 2006032402  |  
  11. |   2 | a20050112 |   2 | 2006032402  |  
  12. |   3 | a20050113 |   2 | 2006032402  |  
  13. |   4 | a20050114 |   2 | 2006032402  |  
  14. |   5 | a20050115 |   2 | 2006032402  |  
  15. |   1 | a20050111 |   3 | 2006032403  |  
  16. |   2 | a20050112 |   3 | 2006032403  |  
  17. |   3 | a20050113 |   3 | 2006032403  |  
  18. |   4 | a20050114 |   3 | 2006032403  |  
  19. |   5 | a20050115 |   3 | 2006032403  |  
  20. |   1 | a20050111 |   4 | 2006032404  |  
  21. |   2 | a20050112 |   4 | 2006032404  |  
  22. |   3 | a20050113 |   4 | 2006032404  |  
  23. |   4 | a20050114 |   4 | 2006032404  |  
  24. |   5 | a20050115 |   4 | 2006032404  |  
  25. |   1 | a20050111 |   8 | 2006032408  |  
  26. |   2 | a20050112 |   8 | 2006032408  |  
  27. |   3 | a20050113 |   8 | 2006032408  |  
  28. |   4 | a20050114 |   8 | 2006032408  |  
  29. |   5 | a20050115 |   8 | 2006032408  |  
  30. +-----+-----------+-----+-------------+  
  31. 25 rows in set (0.00 sec)  
  32.   
  33.  <pre><code class="hljs cs"><span class="hljs-function">#再执行：mysql> <span class="hljs-keyword">select</span> * <span class="hljs-keyword">from</span> A inner <span class="hljs-keyword">join</span> B</span>; 试一试 (与上面的结果一样)  
  34.   
  35. <span class="hljs-meta">#在执行mysql> select * from A cross join B on A.name = B.name; 试一试</span></code>  

 

    实际上，在 MySQL 中（仅限于 MySQL） CROSS JOIN 与 INNER JOIN 的表现是一样的，在不指定 ON 条件得到的结果都是笛卡尔积，反之取得两个表完全匹配的结果。    inner join 与 cross join 可以省略 inner 或 cross关键字，因此下面的 SQL 效果是一样的：

 
  1. ... FROM table1 INNER JOIN table2  
  2. ... FROM table1 CROSS JOIN table2  
  3. ... FROM table1 JOIN table2  

 

六.union实现Full join

    全连接产生的所有记录（双方匹配记录）在表A和表B。如果没有匹配,则对面将包含null。与差集类似。

 

 
  1. mysql> select * from atable  left join btable  on atable.aid=btable.bid  
  2.     -> union  
  3.     -> select * from atable right join btable on atable.aid=btable.bid;  
  4. +------+-----------+------+-------------+  
  5. | aID  | aNum      | bID  | bName       |  
  6. +------+-----------+------+-------------+  
  7. |    1 | a20050111 |    1 |  2006032401 |  
  8. |    2 | a20050112 |    2 | 2006032402  |  
  9. |    3 | a20050113 |    3 | 2006032403  |  
  10. |    4 | a20050114 |    4 | 2006032404  |  
  11. |    5 | a20050115 | NULL | NULL        |  
  12. | NULL | NULL      |    8 | 2006032408  |  
  13. +------+-----------+------+-------------+  


--------------------------------------------------------------------------------------------------------

 

七.性能优化

  1.显示(explicit) inner join VS 隐式(implicit) inner join

 

 
  1. select * from  
  2. table a inner join table b  
  3. on a.id = b.id;  

VS

 
  1. select a.*, b.*  
  2. from table a, table b  
  3. where a.id = b.id;  

    数据库中比较(10w数据)得之，它们用时几乎相同，第一个是显示的inner join，后一个是隐式的inner join。
2.left join/right join VS inner join
    尽量用inner join.避免 left join 和 null.

 

    在使用left join（或right join）时，应该清楚的知道以下几点：

(1). on与 where的执行顺序
    ON 条件（“A LEFT JOIN B ON 条件表达式”中的ON）用来决定如何从 B 表中检索数据行。如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据,在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后，WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。
    所以我们要注意：在使用Left (right) join的时候，一定要在先给出尽可能多的匹配满足条件，减少Where的执行。如：

 
  1. select * from A  
  2. inner join B on B.name = A.name  
  3. left join C on C.name = B.name  
  4. left join D on D.id = C.id  
  5. where C.status>1 and D.status=1;  

下面这种写法更省时

[sql]  view plain  copy
 
  1. select * from A  
  2. inner join B on B.name = A.name  
  3. left join C on C.name = B.name and C.status>1  
  4. left join D on D.id = C.id and D.status=1  

(2).注意ON 子句和 WHERE 子句的不同

[sql]  view plain  copy
 
  1. mysql> SELECT * FROM product LEFT JOIN product_details  
  2.        ON (product.id = product_details.id)  
  3.        AND product_details.id=2;  
  4. +----+--------+------+--------+-------+  
  5. | id | amount | id   | weight | exist |  
  6. +----+--------+------+--------+-------+  
  7. |  1 |    100 | NULL |   NULL |  NULL |  
  8. |  2 |    200 |    2 |     22 |     0 |  
  9. |  3 |    300 | NULL |   NULL |  NULL |  
  10. |  4 |    400 | NULL |   NULL |  NULL |  
  11. +----+--------+------+--------+-------+  
  12. 4 rows in set (0.00 sec)  
  13.    
  14. mysql> SELECT * FROM product LEFT JOIN product_details  
  15.        ON (product.id = product_details.id)  
  16.        WHERE product_details.id=2;  
  17. +----+--------+----+--------+-------+  
  18. | id | amount | id | weight | exist |  
  19. +----+--------+----+--------+-------+  
  20. |  2 |    200 |  2 |     22 |     0 |  
  21. +----+--------+----+--------+-------+  
  22. 1 row in set (0.01 sec)  

    从上可知，第一条查询使用 ON 条件决定了从 LEFT JOIN的 product_details表中检索符合的所有数据行。第二条查询做了简单的LEFT JOIN，然后使用 WHERE 子句从 LEFT JOIN的数据中过滤掉不符合条件的数据行。
(3).尽量避免子查询，而用join
    往往性能这玩意儿，更多时候体现在数据量比较大的时候，此时，我们应该避免复杂的子查询。如下：

 

 

 
  1. insert into t1(a1) select b1 from t2   
  2. where not exists(select 1 from t1 where t1.id = t2.r_id);  

下面这个更好

 
    1. insert into t1(a1)    
    2. select b1 from t2    
    3. left join (select distinct t1.id from t1 ) t1 on t1.id = t2.r_id     
    4. where t1.id is null;    

2018.03.27 python pandas merge join 使用

2018.03.27 python pandas merge join 使用

#2.16 合并 merge-join
import numpy as np
import pandas as pd
df1 = pd.DataFrame({''key1'':[''k0'',''k1'',''k2'',''k3''],
                    ''A'':[''A0'',''A1'',''A2'',''A3''],
                    ''B'':[''B0'',''B1'',''B2'',''B3'']})
df2 = pd.DataFrame({''key1'':[''k0'',''k1'',''k2'',''k3''],
                    ''C'':[''C0'',''C1'',''C2'',''C3''],
                    ''D'':[''D0'',''D1'',''D2'',''D3'']})
df3 = pd.DataFrame({''key1'':[''k0'',''k1'',''k2'',''k3''],
                    ''key2'':[''k0'',''k1'',''k0'',''k1''],
                    ''A'':[''A0'',''A1'',''A2'',''A3''],
                    ''B'':[''B0'',''B1'',''B2'',''B3'']})
df4 = pd.DataFrame({''key1'':[''k0'',''k1'',''k2'',''k3''],
                    ''key2'':[''k0'',''k1'',''k0'',''k3''],
                    ''C'':[''C0'',''C1'',''C2'',''C3''],
                    ''D'':[''D0'',''D1'',''D2'',''D3'']})
print(df1)
print(df2)
print(pd.merge(df1,df2,on=''key1''))
print(''------'')
#on 参考键

print(df3)
print(df4)
print(pd.merge(df3,df4,on=[''key1'',''key2'']))#2个键值同时去匹配

结果：

A   B key1
0  A0  B0   k0
1  A1  B1   k1
2  A2  B2   k2
3  A3  B3   k3
    C   D key1
0  C0  D0   k0
1  C1  D1   k1
2  C2  D2   k2
3  C3  D3   k3
    A   B key1   C   D
0  A0  B0   k0  C0  D0
1  A1  B1   k1  C1  D1
2  A2  B2   k2  C2  D2
3  A3  B3   k3  C3  D3
------
    A   B key1 key2
0  A0  B0   k0   k0
1  A1  B1   k1   k1
2  A2  B2   k2   k0
3  A3  B3   k3   k1
    C   D key1 key2
0  C0  D0   k0   k0
1  C1  D1   k1   k1
2  C2  D2   k2   k0
3  C3  D3   k3   k3
    A   B key1 key2   C   D
0  A0  B0   k0   k0  C0  D0
1  A1  B1   k1   k1  C1  D1
2  A2  B2   k2   k0  C2  D2
#参数how 合并方式
print(pd.merge(df3,df4,on=[''key1'',''key2''],how=''inner''))#取交集
print(pd.merge(df3,df4,on=[''key1'',''key2''],how=''outer''))#并集  数据缺失用Nan
print(pd.merge(df3,df4,on=[''key1'',''key2''],how=''left''))#按照df3为参考，数据缺失用Nan
print(pd.merge(df3,df4,on=[''key1'',''key2''],how=''right''))#按照df4为参考，数据缺失用Nan

 结果：

A   B key1 key2   C   D
0  A0  B0   k0   k0  C0  D0
1  A1  B1   k1   k1  C1  D1
2  A2  B2   k2   k0  C2  D2
     A    B key1 key2    C    D
0   A0   B0   k0   k0   C0   D0
1   A1   B1   k1   k1   C1   D1
2   A2   B2   k2   k0   C2   D2
3   A3   B3   k3   k1  NaN  NaN
4  NaN  NaN   k3   k3   C3   D3
    A   B key1 key2    C    D
0  A0  B0   k0   k0   C0   D0
1  A1  B1   k1   k1   C1   D1
2  A2  B2   k2   k0   C2   D2
3  A3  B3   k3   k1  NaN  NaN
     A    B key1 key2   C   D
0   A0   B0   k0   k0  C0  D0
1   A1   B1   k1   k1  C1  D1
2   A2   B2   k2   k0  C2  D2
3  NaN  NaN   k3   k3  C3  D3
#参数left_on right_on left_index right_index -》当键不在一个列时，可以单独设置左键或右键
df1 = pd.DataFrame({''key'':list(''abdcjeu''),
                    ''data1'':range(7)})
df2 = pd.DataFrame({''rkey'':list(''abc''),
                    ''data2'':range(3)})
print(df1,''\n'',df2)
print(pd.merge(df1,df2,left_on = ''key'',right_on = ''rkey''))#当2个dataframe中的主键名称不一致时，用left_on 和right_on 去指定键值

结果:

data1 key
0      0   a
1      1   b
2      2   d
3      3   c
4      4   j
5      5   e
6      6   u 
    data2 rkey
0      0    a
1      1    b
2      2    c
   data1 key  data2 rkey
0      0   a      0    a
1      1   b      1    b
2      3   c      2    c
df1 = pd.DataFrame({''key'':list(''abdcjeu''),
                    ''data1'':range(7)})
df2 = pd.DataFrame({''data2'':range(100,105)},index = list(''abcde''))
print(df1)
print(df2)
print(pd.merge(df1,df2,left_on=''key'',right_index=True,sort=True))#以index为键 作为左表 key对应的键值对  sort是否按照key排序
data1 key
0      0   a
1      1   b
2      2   d
3      3   c
4      4   j
5      5   e
6      6   u
   data2
a    100
b    101
c    102
d    103
e    104
   data1 key  data2
0      0   a    100
1      1   b    101
3      3   c    102
2      2   d    103
5      5   e    104
#pd.join 直接通过索引链接
left = pd.DataFrame({''A'':[''A0'',''A1'',''A2'',''A3''],
                    ''B'':[''B0'',''B1'',''B2'',''B3'']},
                   index = [''k0'',''k1'',''k2'',''k4''])
right = pd.DataFrame({''C'':[''C0'',''C1'',''C2'',''C3''],
                    ''D'':[''D0'',''D1'',''D2'',''D3'']},
                   index = [''k0'',''k1'',''k2'',''k3''])
print(left)
print(right)
print(left.join(right))
print(left.join(right,how=''outer''))#拓展

结果:

A   B
k0  A0  B0
k1  A1  B1
k2  A2  B2
k4  A3  B3
     C   D
k0  C0  D0
k1  C1  D1
k2  C2  D2
k3  C3  D3
     A   B    C    D
k0  A0  B0   C0   D0
k1  A1  B1   C1   D1
k2  A2  B2   C2   D2
k4  A3  B3  NaN  NaN
      A    B    C    D
k0   A0   B0   C0   D0
k1   A1   B1   C1   D1
k2   A2   B2   C2   D2
k3  NaN  NaN   C3   D3
k4   A3   B3  NaN  NaN
df1 = pd.DataFrame({''key'':list(''bbacaab''),
                    ''data1'':range(7)})
df2 = pd.DataFrame({''key'':list(''abc''),
                    ''data2'':range(3)})
print(pd.merge(df1,df2,left_index=True,right_index=True,suffixes=(''_1'',''_2'')))
print(df1.join(df2[''data2'']))
print(''------'')#当df1 df2的key相同时，使用suffixes 两个相同的key 成为 key_1 key_2

结果：

data1 key_1  data2 key_2
0      0     b      0     a
1      1     b      1     b
2      2     a      2     c
   data1 key  data2
0      0   b    0.0
1      1   b    1.0
2      2   a    2.0
3      3   c    NaN
4      4   a    NaN
5      5   a    NaN
6      6   b    NaN
left = pd.DataFrame({''A'':[''A0'',''A1'',''A2'',''A3''],
                    ''B'':[''B0'',''B1'',''B2'',''B3''],
                    ''key'':[''k0'',''k1'',''k0'',''k3'']})
right = pd.DataFrame({''C'':[''C0'',''C1''],
                    ''D'':[''D0'',''D1'']},
                   index = [''k0'',''k1''])
print(left)
print(right)
print(left.join(right,on=''key''))#用left的key和 right的index 合并

结果：

A   B key
0  A0  B0  k0
1  A1  B1  k1
2  A2  B2  k0
3  A3  B3  k3
     C   D
k0  C0  D0
k1  C1  D1
    A   B key    C    D
0  A0  B0  k0   C0   D0
1  A1  B1  k1   C1   D1
2  A2  B2  k0   C0   D0
3  A3  B3  k3  NaN  NaN

dask - 合并/完整笛卡尔积 - 内存问题

dask - 合并/完整笛卡尔积 - 内存问题

如何解决dask - 合并/完整笛卡尔积 - 内存问题？

我有一个 dask 数据框，需要将一列中的所有值与同一列中的所有值进行比较。最终我将在这些值对上使用一个函数，但现在我只是想让 .merge 工作。示例代码：

my_dd[''dummy''] = 1
my_dd = my_dd.merge(my_dd,how=''inner'',on=''dummy'',npartitions=100000)
print(str(len(my_dd)))

此时我的起始数据集非常小 - 连接前的 my_dd 大约有 19K 行。因此，在加入之后，将有大约 3.6 亿行。

上面的代码给了我一个内存错误。在具有 32GB 内存的单机/LocalCluster 上运行。通过指定 nparitions，代码看起来可以工作，但最终会在中途失败（当大多数图形任务大部分完成时）。

我意识到这里的问题是产生的大量 df，但我想有一些解决方案。挖了很多坑也没找到。

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）

Java 8中的流作为流的笛卡尔积（仅使用流）

Java 8中的流作为流的笛卡尔积（仅使用流）

我想创建一个方法，该方法创建元素流，这些元素流是多个给定流的笛卡尔积（由二元运算符最后汇总为相同类型）。请注意，参数和结果都是流， 而不是 集合。

例如，对于 {A，B} 和 {X，Y}的 两个流，我希望它产生值 {AX，AY，BX，BY}的流
（简单串联用于聚集字符串）。到目前为止，我想出了以下代码：

private static <T> Stream<T> cartesian(BinaryOperator<T> aggregator,Stream<T>... streams) {
    Stream<T> result = null;

    for (Stream<T> stream : streams) {
        if (result == null) {
            result = stream;
        } else {
            result = result.flatMap(m -> stream.map(n -> aggregator.apply(m,n)));
        }
    }

    return result;
}

这是我想要的用例：

Stream<String> result = cartesian(
  (a,b) -> a + b,Stream.of("A","B"),Stream.of("X","Y")
);

System.out.println(result.collect(Collectors.toList()));

预期结果：AX,AY,BX,BY。

另一个例子：

Stream<String> result = cartesian(
  (a,Stream.of("K","L"),"Y")
);

预期结果：AKX,AKY,ALX,ALY,BKX,BKY,BLX,BLY。

但是，如果我运行代码，则会出现此错误：

IllegalStateException：流已被操作或关闭

流在哪里消耗？通过 flatMap ？可以轻松解决吗？

我们今天的关于Python-pandas高性能笛卡尔积和CROSS JOIN的分享就到这里，谢谢您的阅读，如果想了解更多关于(转载) Mysql----Join用法(Inner join,Left join,Right join, Cross join, Union模拟Full join)及---性能优化、2018.03.27 python pandas merge join 使用、dask - 合并/完整笛卡尔积 - 内存问题、Java 8中的流作为流的笛卡尔积（仅使用流）的相关信息，可以在本站进行搜索。

本文标签：

上一篇使用Rabin-Karp搜索字符串中的多个模式（bing的搜索字符串）

下一篇Enumerable.Single的错误实现？（enumerable.range）

相关文章