ENH: anti joins

asv_bench/benchmarks/join_merge.py

@@ -272,10 +272,13 @@ def time_merge_dataframe_empty_left(self, sort):
     def time_merge_dataframes_cross(self, sort):
         merge(self.left.loc[:2000], self.right.loc[:2000], how="cross", sort=sort)
 
+    def time_merge_dataframes_anti(self, sort):
+        merge(self.left, self.right, how="anti_left", sort=sort)
+
 
 class I8Merge:
 
-    params = ["inner", "outer", "left", "right"]
+    params = ["inner", "outer", "left", "right", "anti_left", "anti_right", "anti_full"]
     param_names = ["how"]
 
     def setup(self, how):
@@ -452,7 +455,7 @@ class MergeMultiIndex:
             ("datetime64[ns]", "int64"),
             ("Int64", "Int64"),
         ],
-        ["left", "right", "inner", "outer"],
+        ["left", "right", "inner", "outer", "anti_left", "anti_right", "anti_full"],
     ]
     param_names = ["dtypes", "how"]
 

doc/source/getting_started/comparison/includes/merge.rst

@@ -15,3 +15,12 @@ data does not have to be sorted ahead of time, and different join types are acco
 
    outer_join = df1.merge(df2, on=["key"], how="outer")
    outer_join
+
+   anti_left_join = df1.merge(df2, on=["key"], how="anti_left")
+   anti_left_join
+
+   anti_right_join = df1.merge(df2, on=["key"], how="anti_right")
+   anti_right_join
+
+   anti_full_join = df1.merge(df2, on=["key"], how="anti_full")
+   anti_full_join

doc/source/whatsnew/v2.0.0.rst

@@ -62,6 +62,7 @@ Other enhancements
 - Fix ``test`` optional_extra by adding missing test package ``pytest-asyncio`` (:issue:`48361`)
 - :func:`DataFrame.astype` exception message thrown improved to include column name when type conversion is not possible. (:issue:`47571`)
 - :meth:`DataFrame.to_json` now supports a ``mode`` keyword with supported inputs 'w' and 'a'. Defaulting to 'w', 'a' can be used when lines=True and orient='records' to append record oriented json lines to an existing json file. (:issue:`35849`)
+- :meth:`DataFrame.join` now supports ``how`` with ``anti_left``, ``anti_right`` and ``anti_full`` (:issue:`42916`)
 - Added ``name`` parameter to :meth:`IntervalIndex.from_breaks`, :meth:`IntervalIndex.from_arrays` and :meth:`IntervalIndex.from_tuples` (:issue:`48911`)
 
 .. ---------------------------------------------------------------------------

pandas/core/frame.py

@@ -290,7 +290,8 @@
 ----------%s
 right : DataFrame or named Series
     Object to merge with.
-how : {'left', 'right', 'outer', 'inner', 'cross'}, default 'inner'
+how : {'left', 'right', 'outer', 'inner', 'cross', 'anti_left', \
+'anti_right', 'anti_full'}, default 'inner'
     Type of merge to be performed.
 
     * left: use only keys from left frame, similar to a SQL left outer join;
@@ -305,6 +306,15 @@
       of the left keys.
 
       .. versionadded:: 1.2.0
+    * anti_left: use only keys from left frame that are absent in right
+      frame; preserve key order.
+    * anti_right: use keys from the right frame that are absent in the
+      left frame; preserve key order.
+    * anti_full: use keys from  the right frame that are absent in the
+      left frame, and the keys in the left frame that are absent in the
+      right frame; sort keys lexicographically.
+
+      .. versionadded:: 2.0.0
 
 on : label or list
     Column or index level names to join on. These must be found in both
@@ -464,6 +474,33 @@
 1   foo      8
 2   bar      7
 3   bar      8
+
+>>> df1 = pd.DataFrame({"A": [1, 2, 3], "C": [5, 6, 7]})
+>>> df2 = pd. DataFrame({"B": [1, 2, 4], "C": [7, 8, 9]})
+>>> df1
+   A  C
+0  1  5
+1  2  6
+2  3  7
+>>> df2
+   B  C
+0  1  7
+1  2  8
+2  4  9
+>>> df1.merge(df2, on="C", how="anti_left")
+   A  C   B
+0  1  5 NaN
+1  2  6 NaN
+>>> df1.merge(df2, on="C", how="anti_right")
+    A  C  B
+0 NaN  8  2
+1 NaN  9  4
+>>> df1.merge(df2, on="C", how="anti_full")
+     A  C    B
+0  1.0  5  NaN
+1  2.0  6  NaN
+2  NaN  8  2.0
+3  NaN  9  4.0
 """
 
 

pandas/core/reshape/merge.py

@@ -1014,6 +1014,43 @@ def _get_join_info(
         left_ax = self.left.axes[self.axis]
         right_ax = self.right.axes[self.axis]
 
+        if self.how in ["anti_left", "anti_right", "anti_full"]:
+            how_dict = {
+                "anti_left": "left",
+                "anti_right": "right",
+                "anti_full": "outer",
+            }
+            self.how = how_dict[self.how]
+            if self.left_index and self.right_index:
+                # Merge using `right_index` and `left_index`
+                left_ax = self.left.index[~self.left.index.isin(self.right.index)]
+                right_ax = self.right.index[~self.right.index.isin(self.left.index)]
+                self.left = self.left.loc[left_ax]
+                self.right = self.right.loc[right_ax]
+            elif self.on is not None or (
+                self.left_on is not None and self.right_on is not None
+            ):
+                # Merge using `on` or `left_on` and `right_on`
+                _left = [
+                    ~Index(self.left_join_keys[x]).isin(Index(self.right_join_keys[x]))
+                    for x in range(len(self.left_join_keys))
+                ]
+                _right = [
+                    ~Index(self.right_join_keys[x]).isin(Index(self.left_join_keys[x]))
+                    for x in range(len(self.left_join_keys))
+                ]
+                self.left = self.left[np.sum(np.stack(_left, axis=0), axis=0) > 0]
+                self.right = self.right[np.sum(np.stack(_right, axis=0), axis=0) > 0]
+
+                self.left_join_keys = [
+                    x[np.sum(np.stack(_left, axis=0), axis=0) > 0]
+                    for x in self.left_join_keys
+                ]
+                self.right_join_keys = [
+                    x[np.sum(np.stack(_right, axis=0), axis=0) > 0]
+                    for x in self.right_join_keys
+                ]
+
         if self.left_index and self.right_index and self.how != "asof":
             join_index, left_indexer, right_indexer = left_ax.join(
                 right_ax, how=self.how, return_indexers=True, sort=self.sort