From 95fc0d01c35a291e1c28afa3f66ebe417e63c191 Mon Sep 17 00:00:00 2001 From: "Thomas J. Fan" Date: Fri, 28 Feb 2025 20:48:59 -0500 Subject: [PATCH 1/5] Adds exclude --- docs/api-reference/narwhals.md | 1 + narwhals/__init__.py | 2 ++ narwhals/_arrow/namespace.py | 33 ++++++++++++++++++++++++ narwhals/_dask/namespace.py | 24 ++++++++++++++++++ narwhals/_duckdb/namespace.py | 23 +++++++++++++++++ narwhals/_pandas_like/namespace.py | 31 +++++++++++++++++++++++ narwhals/_spark_like/namespace.py | 22 ++++++++++++++++ narwhals/functions.py | 36 +++++++++++++++++++++++++++ narwhals/stable/v1/__init__.py | 12 +++++++++ tests/expr_and_series/exclude_test.py | 30 ++++++++++++++++++++++ 10 files changed, 214 insertions(+) create mode 100644 tests/expr_and_series/exclude_test.py diff --git a/docs/api-reference/narwhals.md b/docs/api-reference/narwhals.md index f828a33da2..fced41ef45 100644 --- a/docs/api-reference/narwhals.md +++ b/docs/api-reference/narwhals.md @@ -12,6 +12,7 @@ Here are the top-level functions available in Narwhals. - col - concat - concat_str + - exclude - from_arrow - from_dict - from_native diff --git a/narwhals/__init__.py b/narwhals/__init__.py index c90179b9e1..eea037a692 100644 --- a/narwhals/__init__.py +++ b/narwhals/__init__.py @@ -40,6 +40,7 @@ from narwhals.functions import col from narwhals.functions import concat from narwhals.functions import concat_str +from narwhals.functions import exclude from narwhals.functions import from_arrow from narwhals.functions import from_dict from narwhals.functions import from_numpy @@ -123,6 +124,7 @@ "dependencies", "dtypes", "exceptions", + "exclude", "from_arrow", "from_dict", "from_native", diff --git a/narwhals/_arrow/namespace.py b/narwhals/_arrow/namespace.py index a58c595aa8..c837c4429e 100644 --- a/narwhals/_arrow/namespace.py +++ b/narwhals/_arrow/namespace.py @@ -120,6 +120,39 @@ def col(self: Self, *column_names: str) -> ArrowExpr: *column_names, backend_version=self._backend_version, version=self._version ) + def exclude(self: Self, *column_names: str) -> ArrowExpr: + from narwhals._arrow.expr import ArrowExpr + from narwhals._arrow.series import ArrowSeries + + def evaluate_output_names(df: ArrowDataFrame) -> Sequence[str]: + exclude_columns = set(column_names) + return [ + column_name + for column_name in df.columns + if column_name not in exclude_columns + ] + + def func(df: ArrowDataFrame) -> list[ArrowSeries]: + return [ + ArrowSeries( + df._native_frame[column_name], + name=column_name, + backend_version=df._backend_version, + version=df._version, + ) + for column_name in evaluate_output_names(df) + ] + + return ArrowExpr( + func, + depth=0, + function_name="exclude", + evaluate_output_names=evaluate_output_names, + alias_output_names=None, + backend_version=self._backend_version, + version=self._version, + ) + def nth(self: Self, *column_indices: int) -> ArrowExpr: from narwhals._arrow.expr import ArrowExpr diff --git a/narwhals/_dask/namespace.py b/narwhals/_dask/namespace.py index 5f9fa982f6..61a1c46ac9 100644 --- a/narwhals/_dask/namespace.py +++ b/narwhals/_dask/namespace.py @@ -67,6 +67,30 @@ def col(self: Self, *column_names: str) -> DaskExpr: *column_names, backend_version=self._backend_version, version=self._version ) + def exclude(self: Self, *column_names: str) -> DaskExpr: + def evaluate_output_names(df: DaskLazyFrame) -> Sequence[str]: + exclude_columns = set(column_names) + return [ + column_name + for column_name in df.columns + if column_name not in exclude_columns + ] + + def func(df: DaskLazyFrame) -> list[dx.Series]: + return [ + df._native_frame[column_name] for column_name in evaluate_output_names(df) + ] + + return DaskExpr( + func, + depth=0, + function_name="exclude", + evaluate_output_names=evaluate_output_names, + alias_output_names=None, + backend_version=self._backend_version, + version=self._version, + ) + def nth(self: Self, *column_indices: int) -> DaskExpr: return DaskExpr.from_column_indices( *column_indices, backend_version=self._backend_version, version=self._version diff --git a/narwhals/_duckdb/namespace.py b/narwhals/_duckdb/namespace.py index 4ea72fae3b..57eedf665e 100644 --- a/narwhals/_duckdb/namespace.py +++ b/narwhals/_duckdb/namespace.py @@ -237,6 +237,29 @@ def col(self: Self, *column_names: str) -> DuckDBExpr: *column_names, backend_version=self._backend_version, version=self._version ) + def exclude(self: Self, *column_names: str) -> DuckDBExpr: + def evaluate_output_names(df: DuckDBLazyFrame) -> Sequence[str]: + exclude_names = set(column_names) + return [ + column_name + for column_name in df.columns + if column_name not in exclude_names + ] + + def func(df: DuckDBLazyFrame) -> list[duckdb.Expression]: + return [ + ColumnExpression(column_name) for column_name in evaluate_output_names(df) + ] + + return DuckDBExpr( + func, + function_name="exclude", + evaluate_output_names=evaluate_output_names, + alias_output_names=None, + backend_version=self._backend_version, + version=self._version, + ) + def nth(self: Self, *column_indices: int) -> DuckDBExpr: return DuckDBExpr.from_column_indices( *column_indices, backend_version=self._backend_version, version=self._version diff --git a/narwhals/_pandas_like/namespace.py b/narwhals/_pandas_like/namespace.py index 4e1b887fc0..f1dfeaf0bd 100644 --- a/narwhals/_pandas_like/namespace.py +++ b/narwhals/_pandas_like/namespace.py @@ -115,6 +115,37 @@ def col(self: Self, *column_names: str) -> PandasLikeExpr: version=self._version, ) + def exclude(self: Self, *column_names: str) -> PandasLikeExpr: + def evaluate_output_names(df: PandasLikeDataFrame) -> Sequence[str]: + exclude_columns = set(column_names) + return [ + column_name + for column_name in df.columns + if column_name not in exclude_columns + ] + + def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]: + return [ + PandasLikeSeries( + df._native_frame[column_name], + implementation=df._implementation, + backend_version=df._backend_version, + version=df._version, + ) + for column_name in evaluate_output_names(df) + ] + + return PandasLikeExpr( + func, + depth=0, + evaluate_output_names=evaluate_output_names, + function_name="exclude", + alias_output_names=None, + implementation=self._implementation, + backend_version=self._backend_version, + version=self._version, + ) + def nth(self: Self, *column_indices: int) -> PandasLikeExpr: return PandasLikeExpr.from_column_indices( *column_indices, diff --git a/narwhals/_spark_like/namespace.py b/narwhals/_spark_like/namespace.py index 07303aee67..be3f40fb0e 100644 --- a/narwhals/_spark_like/namespace.py +++ b/narwhals/_spark_like/namespace.py @@ -68,6 +68,28 @@ def col(self: Self, *column_names: str) -> SparkLikeExpr: implementation=self._implementation, ) + def exclude(self: Self, *column_names: str) -> SparkLikeExpr: + def evaluate_output_names(df: SparkLikeLazyFrame) -> Sequence[str]: + exclude_names = set(column_names) + return [ + column_name + for column_name in df.columns + if column_name not in exclude_names + ] + + def func(df: SparkLikeLazyFrame) -> list[Column]: + return [df._F.col(column_name) for column_name in evaluate_output_names(df)] + + return SparkLikeExpr( + func, + function_name="exclude", + evaluate_output_names=evaluate_output_names, + alias_output_names=None, + backend_version=self._backend_version, + version=self._version, + implementation=self._implementation, + ) + def nth(self: Self, *column_indices: int) -> SparkLikeExpr: return SparkLikeExpr.from_column_indices( *column_indices, diff --git a/narwhals/functions.py b/narwhals/functions.py index 5e80e05c64..6b2ef86ffd 100644 --- a/narwhals/functions.py +++ b/narwhals/functions.py @@ -1040,6 +1040,42 @@ def func(plx: Any) -> Any: return Expr(func, ExprMetadata.selector()) +def exclude(*names: str | Iterable[str]) -> Expr: + """Creates an expression that excludes columns by their name(s). + + Arguments: + names: Name(s) of the columns to exclude. + + Returns: + A new expression. + + Examples: + >>> import polars as pl + >>> import narwhals as nw + >>> + >>> df_native = pl.DataFrame({"a": [1, 2], "b": [3, 4], "c": ["x", "z"]}) + >>> nw.from_native(df_native).select(nw.exclude("c")) + ┌──────────────────┐ + |Narwhals DataFrame| + |------------------| + | shape: (2, 1) | + | ┌─────┐ | + | │ b │ | + | │ --- │ | + | │ i64 │ | + | ╞═════╡ | + | │ 3 │ | + | │ 4 │ | + | └─────┘ | + └──────────────────┘ + """ + + def func(plx: Any) -> Any: + return plx.exclude(*flatten(names)) + + return Expr(func, ExprMetadata.selector()) + + def nth(*indices: int | Sequence[int]) -> Expr: """Creates an expression that references one or more columns by their index(es). diff --git a/narwhals/stable/v1/__init__.py b/narwhals/stable/v1/__init__.py index cececde65d..8a6ad2fb7c 100644 --- a/narwhals/stable/v1/__init__.py +++ b/narwhals/stable/v1/__init__.py @@ -1812,6 +1812,18 @@ def col(*names: str | Iterable[str]) -> Expr: return _stableify(nw.col(*names)) +def exclude(*names: str | Iterable[str]) -> Expr: + """Creates an expression that excludes columns by their name(s). + + Arguments: + names: Name(s) of the columns to exclude. + + Returns: + A new expression. + """ + return _stableify(nw.exclude(*names)) + + def nth(*indices: int | Sequence[int]) -> Expr: """Creates an expression that references one or more columns by their index(es). diff --git a/tests/expr_and_series/exclude_test.py b/tests/expr_and_series/exclude_test.py new file mode 100644 index 0000000000..c6d8197e4c --- /dev/null +++ b/tests/expr_and_series/exclude_test.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + +import pytest + +import narwhals.stable.v1 as nw +from tests.utils import assert_equal_data + +if TYPE_CHECKING: + from tests.utils import Constructor + + +@pytest.mark.parametrize( + ("exclude_selector", "expected_cols"), + [ + (nw.exclude("a"), ["b", "z"]), + (nw.exclude("b", "z"), ["a"]), + ], +) +def test_exclude( + constructor: Constructor, exclude_selector: nw.Expr, expected_cols: list[str] +) -> None: + data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8.0, 9.0]} + + df = nw.from_native(constructor(data)) + result = df.select(exclude_selector) + + expected = {col: data[col] for col in expected_cols} + assert_equal_data(result, expected) From d733bb24b79c1f79f3033b8433e82f76cf056c1d Mon Sep 17 00:00:00 2001 From: "Thomas J. Fan" Date: Sat, 1 Mar 2025 09:05:16 -0500 Subject: [PATCH 2/5] Address comments --- narwhals/_arrow/namespace.py | 5 +---- narwhals/_pandas_like/namespace.py | 5 +---- narwhals/functions.py | 2 +- narwhals/stable/v1/__init__.py | 1 + tests/expr_and_series/exclude_test.py | 2 ++ 5 files changed, 6 insertions(+), 9 deletions(-) diff --git a/narwhals/_arrow/namespace.py b/narwhals/_arrow/namespace.py index c837c4429e..01925d11ec 100644 --- a/narwhals/_arrow/namespace.py +++ b/narwhals/_arrow/namespace.py @@ -121,7 +121,6 @@ def col(self: Self, *column_names: str) -> ArrowExpr: ) def exclude(self: Self, *column_names: str) -> ArrowExpr: - from narwhals._arrow.expr import ArrowExpr from narwhals._arrow.series import ArrowSeries def evaluate_output_names(df: ArrowDataFrame) -> Sequence[str]: @@ -143,14 +142,12 @@ def func(df: ArrowDataFrame) -> list[ArrowSeries]: for column_name in evaluate_output_names(df) ] - return ArrowExpr( + return self._create_expr_from_callable( func, depth=0, function_name="exclude", evaluate_output_names=evaluate_output_names, alias_output_names=None, - backend_version=self._backend_version, - version=self._version, ) def nth(self: Self, *column_indices: int) -> ArrowExpr: diff --git a/narwhals/_pandas_like/namespace.py b/narwhals/_pandas_like/namespace.py index f1dfeaf0bd..05a6cb8ed7 100644 --- a/narwhals/_pandas_like/namespace.py +++ b/narwhals/_pandas_like/namespace.py @@ -135,15 +135,12 @@ def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]: for column_name in evaluate_output_names(df) ] - return PandasLikeExpr( + return self._create_expr_from_callable( func, depth=0, evaluate_output_names=evaluate_output_names, function_name="exclude", alias_output_names=None, - implementation=self._implementation, - backend_version=self._backend_version, - version=self._version, ) def nth(self: Self, *column_indices: int) -> PandasLikeExpr: diff --git a/narwhals/functions.py b/narwhals/functions.py index 6b2ef86ffd..d17e3e2ee5 100644 --- a/narwhals/functions.py +++ b/narwhals/functions.py @@ -1054,7 +1054,7 @@ def exclude(*names: str | Iterable[str]) -> Expr: >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2], "b": [3, 4], "c": ["x", "z"]}) - >>> nw.from_native(df_native).select(nw.exclude("c")) + >>> nw.from_native(df_native).select(nw.exclude("c", "a")) ┌──────────────────┐ |Narwhals DataFrame| |------------------| diff --git a/narwhals/stable/v1/__init__.py b/narwhals/stable/v1/__init__.py index 8a6ad2fb7c..f4da543913 100644 --- a/narwhals/stable/v1/__init__.py +++ b/narwhals/stable/v1/__init__.py @@ -2415,6 +2415,7 @@ def scan_parquet( "dependencies", "dtypes", "exceptions", + "exclude", "from_arrow", "from_dict", "from_native", diff --git a/tests/expr_and_series/exclude_test.py b/tests/expr_and_series/exclude_test.py index c6d8197e4c..a6679faa71 100644 --- a/tests/expr_and_series/exclude_test.py +++ b/tests/expr_and_series/exclude_test.py @@ -16,6 +16,8 @@ [ (nw.exclude("a"), ["b", "z"]), (nw.exclude("b", "z"), ["a"]), + (nw.exclude(["a"]), ["b", "z"]), + (nw.exclude(["b", "z"]), ["a"]), ], ) def test_exclude( From 07deb3a365d11a4ea1ee09313538a6af9aa3842f Mon Sep 17 00:00:00 2001 From: "Thomas J. Fan" Date: Sat, 1 Mar 2025 14:28:25 -0500 Subject: [PATCH 3/5] Use frozenset --- narwhals/_arrow/namespace.py | 6 +++--- narwhals/_dask/namespace.py | 6 +++--- narwhals/_duckdb/namespace.py | 6 +++--- narwhals/_pandas_like/namespace.py | 6 +++--- narwhals/_spark_like/namespace.py | 6 +++--- narwhals/functions.py | 2 +- 6 files changed, 16 insertions(+), 16 deletions(-) diff --git a/narwhals/_arrow/namespace.py b/narwhals/_arrow/namespace.py index 01925d11ec..8e631dc887 100644 --- a/narwhals/_arrow/namespace.py +++ b/narwhals/_arrow/namespace.py @@ -5,6 +5,7 @@ from typing import TYPE_CHECKING from typing import Any from typing import Callable +from typing import Container from typing import Iterable from typing import Literal from typing import Sequence @@ -120,15 +121,14 @@ def col(self: Self, *column_names: str) -> ArrowExpr: *column_names, backend_version=self._backend_version, version=self._version ) - def exclude(self: Self, *column_names: str) -> ArrowExpr: + def exclude(self: Self, column_names: Container[str]) -> ArrowExpr: from narwhals._arrow.series import ArrowSeries def evaluate_output_names(df: ArrowDataFrame) -> Sequence[str]: - exclude_columns = set(column_names) return [ column_name for column_name in df.columns - if column_name not in exclude_columns + if column_name not in column_names ] def func(df: ArrowDataFrame) -> list[ArrowSeries]: diff --git a/narwhals/_dask/namespace.py b/narwhals/_dask/namespace.py index 61a1c46ac9..c56e55c4db 100644 --- a/narwhals/_dask/namespace.py +++ b/narwhals/_dask/namespace.py @@ -5,6 +5,7 @@ from typing import TYPE_CHECKING from typing import Any from typing import Callable +from typing import Container from typing import Iterable from typing import Literal from typing import Sequence @@ -67,13 +68,12 @@ def col(self: Self, *column_names: str) -> DaskExpr: *column_names, backend_version=self._backend_version, version=self._version ) - def exclude(self: Self, *column_names: str) -> DaskExpr: + def exclude(self: Self, column_names: Container[str]) -> DaskExpr: def evaluate_output_names(df: DaskLazyFrame) -> Sequence[str]: - exclude_columns = set(column_names) return [ column_name for column_name in df.columns - if column_name not in exclude_columns + if column_name not in column_names ] def func(df: DaskLazyFrame) -> list[dx.Series]: diff --git a/narwhals/_duckdb/namespace.py b/narwhals/_duckdb/namespace.py index 57eedf665e..a3ec3a96ad 100644 --- a/narwhals/_duckdb/namespace.py +++ b/narwhals/_duckdb/namespace.py @@ -6,6 +6,7 @@ from typing import TYPE_CHECKING from typing import Any from typing import Callable +from typing import Container from typing import Literal from typing import Sequence @@ -237,13 +238,12 @@ def col(self: Self, *column_names: str) -> DuckDBExpr: *column_names, backend_version=self._backend_version, version=self._version ) - def exclude(self: Self, *column_names: str) -> DuckDBExpr: + def exclude(self: Self, column_names: Container[str]) -> DuckDBExpr: def evaluate_output_names(df: DuckDBLazyFrame) -> Sequence[str]: - exclude_names = set(column_names) return [ column_name for column_name in df.columns - if column_name not in exclude_names + if column_name not in column_names ] def func(df: DuckDBLazyFrame) -> list[duckdb.Expression]: diff --git a/narwhals/_pandas_like/namespace.py b/narwhals/_pandas_like/namespace.py index 05a6cb8ed7..e46b8ea615 100644 --- a/narwhals/_pandas_like/namespace.py +++ b/narwhals/_pandas_like/namespace.py @@ -5,6 +5,7 @@ from typing import TYPE_CHECKING from typing import Any from typing import Callable +from typing import Container from typing import Iterable from typing import Literal from typing import Sequence @@ -115,13 +116,12 @@ def col(self: Self, *column_names: str) -> PandasLikeExpr: version=self._version, ) - def exclude(self: Self, *column_names: str) -> PandasLikeExpr: + def exclude(self: Self, column_names: Container[str]) -> PandasLikeExpr: def evaluate_output_names(df: PandasLikeDataFrame) -> Sequence[str]: - exclude_columns = set(column_names) return [ column_name for column_name in df.columns - if column_name not in exclude_columns + if column_name not in column_names ] def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]: diff --git a/narwhals/_spark_like/namespace.py b/narwhals/_spark_like/namespace.py index be3f40fb0e..f867800503 100644 --- a/narwhals/_spark_like/namespace.py +++ b/narwhals/_spark_like/namespace.py @@ -5,6 +5,7 @@ from typing import TYPE_CHECKING from typing import Any from typing import Callable +from typing import Container from typing import Iterable from typing import Literal from typing import Sequence @@ -68,13 +69,12 @@ def col(self: Self, *column_names: str) -> SparkLikeExpr: implementation=self._implementation, ) - def exclude(self: Self, *column_names: str) -> SparkLikeExpr: + def exclude(self: Self, column_names: Container[str]) -> SparkLikeExpr: def evaluate_output_names(df: SparkLikeLazyFrame) -> Sequence[str]: - exclude_names = set(column_names) return [ column_name for column_name in df.columns - if column_name not in exclude_names + if column_name not in column_names ] def func(df: SparkLikeLazyFrame) -> list[Column]: diff --git a/narwhals/functions.py b/narwhals/functions.py index d17e3e2ee5..d04693be73 100644 --- a/narwhals/functions.py +++ b/narwhals/functions.py @@ -1071,7 +1071,7 @@ def exclude(*names: str | Iterable[str]) -> Expr: """ def func(plx: Any) -> Any: - return plx.exclude(*flatten(names)) + return plx.exclude(frozenset(flatten(names))) return Expr(func, ExprMetadata.selector()) From 8fa7acd128aace64afd4d20dcfaf63eb43823860 Mon Sep 17 00:00:00 2001 From: dangotbanned <125183946+dangotbanned@users.noreply.github.com> Date: Sat, 1 Mar 2025 19:39:40 +0000 Subject: [PATCH 4/5] refactor: share `frozenset` https://github.com/narwhals-dev/narwhals/pull/2122#discussion_r1976479946 --- narwhals/functions.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/narwhals/functions.py b/narwhals/functions.py index d04693be73..e1f85f5d1f 100644 --- a/narwhals/functions.py +++ b/narwhals/functions.py @@ -1069,9 +1069,10 @@ def exclude(*names: str | Iterable[str]) -> Expr: | └─────┘ | └──────────────────┘ """ + exclude_names = frozenset(flatten(names)) def func(plx: Any) -> Any: - return plx.exclude(frozenset(flatten(names))) + return plx.exclude(exclude_names) return Expr(func, ExprMetadata.selector()) From 5c51214e6b20555b1b8376d668e90b814133cbff Mon Sep 17 00:00:00 2001 From: "Thomas J. Fan" Date: Sat, 1 Mar 2025 15:03:12 -0500 Subject: [PATCH 5/5] Use better name for namespace functions --- narwhals/_arrow/namespace.py | 4 ++-- narwhals/_dask/namespace.py | 4 ++-- narwhals/_duckdb/namespace.py | 4 ++-- narwhals/_pandas_like/namespace.py | 4 ++-- narwhals/_spark_like/namespace.py | 4 ++-- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/narwhals/_arrow/namespace.py b/narwhals/_arrow/namespace.py index 8e631dc887..e740b85929 100644 --- a/narwhals/_arrow/namespace.py +++ b/narwhals/_arrow/namespace.py @@ -121,14 +121,14 @@ def col(self: Self, *column_names: str) -> ArrowExpr: *column_names, backend_version=self._backend_version, version=self._version ) - def exclude(self: Self, column_names: Container[str]) -> ArrowExpr: + def exclude(self: Self, excluded_names: Container[str]) -> ArrowExpr: from narwhals._arrow.series import ArrowSeries def evaluate_output_names(df: ArrowDataFrame) -> Sequence[str]: return [ column_name for column_name in df.columns - if column_name not in column_names + if column_name not in excluded_names ] def func(df: ArrowDataFrame) -> list[ArrowSeries]: diff --git a/narwhals/_dask/namespace.py b/narwhals/_dask/namespace.py index c56e55c4db..828ad2afdd 100644 --- a/narwhals/_dask/namespace.py +++ b/narwhals/_dask/namespace.py @@ -68,12 +68,12 @@ def col(self: Self, *column_names: str) -> DaskExpr: *column_names, backend_version=self._backend_version, version=self._version ) - def exclude(self: Self, column_names: Container[str]) -> DaskExpr: + def exclude(self: Self, excluded_names: Container[str]) -> DaskExpr: def evaluate_output_names(df: DaskLazyFrame) -> Sequence[str]: return [ column_name for column_name in df.columns - if column_name not in column_names + if column_name not in excluded_names ] def func(df: DaskLazyFrame) -> list[dx.Series]: diff --git a/narwhals/_duckdb/namespace.py b/narwhals/_duckdb/namespace.py index a3ec3a96ad..047355e940 100644 --- a/narwhals/_duckdb/namespace.py +++ b/narwhals/_duckdb/namespace.py @@ -238,12 +238,12 @@ def col(self: Self, *column_names: str) -> DuckDBExpr: *column_names, backend_version=self._backend_version, version=self._version ) - def exclude(self: Self, column_names: Container[str]) -> DuckDBExpr: + def exclude(self: Self, excluded_names: Container[str]) -> DuckDBExpr: def evaluate_output_names(df: DuckDBLazyFrame) -> Sequence[str]: return [ column_name for column_name in df.columns - if column_name not in column_names + if column_name not in excluded_names ] def func(df: DuckDBLazyFrame) -> list[duckdb.Expression]: diff --git a/narwhals/_pandas_like/namespace.py b/narwhals/_pandas_like/namespace.py index e46b8ea615..75b5cec617 100644 --- a/narwhals/_pandas_like/namespace.py +++ b/narwhals/_pandas_like/namespace.py @@ -116,12 +116,12 @@ def col(self: Self, *column_names: str) -> PandasLikeExpr: version=self._version, ) - def exclude(self: Self, column_names: Container[str]) -> PandasLikeExpr: + def exclude(self: Self, excluded_names: Container[str]) -> PandasLikeExpr: def evaluate_output_names(df: PandasLikeDataFrame) -> Sequence[str]: return [ column_name for column_name in df.columns - if column_name not in column_names + if column_name not in excluded_names ] def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]: diff --git a/narwhals/_spark_like/namespace.py b/narwhals/_spark_like/namespace.py index f867800503..91cbd4f30c 100644 --- a/narwhals/_spark_like/namespace.py +++ b/narwhals/_spark_like/namespace.py @@ -69,12 +69,12 @@ def col(self: Self, *column_names: str) -> SparkLikeExpr: implementation=self._implementation, ) - def exclude(self: Self, column_names: Container[str]) -> SparkLikeExpr: + def exclude(self: Self, excluded_names: Container[str]) -> SparkLikeExpr: def evaluate_output_names(df: SparkLikeLazyFrame) -> Sequence[str]: return [ column_name for column_name in df.columns - if column_name not in column_names + if column_name not in excluded_names ] def func(df: SparkLikeLazyFrame) -> list[Column]: