0
点赞
收藏
分享

微信扫一扫

Pandas的join和merge到底哪个快

悲催博士僧 2023-01-28 阅读 91
pandaspython数据分析缓存数据Spark大数据


大家好，我是小小明。上次我们的云朵君同学在不严谨的测试下，得出了join可以比merge快5倍的结论。虽然默认参数用法下，join确实比merge快一些，但实际上join并不见得会比merge快。链接：《​​再见！不再使用 Pandas 中的 Merge 方法​​》

下面我们继续深入测试，首先构造如下生成测试数据的方法：

import pandas as pd
import numpy as np
from time import time

def create_df(col_prefix, nrows=1000_0000):
    data = np.random.randint(0, 255, size=(nrows, 4))
    df = pd.DataFrame(data, columns=map(f"{col_prefix}_{{}}".format, range(4)), dtype="uint8")
    df["idx"] = df.index.values
    return df

生成的测试数据格式如下：

print(create_df("c"))

c_0  c_1  c_2  c_3      idx
0        111   32   70   73        0
1         12   78   38  205        1
2          9   52  203  171        2
3        200   22   99   19        3
4        124  205  233   65        4
...      ...  ...  ...  ...      ...
9999995   41  136  246  162  9999995
9999996  209   16   73   51  9999996
9999997  132   41   46  234  9999997
9999998  163  101  120  184  9999998
9999999  116  189  205   40  9999999

[10000000 rows x 5 columns]

默认生成1千万条数据，连接字段idx确保唯一。

初步测试

我们按照原文的逻辑简单测试一下：

df1 = create_df("x")
df2 = create_df("y")

start = time()
df1.merge(df2, on="idx")
print(f"merge耗时：{time() - start:.2f}s")

start = time()
df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
df1.join(df2, how="inner")
print(f"join耗时：{time() - start:.2f}s")

merge 耗时：4.68s
join 耗时：1.13s

确实默认参数情况下join比merge快4倍。

join函数的本质

但是为什么join会比merge快呢？pandas开发者总不能开发两套完全不相同的处理逻辑把？所以我们点开源码一探究竟。

下面我的pandas环境是基于1.5.1版本进行测试。

这里我使用pycharm通过Ctrl+点击对应函数查看源码，首先看看join的核心源码：

def join(
        self,
        other: DataFrame | Series | list[DataFrame | Series],
        on: IndexLabel | None = None,
        how: str = "left",
        lsuffix: str = "",
        rsuffix: str = "",
        sort: bool = False,
        validate: str | None = None,
) -> DataFrame:
    return self._join_compat(
        other,
        on=on,
        how=how,
        lsuffix=lsuffix,
        rsuffix=rsuffix,
        sort=sort,
        validate=validate,
    )


def _join_compat(
        self,
        other: DataFrame | Series,
        on: IndexLabel | None = None,
        how: str = "left",
        lsuffix: str = "",
        rsuffix: str = "",
        sort: bool = False,
        validate: str | None = None,
):
    from pandas.core.reshape.merge import merge
    return merge(
        self,
        other,
        left_on=on,
        how=how,
        left_index=on is None,
        right_index=True,
        suffixes=(lsuffix, rsuffix),
        sort=sort,
        validate=validate,
    )

咦，join不就是最终依然调用merge方法吗？

再看看merge的源码：

def merge(
        self,
        right: DataFrame | Series,
        how: str = "inner",
        on: IndexLabel | None = None,
        left_on: IndexLabel | None = None,
        right_on: IndexLabel | None = None,
        left_index: bool = False,
        right_index: bool = False,
        sort: bool = False,
        suffixes: Suffixes = ("_x", "_y"),
        copy: bool = True,
        indicator: bool = False,
        validate: str | None = None,
) -> DataFrame:
    from pandas.core.reshape.merge import merge
    return merge(
        self,
        right,
        how=how,
        on=on,
        left_on=left_on,
        right_on=right_on,
        left_index=left_index,
        right_index=right_index,
        sort=sort,
        suffixes=suffixes,
        copy=copy,
        indicator=indicator,
        validate=validate,
    )

merge也是调用了​​pandas.core.reshape.merge​​中的merge方法。

**结论：**join本质上是merge传入了left_index和right_index为True。

再次测试

基于上述结论，我们再次测试一下：

df1 = create_df("x")
df2 = create_df("y")

df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
start = time()
df1.merge(df2, on="idx")
print(f"merge on耗时：{time() - start:.2f}s")

start = time()
df1.merge(df2, left_index=True, right_index=True)
print(f"merge index耗时：{time() - start:.2f}s")

start = time()
df1.join(df2, how="inner")
print(f"join耗时：{time() - start:.2f}s")

merge on耗时：4.30s
merge index耗时：1.15s
join耗时：0.11s

merge index依然比merge on快了4倍，可是join为啥又比merge index快10倍？按照前面的分析，join多调用了2层，应该比merge index更慢才对呀？难道是因为缓存？

现在我们调换一下merge index和join的执行顺序再试试：

df1 = create_df("x")
df2 = create_df("y")
df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)

start = time()
df1.join(df2, how="inner")
print(f"join耗时：{time() - start:.2f}s")

start = time()
df1.merge(df2, left_index=True, right_index=True)
print(f"merge index耗时：{time() - start:.2f}s")

join耗时：1.12s
merge index耗时：0.13s

结果这次变成merge index比join快10倍了。那么我们干脆让数据都重新生成后再测试：

df1 = create_df("x")
df2 = create_df("y")
df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
start = time()
df1.join(df2, how="inner")
print(f"join耗时：{time() - start:.2f}s")

df1 = create_df("x")
df2 = create_df("y")
df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
start = time()
df1.merge(df2, left_index=True, right_index=True)
print(f"merge index耗时：{time() - start:.2f}s")

join耗时：1.21s
merge index耗时：1.10s

这次相差不大，merge index比join略快一点，符合对源码的认知。但是明显第二次join或merge时，会比第一次快10倍，初步推测肯定是存在某种缓存。

缓存存在的位置

在join函数打上断点后，一步步内层跟，发现如下缓存位置：

Pandas的join和merge到底哪个快_pandas

而self是​​Int64Index​​对象，说明索引对象缓存是否具备唯一性的属性。索引是否具备唯一性决定了索引连接的形式：

Pandas的join和merge到底哪个快_pandas_02

我们可以再对比前先判断索引唯一性再测试：

df1 = create_df("x")
df2 = create_df("y")
df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
start = time()
print(df1.index.is_unique, df2.index.is_unique)
print(f"索引判断唯一性耗时：{time() - start:.2f}s")

time1s = []
time2s = []
repeat = 10
for _ in range(repeat):
    start = time()
    df1.join(df2)
    time2s.append(time() - start)

    start = time()
    df1.merge(df2, left_index=True, right_index=True)
    time1s.append(time() - start)

print(f"merge index耗时：{sum(time1s) / repeat :.2f}s")
print(f"join耗时：{sum(time2s) / repeat :.2f}s")

True True
索引判断唯一性耗时：0.99s
merge index耗时：0.12s
join耗时：0.12s

可以看到索引判断唯一性耗时占了大头，取消这部分耗时后，两者耗时相差无几。

索引不唯一时速度对比

以上对比都是基于索引唯一的情景下，这次我们重新设计数据，假设索引存在五分之一的重复：

import pandas as pd
import numpy as np
from time import time


def create_df(col_prefix, nrows=100_0000):
    data = np.random.randint(0, 255, size=(nrows, 4))
    df = pd.DataFrame(data, columns=map(f"{col_prefix}_{{}}".format, range(4)))
    df["idx"] = np.random.choice(np.arange(nrows * 4 // 5), nrows)
    return df

再次测试：

start = time()
df1.merge(df2, on="idx")
print(f"merge on耗时：{time() - start:.2f}s")

df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
start = time()
print(df1.index.is_unique, df2.index.is_unique)
print(f"索引判断唯一性耗时：{time() - start:.2f}s")

start = time()
df1.merge(df2, left_index=True, right_index=True)
print(f"merge index耗时：{time() - start:.2f}s")

start = time()
df1.join(df2, how="inner")
print(f"join耗时：{time() - start:.2f}s")

df1.reset_index(inplace=True)
df2.reset_index(inplace=True)
start = time()
df1.merge(df2, on="idx")
print(f"merge on耗时：{time() - start:.2f}s")

merge on耗时：0.53s
False False
索引判断唯一性耗时：0.06s
merge index耗时：0.91s
join耗时：0.93s
merge on耗时：0.50s

可以看到，在索引存在重复时，直接merge on反而更快。

但是不对劲啊，云朵君的测试明显是基于索引重复的情况下，得到join比merge on快的结论。其实这是因为云朵君的测试数据中，数据的重复度过大导致的，并不符合实际的数据情况。

云朵君给出的测试数据中，索引几乎达到100倍的重复，就是一个id能够重复出现100次左右。假如我们的测试也调整到10倍的索引重复度差距，结论就会不一样：

import pandas as pd
import numpy as np
from time import time


def create_df(col_prefix, nrows=100_0000):
    data = np.random.randint(0, 255, size=(nrows, 4))
    df = pd.DataFrame(data, columns=map(f"{col_prefix}_{{}}".format, range(4)))
    df["idx"] = np.random.choice(np.arange(nrows // 10), nrows)
    return df


df1 = create_df("x")
df2 = create_df("y")

start = time()
df1.merge(df2, how="left", on="idx")
print(f"merge on耗时：{time() - start:.2f}s")

df1.set_index("idx", inplace=True)
df2.set_index("idx", inplace=True)
start = time()
df1.join(df2)
print(f"join耗时：{time() - start:.2f}s")

df1.reset_index(inplace=True)
df2.reset_index(inplace=True)
start = time()
df1.merge(df2, how="left", on="idx")
print(f"merge on耗时：{time() - start:.2f}s")

merge on耗时：1.58s
join耗时：1.42s
merge on耗时：1.64s

很明显的看到这时join就比merge on快了。

如果提升到50倍：

merge on耗时：6.02s
join耗时：4.16s
merge on耗时：6.95s

结论

  1. join等价于merge传入left_index和right_index参数为True
  2. 索引唯一时，join比merge默认的on指定字段速度快
  3. 索引不唯一时，少量重复的索引时，merge默认的on指定字段比join快；每个索引能够重复10次以上时，join比merge默认的on指定字段快


举报

相关推荐

Pandas中DataFrame数据合并、连接（concat、merge、join）

笔记Python数据分析

pandas中DF拼接：concat，merge，join，append方法区别

python数据挖掘

Pandas的Merge实现

Pandas应用Python数据分析

Pandas 合并 merge

d3资料集数据Spark大数据

mysql in和范围查询哪个快

sqlMySQL性能比较数据库

openGauss向量化Merge Join--inner join

python算法java人工智能机器学习虚拟化云计算

openGauss向量化Merge Join--semi join

java算法mysqlpythonleetcode虚拟化云计算

pandas dataframe join

编程语言

Python - Pandas Dataframe的合并Merge

python

PostgreSQL 和 MySQL 到底哪个更好用？

mysqlpostgresql数据MySQL数据库yyds干货盘点
0 条评论