feat(selectors): add Selector.__xor__ for symmetric difference

Author: SAY-5

narwhals/_compliant/selectors.py

@@ -310,6 +310,45 @@ def names(df: FrameT) -> Sequence[str]:
             return self.selectors._selector.from_callables(series, names, context=self)
         return self._to_expr() & other
 
+    @overload  # type: ignore[override]
+    def __xor__(self, other: Self) -> Self: ...
+    @overload
+    def __xor__(
+        self, other: CompliantExpr[FrameT, SeriesOrExprT]
+    ) -> CompliantExpr[FrameT, SeriesOrExprT]: ...
+    def __xor__(
+        self, other: SelectorOrExpr[FrameT, SeriesOrExprT]
+    ) -> SelectorOrExpr[FrameT, SeriesOrExprT]:
+        if self._is_selector(other):
+
+            def series(df: FrameT) -> Sequence[SeriesOrExprT]:
+                lhs_names, rhs_names = _eval_lhs_rhs(df, self, other)
+                return [
+                    *(
+                        x
+                        for x, name in zip(self(df), lhs_names, strict=True)
+                        if name not in rhs_names
+                    ),
+                    *(
+                        x
+                        for x, name in zip(other(df), rhs_names, strict=True)
+                        if name not in lhs_names
+                    ),
+                ]
+
+            def names(df: FrameT) -> Sequence[str]:
+                lhs_names, rhs_names = _eval_lhs_rhs(df, self, other)
+                return [
+                    *(x for x in lhs_names if x not in rhs_names),
+                    *(x for x in rhs_names if x not in lhs_names),
+                ]
+
+            return self.selectors._selector.from_callables(series, names, context=self)
+        msg = (
+            f"unsupported operand type(s) for op: ('Selector' ^ '{type(other).__name__}')"
+        )
+        raise TypeError(msg)
+
     def __invert__(self) -> CompliantSelector[FrameT, SeriesOrExprT]:
         return self.selectors.all() - self
 

narwhals/_polars/expr.py

@@ -272,6 +272,15 @@ def __and__(self, other: PolarsExpr) -> Self:
     def __or__(self, other: PolarsExpr) -> Self:
         return self._with_native(self.native.__or__(extract_native(other)))
 
+    def __xor__(self, other: PolarsExpr) -> Self:
+        if self._backend_version >= (1,):
+            return self._with_native(self.native.__xor__(extract_native(other)))
+        # Polars added Selector.__xor__ in 1.0.0; emulate via existing set ops.
+        other_native = extract_native(other)
+        return self._with_native(
+            self.native.__or__(other_native).__sub__(self.native.__and__(other_native))
+        )
+
     def __add__(self, other: Any) -> Self:
         return self._with_native(self.native.__add__(extract_native(other)))
 

narwhals/selectors.py

@@ -56,6 +56,22 @@ def __and__(self, other: Any) -> Expr:  # type: ignore[override]
             ExprNode(ExprKind.ELEMENTWISE, "__and__", exprs=(other,), str_as_lit=True)
         )
 
+    def __xor__(self, other: Any) -> Expr:  # type: ignore[override]
+        if isinstance(other, Selector):
+            return self._append_node(
+                ExprNode(
+                    ExprKind.ELEMENTWISE,
+                    "__xor__",
+                    exprs=(other,),
+                    str_as_lit=True,
+                    allow_multi_output=True,
+                )
+            )
+        msg = (
+            f"unsupported operand type(s) for op: ('Selector' ^ '{type(other).__name__}')"
+        )
+        raise TypeError(msg)
+
     def __rsub__(self, other: Any) -> NoReturn:
         raise NotImplementedError
 
@@ -65,6 +81,9 @@ def __rand__(self, other: Any) -> NoReturn:
     def __ror__(self, other: Any) -> NoReturn:
         raise NotImplementedError
 
+    def __rxor__(self, other: Any) -> NoReturn:
+        raise NotImplementedError
+
 
 def by_dtype(*dtypes: DType | type[DType] | Iterable[DType | type[DType]]) -> Selector:
     """Select columns based on their dtype.

tests/selectors_test.py

@@ -207,6 +207,10 @@ def test_datetime_no_tz(constructor: Constructor) -> None:
         (ncs.boolean() & True, ["d"]),
         (ncs.boolean() | True, ["d"]),
         (ncs.numeric() - 1, ["a", "c"]),
+        (ncs.numeric() ^ ncs.boolean(), ["a", "c", "d"]),
+        (ncs.numeric() ^ ncs.by_dtype(nw.Int64), ["c"]),
+        (ncs.by_dtype(nw.Int64) ^ ncs.numeric(), ["c"]),
+        (ncs.numeric() ^ ncs.numeric(), []),
         (ncs.all(), ["a", "b", "c", "d"]),
     ],
 )
@@ -247,13 +251,20 @@ def test_set_ops_invalid(constructor: Constructor) -> None:
         df.select(1 | ncs.numeric())
     with pytest.raises((NotImplementedError, ValueError)):
         df.select(1 & ncs.numeric())
+    with pytest.raises((NotImplementedError, TypeError, ValueError)):
+        df.select(1 ^ ncs.numeric())
 
     with pytest.raises(
         TypeError,
         match=re.escape("unsupported operand type(s) for op: ('Selector' + 'Selector')"),
     ):
         df.select(ncs.boolean() + ncs.numeric())
 
+    with pytest.raises(
+        TypeError, match=re.escape("unsupported operand type(s) for op: ('Selector' ^ ")
+    ):
+        df.select(ncs.boolean() ^ 1)
+
 
 @pytest.mark.skipif(is_windows(), reason="windows is what it is")
 def test_tz_aware(constructor: Constructor, request: pytest.FixtureRequest) -> None: