2654 lines
90 KiB
Python
2654 lines
90 KiB
Python
from datetime import (
|
|
date,
|
|
datetime,
|
|
timedelta,
|
|
)
|
|
import random
|
|
import re
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
from pandas.core.dtypes.common import (
|
|
is_categorical_dtype,
|
|
is_object_dtype,
|
|
)
|
|
from pandas.core.dtypes.dtypes import CategoricalDtype
|
|
|
|
import pandas as pd
|
|
from pandas import (
|
|
Categorical,
|
|
CategoricalIndex,
|
|
DataFrame,
|
|
DatetimeIndex,
|
|
IntervalIndex,
|
|
MultiIndex,
|
|
PeriodIndex,
|
|
RangeIndex,
|
|
Series,
|
|
TimedeltaIndex,
|
|
)
|
|
import pandas._testing as tm
|
|
from pandas.api.types import CategoricalDtype as CDT
|
|
from pandas.core.api import (
|
|
Float64Index,
|
|
Int64Index,
|
|
UInt64Index,
|
|
)
|
|
from pandas.core.reshape.concat import concat
|
|
from pandas.core.reshape.merge import (
|
|
MergeError,
|
|
merge,
|
|
)
|
|
|
|
N = 50
|
|
NGROUPS = 8
|
|
|
|
|
|
def get_test_data(ngroups=NGROUPS, n=N):
|
|
unique_groups = list(range(ngroups))
|
|
arr = np.asarray(np.tile(unique_groups, n // ngroups))
|
|
|
|
if len(arr) < n:
|
|
arr = np.asarray(list(arr) + unique_groups[: n - len(arr)])
|
|
|
|
random.shuffle(arr)
|
|
return arr
|
|
|
|
|
|
def get_series():
|
|
return [
|
|
Series([1], dtype="int64"),
|
|
Series([1], dtype="Int64"),
|
|
Series([1.23]),
|
|
Series(["foo"]),
|
|
Series([True]),
|
|
Series([pd.Timestamp("2018-01-01")]),
|
|
Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
|
|
]
|
|
|
|
|
|
def get_series_na():
|
|
return [
|
|
Series([np.nan], dtype="Int64"),
|
|
Series([np.nan], dtype="float"),
|
|
Series([np.nan], dtype="object"),
|
|
Series([pd.NaT]),
|
|
]
|
|
|
|
|
|
@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
|
|
def series_of_dtype(request):
|
|
"""
|
|
A parametrized fixture returning a variety of Series of different
|
|
dtypes
|
|
"""
|
|
return request.param
|
|
|
|
|
|
@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
|
|
def series_of_dtype2(request):
|
|
"""
|
|
A duplicate of the series_of_dtype fixture, so that it can be used
|
|
twice by a single function
|
|
"""
|
|
return request.param
|
|
|
|
|
|
@pytest.fixture(params=get_series_na(), ids=lambda x: x.dtype.name)
|
|
def series_of_dtype_all_na(request):
|
|
"""
|
|
A parametrized fixture returning a variety of Series with all NA
|
|
values
|
|
"""
|
|
return request.param
|
|
|
|
|
|
@pytest.fixture
|
|
def dfs_for_indicator():
|
|
df1 = DataFrame({"col1": [0, 1], "col_conflict": [1, 2], "col_left": ["a", "b"]})
|
|
df2 = DataFrame(
|
|
{
|
|
"col1": [1, 2, 3, 4, 5],
|
|
"col_conflict": [1, 2, 3, 4, 5],
|
|
"col_right": [2, 2, 2, 2, 2],
|
|
}
|
|
)
|
|
return df1, df2
|
|
|
|
|
|
class TestMerge:
|
|
def setup_method(self, method):
|
|
# aggregate multiple columns
|
|
self.df = DataFrame(
|
|
{
|
|
"key1": get_test_data(),
|
|
"key2": get_test_data(),
|
|
"data1": np.random.randn(N),
|
|
"data2": np.random.randn(N),
|
|
}
|
|
)
|
|
|
|
# exclude a couple keys for fun
|
|
self.df = self.df[self.df["key2"] > 1]
|
|
|
|
self.df2 = DataFrame(
|
|
{
|
|
"key1": get_test_data(n=N // 5),
|
|
"key2": get_test_data(ngroups=NGROUPS // 2, n=N // 5),
|
|
"value": np.random.randn(N // 5),
|
|
}
|
|
)
|
|
|
|
self.left = DataFrame(
|
|
{"key": ["a", "b", "c", "d", "e", "e", "a"], "v1": np.random.randn(7)}
|
|
)
|
|
self.right = DataFrame({"v2": np.random.randn(4)}, index=["d", "b", "c", "a"])
|
|
|
|
def test_merge_inner_join_empty(self):
|
|
# GH 15328
|
|
df_empty = DataFrame()
|
|
df_a = DataFrame({"a": [1, 2]}, index=[0, 1], dtype="int64")
|
|
result = merge(df_empty, df_a, left_index=True, right_index=True)
|
|
expected = DataFrame({"a": []}, index=[], dtype="int64")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_common(self):
|
|
joined = merge(self.df, self.df2)
|
|
exp = merge(self.df, self.df2, on=["key1", "key2"])
|
|
tm.assert_frame_equal(joined, exp)
|
|
|
|
def test_merge_non_string_columns(self):
|
|
# https://github.com/pandas-dev/pandas/issues/17962
|
|
# Checks that method runs for non string column names
|
|
left = DataFrame(
|
|
{0: [1, 0, 1, 0], 1: [0, 1, 0, 0], 2: [0, 0, 2, 0], 3: [1, 0, 0, 3]}
|
|
)
|
|
|
|
right = left.astype(float)
|
|
expected = left
|
|
result = merge(left, right)
|
|
tm.assert_frame_equal(expected, result)
|
|
|
|
def test_merge_index_as_on_arg(self):
|
|
# GH14355
|
|
|
|
left = self.df.set_index("key1")
|
|
right = self.df2.set_index("key1")
|
|
result = merge(left, right, on="key1")
|
|
expected = merge(self.df, self.df2, on="key1").set_index("key1")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_index_singlekey_right_vs_left(self):
|
|
left = DataFrame(
|
|
{"key": ["a", "b", "c", "d", "e", "e", "a"], "v1": np.random.randn(7)}
|
|
)
|
|
right = DataFrame({"v2": np.random.randn(4)}, index=["d", "b", "c", "a"])
|
|
|
|
merged1 = merge(
|
|
left, right, left_on="key", right_index=True, how="left", sort=False
|
|
)
|
|
merged2 = merge(
|
|
right, left, right_on="key", left_index=True, how="right", sort=False
|
|
)
|
|
tm.assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
|
|
|
|
merged1 = merge(
|
|
left, right, left_on="key", right_index=True, how="left", sort=True
|
|
)
|
|
merged2 = merge(
|
|
right, left, right_on="key", left_index=True, how="right", sort=True
|
|
)
|
|
tm.assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
|
|
|
|
def test_merge_index_singlekey_inner(self):
|
|
left = DataFrame(
|
|
{"key": ["a", "b", "c", "d", "e", "e", "a"], "v1": np.random.randn(7)}
|
|
)
|
|
right = DataFrame({"v2": np.random.randn(4)}, index=["d", "b", "c", "a"])
|
|
|
|
# inner join
|
|
result = merge(left, right, left_on="key", right_index=True, how="inner")
|
|
expected = left.join(right, on="key").loc[result.index]
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
result = merge(right, left, right_on="key", left_index=True, how="inner")
|
|
expected = left.join(right, on="key").loc[result.index]
|
|
tm.assert_frame_equal(result, expected.loc[:, result.columns])
|
|
|
|
def test_merge_misspecified(self):
|
|
msg = "Must pass right_on or right_index=True"
|
|
with pytest.raises(pd.errors.MergeError, match=msg):
|
|
merge(self.left, self.right, left_index=True)
|
|
msg = "Must pass left_on or left_index=True"
|
|
with pytest.raises(pd.errors.MergeError, match=msg):
|
|
merge(self.left, self.right, right_index=True)
|
|
|
|
msg = (
|
|
'Can only pass argument "on" OR "left_on" and "right_on", not '
|
|
"a combination of both"
|
|
)
|
|
with pytest.raises(pd.errors.MergeError, match=msg):
|
|
merge(self.left, self.left, left_on="key", on="key")
|
|
|
|
msg = r"len\(right_on\) must equal len\(left_on\)"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(self.df, self.df2, left_on=["key1"], right_on=["key1", "key2"])
|
|
|
|
def test_index_and_on_parameters_confusion(self):
|
|
msg = "right_index parameter must be of type bool, not <class 'list'>"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(
|
|
self.df,
|
|
self.df2,
|
|
how="left",
|
|
left_index=False,
|
|
right_index=["key1", "key2"],
|
|
)
|
|
msg = "left_index parameter must be of type bool, not <class 'list'>"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(
|
|
self.df,
|
|
self.df2,
|
|
how="left",
|
|
left_index=["key1", "key2"],
|
|
right_index=False,
|
|
)
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(
|
|
self.df,
|
|
self.df2,
|
|
how="left",
|
|
left_index=["key1", "key2"],
|
|
right_index=["key1", "key2"],
|
|
)
|
|
|
|
def test_merge_overlap(self):
|
|
merged = merge(self.left, self.left, on="key")
|
|
exp_len = (self.left["key"].value_counts() ** 2).sum()
|
|
assert len(merged) == exp_len
|
|
assert "v1_x" in merged
|
|
assert "v1_y" in merged
|
|
|
|
def test_merge_different_column_key_names(self):
|
|
left = DataFrame({"lkey": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 4]})
|
|
right = DataFrame({"rkey": ["foo", "bar", "qux", "foo"], "value": [5, 6, 7, 8]})
|
|
|
|
merged = left.merge(
|
|
right, left_on="lkey", right_on="rkey", how="outer", sort=True
|
|
)
|
|
|
|
exp = Series(["bar", "baz", "foo", "foo", "foo", "foo", np.nan], name="lkey")
|
|
tm.assert_series_equal(merged["lkey"], exp)
|
|
|
|
exp = Series(["bar", np.nan, "foo", "foo", "foo", "foo", "qux"], name="rkey")
|
|
tm.assert_series_equal(merged["rkey"], exp)
|
|
|
|
exp = Series([2, 3, 1, 1, 4, 4, np.nan], name="value_x")
|
|
tm.assert_series_equal(merged["value_x"], exp)
|
|
|
|
exp = Series([6, np.nan, 5, 8, 5, 8, 7], name="value_y")
|
|
tm.assert_series_equal(merged["value_y"], exp)
|
|
|
|
def test_merge_copy(self):
|
|
left = DataFrame({"a": 0, "b": 1}, index=range(10))
|
|
right = DataFrame({"c": "foo", "d": "bar"}, index=range(10))
|
|
|
|
merged = merge(left, right, left_index=True, right_index=True, copy=True)
|
|
|
|
merged["a"] = 6
|
|
assert (left["a"] == 0).all()
|
|
|
|
merged["d"] = "peekaboo"
|
|
assert (right["d"] == "bar").all()
|
|
|
|
def test_merge_nocopy(self, using_array_manager):
|
|
left = DataFrame({"a": 0, "b": 1}, index=range(10))
|
|
right = DataFrame({"c": "foo", "d": "bar"}, index=range(10))
|
|
|
|
merged = merge(left, right, left_index=True, right_index=True, copy=False)
|
|
|
|
assert np.shares_memory(merged["a"]._values, left["a"]._values)
|
|
assert np.shares_memory(merged["d"]._values, right["d"]._values)
|
|
|
|
def test_intelligently_handle_join_key(self):
|
|
# #733, be a bit more 1337 about not returning unconsolidated DataFrame
|
|
|
|
left = DataFrame(
|
|
{"key": [1, 1, 2, 2, 3], "value": list(range(5))}, columns=["value", "key"]
|
|
)
|
|
right = DataFrame({"key": [1, 1, 2, 3, 4, 5], "rvalue": list(range(6))})
|
|
|
|
joined = merge(left, right, on="key", how="outer")
|
|
expected = DataFrame(
|
|
{
|
|
"key": [1, 1, 1, 1, 2, 2, 3, 4, 5],
|
|
"value": np.array([0, 0, 1, 1, 2, 3, 4, np.nan, np.nan]),
|
|
"rvalue": [0, 1, 0, 1, 2, 2, 3, 4, 5],
|
|
},
|
|
columns=["value", "key", "rvalue"],
|
|
)
|
|
tm.assert_frame_equal(joined, expected)
|
|
|
|
def test_merge_join_key_dtype_cast(self):
|
|
# #8596
|
|
|
|
df1 = DataFrame({"key": [1], "v1": [10]})
|
|
df2 = DataFrame({"key": [2], "v1": [20]})
|
|
df = merge(df1, df2, how="outer")
|
|
assert df["key"].dtype == "int64"
|
|
|
|
df1 = DataFrame({"key": [True], "v1": [1]})
|
|
df2 = DataFrame({"key": [False], "v1": [0]})
|
|
df = merge(df1, df2, how="outer")
|
|
|
|
# GH13169
|
|
# GH#40073
|
|
assert df["key"].dtype == "bool"
|
|
|
|
df1 = DataFrame({"val": [1]})
|
|
df2 = DataFrame({"val": [2]})
|
|
lkey = np.array([1])
|
|
rkey = np.array([2])
|
|
df = merge(df1, df2, left_on=lkey, right_on=rkey, how="outer")
|
|
assert df["key_0"].dtype == "int64"
|
|
|
|
def test_handle_join_key_pass_array(self):
|
|
left = DataFrame(
|
|
{"key": [1, 1, 2, 2, 3], "value": np.arange(5)},
|
|
columns=["value", "key"],
|
|
dtype="int64",
|
|
)
|
|
right = DataFrame({"rvalue": np.arange(6)}, dtype="int64")
|
|
key = np.array([1, 1, 2, 3, 4, 5], dtype="int64")
|
|
|
|
merged = merge(left, right, left_on="key", right_on=key, how="outer")
|
|
merged2 = merge(right, left, left_on=key, right_on="key", how="outer")
|
|
|
|
tm.assert_series_equal(merged["key"], merged2["key"])
|
|
assert merged["key"].notna().all()
|
|
assert merged2["key"].notna().all()
|
|
|
|
left = DataFrame({"value": np.arange(5)}, columns=["value"])
|
|
right = DataFrame({"rvalue": np.arange(6)})
|
|
lkey = np.array([1, 1, 2, 2, 3])
|
|
rkey = np.array([1, 1, 2, 3, 4, 5])
|
|
|
|
merged = merge(left, right, left_on=lkey, right_on=rkey, how="outer")
|
|
tm.assert_series_equal(
|
|
merged["key_0"], Series([1, 1, 1, 1, 2, 2, 3, 4, 5], name="key_0")
|
|
)
|
|
|
|
left = DataFrame({"value": np.arange(3)})
|
|
right = DataFrame({"rvalue": np.arange(6)})
|
|
|
|
key = np.array([0, 1, 1, 2, 2, 3], dtype=np.int64)
|
|
merged = merge(left, right, left_index=True, right_on=key, how="outer")
|
|
tm.assert_series_equal(merged["key_0"], Series(key, name="key_0"))
|
|
|
|
def test_no_overlap_more_informative_error(self):
|
|
dt = datetime.now()
|
|
df1 = DataFrame({"x": ["a"]}, index=[dt])
|
|
|
|
df2 = DataFrame({"y": ["b", "c"]}, index=[dt, dt])
|
|
|
|
msg = (
|
|
"No common columns to perform merge on. "
|
|
f"Merge options: left_on={None}, right_on={None}, "
|
|
f"left_index={False}, right_index={False}"
|
|
)
|
|
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(df1, df2)
|
|
|
|
def test_merge_non_unique_indexes(self):
|
|
|
|
dt = datetime(2012, 5, 1)
|
|
dt2 = datetime(2012, 5, 2)
|
|
dt3 = datetime(2012, 5, 3)
|
|
dt4 = datetime(2012, 5, 4)
|
|
|
|
df1 = DataFrame({"x": ["a"]}, index=[dt])
|
|
df2 = DataFrame({"y": ["b", "c"]}, index=[dt, dt])
|
|
_check_merge(df1, df2)
|
|
|
|
# Not monotonic
|
|
df1 = DataFrame({"x": ["a", "b", "q"]}, index=[dt2, dt, dt4])
|
|
df2 = DataFrame(
|
|
{"y": ["c", "d", "e", "f", "g", "h"]}, index=[dt3, dt3, dt2, dt2, dt, dt]
|
|
)
|
|
_check_merge(df1, df2)
|
|
|
|
df1 = DataFrame({"x": ["a", "b"]}, index=[dt, dt])
|
|
df2 = DataFrame({"y": ["c", "d"]}, index=[dt, dt])
|
|
_check_merge(df1, df2)
|
|
|
|
def test_merge_non_unique_index_many_to_many(self):
|
|
dt = datetime(2012, 5, 1)
|
|
dt2 = datetime(2012, 5, 2)
|
|
dt3 = datetime(2012, 5, 3)
|
|
df1 = DataFrame({"x": ["a", "b", "c", "d"]}, index=[dt2, dt2, dt, dt])
|
|
df2 = DataFrame(
|
|
{"y": ["e", "f", "g", " h", "i"]}, index=[dt2, dt2, dt3, dt, dt]
|
|
)
|
|
_check_merge(df1, df2)
|
|
|
|
def test_left_merge_empty_dataframe(self):
|
|
left = DataFrame({"key": [1], "value": [2]})
|
|
right = DataFrame({"key": []})
|
|
|
|
result = merge(left, right, on="key", how="left")
|
|
tm.assert_frame_equal(result, left)
|
|
|
|
result = merge(right, left, on="key", how="right")
|
|
tm.assert_frame_equal(result, left)
|
|
|
|
@pytest.mark.parametrize(
|
|
"kwarg",
|
|
[
|
|
{"left_index": True, "right_index": True},
|
|
{"left_index": True, "right_on": "x"},
|
|
{"left_on": "a", "right_index": True},
|
|
{"left_on": "a", "right_on": "x"},
|
|
],
|
|
)
|
|
def test_merge_left_empty_right_empty(self, join_type, kwarg):
|
|
# GH 10824
|
|
left = DataFrame(columns=["a", "b", "c"])
|
|
right = DataFrame(columns=["x", "y", "z"])
|
|
|
|
exp_in = DataFrame(
|
|
columns=["a", "b", "c", "x", "y", "z"],
|
|
index=pd.Index([], dtype=object),
|
|
dtype=object,
|
|
)
|
|
|
|
result = merge(left, right, how=join_type, **kwarg)
|
|
tm.assert_frame_equal(result, exp_in)
|
|
|
|
def test_merge_left_empty_right_notempty(self):
|
|
# GH 10824
|
|
left = DataFrame(columns=["a", "b", "c"])
|
|
right = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=["x", "y", "z"])
|
|
|
|
exp_out = DataFrame(
|
|
{
|
|
"a": np.array([np.nan] * 3, dtype=object),
|
|
"b": np.array([np.nan] * 3, dtype=object),
|
|
"c": np.array([np.nan] * 3, dtype=object),
|
|
"x": [1, 4, 7],
|
|
"y": [2, 5, 8],
|
|
"z": [3, 6, 9],
|
|
},
|
|
columns=["a", "b", "c", "x", "y", "z"],
|
|
)
|
|
exp_in = exp_out[0:0] # make empty DataFrame keeping dtype
|
|
# result will have object dtype
|
|
exp_in.index = exp_in.index.astype(object)
|
|
|
|
def check1(exp, kwarg):
|
|
result = merge(left, right, how="inner", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
result = merge(left, right, how="left", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
def check2(exp, kwarg):
|
|
result = merge(left, right, how="right", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
result = merge(left, right, how="outer", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
for kwarg in [
|
|
{"left_index": True, "right_index": True},
|
|
{"left_index": True, "right_on": "x"},
|
|
]:
|
|
check1(exp_in, kwarg)
|
|
check2(exp_out, kwarg)
|
|
|
|
kwarg = {"left_on": "a", "right_index": True}
|
|
check1(exp_in, kwarg)
|
|
exp_out["a"] = [0, 1, 2]
|
|
check2(exp_out, kwarg)
|
|
|
|
kwarg = {"left_on": "a", "right_on": "x"}
|
|
check1(exp_in, kwarg)
|
|
exp_out["a"] = np.array([np.nan] * 3, dtype=object)
|
|
check2(exp_out, kwarg)
|
|
|
|
def test_merge_left_notempty_right_empty(self):
|
|
# GH 10824
|
|
left = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=["a", "b", "c"])
|
|
right = DataFrame(columns=["x", "y", "z"])
|
|
|
|
exp_out = DataFrame(
|
|
{
|
|
"a": [1, 4, 7],
|
|
"b": [2, 5, 8],
|
|
"c": [3, 6, 9],
|
|
"x": np.array([np.nan] * 3, dtype=object),
|
|
"y": np.array([np.nan] * 3, dtype=object),
|
|
"z": np.array([np.nan] * 3, dtype=object),
|
|
},
|
|
columns=["a", "b", "c", "x", "y", "z"],
|
|
)
|
|
exp_in = exp_out[0:0] # make empty DataFrame keeping dtype
|
|
# result will have object dtype
|
|
exp_in.index = exp_in.index.astype(object)
|
|
|
|
def check1(exp, kwarg):
|
|
result = merge(left, right, how="inner", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
result = merge(left, right, how="right", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
def check2(exp, kwarg):
|
|
result = merge(left, right, how="left", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
result = merge(left, right, how="outer", **kwarg)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
# TODO: should the next loop be un-indented? doing so breaks this test
|
|
for kwarg in [
|
|
{"left_index": True, "right_index": True},
|
|
{"left_index": True, "right_on": "x"},
|
|
{"left_on": "a", "right_index": True},
|
|
{"left_on": "a", "right_on": "x"},
|
|
]:
|
|
check1(exp_in, kwarg)
|
|
check2(exp_out, kwarg)
|
|
|
|
def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
|
|
# GH 25183
|
|
df = DataFrame(
|
|
{"key": series_of_dtype, "value": series_of_dtype2},
|
|
columns=["key", "value"],
|
|
)
|
|
df_empty = df[:0]
|
|
expected = DataFrame(
|
|
{
|
|
"value_x": Series(dtype=df.dtypes["value"]),
|
|
"key": Series(dtype=df.dtypes["key"]),
|
|
"value_y": Series(dtype=df.dtypes["value"]),
|
|
},
|
|
columns=["value_x", "key", "value_y"],
|
|
)
|
|
actual = df_empty.merge(df, on="key")
|
|
tm.assert_frame_equal(actual, expected)
|
|
|
|
def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
|
|
# GH 25183
|
|
df_left = DataFrame(
|
|
{"key": series_of_dtype, "value": series_of_dtype_all_na},
|
|
columns=["key", "value"],
|
|
)
|
|
df_right = DataFrame(
|
|
{"key": series_of_dtype, "value": series_of_dtype_all_na},
|
|
columns=["key", "value"],
|
|
)
|
|
expected = DataFrame(
|
|
{
|
|
"key": series_of_dtype,
|
|
"value_x": series_of_dtype_all_na,
|
|
"value_y": series_of_dtype_all_na,
|
|
},
|
|
columns=["key", "value_x", "value_y"],
|
|
)
|
|
actual = df_left.merge(df_right, on="key")
|
|
tm.assert_frame_equal(actual, expected)
|
|
|
|
def test_merge_nosort(self):
|
|
# GH#2098
|
|
|
|
d = {
|
|
"var1": np.random.randint(0, 10, size=10),
|
|
"var2": np.random.randint(0, 10, size=10),
|
|
"var3": [
|
|
datetime(2012, 1, 12),
|
|
datetime(2011, 2, 4),
|
|
datetime(2010, 2, 3),
|
|
datetime(2012, 1, 12),
|
|
datetime(2011, 2, 4),
|
|
datetime(2012, 4, 3),
|
|
datetime(2012, 3, 4),
|
|
datetime(2008, 5, 1),
|
|
datetime(2010, 2, 3),
|
|
datetime(2012, 2, 3),
|
|
],
|
|
}
|
|
df = DataFrame.from_dict(d)
|
|
var3 = df.var3.unique()
|
|
var3.sort()
|
|
new = DataFrame.from_dict({"var3": var3, "var8": np.random.random(7)})
|
|
|
|
result = df.merge(new, on="var3", sort=False)
|
|
exp = merge(df, new, on="var3", sort=False)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
assert (df.var3.unique() == result.var3.unique()).all()
|
|
|
|
@pytest.mark.parametrize(
|
|
("sort", "values"), [(False, [1, 1, 0, 1, 1]), (True, [0, 1, 1, 1, 1])]
|
|
)
|
|
@pytest.mark.parametrize("how", ["left", "right"])
|
|
def test_merge_same_order_left_right(self, sort, values, how):
|
|
# GH#35382
|
|
df = DataFrame({"a": [1, 0, 1]})
|
|
|
|
result = df.merge(df, on="a", how=how, sort=sort)
|
|
expected = DataFrame(values, columns=["a"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_nan_right(self):
|
|
df1 = DataFrame({"i1": [0, 1], "i2": [0, 1]})
|
|
df2 = DataFrame({"i1": [0], "i3": [0]})
|
|
result = df1.join(df2, on="i1", rsuffix="_")
|
|
expected = (
|
|
DataFrame(
|
|
{
|
|
"i1": {0: 0.0, 1: 1},
|
|
"i2": {0: 0, 1: 1},
|
|
"i1_": {0: 0, 1: np.nan},
|
|
"i3": {0: 0.0, 1: np.nan},
|
|
None: {0: 0, 1: 0},
|
|
}
|
|
)
|
|
.set_index(None)
|
|
.reset_index()[["i1", "i2", "i1_", "i3"]]
|
|
)
|
|
tm.assert_frame_equal(result, expected, check_dtype=False)
|
|
|
|
def test_merge_nan_right2(self):
|
|
df1 = DataFrame({"i1": [0, 1], "i2": [0.5, 1.5]})
|
|
df2 = DataFrame({"i1": [0], "i3": [0.7]})
|
|
result = df1.join(df2, rsuffix="_", on="i1")
|
|
expected = DataFrame(
|
|
{
|
|
"i1": {0: 0, 1: 1},
|
|
"i1_": {0: 0.0, 1: np.nan},
|
|
"i2": {0: 0.5, 1: 1.5},
|
|
"i3": {0: 0.69999999999999996, 1: np.nan},
|
|
}
|
|
)[["i1", "i2", "i1_", "i3"]]
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_type(self):
|
|
class NotADataFrame(DataFrame):
|
|
@property
|
|
def _constructor(self):
|
|
return NotADataFrame
|
|
|
|
nad = NotADataFrame(self.df)
|
|
result = nad.merge(self.df2, on="key1")
|
|
|
|
assert isinstance(result, NotADataFrame)
|
|
|
|
def test_join_append_timedeltas(self, using_array_manager):
|
|
# timedelta64 issues with join/merge
|
|
# GH 5695
|
|
|
|
d = DataFrame.from_dict(
|
|
{"d": [datetime(2013, 11, 5, 5, 56)], "t": [timedelta(0, 22500)]}
|
|
)
|
|
df = DataFrame(columns=list("dt"))
|
|
df = concat([df, d], ignore_index=True)
|
|
result = concat([df, d], ignore_index=True)
|
|
expected = DataFrame(
|
|
{
|
|
"d": [datetime(2013, 11, 5, 5, 56), datetime(2013, 11, 5, 5, 56)],
|
|
"t": [timedelta(0, 22500), timedelta(0, 22500)],
|
|
}
|
|
)
|
|
if using_array_manager:
|
|
# TODO(ArrayManager) decide on exact casting rules in concat
|
|
expected = expected.astype(object)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_join_append_timedeltas2(self):
|
|
# timedelta64 issues with join/merge
|
|
# GH 5695
|
|
td = np.timedelta64(300000000)
|
|
lhs = DataFrame(Series([td, td], index=["A", "B"]))
|
|
rhs = DataFrame(Series([td], index=["A"]))
|
|
|
|
result = lhs.join(rhs, rsuffix="r", how="left")
|
|
expected = DataFrame(
|
|
{
|
|
"0": Series([td, td], index=list("AB")),
|
|
"0r": Series([td, pd.NaT], index=list("AB")),
|
|
}
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_other_datetime_unit(self):
|
|
# GH 13389
|
|
df1 = DataFrame({"entity_id": [101, 102]})
|
|
s = Series([None, None], index=[101, 102], name="days")
|
|
|
|
for dtype in [
|
|
"datetime64[D]",
|
|
"datetime64[h]",
|
|
"datetime64[m]",
|
|
"datetime64[s]",
|
|
"datetime64[ms]",
|
|
"datetime64[us]",
|
|
"datetime64[ns]",
|
|
]:
|
|
|
|
df2 = s.astype(dtype).to_frame("days")
|
|
# coerces to datetime64[ns], thus should not be affected
|
|
assert df2["days"].dtype == "datetime64[ns]"
|
|
|
|
result = df1.merge(df2, left_on="entity_id", right_index=True)
|
|
|
|
exp = DataFrame(
|
|
{
|
|
"entity_id": [101, 102],
|
|
"days": np.array(["nat", "nat"], dtype="datetime64[ns]"),
|
|
},
|
|
columns=["entity_id", "days"],
|
|
)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
@pytest.mark.parametrize("unit", ["D", "h", "m", "s", "ms", "us", "ns"])
|
|
def test_other_timedelta_unit(self, unit):
|
|
# GH 13389
|
|
df1 = DataFrame({"entity_id": [101, 102]})
|
|
s = Series([None, None], index=[101, 102], name="days")
|
|
|
|
dtype = f"m8[{unit}]"
|
|
df2 = s.astype(dtype).to_frame("days")
|
|
assert df2["days"].dtype == "m8[ns]"
|
|
|
|
result = df1.merge(df2, left_on="entity_id", right_index=True)
|
|
|
|
exp = DataFrame(
|
|
{"entity_id": [101, 102], "days": np.array(["nat", "nat"], dtype=dtype)},
|
|
columns=["entity_id", "days"],
|
|
)
|
|
tm.assert_frame_equal(result, exp)
|
|
|
|
def test_overlapping_columns_error_message(self):
|
|
df = DataFrame({"key": [1, 2, 3], "v1": [4, 5, 6], "v2": [7, 8, 9]})
|
|
df2 = DataFrame({"key": [1, 2, 3], "v1": [4, 5, 6], "v2": [7, 8, 9]})
|
|
|
|
df.columns = ["key", "foo", "foo"]
|
|
df2.columns = ["key", "bar", "bar"]
|
|
expected = DataFrame(
|
|
{
|
|
"key": [1, 2, 3],
|
|
"v1": [4, 5, 6],
|
|
"v2": [7, 8, 9],
|
|
"v3": [4, 5, 6],
|
|
"v4": [7, 8, 9],
|
|
}
|
|
)
|
|
expected.columns = ["key", "foo", "foo", "bar", "bar"]
|
|
tm.assert_frame_equal(merge(df, df2), expected)
|
|
|
|
# #2649, #10639
|
|
df2.columns = ["key1", "foo", "foo"]
|
|
msg = r"Data columns not unique: Index\(\['foo'\], dtype='object'\)"
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(df, df2)
|
|
|
|
def test_merge_on_datetime64tz(self):
|
|
|
|
# GH11405
|
|
left = DataFrame(
|
|
{
|
|
"key": pd.date_range("20151010", periods=2, tz="US/Eastern"),
|
|
"value": [1, 2],
|
|
}
|
|
)
|
|
right = DataFrame(
|
|
{
|
|
"key": pd.date_range("20151011", periods=3, tz="US/Eastern"),
|
|
"value": [1, 2, 3],
|
|
}
|
|
)
|
|
|
|
expected = DataFrame(
|
|
{
|
|
"key": pd.date_range("20151010", periods=4, tz="US/Eastern"),
|
|
"value_x": [1, 2, np.nan, np.nan],
|
|
"value_y": [np.nan, 1, 2, 3],
|
|
}
|
|
)
|
|
result = merge(left, right, on="key", how="outer")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_datetime64tz_values(self):
|
|
left = DataFrame(
|
|
{
|
|
"key": [1, 2],
|
|
"value": pd.date_range("20151010", periods=2, tz="US/Eastern"),
|
|
}
|
|
)
|
|
right = DataFrame(
|
|
{
|
|
"key": [2, 3],
|
|
"value": pd.date_range("20151011", periods=2, tz="US/Eastern"),
|
|
}
|
|
)
|
|
expected = DataFrame(
|
|
{
|
|
"key": [1, 2, 3],
|
|
"value_x": list(pd.date_range("20151010", periods=2, tz="US/Eastern"))
|
|
+ [pd.NaT],
|
|
"value_y": [pd.NaT]
|
|
+ list(pd.date_range("20151011", periods=2, tz="US/Eastern")),
|
|
}
|
|
)
|
|
result = merge(left, right, on="key", how="outer")
|
|
tm.assert_frame_equal(result, expected)
|
|
assert result["value_x"].dtype == "datetime64[ns, US/Eastern]"
|
|
assert result["value_y"].dtype == "datetime64[ns, US/Eastern]"
|
|
|
|
def test_merge_on_datetime64tz_empty(self):
|
|
# https://github.com/pandas-dev/pandas/issues/25014
|
|
dtz = pd.DatetimeTZDtype(tz="UTC")
|
|
right = DataFrame(
|
|
{
|
|
"date": [pd.Timestamp("2018", tz=dtz.tz)],
|
|
"value": [4.0],
|
|
"date2": [pd.Timestamp("2019", tz=dtz.tz)],
|
|
},
|
|
columns=["date", "value", "date2"],
|
|
)
|
|
left = right[:0]
|
|
result = left.merge(right, on="date")
|
|
expected = DataFrame(
|
|
{
|
|
"value_x": Series(dtype=float),
|
|
"date2_x": Series(dtype=dtz),
|
|
"date": Series(dtype=dtz),
|
|
"value_y": Series(dtype=float),
|
|
"date2_y": Series(dtype=dtz),
|
|
},
|
|
columns=["value_x", "date2_x", "date", "value_y", "date2_y"],
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_datetime64tz_with_dst_transition(self):
|
|
# GH 18885
|
|
df1 = DataFrame(
|
|
pd.date_range("2017-10-29 01:00", periods=4, freq="H", tz="Europe/Madrid"),
|
|
columns=["date"],
|
|
)
|
|
df1["value"] = 1
|
|
df2 = DataFrame(
|
|
{
|
|
"date": pd.to_datetime(
|
|
[
|
|
"2017-10-29 03:00:00",
|
|
"2017-10-29 04:00:00",
|
|
"2017-10-29 05:00:00",
|
|
]
|
|
),
|
|
"value": 2,
|
|
}
|
|
)
|
|
df2["date"] = df2["date"].dt.tz_localize("UTC").dt.tz_convert("Europe/Madrid")
|
|
result = merge(df1, df2, how="outer", on="date")
|
|
expected = DataFrame(
|
|
{
|
|
"date": pd.date_range(
|
|
"2017-10-29 01:00", periods=7, freq="H", tz="Europe/Madrid"
|
|
),
|
|
"value_x": [1] * 4 + [np.nan] * 3,
|
|
"value_y": [np.nan] * 4 + [2] * 3,
|
|
}
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_non_unique_period_index(self):
|
|
# GH #16871
|
|
index = pd.period_range("2016-01-01", periods=16, freq="M")
|
|
df = DataFrame(list(range(len(index))), index=index, columns=["pnum"])
|
|
df2 = concat([df, df])
|
|
result = df.merge(df2, left_index=True, right_index=True, how="inner")
|
|
expected = DataFrame(
|
|
np.tile(np.arange(16, dtype=np.int64).repeat(2).reshape(-1, 1), 2),
|
|
columns=["pnum_x", "pnum_y"],
|
|
index=df2.sort_index().index,
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_on_periods(self):
|
|
left = DataFrame(
|
|
{"key": pd.period_range("20151010", periods=2, freq="D"), "value": [1, 2]}
|
|
)
|
|
right = DataFrame(
|
|
{
|
|
"key": pd.period_range("20151011", periods=3, freq="D"),
|
|
"value": [1, 2, 3],
|
|
}
|
|
)
|
|
|
|
expected = DataFrame(
|
|
{
|
|
"key": pd.period_range("20151010", periods=4, freq="D"),
|
|
"value_x": [1, 2, np.nan, np.nan],
|
|
"value_y": [np.nan, 1, 2, 3],
|
|
}
|
|
)
|
|
result = merge(left, right, on="key", how="outer")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_period_values(self):
|
|
left = DataFrame(
|
|
{"key": [1, 2], "value": pd.period_range("20151010", periods=2, freq="D")}
|
|
)
|
|
right = DataFrame(
|
|
{"key": [2, 3], "value": pd.period_range("20151011", periods=2, freq="D")}
|
|
)
|
|
|
|
exp_x = pd.period_range("20151010", periods=2, freq="D")
|
|
exp_y = pd.period_range("20151011", periods=2, freq="D")
|
|
expected = DataFrame(
|
|
{
|
|
"key": [1, 2, 3],
|
|
"value_x": list(exp_x) + [pd.NaT],
|
|
"value_y": [pd.NaT] + list(exp_y),
|
|
}
|
|
)
|
|
result = merge(left, right, on="key", how="outer")
|
|
tm.assert_frame_equal(result, expected)
|
|
assert result["value_x"].dtype == "Period[D]"
|
|
assert result["value_y"].dtype == "Period[D]"
|
|
|
|
def test_indicator(self, dfs_for_indicator):
|
|
# PR #10054. xref #7412 and closes #8790.
|
|
df1, df2 = dfs_for_indicator
|
|
df1_copy = df1.copy()
|
|
|
|
df2_copy = df2.copy()
|
|
|
|
df_result = DataFrame(
|
|
{
|
|
"col1": [0, 1, 2, 3, 4, 5],
|
|
"col_conflict_x": [1, 2, np.nan, np.nan, np.nan, np.nan],
|
|
"col_left": ["a", "b", np.nan, np.nan, np.nan, np.nan],
|
|
"col_conflict_y": [np.nan, 1, 2, 3, 4, 5],
|
|
"col_right": [np.nan, 2, 2, 2, 2, 2],
|
|
}
|
|
)
|
|
df_result["_merge"] = Categorical(
|
|
[
|
|
"left_only",
|
|
"both",
|
|
"right_only",
|
|
"right_only",
|
|
"right_only",
|
|
"right_only",
|
|
],
|
|
categories=["left_only", "right_only", "both"],
|
|
)
|
|
|
|
df_result = df_result[
|
|
[
|
|
"col1",
|
|
"col_conflict_x",
|
|
"col_left",
|
|
"col_conflict_y",
|
|
"col_right",
|
|
"_merge",
|
|
]
|
|
]
|
|
|
|
test = merge(df1, df2, on="col1", how="outer", indicator=True)
|
|
tm.assert_frame_equal(test, df_result)
|
|
test = df1.merge(df2, on="col1", how="outer", indicator=True)
|
|
tm.assert_frame_equal(test, df_result)
|
|
|
|
# No side effects
|
|
tm.assert_frame_equal(df1, df1_copy)
|
|
tm.assert_frame_equal(df2, df2_copy)
|
|
|
|
# Check with custom name
|
|
df_result_custom_name = df_result
|
|
df_result_custom_name = df_result_custom_name.rename(
|
|
columns={"_merge": "custom_name"}
|
|
)
|
|
|
|
test_custom_name = merge(
|
|
df1, df2, on="col1", how="outer", indicator="custom_name"
|
|
)
|
|
tm.assert_frame_equal(test_custom_name, df_result_custom_name)
|
|
test_custom_name = df1.merge(
|
|
df2, on="col1", how="outer", indicator="custom_name"
|
|
)
|
|
tm.assert_frame_equal(test_custom_name, df_result_custom_name)
|
|
|
|
def test_merge_indicator_arg_validation(self, dfs_for_indicator):
|
|
# Check only accepts strings and booleans
|
|
df1, df2 = dfs_for_indicator
|
|
|
|
msg = "indicator option can only accept boolean or string arguments"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(df1, df2, on="col1", how="outer", indicator=5)
|
|
with pytest.raises(ValueError, match=msg):
|
|
df1.merge(df2, on="col1", how="outer", indicator=5)
|
|
|
|
def test_merge_indicator_result_integrity(self, dfs_for_indicator):
|
|
# Check result integrity
|
|
df1, df2 = dfs_for_indicator
|
|
|
|
test2 = merge(df1, df2, on="col1", how="left", indicator=True)
|
|
assert (test2._merge != "right_only").all()
|
|
test2 = df1.merge(df2, on="col1", how="left", indicator=True)
|
|
assert (test2._merge != "right_only").all()
|
|
|
|
test3 = merge(df1, df2, on="col1", how="right", indicator=True)
|
|
assert (test3._merge != "left_only").all()
|
|
test3 = df1.merge(df2, on="col1", how="right", indicator=True)
|
|
assert (test3._merge != "left_only").all()
|
|
|
|
test4 = merge(df1, df2, on="col1", how="inner", indicator=True)
|
|
assert (test4._merge == "both").all()
|
|
test4 = df1.merge(df2, on="col1", how="inner", indicator=True)
|
|
assert (test4._merge == "both").all()
|
|
|
|
def test_merge_indicator_invalid(self, dfs_for_indicator):
|
|
# Check if working name in df
|
|
df1, _ = dfs_for_indicator
|
|
|
|
for i in ["_right_indicator", "_left_indicator", "_merge"]:
|
|
df_badcolumn = DataFrame({"col1": [1, 2], i: [2, 2]})
|
|
|
|
msg = (
|
|
"Cannot use `indicator=True` option when data contains a "
|
|
f"column named {i}|"
|
|
"Cannot use name of an existing column for indicator column"
|
|
)
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(df1, df_badcolumn, on="col1", how="outer", indicator=True)
|
|
with pytest.raises(ValueError, match=msg):
|
|
df1.merge(df_badcolumn, on="col1", how="outer", indicator=True)
|
|
|
|
# Check for name conflict with custom name
|
|
df_badcolumn = DataFrame({"col1": [1, 2], "custom_column_name": [2, 2]})
|
|
|
|
msg = "Cannot use name of an existing column for indicator column"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(
|
|
df1,
|
|
df_badcolumn,
|
|
on="col1",
|
|
how="outer",
|
|
indicator="custom_column_name",
|
|
)
|
|
with pytest.raises(ValueError, match=msg):
|
|
df1.merge(
|
|
df_badcolumn, on="col1", how="outer", indicator="custom_column_name"
|
|
)
|
|
|
|
def test_merge_indicator_multiple_columns(self):
|
|
# Merge on multiple columns
|
|
df3 = DataFrame({"col1": [0, 1], "col2": ["a", "b"]})
|
|
|
|
df4 = DataFrame({"col1": [1, 1, 3], "col2": ["b", "x", "y"]})
|
|
|
|
hand_coded_result = DataFrame(
|
|
{"col1": [0, 1, 1, 3], "col2": ["a", "b", "x", "y"]}
|
|
)
|
|
hand_coded_result["_merge"] = Categorical(
|
|
["left_only", "both", "right_only", "right_only"],
|
|
categories=["left_only", "right_only", "both"],
|
|
)
|
|
|
|
test5 = merge(df3, df4, on=["col1", "col2"], how="outer", indicator=True)
|
|
tm.assert_frame_equal(test5, hand_coded_result)
|
|
test5 = df3.merge(df4, on=["col1", "col2"], how="outer", indicator=True)
|
|
tm.assert_frame_equal(test5, hand_coded_result)
|
|
|
|
def test_validation(self):
|
|
left = DataFrame(
|
|
{"a": ["a", "b", "c", "d"], "b": ["cat", "dog", "weasel", "horse"]},
|
|
index=range(4),
|
|
)
|
|
|
|
right = DataFrame(
|
|
{
|
|
"a": ["a", "b", "c", "d", "e"],
|
|
"c": ["meow", "bark", "um... weasel noise?", "nay", "chirp"],
|
|
},
|
|
index=range(5),
|
|
)
|
|
|
|
# Make sure no side effects.
|
|
left_copy = left.copy()
|
|
right_copy = right.copy()
|
|
|
|
result = merge(left, right, left_index=True, right_index=True, validate="1:1")
|
|
tm.assert_frame_equal(left, left_copy)
|
|
tm.assert_frame_equal(right, right_copy)
|
|
|
|
# make sure merge still correct
|
|
expected = DataFrame(
|
|
{
|
|
"a_x": ["a", "b", "c", "d"],
|
|
"b": ["cat", "dog", "weasel", "horse"],
|
|
"a_y": ["a", "b", "c", "d"],
|
|
"c": ["meow", "bark", "um... weasel noise?", "nay"],
|
|
},
|
|
index=range(4),
|
|
columns=["a_x", "b", "a_y", "c"],
|
|
)
|
|
|
|
result = merge(
|
|
left, right, left_index=True, right_index=True, validate="one_to_one"
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
expected_2 = DataFrame(
|
|
{
|
|
"a": ["a", "b", "c", "d"],
|
|
"b": ["cat", "dog", "weasel", "horse"],
|
|
"c": ["meow", "bark", "um... weasel noise?", "nay"],
|
|
},
|
|
index=range(4),
|
|
)
|
|
|
|
result = merge(left, right, on="a", validate="1:1")
|
|
tm.assert_frame_equal(left, left_copy)
|
|
tm.assert_frame_equal(right, right_copy)
|
|
tm.assert_frame_equal(result, expected_2)
|
|
|
|
result = merge(left, right, on="a", validate="one_to_one")
|
|
tm.assert_frame_equal(result, expected_2)
|
|
|
|
# One index, one column
|
|
expected_3 = DataFrame(
|
|
{
|
|
"b": ["cat", "dog", "weasel", "horse"],
|
|
"a": ["a", "b", "c", "d"],
|
|
"c": ["meow", "bark", "um... weasel noise?", "nay"],
|
|
},
|
|
columns=["b", "a", "c"],
|
|
index=range(4),
|
|
)
|
|
|
|
left_index_reset = left.set_index("a")
|
|
result = merge(
|
|
left_index_reset,
|
|
right,
|
|
left_index=True,
|
|
right_on="a",
|
|
validate="one_to_one",
|
|
)
|
|
tm.assert_frame_equal(result, expected_3)
|
|
|
|
# Dups on right
|
|
right_w_dups = concat([right, DataFrame({"a": ["e"], "c": ["moo"]}, index=[4])])
|
|
merge(
|
|
left,
|
|
right_w_dups,
|
|
left_index=True,
|
|
right_index=True,
|
|
validate="one_to_many",
|
|
)
|
|
|
|
msg = "Merge keys are not unique in right dataset; not a one-to-one merge"
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(
|
|
left,
|
|
right_w_dups,
|
|
left_index=True,
|
|
right_index=True,
|
|
validate="one_to_one",
|
|
)
|
|
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(left, right_w_dups, on="a", validate="one_to_one")
|
|
|
|
# Dups on left
|
|
left_w_dups = concat(
|
|
[left, DataFrame({"a": ["a"], "c": ["cow"]}, index=[3])], sort=True
|
|
)
|
|
merge(
|
|
left_w_dups,
|
|
right,
|
|
left_index=True,
|
|
right_index=True,
|
|
validate="many_to_one",
|
|
)
|
|
|
|
msg = "Merge keys are not unique in left dataset; not a one-to-one merge"
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(
|
|
left_w_dups,
|
|
right,
|
|
left_index=True,
|
|
right_index=True,
|
|
validate="one_to_one",
|
|
)
|
|
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(left_w_dups, right, on="a", validate="one_to_one")
|
|
|
|
# Dups on both
|
|
merge(left_w_dups, right_w_dups, on="a", validate="many_to_many")
|
|
|
|
msg = "Merge keys are not unique in right dataset; not a many-to-one merge"
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(
|
|
left_w_dups,
|
|
right_w_dups,
|
|
left_index=True,
|
|
right_index=True,
|
|
validate="many_to_one",
|
|
)
|
|
|
|
msg = "Merge keys are not unique in left dataset; not a one-to-many merge"
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(left_w_dups, right_w_dups, on="a", validate="one_to_many")
|
|
|
|
# Check invalid arguments
|
|
msg = "Not a valid argument for validate"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(left, right, on="a", validate="jibberish")
|
|
|
|
# Two column merge, dups in both, but jointly no dups.
|
|
left = DataFrame(
|
|
{
|
|
"a": ["a", "a", "b", "b"],
|
|
"b": [0, 1, 0, 1],
|
|
"c": ["cat", "dog", "weasel", "horse"],
|
|
},
|
|
index=range(4),
|
|
)
|
|
|
|
right = DataFrame(
|
|
{
|
|
"a": ["a", "a", "b"],
|
|
"b": [0, 1, 0],
|
|
"d": ["meow", "bark", "um... weasel noise?"],
|
|
},
|
|
index=range(3),
|
|
)
|
|
|
|
expected_multi = DataFrame(
|
|
{
|
|
"a": ["a", "a", "b"],
|
|
"b": [0, 1, 0],
|
|
"c": ["cat", "dog", "weasel"],
|
|
"d": ["meow", "bark", "um... weasel noise?"],
|
|
},
|
|
index=range(3),
|
|
)
|
|
|
|
msg = (
|
|
"Merge keys are not unique in either left or right dataset; "
|
|
"not a one-to-one merge"
|
|
)
|
|
with pytest.raises(MergeError, match=msg):
|
|
merge(left, right, on="a", validate="1:1")
|
|
|
|
result = merge(left, right, on=["a", "b"], validate="1:1")
|
|
tm.assert_frame_equal(result, expected_multi)
|
|
|
|
def test_merge_two_empty_df_no_division_error(self):
|
|
# GH17776, PR #17846
|
|
a = DataFrame({"a": [], "b": [], "c": []})
|
|
with np.errstate(divide="raise"):
|
|
merge(a, a, on=("a", "b"))
|
|
|
|
@pytest.mark.parametrize("how", ["right", "outer"])
|
|
@pytest.mark.parametrize(
|
|
"index,expected_index",
|
|
[
|
|
(
|
|
CategoricalIndex([1, 2, 4]),
|
|
CategoricalIndex([1, 2, 4, None, None, None]),
|
|
),
|
|
(
|
|
DatetimeIndex(["2001-01-01", "2002-02-02", "2003-03-03"]),
|
|
DatetimeIndex(
|
|
["2001-01-01", "2002-02-02", "2003-03-03", pd.NaT, pd.NaT, pd.NaT]
|
|
),
|
|
),
|
|
(Float64Index([1, 2, 3]), Float64Index([1, 2, 3, None, None, None])),
|
|
(Int64Index([1, 2, 3]), Float64Index([1, 2, 3, None, None, None])),
|
|
(
|
|
IntervalIndex.from_tuples([(1, 2), (2, 3), (3, 4)]),
|
|
IntervalIndex.from_tuples(
|
|
[(1, 2), (2, 3), (3, 4), np.nan, np.nan, np.nan]
|
|
),
|
|
),
|
|
(
|
|
PeriodIndex(["2001-01-01", "2001-01-02", "2001-01-03"], freq="D"),
|
|
PeriodIndex(
|
|
["2001-01-01", "2001-01-02", "2001-01-03", pd.NaT, pd.NaT, pd.NaT],
|
|
freq="D",
|
|
),
|
|
),
|
|
(
|
|
TimedeltaIndex(["1d", "2d", "3d"]),
|
|
TimedeltaIndex(["1d", "2d", "3d", pd.NaT, pd.NaT, pd.NaT]),
|
|
),
|
|
],
|
|
)
|
|
def test_merge_on_index_with_more_values(self, how, index, expected_index):
|
|
# GH 24212
|
|
# pd.merge gets [0, 1, 2, -1, -1, -1] as left_indexer, ensure that
|
|
# -1 is interpreted as a missing value instead of the last element
|
|
df1 = DataFrame({"a": [0, 1, 2], "key": [0, 1, 2]}, index=index)
|
|
df2 = DataFrame({"b": [0, 1, 2, 3, 4, 5]})
|
|
result = df1.merge(df2, left_on="key", right_index=True, how=how)
|
|
expected = DataFrame(
|
|
[
|
|
[0, 0, 0],
|
|
[1, 1, 1],
|
|
[2, 2, 2],
|
|
[np.nan, 3, 3],
|
|
[np.nan, 4, 4],
|
|
[np.nan, 5, 5],
|
|
],
|
|
columns=["a", "key", "b"],
|
|
)
|
|
expected.set_index(expected_index, inplace=True)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_right_index_right(self):
|
|
# Note: the expected output here is probably incorrect.
|
|
# See https://github.com/pandas-dev/pandas/issues/17257 for more.
|
|
# We include this as a regression test for GH-24897.
|
|
left = DataFrame({"a": [1, 2, 3], "key": [0, 1, 1]})
|
|
right = DataFrame({"b": [1, 2, 3]})
|
|
|
|
expected = DataFrame(
|
|
{"a": [1, 2, 3, None], "key": [0, 1, 1, 2], "b": [1, 2, 2, 3]},
|
|
columns=["a", "key", "b"],
|
|
index=[0, 1, 2, np.nan],
|
|
)
|
|
result = left.merge(right, left_on="key", right_index=True, how="right")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize("how", ["left", "right"])
|
|
def test_merge_preserves_row_order(self, how):
|
|
# GH 27453
|
|
left_df = DataFrame({"animal": ["dog", "pig"], "max_speed": [40, 11]})
|
|
right_df = DataFrame({"animal": ["quetzal", "pig"], "max_speed": [80, 11]})
|
|
result = left_df.merge(right_df, on=["animal", "max_speed"], how=how)
|
|
if how == "right":
|
|
expected = DataFrame({"animal": ["quetzal", "pig"], "max_speed": [80, 11]})
|
|
else:
|
|
expected = DataFrame({"animal": ["dog", "pig"], "max_speed": [40, 11]})
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_take_missing_values_from_index_of_other_dtype(self):
|
|
# GH 24212
|
|
left = DataFrame(
|
|
{
|
|
"a": [1, 2, 3],
|
|
"key": Categorical(["a", "a", "b"], categories=list("abc")),
|
|
}
|
|
)
|
|
right = DataFrame({"b": [1, 2, 3]}, index=CategoricalIndex(["a", "b", "c"]))
|
|
result = left.merge(right, left_on="key", right_index=True, how="right")
|
|
expected = DataFrame(
|
|
{
|
|
"a": [1, 2, 3, None],
|
|
"key": Categorical(["a", "a", "b", "c"]),
|
|
"b": [1, 1, 2, 3],
|
|
},
|
|
index=[0, 1, 2, np.nan],
|
|
)
|
|
expected = expected.reindex(columns=["a", "key", "b"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_readonly(self):
|
|
# https://github.com/pandas-dev/pandas/issues/27943
|
|
data1 = DataFrame(
|
|
np.arange(20).reshape((4, 5)) + 1, columns=["a", "b", "c", "d", "e"]
|
|
)
|
|
data2 = DataFrame(
|
|
np.arange(20).reshape((5, 4)) + 1, columns=["a", "b", "x", "y"]
|
|
)
|
|
|
|
# make each underlying block array / column array read-only
|
|
for arr in data1._mgr.arrays:
|
|
arr.flags.writeable = False
|
|
|
|
data1.merge(data2) # no error
|
|
|
|
|
|
def _check_merge(x, y):
|
|
for how in ["inner", "left", "outer"]:
|
|
result = x.join(y, how=how)
|
|
|
|
expected = merge(x.reset_index(), y.reset_index(), how=how, sort=True)
|
|
expected = expected.set_index("index")
|
|
|
|
# TODO check_names on merge?
|
|
tm.assert_frame_equal(result, expected, check_names=False)
|
|
|
|
|
|
class TestMergeDtypes:
|
|
@pytest.mark.parametrize(
|
|
"right_vals", [["foo", "bar"], Series(["foo", "bar"]).astype("category")]
|
|
)
|
|
def test_different(self, right_vals):
|
|
|
|
left = DataFrame(
|
|
{
|
|
"A": ["foo", "bar"],
|
|
"B": Series(["foo", "bar"]).astype("category"),
|
|
"C": [1, 2],
|
|
"D": [1.0, 2.0],
|
|
"E": Series([1, 2], dtype="uint64"),
|
|
"F": Series([1, 2], dtype="int32"),
|
|
}
|
|
)
|
|
right = DataFrame({"A": right_vals})
|
|
|
|
# GH 9780
|
|
# We allow merging on object and categorical cols and cast
|
|
# categorical cols to object
|
|
result = merge(left, right, on="A")
|
|
assert is_object_dtype(result.A.dtype)
|
|
|
|
@pytest.mark.parametrize("d1", [np.int64, np.int32, np.int16, np.int8, np.uint8])
|
|
@pytest.mark.parametrize("d2", [np.int64, np.float64, np.float32, np.float16])
|
|
def test_join_multi_dtypes(self, d1, d2):
|
|
|
|
dtype1 = np.dtype(d1)
|
|
dtype2 = np.dtype(d2)
|
|
|
|
left = DataFrame(
|
|
{
|
|
"k1": np.array([0, 1, 2] * 8, dtype=dtype1),
|
|
"k2": ["foo", "bar"] * 12,
|
|
"v": np.array(np.arange(24), dtype=np.int64),
|
|
}
|
|
)
|
|
|
|
index = MultiIndex.from_tuples([(2, "bar"), (1, "foo")])
|
|
right = DataFrame({"v2": np.array([5, 7], dtype=dtype2)}, index=index)
|
|
|
|
result = left.join(right, on=["k1", "k2"])
|
|
|
|
expected = left.copy()
|
|
|
|
if dtype2.kind == "i":
|
|
dtype2 = np.dtype("float64")
|
|
expected["v2"] = np.array(np.nan, dtype=dtype2)
|
|
expected.loc[(expected.k1 == 2) & (expected.k2 == "bar"), "v2"] = 5
|
|
expected.loc[(expected.k1 == 1) & (expected.k2 == "foo"), "v2"] = 7
|
|
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
result = left.join(right, on=["k1", "k2"], sort=True)
|
|
expected.sort_values(["k1", "k2"], kind="mergesort", inplace=True)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize(
|
|
"int_vals, float_vals, exp_vals",
|
|
[
|
|
([1, 2, 3], [1.0, 2.0, 3.0], {"X": [1, 2, 3], "Y": [1.0, 2.0, 3.0]}),
|
|
([1, 2, 3], [1.0, 3.0], {"X": [1, 3], "Y": [1.0, 3.0]}),
|
|
([1, 2], [1.0, 2.0, 3.0], {"X": [1, 2], "Y": [1.0, 2.0]}),
|
|
],
|
|
)
|
|
def test_merge_on_ints_floats(self, int_vals, float_vals, exp_vals):
|
|
# GH 16572
|
|
# Check that float column is not cast to object if
|
|
# merging on float and int columns
|
|
A = DataFrame({"X": int_vals})
|
|
B = DataFrame({"Y": float_vals})
|
|
expected = DataFrame(exp_vals)
|
|
|
|
result = A.merge(B, left_on="X", right_on="Y")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
result = B.merge(A, left_on="Y", right_on="X")
|
|
tm.assert_frame_equal(result, expected[["Y", "X"]])
|
|
|
|
def test_merge_key_dtype_cast(self):
|
|
# GH 17044
|
|
df1 = DataFrame({"key": [1.0, 2.0], "v1": [10, 20]}, columns=["key", "v1"])
|
|
df2 = DataFrame({"key": [2], "v2": [200]}, columns=["key", "v2"])
|
|
result = df1.merge(df2, on="key", how="left")
|
|
expected = DataFrame(
|
|
{"key": [1.0, 2.0], "v1": [10, 20], "v2": [np.nan, 200.0]},
|
|
columns=["key", "v1", "v2"],
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_on_ints_floats_warning(self):
|
|
# GH 16572
|
|
# merge will produce a warning when merging on int and
|
|
# float columns where the float values are not exactly
|
|
# equal to their int representation
|
|
A = DataFrame({"X": [1, 2, 3]})
|
|
B = DataFrame({"Y": [1.1, 2.5, 3.0]})
|
|
expected = DataFrame({"X": [3], "Y": [3.0]})
|
|
|
|
with tm.assert_produces_warning(UserWarning):
|
|
result = A.merge(B, left_on="X", right_on="Y")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
with tm.assert_produces_warning(UserWarning):
|
|
result = B.merge(A, left_on="Y", right_on="X")
|
|
tm.assert_frame_equal(result, expected[["Y", "X"]])
|
|
|
|
# test no warning if float has NaNs
|
|
B = DataFrame({"Y": [np.nan, np.nan, 3.0]})
|
|
|
|
with tm.assert_produces_warning(None):
|
|
result = B.merge(A, left_on="Y", right_on="X")
|
|
tm.assert_frame_equal(result, expected[["Y", "X"]])
|
|
|
|
def test_merge_incompat_infer_boolean_object(self):
|
|
# GH21119: bool + object bool merge OK
|
|
df1 = DataFrame({"key": Series([True, False], dtype=object)})
|
|
df2 = DataFrame({"key": [True, False]})
|
|
|
|
expected = DataFrame({"key": [True, False]}, dtype=object)
|
|
result = merge(df1, df2, on="key")
|
|
tm.assert_frame_equal(result, expected)
|
|
result = merge(df2, df1, on="key")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_incompat_infer_boolean_object_with_missing(self):
|
|
# GH21119: bool + object bool merge OK
|
|
# with missing value
|
|
df1 = DataFrame({"key": Series([True, False, np.nan], dtype=object)})
|
|
df2 = DataFrame({"key": [True, False]})
|
|
|
|
expected = DataFrame({"key": [True, False]}, dtype=object)
|
|
result = merge(df1, df2, on="key")
|
|
tm.assert_frame_equal(result, expected)
|
|
result = merge(df2, df1, on="key")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize(
|
|
"df1_vals, df2_vals",
|
|
[
|
|
# merge on category coerces to object
|
|
([0, 1, 2], Series(["a", "b", "a"]).astype("category")),
|
|
([0.0, 1.0, 2.0], Series(["a", "b", "a"]).astype("category")),
|
|
# no not infer
|
|
([0, 1], Series([False, True], dtype=object)),
|
|
([0, 1], Series([False, True], dtype=bool)),
|
|
],
|
|
)
|
|
def test_merge_incompat_dtypes_are_ok(self, df1_vals, df2_vals):
|
|
# these are explicitly allowed incompat merges, that pass thru
|
|
# the result type is dependent on if the values on the rhs are
|
|
# inferred, otherwise these will be coerced to object
|
|
|
|
df1 = DataFrame({"A": df1_vals})
|
|
df2 = DataFrame({"A": df2_vals})
|
|
|
|
result = merge(df1, df2, on=["A"])
|
|
assert is_object_dtype(result.A.dtype)
|
|
result = merge(df2, df1, on=["A"])
|
|
assert is_object_dtype(result.A.dtype)
|
|
|
|
@pytest.mark.parametrize(
|
|
"df1_vals, df2_vals",
|
|
[
|
|
# do not infer to numeric
|
|
(Series([1, 2], dtype="uint64"), ["a", "b", "c"]),
|
|
(Series([1, 2], dtype="int32"), ["a", "b", "c"]),
|
|
([0, 1, 2], ["0", "1", "2"]),
|
|
([0.0, 1.0, 2.0], ["0", "1", "2"]),
|
|
([0, 1, 2], ["0", "1", "2"]),
|
|
(
|
|
pd.date_range("1/1/2011", periods=2, freq="D"),
|
|
["2011-01-01", "2011-01-02"],
|
|
),
|
|
(pd.date_range("1/1/2011", periods=2, freq="D"), [0, 1]),
|
|
(pd.date_range("1/1/2011", periods=2, freq="D"), [0.0, 1.0]),
|
|
(
|
|
pd.date_range("20130101", periods=3),
|
|
pd.date_range("20130101", periods=3, tz="US/Eastern"),
|
|
),
|
|
],
|
|
)
|
|
def test_merge_incompat_dtypes_error(self, df1_vals, df2_vals):
|
|
# GH 9780, GH 15800
|
|
# Raise a ValueError when a user tries to merge on
|
|
# dtypes that are incompatible (e.g., obj and int/float)
|
|
|
|
df1 = DataFrame({"A": df1_vals})
|
|
df2 = DataFrame({"A": df2_vals})
|
|
|
|
msg = (
|
|
f"You are trying to merge on {df1['A'].dtype} and "
|
|
f"{df2['A'].dtype} columns. If you wish to proceed "
|
|
"you should use pd.concat"
|
|
)
|
|
msg = re.escape(msg)
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(df1, df2, on=["A"])
|
|
|
|
# Check that error still raised when swapping order of dataframes
|
|
msg = (
|
|
f"You are trying to merge on {df2['A'].dtype} and "
|
|
f"{df1['A'].dtype} columns. If you wish to proceed "
|
|
"you should use pd.concat"
|
|
)
|
|
msg = re.escape(msg)
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(df2, df1, on=["A"])
|
|
|
|
@pytest.mark.parametrize(
|
|
"expected_data, how",
|
|
[
|
|
([1, 2], "outer"),
|
|
([], "inner"),
|
|
([2], "right"),
|
|
([1], "left"),
|
|
],
|
|
)
|
|
def test_merge_EA_dtype(self, any_numeric_ea_dtype, how, expected_data):
|
|
# GH#40073
|
|
d1 = DataFrame([(1,)], columns=["id"], dtype=any_numeric_ea_dtype)
|
|
d2 = DataFrame([(2,)], columns=["id"], dtype=any_numeric_ea_dtype)
|
|
result = merge(d1, d2, how=how)
|
|
expected = DataFrame(expected_data, columns=["id"], dtype=any_numeric_ea_dtype)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize(
|
|
"expected_data, how",
|
|
[
|
|
(["a", "b"], "outer"),
|
|
([], "inner"),
|
|
(["b"], "right"),
|
|
(["a"], "left"),
|
|
],
|
|
)
|
|
def test_merge_string_dtype(self, how, expected_data, any_string_dtype):
|
|
# GH#40073
|
|
d1 = DataFrame([("a",)], columns=["id"], dtype=any_string_dtype)
|
|
d2 = DataFrame([("b",)], columns=["id"], dtype=any_string_dtype)
|
|
result = merge(d1, d2, how=how)
|
|
expected = DataFrame(expected_data, columns=["id"], dtype=any_string_dtype)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize(
|
|
"how, expected_data",
|
|
[
|
|
("inner", [[True, 1, 4], [False, 5, 3]]),
|
|
("outer", [[True, 1, 4], [False, 5, 3]]),
|
|
("left", [[True, 1, 4], [False, 5, 3]]),
|
|
("right", [[False, 5, 3], [True, 1, 4]]),
|
|
],
|
|
)
|
|
def test_merge_bool_dtype(self, how, expected_data):
|
|
# GH#40073
|
|
df1 = DataFrame({"A": [True, False], "B": [1, 5]})
|
|
df2 = DataFrame({"A": [False, True], "C": [3, 4]})
|
|
result = merge(df1, df2, how=how)
|
|
expected = DataFrame(expected_data, columns=["A", "B", "C"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_merge_ea_with_string(self, join_type, string_dtype):
|
|
# GH 43734 Avoid the use of `assign` with multi-index
|
|
df1 = DataFrame(
|
|
data={
|
|
("lvl0", "lvl1-a"): ["1", "2", "3", "4", None],
|
|
("lvl0", "lvl1-b"): ["4", "5", "6", "7", "8"],
|
|
},
|
|
dtype=pd.StringDtype(),
|
|
)
|
|
df1_copy = df1.copy()
|
|
df2 = DataFrame(
|
|
data={
|
|
("lvl0", "lvl1-a"): ["1", "2", "3", pd.NA, "5"],
|
|
("lvl0", "lvl1-c"): ["7", "8", "9", pd.NA, "11"],
|
|
},
|
|
dtype=string_dtype,
|
|
)
|
|
df2_copy = df2.copy()
|
|
merged = merge(left=df1, right=df2, on=[("lvl0", "lvl1-a")], how=join_type)
|
|
|
|
# No change in df1 and df2
|
|
tm.assert_frame_equal(df1, df1_copy)
|
|
tm.assert_frame_equal(df2, df2_copy)
|
|
|
|
# Check the expected types for the merged data frame
|
|
expected = Series(
|
|
[np.dtype("O"), pd.StringDtype(), np.dtype("O")],
|
|
index=MultiIndex.from_tuples(
|
|
[("lvl0", "lvl1-a"), ("lvl0", "lvl1-b"), ("lvl0", "lvl1-c")]
|
|
),
|
|
)
|
|
tm.assert_series_equal(merged.dtypes, expected)
|
|
|
|
|
|
@pytest.fixture
|
|
def left():
|
|
np.random.seed(1234)
|
|
return DataFrame(
|
|
{
|
|
"X": Series(np.random.choice(["foo", "bar"], size=(10,))).astype(
|
|
CDT(["foo", "bar"])
|
|
),
|
|
"Y": np.random.choice(["one", "two", "three"], size=(10,)),
|
|
}
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def right():
|
|
np.random.seed(1234)
|
|
return DataFrame(
|
|
{"X": Series(["foo", "bar"]).astype(CDT(["foo", "bar"])), "Z": [1, 2]}
|
|
)
|
|
|
|
|
|
class TestMergeCategorical:
|
|
def test_identical(self, left):
|
|
# merging on the same, should preserve dtypes
|
|
merged = merge(left, left, on="X")
|
|
result = merged.dtypes.sort_index()
|
|
expected = Series(
|
|
[CategoricalDtype(categories=["foo", "bar"]), np.dtype("O"), np.dtype("O")],
|
|
index=["X", "Y_x", "Y_y"],
|
|
)
|
|
tm.assert_series_equal(result, expected)
|
|
|
|
def test_basic(self, left, right):
|
|
# we have matching Categorical dtypes in X
|
|
# so should preserve the merged column
|
|
merged = merge(left, right, on="X")
|
|
result = merged.dtypes.sort_index()
|
|
expected = Series(
|
|
[
|
|
CategoricalDtype(categories=["foo", "bar"]),
|
|
np.dtype("O"),
|
|
np.dtype("int64"),
|
|
],
|
|
index=["X", "Y", "Z"],
|
|
)
|
|
tm.assert_series_equal(result, expected)
|
|
|
|
def test_merge_categorical(self):
|
|
# GH 9426
|
|
|
|
right = DataFrame(
|
|
{
|
|
"c": {0: "a", 1: "b", 2: "c", 3: "d", 4: "e"},
|
|
"d": {0: "null", 1: "null", 2: "null", 3: "null", 4: "null"},
|
|
}
|
|
)
|
|
left = DataFrame(
|
|
{
|
|
"a": {0: "f", 1: "f", 2: "f", 3: "f", 4: "f"},
|
|
"b": {0: "g", 1: "g", 2: "g", 3: "g", 4: "g"},
|
|
}
|
|
)
|
|
df = merge(left, right, how="left", left_on="b", right_on="c")
|
|
|
|
# object-object
|
|
expected = df.copy()
|
|
|
|
# object-cat
|
|
# note that we propagate the category
|
|
# because we don't have any matching rows
|
|
cright = right.copy()
|
|
cright["d"] = cright["d"].astype("category")
|
|
result = merge(left, cright, how="left", left_on="b", right_on="c")
|
|
expected["d"] = expected["d"].astype(CategoricalDtype(["null"]))
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
# cat-object
|
|
cleft = left.copy()
|
|
cleft["b"] = cleft["b"].astype("category")
|
|
result = merge(cleft, cright, how="left", left_on="b", right_on="c")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
# cat-cat
|
|
cright = right.copy()
|
|
cright["d"] = cright["d"].astype("category")
|
|
cleft = left.copy()
|
|
cleft["b"] = cleft["b"].astype("category")
|
|
result = merge(cleft, cright, how="left", left_on="b", right_on="c")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def tests_merge_categorical_unordered_equal(self):
|
|
# GH-19551
|
|
df1 = DataFrame(
|
|
{
|
|
"Foo": Categorical(["A", "B", "C"], categories=["A", "B", "C"]),
|
|
"Left": ["A0", "B0", "C0"],
|
|
}
|
|
)
|
|
|
|
df2 = DataFrame(
|
|
{
|
|
"Foo": Categorical(["C", "B", "A"], categories=["C", "B", "A"]),
|
|
"Right": ["C1", "B1", "A1"],
|
|
}
|
|
)
|
|
result = merge(df1, df2, on=["Foo"])
|
|
expected = DataFrame(
|
|
{
|
|
"Foo": Categorical(["A", "B", "C"]),
|
|
"Left": ["A0", "B0", "C0"],
|
|
"Right": ["A1", "B1", "C1"],
|
|
}
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
@pytest.mark.parametrize("ordered", [True, False])
|
|
def test_multiindex_merge_with_unordered_categoricalindex(self, ordered):
|
|
# GH 36973
|
|
pcat = CategoricalDtype(categories=["P2", "P1"], ordered=ordered)
|
|
df1 = DataFrame(
|
|
{
|
|
"id": ["C", "C", "D"],
|
|
"p": Categorical(["P2", "P1", "P2"], dtype=pcat),
|
|
"a": [0, 1, 2],
|
|
}
|
|
).set_index(["id", "p"])
|
|
df2 = DataFrame(
|
|
{
|
|
"id": ["A", "C", "C"],
|
|
"p": Categorical(["P2", "P2", "P1"], dtype=pcat),
|
|
"d1": [10, 11, 12],
|
|
}
|
|
).set_index(["id", "p"])
|
|
result = merge(df1, df2, how="left", left_index=True, right_index=True)
|
|
expected = DataFrame(
|
|
{
|
|
"id": ["C", "C", "D"],
|
|
"p": Categorical(["P2", "P1", "P2"], dtype=pcat),
|
|
"a": [0, 1, 2],
|
|
"d1": [11.0, 12.0, np.nan],
|
|
}
|
|
).set_index(["id", "p"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
def test_other_columns(self, left, right):
|
|
# non-merge columns should preserve if possible
|
|
right = right.assign(Z=right.Z.astype("category"))
|
|
|
|
merged = merge(left, right, on="X")
|
|
result = merged.dtypes.sort_index()
|
|
expected = Series(
|
|
[
|
|
CategoricalDtype(categories=["foo", "bar"]),
|
|
np.dtype("O"),
|
|
CategoricalDtype(categories=[1, 2]),
|
|
],
|
|
index=["X", "Y", "Z"],
|
|
)
|
|
tm.assert_series_equal(result, expected)
|
|
|
|
# categories are preserved
|
|
assert left.X.values._categories_match_up_to_permutation(merged.X.values)
|
|
assert right.Z.values._categories_match_up_to_permutation(merged.Z.values)
|
|
|
|
@pytest.mark.parametrize(
|
|
"change",
|
|
[
|
|
lambda x: x,
|
|
lambda x: x.astype(CDT(["foo", "bar", "bah"])),
|
|
lambda x: x.astype(CDT(ordered=True)),
|
|
],
|
|
)
|
|
def test_dtype_on_merged_different(self, change, join_type, left, right):
|
|
# our merging columns, X now has 2 different dtypes
|
|
# so we must be object as a result
|
|
|
|
X = change(right.X.astype("object"))
|
|
right = right.assign(X=X)
|
|
assert is_categorical_dtype(left.X.values.dtype)
|
|
# assert not left.X.values._categories_match_up_to_permutation(right.X.values)
|
|
|
|
merged = merge(left, right, on="X", how=join_type)
|
|
|
|
result = merged.dtypes.sort_index()
|
|
expected = Series(
|
|
[np.dtype("O"), np.dtype("O"), np.dtype("int64")], index=["X", "Y", "Z"]
|
|
)
|
|
tm.assert_series_equal(result, expected)
|
|
|
|
def test_self_join_multiple_categories(self):
|
|
# GH 16767
|
|
# non-duplicates should work with multiple categories
|
|
m = 5
|
|
df = DataFrame(
|
|
{
|
|
"a": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"] * m,
|
|
"b": ["t", "w", "x", "y", "z"] * 2 * m,
|
|
"c": [
|
|
letter
|
|
for each in ["m", "n", "u", "p", "o"]
|
|
for letter in [each] * 2 * m
|
|
],
|
|
"d": [
|
|
letter
|
|
for each in [
|
|
"aa",
|
|
"bb",
|
|
"cc",
|
|
"dd",
|
|
"ee",
|
|
"ff",
|
|
"gg",
|
|
"hh",
|
|
"ii",
|
|
"jj",
|
|
]
|
|
for letter in [each] * m
|
|
],
|
|
}
|
|
)
|
|
|
|
# change them all to categorical variables
|
|
df = df.apply(lambda x: x.astype("category"))
|
|
|
|
# self-join should equal ourselves
|
|
result = merge(df, df, on=list(df.columns))
|
|
|
|
tm.assert_frame_equal(result, df)
|
|
|
|
def test_dtype_on_categorical_dates(self):
|
|
# GH 16900
|
|
# dates should not be coerced to ints
|
|
|
|
df = DataFrame(
|
|
[[date(2001, 1, 1), 1.1], [date(2001, 1, 2), 1.3]], columns=["date", "num2"]
|
|
)
|
|
df["date"] = df["date"].astype("category")
|
|
|
|
df2 = DataFrame(
|
|
[[date(2001, 1, 1), 1.3], [date(2001, 1, 3), 1.4]], columns=["date", "num4"]
|
|
)
|
|
df2["date"] = df2["date"].astype("category")
|
|
|
|
expected_outer = DataFrame(
|
|
[
|
|
[pd.Timestamp("2001-01-01").date(), 1.1, 1.3],
|
|
[pd.Timestamp("2001-01-02").date(), 1.3, np.nan],
|
|
[pd.Timestamp("2001-01-03").date(), np.nan, 1.4],
|
|
],
|
|
columns=["date", "num2", "num4"],
|
|
)
|
|
result_outer = merge(df, df2, how="outer", on=["date"])
|
|
tm.assert_frame_equal(result_outer, expected_outer)
|
|
|
|
expected_inner = DataFrame(
|
|
[[pd.Timestamp("2001-01-01").date(), 1.1, 1.3]],
|
|
columns=["date", "num2", "num4"],
|
|
)
|
|
result_inner = merge(df, df2, how="inner", on=["date"])
|
|
tm.assert_frame_equal(result_inner, expected_inner)
|
|
|
|
@pytest.mark.parametrize("ordered", [True, False])
|
|
@pytest.mark.parametrize(
|
|
"category_column,categories,expected_categories",
|
|
[
|
|
([False, True, True, False], [True, False], [True, False]),
|
|
([2, 1, 1, 2], [1, 2], [1, 2]),
|
|
(["False", "True", "True", "False"], ["True", "False"], ["True", "False"]),
|
|
],
|
|
)
|
|
def test_merging_with_bool_or_int_cateorical_column(
|
|
self, category_column, categories, expected_categories, ordered
|
|
):
|
|
# GH 17187
|
|
# merging with a boolean/int categorical column
|
|
df1 = DataFrame({"id": [1, 2, 3, 4], "cat": category_column})
|
|
df1["cat"] = df1["cat"].astype(CDT(categories, ordered=ordered))
|
|
df2 = DataFrame({"id": [2, 4], "num": [1, 9]})
|
|
result = df1.merge(df2)
|
|
expected = DataFrame({"id": [2, 4], "cat": expected_categories, "num": [1, 9]})
|
|
expected["cat"] = expected["cat"].astype(CDT(categories, ordered=ordered))
|
|
tm.assert_frame_equal(expected, result)
|
|
|
|
def test_merge_on_int_array(self):
|
|
# GH 23020
|
|
df = DataFrame({"A": Series([1, 2, np.nan], dtype="Int64"), "B": 1})
|
|
result = merge(df, df, on="A")
|
|
expected = DataFrame(
|
|
{"A": Series([1, 2, np.nan], dtype="Int64"), "B_x": 1, "B_y": 1}
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.fixture
|
|
def left_df():
|
|
return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
|
|
|
|
|
|
@pytest.fixture
|
|
def right_df():
|
|
return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
|
|
|
|
|
|
class TestMergeOnIndexes:
|
|
@pytest.mark.parametrize(
|
|
"how, sort, expected",
|
|
[
|
|
("inner", False, DataFrame({"a": [20, 10], "b": [200, 100]}, index=[2, 1])),
|
|
("inner", True, DataFrame({"a": [10, 20], "b": [100, 200]}, index=[1, 2])),
|
|
(
|
|
"left",
|
|
False,
|
|
DataFrame({"a": [20, 10, 0], "b": [200, 100, np.nan]}, index=[2, 1, 0]),
|
|
),
|
|
(
|
|
"left",
|
|
True,
|
|
DataFrame({"a": [0, 10, 20], "b": [np.nan, 100, 200]}, index=[0, 1, 2]),
|
|
),
|
|
(
|
|
"right",
|
|
False,
|
|
DataFrame(
|
|
{"a": [np.nan, 10, 20], "b": [300, 100, 200]}, index=[3, 1, 2]
|
|
),
|
|
),
|
|
(
|
|
"right",
|
|
True,
|
|
DataFrame(
|
|
{"a": [10, 20, np.nan], "b": [100, 200, 300]}, index=[1, 2, 3]
|
|
),
|
|
),
|
|
(
|
|
"outer",
|
|
False,
|
|
DataFrame(
|
|
{"a": [0, 10, 20, np.nan], "b": [np.nan, 100, 200, 300]},
|
|
index=[0, 1, 2, 3],
|
|
),
|
|
),
|
|
(
|
|
"outer",
|
|
True,
|
|
DataFrame(
|
|
{"a": [0, 10, 20, np.nan], "b": [np.nan, 100, 200, 300]},
|
|
index=[0, 1, 2, 3],
|
|
),
|
|
),
|
|
],
|
|
)
|
|
def test_merge_on_indexes(self, left_df, right_df, how, sort, expected):
|
|
result = merge(
|
|
left_df, right_df, left_index=True, right_index=True, how=how, sort=sort
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"index",
|
|
[
|
|
CategoricalIndex(["A", "B"], categories=["A", "B"], name="index_col"),
|
|
Float64Index([1.0, 2.0], name="index_col"),
|
|
Int64Index([1, 2], name="index_col"),
|
|
UInt64Index([1, 2], name="index_col"),
|
|
RangeIndex(start=0, stop=2, name="index_col"),
|
|
DatetimeIndex(["2018-01-01", "2018-01-02"], name="index_col"),
|
|
],
|
|
ids=lambda x: type(x).__name__,
|
|
)
|
|
def test_merge_index_types(index):
|
|
# gh-20777
|
|
# assert key access is consistent across index types
|
|
left = DataFrame({"left_data": [1, 2]}, index=index)
|
|
right = DataFrame({"right_data": [1.0, 2.0]}, index=index)
|
|
|
|
result = left.merge(right, on=["index_col"])
|
|
|
|
expected = DataFrame({"left_data": [1, 2], "right_data": [1.0, 2.0]}, index=index)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"on,left_on,right_on,left_index,right_index,nm",
|
|
[
|
|
(["outer", "inner"], None, None, False, False, "B"),
|
|
(None, None, None, True, True, "B"),
|
|
(None, ["outer", "inner"], None, False, True, "B"),
|
|
(None, None, ["outer", "inner"], True, False, "B"),
|
|
(["outer", "inner"], None, None, False, False, None),
|
|
(None, None, None, True, True, None),
|
|
(None, ["outer", "inner"], None, False, True, None),
|
|
(None, None, ["outer", "inner"], True, False, None),
|
|
],
|
|
)
|
|
def test_merge_series(on, left_on, right_on, left_index, right_index, nm):
|
|
# GH 21220
|
|
a = DataFrame(
|
|
{"A": [1, 2, 3, 4]},
|
|
index=MultiIndex.from_product([["a", "b"], [0, 1]], names=["outer", "inner"]),
|
|
)
|
|
b = Series(
|
|
[1, 2, 3, 4],
|
|
index=MultiIndex.from_product([["a", "b"], [1, 2]], names=["outer", "inner"]),
|
|
name=nm,
|
|
)
|
|
expected = DataFrame(
|
|
{"A": [2, 4], "B": [1, 3]},
|
|
index=MultiIndex.from_product([["a", "b"], [1]], names=["outer", "inner"]),
|
|
)
|
|
if nm is not None:
|
|
result = merge(
|
|
a,
|
|
b,
|
|
on=on,
|
|
left_on=left_on,
|
|
right_on=right_on,
|
|
left_index=left_index,
|
|
right_index=right_index,
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
else:
|
|
msg = "Cannot merge a Series without a name"
|
|
with pytest.raises(ValueError, match=msg):
|
|
result = merge(
|
|
a,
|
|
b,
|
|
on=on,
|
|
left_on=left_on,
|
|
right_on=right_on,
|
|
left_index=left_index,
|
|
right_index=right_index,
|
|
)
|
|
|
|
|
|
def test_merge_series_multilevel():
|
|
# GH#47946
|
|
a = DataFrame(
|
|
{"A": [1, 2, 3, 4]},
|
|
index=MultiIndex.from_product([["a", "b"], [0, 1]], names=["outer", "inner"]),
|
|
)
|
|
b = Series(
|
|
[1, 2, 3, 4],
|
|
index=MultiIndex.from_product([["a", "b"], [1, 2]], names=["outer", "inner"]),
|
|
name=("B", "C"),
|
|
)
|
|
expected = DataFrame(
|
|
{"A": [2, 4], ("B", "C"): [1, 3]},
|
|
index=MultiIndex.from_product([["a", "b"], [1]], names=["outer", "inner"]),
|
|
)
|
|
with tm.assert_produces_warning(FutureWarning):
|
|
result = merge(a, b, on=["outer", "inner"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"col1, col2, kwargs, expected_cols",
|
|
[
|
|
(0, 0, {"suffixes": ("", "_dup")}, ["0", "0_dup"]),
|
|
(0, 0, {"suffixes": (None, "_dup")}, [0, "0_dup"]),
|
|
(0, 0, {"suffixes": ("_x", "_y")}, ["0_x", "0_y"]),
|
|
(0, 0, {"suffixes": ["_x", "_y"]}, ["0_x", "0_y"]),
|
|
("a", 0, {"suffixes": (None, "_y")}, ["a", 0]),
|
|
(0.0, 0.0, {"suffixes": ("_x", None)}, ["0.0_x", 0.0]),
|
|
("b", "b", {"suffixes": (None, "_y")}, ["b", "b_y"]),
|
|
("a", "a", {"suffixes": ("_x", None)}, ["a_x", "a"]),
|
|
("a", "b", {"suffixes": ("_x", None)}, ["a", "b"]),
|
|
("a", "a", {"suffixes": (None, "_x")}, ["a", "a_x"]),
|
|
(0, 0, {"suffixes": ("_a", None)}, ["0_a", 0]),
|
|
("a", "a", {}, ["a_x", "a_y"]),
|
|
(0, 0, {}, ["0_x", "0_y"]),
|
|
],
|
|
)
|
|
def test_merge_suffix(col1, col2, kwargs, expected_cols):
|
|
# issue: 24782
|
|
a = DataFrame({col1: [1, 2, 3]})
|
|
b = DataFrame({col2: [4, 5, 6]})
|
|
|
|
expected = DataFrame([[1, 4], [2, 5], [3, 6]], columns=expected_cols)
|
|
|
|
result = a.merge(b, left_index=True, right_index=True, **kwargs)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
result = merge(a, b, left_index=True, right_index=True, **kwargs)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"how,expected",
|
|
[
|
|
(
|
|
"right",
|
|
DataFrame(
|
|
{"A": [100, 200, 300], "B1": [60, 70, np.nan], "B2": [600, 700, 800]}
|
|
),
|
|
),
|
|
(
|
|
"outer",
|
|
DataFrame(
|
|
{
|
|
"A": [100, 200, 1, 300],
|
|
"B1": [60, 70, 80, np.nan],
|
|
"B2": [600, 700, np.nan, 800],
|
|
}
|
|
),
|
|
),
|
|
],
|
|
)
|
|
def test_merge_duplicate_suffix(how, expected):
|
|
left_df = DataFrame({"A": [100, 200, 1], "B": [60, 70, 80]})
|
|
right_df = DataFrame({"A": [100, 200, 300], "B": [600, 700, 800]})
|
|
result = merge(left_df, right_df, on="A", how=how, suffixes=("_x", "_x"))
|
|
expected.columns = ["A", "B_x", "B_x"]
|
|
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"col1, col2, suffixes",
|
|
[("a", "a", (None, None)), ("a", "a", ("", None)), (0, 0, (None, ""))],
|
|
)
|
|
def test_merge_suffix_error(col1, col2, suffixes):
|
|
# issue: 24782
|
|
a = DataFrame({col1: [1, 2, 3]})
|
|
b = DataFrame({col2: [3, 4, 5]})
|
|
|
|
# TODO: might reconsider current raise behaviour, see issue 24782
|
|
msg = "columns overlap but no suffix specified"
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
|
|
|
|
|
|
@pytest.mark.parametrize("suffixes", [{"left", "right"}, {"left": 0, "right": 0}])
|
|
def test_merge_suffix_warns(suffixes):
|
|
a = DataFrame({"a": [1, 2, 3]})
|
|
b = DataFrame({"b": [3, 4, 5]})
|
|
|
|
with tm.assert_produces_warning(FutureWarning):
|
|
merge(a, b, left_index=True, right_index=True, suffixes={"left", "right"})
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"col1, col2, suffixes, msg",
|
|
[
|
|
("a", "a", ("a", "b", "c"), r"too many values to unpack \(expected 2\)"),
|
|
("a", "a", tuple("a"), r"not enough values to unpack \(expected 2, got 1\)"),
|
|
],
|
|
)
|
|
def test_merge_suffix_length_error(col1, col2, suffixes, msg):
|
|
a = DataFrame({col1: [1, 2, 3]})
|
|
b = DataFrame({col2: [3, 4, 5]})
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
|
|
|
|
|
|
@pytest.mark.parametrize("cat_dtype", ["one", "two"])
|
|
@pytest.mark.parametrize("reverse", [True, False])
|
|
def test_merge_equal_cat_dtypes(cat_dtype, reverse):
|
|
# see gh-22501
|
|
cat_dtypes = {
|
|
"one": CategoricalDtype(categories=["a", "b", "c"], ordered=False),
|
|
"two": CategoricalDtype(categories=["a", "b", "c"], ordered=False),
|
|
}
|
|
|
|
df1 = DataFrame(
|
|
{"foo": Series(["a", "b", "c"]).astype(cat_dtypes["one"]), "left": [1, 2, 3]}
|
|
).set_index("foo")
|
|
|
|
data_foo = ["a", "b", "c"]
|
|
data_right = [1, 2, 3]
|
|
|
|
if reverse:
|
|
data_foo.reverse()
|
|
data_right.reverse()
|
|
|
|
df2 = DataFrame(
|
|
{"foo": Series(data_foo).astype(cat_dtypes[cat_dtype]), "right": data_right}
|
|
).set_index("foo")
|
|
|
|
result = df1.merge(df2, left_index=True, right_index=True)
|
|
|
|
expected = DataFrame(
|
|
{
|
|
"left": [1, 2, 3],
|
|
"right": [1, 2, 3],
|
|
"foo": Series(["a", "b", "c"]).astype(cat_dtypes["one"]),
|
|
}
|
|
).set_index("foo")
|
|
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_equal_cat_dtypes2():
|
|
# see gh-22501
|
|
cat_dtype = CategoricalDtype(categories=["a", "b", "c"], ordered=False)
|
|
|
|
# Test Data
|
|
df1 = DataFrame(
|
|
{"foo": Series(["a", "b"]).astype(cat_dtype), "left": [1, 2]}
|
|
).set_index("foo")
|
|
|
|
df2 = DataFrame(
|
|
{"foo": Series(["a", "b", "c"]).astype(cat_dtype), "right": [3, 2, 1]}
|
|
).set_index("foo")
|
|
|
|
result = df1.merge(df2, left_index=True, right_index=True)
|
|
|
|
expected = DataFrame(
|
|
{"left": [1, 2], "right": [3, 2], "foo": Series(["a", "b"]).astype(cat_dtype)}
|
|
).set_index("foo")
|
|
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_on_cat_and_ext_array():
|
|
# GH 28668
|
|
right = DataFrame(
|
|
{"a": Series([pd.Interval(0, 1), pd.Interval(1, 2)], dtype="interval")}
|
|
)
|
|
left = right.copy()
|
|
left["a"] = left["a"].astype("category")
|
|
|
|
result = merge(left, right, how="inner", on="a")
|
|
expected = right.copy()
|
|
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_multiindex_columns():
|
|
# Issue #28518
|
|
# Verify that merging two dataframes give the expected labels
|
|
# The original cause of this issue come from a bug lexsort_depth and is tested in
|
|
# test_lexsort_depth
|
|
|
|
letters = ["a", "b", "c", "d"]
|
|
numbers = ["1", "2", "3"]
|
|
index = MultiIndex.from_product((letters, numbers), names=["outer", "inner"])
|
|
|
|
frame_x = DataFrame(columns=index)
|
|
frame_x["id"] = ""
|
|
frame_y = DataFrame(columns=index)
|
|
frame_y["id"] = ""
|
|
|
|
l_suf = "_x"
|
|
r_suf = "_y"
|
|
result = frame_x.merge(frame_y, on="id", suffixes=((l_suf, r_suf)))
|
|
|
|
# Constructing the expected results
|
|
expected_labels = [letter + l_suf for letter in letters] + [
|
|
letter + r_suf for letter in letters
|
|
]
|
|
expected_index = MultiIndex.from_product(
|
|
[expected_labels, numbers], names=["outer", "inner"]
|
|
)
|
|
expected = DataFrame(columns=expected_index)
|
|
expected["id"] = ""
|
|
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_datetime_upcast_dtype():
|
|
# https://github.com/pandas-dev/pandas/issues/31208
|
|
df1 = DataFrame({"x": ["a", "b", "c"], "y": ["1", "2", "4"]})
|
|
df2 = DataFrame(
|
|
{"y": ["1", "2", "3"], "z": pd.to_datetime(["2000", "2001", "2002"])}
|
|
)
|
|
result = merge(df1, df2, how="left", on="y")
|
|
expected = DataFrame(
|
|
{
|
|
"x": ["a", "b", "c"],
|
|
"y": ["1", "2", "4"],
|
|
"z": pd.to_datetime(["2000", "2001", "NaT"]),
|
|
}
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("n_categories", [5, 128])
|
|
def test_categorical_non_unique_monotonic(n_categories):
|
|
# GH 28189
|
|
# With n_categories as 5, we test the int8 case is hit in libjoin,
|
|
# with n_categories as 128 we test the int16 case.
|
|
left_index = CategoricalIndex([0] + list(range(n_categories)))
|
|
df1 = DataFrame(range(n_categories + 1), columns=["value"], index=left_index)
|
|
df2 = DataFrame(
|
|
[[6]],
|
|
columns=["value"],
|
|
index=CategoricalIndex([0], categories=np.arange(n_categories)),
|
|
)
|
|
|
|
result = merge(df1, df2, how="left", left_index=True, right_index=True)
|
|
expected = DataFrame(
|
|
[[i, 6.0] if i < 2 else [i, np.nan] for i in range(n_categories + 1)],
|
|
columns=["value_x", "value_y"],
|
|
index=left_index,
|
|
)
|
|
tm.assert_frame_equal(expected, result)
|
|
|
|
|
|
def test_merge_join_categorical_multiindex():
|
|
# From issue 16627
|
|
a = {
|
|
"Cat1": Categorical(["a", "b", "a", "c", "a", "b"], ["a", "b", "c"]),
|
|
"Int1": [0, 1, 0, 1, 0, 0],
|
|
}
|
|
a = DataFrame(a)
|
|
|
|
b = {
|
|
"Cat": Categorical(["a", "b", "c", "a", "b", "c"], ["a", "b", "c"]),
|
|
"Int": [0, 0, 0, 1, 1, 1],
|
|
"Factor": [1.1, 1.2, 1.3, 1.4, 1.5, 1.6],
|
|
}
|
|
b = DataFrame(b).set_index(["Cat", "Int"])["Factor"]
|
|
|
|
expected = merge(
|
|
a,
|
|
b.reset_index(),
|
|
left_on=["Cat1", "Int1"],
|
|
right_on=["Cat", "Int"],
|
|
how="left",
|
|
)
|
|
expected = expected.drop(["Cat", "Int"], axis=1)
|
|
result = a.join(b, on=["Cat1", "Int1"])
|
|
tm.assert_frame_equal(expected, result)
|
|
|
|
# Same test, but with ordered categorical
|
|
a = {
|
|
"Cat1": Categorical(
|
|
["a", "b", "a", "c", "a", "b"], ["b", "a", "c"], ordered=True
|
|
),
|
|
"Int1": [0, 1, 0, 1, 0, 0],
|
|
}
|
|
a = DataFrame(a)
|
|
|
|
b = {
|
|
"Cat": Categorical(
|
|
["a", "b", "c", "a", "b", "c"], ["b", "a", "c"], ordered=True
|
|
),
|
|
"Int": [0, 0, 0, 1, 1, 1],
|
|
"Factor": [1.1, 1.2, 1.3, 1.4, 1.5, 1.6],
|
|
}
|
|
b = DataFrame(b).set_index(["Cat", "Int"])["Factor"]
|
|
|
|
expected = merge(
|
|
a,
|
|
b.reset_index(),
|
|
left_on=["Cat1", "Int1"],
|
|
right_on=["Cat", "Int"],
|
|
how="left",
|
|
)
|
|
expected = expected.drop(["Cat", "Int"], axis=1)
|
|
result = a.join(b, on=["Cat1", "Int1"])
|
|
tm.assert_frame_equal(expected, result)
|
|
|
|
|
|
@pytest.mark.parametrize("func", ["merge", "merge_asof"])
|
|
@pytest.mark.parametrize(
|
|
("kwargs", "err_msg"),
|
|
[
|
|
({"left_on": "a", "left_index": True}, ["left_on", "left_index"]),
|
|
({"right_on": "a", "right_index": True}, ["right_on", "right_index"]),
|
|
],
|
|
)
|
|
def test_merge_join_cols_error_reporting_duplicates(func, kwargs, err_msg):
|
|
# GH: 16228
|
|
left = DataFrame({"a": [1, 2], "b": [3, 4]})
|
|
right = DataFrame({"a": [1, 1], "c": [5, 6]})
|
|
msg = rf'Can only pass argument "{err_msg[0]}" OR "{err_msg[1]}" not both\.'
|
|
with pytest.raises(MergeError, match=msg):
|
|
getattr(pd, func)(left, right, **kwargs)
|
|
|
|
|
|
@pytest.mark.parametrize("func", ["merge", "merge_asof"])
|
|
@pytest.mark.parametrize(
|
|
("kwargs", "err_msg"),
|
|
[
|
|
({"left_on": "a"}, ["right_on", "right_index"]),
|
|
({"right_on": "a"}, ["left_on", "left_index"]),
|
|
],
|
|
)
|
|
def test_merge_join_cols_error_reporting_missing(func, kwargs, err_msg):
|
|
# GH: 16228
|
|
left = DataFrame({"a": [1, 2], "b": [3, 4]})
|
|
right = DataFrame({"a": [1, 1], "c": [5, 6]})
|
|
msg = rf'Must pass "{err_msg[0]}" OR "{err_msg[1]}"\.'
|
|
with pytest.raises(MergeError, match=msg):
|
|
getattr(pd, func)(left, right, **kwargs)
|
|
|
|
|
|
@pytest.mark.parametrize("func", ["merge", "merge_asof"])
|
|
@pytest.mark.parametrize(
|
|
"kwargs",
|
|
[
|
|
{"right_index": True},
|
|
{"left_index": True},
|
|
],
|
|
)
|
|
def test_merge_join_cols_error_reporting_on_and_index(func, kwargs):
|
|
# GH: 16228
|
|
left = DataFrame({"a": [1, 2], "b": [3, 4]})
|
|
right = DataFrame({"a": [1, 1], "c": [5, 6]})
|
|
msg = (
|
|
r'Can only pass argument "on" OR "left_index" '
|
|
r'and "right_index", not a combination of both\.'
|
|
)
|
|
with pytest.raises(MergeError, match=msg):
|
|
getattr(pd, func)(left, right, on="a", **kwargs)
|
|
|
|
|
|
def test_merge_right_left_index():
|
|
# GH#38616
|
|
left = DataFrame({"x": [1, 1], "z": ["foo", "foo"]})
|
|
right = DataFrame({"x": [1, 1], "z": ["foo", "foo"]})
|
|
result = merge(left, right, how="right", left_index=True, right_on="x")
|
|
expected = DataFrame(
|
|
{
|
|
"x": [1, 1],
|
|
"x_x": [1, 1],
|
|
"z_x": ["foo", "foo"],
|
|
"x_y": [1, 1],
|
|
"z_y": ["foo", "foo"],
|
|
}
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_result_empty_index_and_on():
|
|
# GH#33814
|
|
df1 = DataFrame({"a": [1], "b": [2]}).set_index(["a", "b"])
|
|
df2 = DataFrame({"b": [1]}).set_index(["b"])
|
|
expected = DataFrame({"a": [], "b": []}, dtype=np.int64).set_index(["a", "b"])
|
|
result = merge(df1, df2, left_on=["b"], right_index=True)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
result = merge(df2, df1, left_index=True, right_on=["b"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_suffixes_produce_dup_columns_warns():
|
|
# GH#22818
|
|
left = DataFrame({"a": [1, 2, 3], "b": 1, "b_x": 2})
|
|
right = DataFrame({"a": [1, 2, 3], "b": 2})
|
|
expected = DataFrame(
|
|
[[1, 1, 2, 2], [2, 1, 2, 2], [3, 1, 2, 2]], columns=["a", "b_x", "b_x", "b_y"]
|
|
)
|
|
with tm.assert_produces_warning(FutureWarning):
|
|
result = merge(left, right, on="a")
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
with tm.assert_produces_warning(FutureWarning):
|
|
merge(right, left, on="a", suffixes=("_y", "_x"))
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_duplicate_columns_with_suffix_no_warning():
|
|
# GH#22818
|
|
# Do not raise warning when duplicates are caused by duplicates in origin
|
|
left = DataFrame([[1, 1, 1], [2, 2, 2]], columns=["a", "b", "b"])
|
|
right = DataFrame({"a": [1, 3], "b": 2})
|
|
result = merge(left, right, on="a")
|
|
expected = DataFrame([[1, 1, 1, 2]], columns=["a", "b_x", "b_x", "b_y"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_duplicate_columns_with_suffix_causing_another_duplicate():
|
|
# GH#22818
|
|
# This should raise warning because suffixes cause another collision
|
|
left = DataFrame([[1, 1, 1, 1], [2, 2, 2, 2]], columns=["a", "b", "b", "b_x"])
|
|
right = DataFrame({"a": [1, 3], "b": 2})
|
|
with tm.assert_produces_warning(FutureWarning):
|
|
result = merge(left, right, on="a")
|
|
expected = DataFrame([[1, 1, 1, 1, 2]], columns=["a", "b_x", "b_x", "b_x", "b_y"])
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_string_float_column_result():
|
|
# GH 13353
|
|
df1 = DataFrame([[1, 2], [3, 4]], columns=pd.Index(["a", 114.0]))
|
|
df2 = DataFrame([[9, 10], [11, 12]], columns=["x", "y"])
|
|
result = merge(df2, df1, how="inner", left_index=True, right_index=True)
|
|
expected = DataFrame(
|
|
[[9, 10, 1, 2], [11, 12, 3, 4]], columns=pd.Index(["x", "y", "a", 114.0])
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_mergeerror_on_left_index_mismatched_dtypes():
|
|
# GH 22449
|
|
df_1 = DataFrame(data=["X"], columns=["C"], index=[22])
|
|
df_2 = DataFrame(data=["X"], columns=["C"], index=[999])
|
|
with pytest.raises(MergeError, match="Can only pass argument"):
|
|
merge(df_1, df_2, on=["C"], left_index=True)
|
|
|
|
|
|
@pytest.mark.parametrize("dtype", [None, "Int64"])
|
|
def test_merge_outer_with_NaN(dtype):
|
|
# GH#43550
|
|
left = DataFrame({"key": [1, 2], "col1": [1, 2]}, dtype=dtype)
|
|
right = DataFrame({"key": [np.nan, np.nan], "col2": [3, 4]}, dtype=dtype)
|
|
result = merge(left, right, on="key", how="outer")
|
|
expected = DataFrame(
|
|
{
|
|
"key": [1, 2, np.nan, np.nan],
|
|
"col1": [1, 2, np.nan, np.nan],
|
|
"col2": [np.nan, np.nan, 3, 4],
|
|
},
|
|
dtype=dtype,
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
# switch left and right
|
|
result = merge(right, left, on="key", how="outer")
|
|
expected = DataFrame(
|
|
{
|
|
"key": [np.nan, np.nan, 1, 2],
|
|
"col2": [3, 4, np.nan, np.nan],
|
|
"col1": [np.nan, np.nan, 1, 2],
|
|
},
|
|
dtype=dtype,
|
|
)
|
|
tm.assert_frame_equal(result, expected)
|
|
|
|
|
|
def test_merge_different_index_names():
|
|
# GH#45094
|
|
left = DataFrame({"a": [1]}, index=pd.Index([1], name="c"))
|
|
right = DataFrame({"a": [1]}, index=pd.Index([1], name="d"))
|
|
result = merge(left, right, left_on="c", right_on="d")
|
|
expected = DataFrame({"a_x": [1], "a_y": 1})
|
|
tm.assert_frame_equal(result, expected)
|