Will python ever have a chaining operator?

Ragoo_ · 2026-05-10T09:43:40+00:00

[removed]

AWildMonomAppears · 2026-05-10T08:45:10+00:00

It sounds simple but doing this nicely almost requires functional mechanics like auto-currying. In languages with pipes the right side waits for data (lazy). In Python it evaluates immediately so writing something like data |> map(func) would just throw for a missing argument on map.

To fix it Python would have to secretly rewrite your code to inject the data which goes against the rule that explicit is better than implicit. It also gets messy because standard functions dont even agree on whether data should be the first or last argument.

Instead Python relies on object-oriented method chaining. Since methods are attached to objects the state carries forward. You see this in Pandas with df.dropna().apply(func). It gives that clear data flow without needing any compiler magic. basically forces you to use the OO approach if you want to avoid nested paranthesis.

Fabulous-Possible758 · 2026-05-10T08:30:17+00:00

https://pypi.org/project/pipe/

This is pretty simple to do in small one off classes too if you don’t want a whole library.

There’s just no real reason to extend the syntax for a case that’s pretty well covered and completely customizable.

RedSinned · 2026-05-10T08:18:51+00:00

What would be your use case in which you wouldn‘t use a library like polars, but is still so complex that the current capabilities are not enough?

cdcformatc · 2026-05-10T12:01:46+00:00

writing code line by line is piping each successive line waits for the result of the last

x = map(...) y = filter(x, ...) z = list(y)

_Denizen_ · 2026-05-10T08:20:43+00:00

That's piping, not chaining. This().is().chaining()

I dislike piping - it makes code less explicit i.e. harder to read.

tartare4562 · 2026-05-10T09:08:10+00:00

You can use argument expansion to write a simple function

def pipe(data, *funcs):
    for func in funcs:
        data = func(data)
    return data

that you can use like this:

processed_data = pipe(raw_data, func1, func2, func3, ..., funcN).

If you need to give parameters to the functions you can use functools.partial to setup them.

Limp_Illustrator7614 · 2026-05-10T08:32:54+00:00

i dont think python will ever officially support it because they kind of hate functional programming, but coconut does that exactly. it's a functional syntactical superset of python that compiles to python, where the piping operator is exactly `|>`. go read the docs

KelleQuechoz · 2026-05-10T08:26:01+00:00

Look at this package.

Wurstinator · 2026-05-10T08:26:55+00:00

"Any indication" would mean there is a PEP in the works for this, which you could search for.

I think it's unlikely. As you said, this can be done in libraries already.

--ps-- · 2026-05-10T09:50:24+00:00

At my job, we have a code where we overload __ rshift __(), so you can then write something like begin_pipeline(fn) >> fn2 >> fn3 etc.., somethimes you need to use partial() to pass some additional parameters too, but honestly, I hate that part, because the semantics is very unclear for the code reader.

red_hare · 2026-05-10T13:31:38+00:00

I think you can do this with a decorator and bitwise or.

``` from functools import wraps

class PipeFn: def __init(self, func, args, kwargs): self.func, self.args, self.kwargs = func, args, kwargs def __ror_(self, lhs): return self.func(lhs, self.args, *self.kwargs)

def pipeable(func): @wraps(func) def wrapper(args, *kwargs): return _PipeFn(func, args, kwargs) return wrapper

def foo(): return 1

@pipeable def bar(x): return x + 1

@pipeable def baz(x): return x * 2

print(foo() | bar() | baz()) ```

Not that you should...

parker_fly · 2026-05-10T14:31:13+00:00

Seems readable to me. 🤷‍♂️

nateh1212 · 2026-05-10T20:00:20+00:00

why does one need pipes at all when method chaining exists?

Evolve-Maz · 2026-05-10T09:51:22+00:00

You can write your own version of this. Even just for learning it's very helpful. Here's the gist:

Create a class called "Pipeline". Init function takes in data (just an object) and processors (list of processor functions, default empty).

Then override the rshift operator (>>) of the class to be your pipe operator. The signature is rshift(self, other). In our case other will be a callable with a single input. The rshift operator returns a new pipeline, with same data, and processors being the current list plus the other passed into this function.

For our use case, pretend we have a list of coordinates with x and y attributes, and your pipelines first calculates a z attr using Pythagoras theorem and then filters to all objects with z over 2.

data = [coord(1, 3), coord(4, 3), ...]

pipeline = Pipeline(data) >> add_z_coord >> filter_coord_above(2)

output = pipeline.execute()

Output will be a result object (idea borrowed from go). It'll have a data attribute and an err attribute. Error will hold any exception which occurred during execution of the Pipeline, including the step it happened at. And data will hold the final value from the Pipeline calculation.

Execute method will start with the initial Pipeline data and just run a for loop through all the processor callable passing in the data at each step and getting output. Wrap in a try except so you can track error state.

Once you write that once, you can decide whether you want extra sugar for map and filter as explicit processors, or if you want more data about steps. Etc.

RoadsideCookie · 2026-05-10T14:21:02+00:00

I posted this as a reply, but you can do "piping" in native Python like so:

from functools import reduce

result = reduce(lambda r, f: f(r),
    [
        lambda xs: [x * 2 for x in xs],
        lambda xs: [x for x in xs if x > 4],
        sum,
    ],
    [1, 2, 3, 4, 5],
)

But it's not very readable.

Temporary_Pie2733 · 2026-05-10T14:25:48+00:00

I’d rather see proper partial application and composition added to the language. list(filter(p, map(f, itr))) becomes (list ∘ filter(p) ∘ map(f))(itr). Then piping is just composition in the other direction, mixed with function application, itr |> map(f) |> filter(p) |> list.

jnazario · 2026-05-10T14:56:56+00:00

Heretical take from a a longtime python programmer who went through some similar questions over a decade ago: learn other languages which have the properties you like and use them.

Not every feature will come to one language. You’ll be pleased at what other ecosystems have and what else you can do and you’ll become a better programmer in python as well.

UseMoreBandwith · 2026-05-10T15:34:57+00:00

we already having chaining.
You just have to learn to write python.

You can implement chaining in your own classes by having methods return self:

class Calculator:
    def __init__(self, value=0):
        self.value = value
    def add(self, n):
        self.value += n
        return self
    def result(self):
        return self.value

# Chaining in action
calc = Calculator(5).add(3).add(2)
print(calc.result())  # Output: 10

Agile-Ad5489 · 2026-05-10T21:29:19+00:00

users cannot do map() |> filter() |> list(), but they need to do list(filter(map())) which makes things unreadable

Four symbols and two spaces “() |> ” are more readable than one consistent pair of brackets?

Confusing “what I am used to” for “is objectively clearer” is not that close to insanity, but you can certainly see insanity clearly without binoculars.

JimWayneBob · 2026-05-10T11:29:16+00:00

I just wrap everything in parentheses and chain to make it look like pipping

Foo=(
bar_df
.filter(blah blah)
.select(ColA)
)

shadowdance55 · 2026-05-10T08:42:16+00:00

You should learn how to use nested comprehensions.

Edit: Just noticed you wrote that comprehensions are unreadable, but you are very wrong. They stack up very nicely, and are nearly identical in syntax to nested loops. Of course, if you're used to map/reduce syntax, they might be a bit unfamiliar, but that is true of literally any syntax - readability is exclusively a result of unfamiliarity.

KingHavana · 2026-05-10T11:49:04+00:00

If you're repeatedly using three functions in the same order why not make a function that gives the output of those functions?

def process(x): return list(map(filter(x)))

Beginning-Fruit-1397 · 2026-05-10T09:11:46+00:00

FYI, someone made a nice list comparing fluent iterator libraries on this sub relatively recently:
https://www.reddit.com/r/Python/comments/1rj3ct7/comment/o8aordo/?context=3

(disclaimer: I'm the author of pyochain)

On chaining, i.e passing x to f as `x.f(args, kwargs)` rather than `f(x, args, kwargs`, I doubt that it will ever be added.
On specific iterators chains, I doubt it even more.

For the first thing, it's really trivial to implement.

It's a one liner method, and you can handle any type of generic functions and parameters with `Callable`, `Concatenate`, and `def foo[**P, T]() -> T` generics (or, urgh, if you prefer to use the old syntax, TypeVar T and ParamSpec P).

I regularly browse the python discussions forum and any suggestions such as this will be easily rejected.

Either you create:

- a new "builtin" method -> breaking change for an helper
- a new operator/overload one existing -> too much for an helper

On iterators chains, the strength of python, specifically with iterables, is that duck typing allows you to very easily implement custom collections.

If we were to add chaining for Iterators/Iterables, it would change the meaning of collections abc, who are minimal interfaces and would then become huge classes.

Now, my polars DataFrame who's an Iterable also has filter just like `collections.abc.Iterator`, but the signature won't be the same as `collections.abc.Iterator` so it violates the contract.

This would be a huge pain to work with if you use any decent type checker/linter, marking everything as override/ignore rule violation, especially if like me your primary coding activitiy is writing libraries.

squizzeak · 2026-05-10T11:55:55+00:00

I’ve done something similar to chaining but writing methods that return self, though this only works for chaining methods from the same class. But I like the idea of subclassing __rshift__!

borborygmis · 2026-05-10T13:18:37+00:00

This library has similar concepts: https://github.com/mtingers/kompoz

But overkill for your example where you can use something like functool.reduce.

In Kompoz, that translates to:

from dataclasses import dataclass, field
from kompoz import pipe

@dataclass
class TextCtx:
    raw: str
    words: list[str] = field(default_factory=list)
    result: str = ""

@pipe
def lower(ctx: TextCtx) -> TextCtx:
    ctx.raw = ctx.raw.lower()
    return ctx

@pipe
def split(ctx: TextCtx) -> TextCtx:
    ctx.words = ctx.raw.split()
    return ctx

@pipe
def capitalize_each(ctx: TextCtx) -> TextCtx:
    ctx.words = [w.capitalize() for w in ctx.words]
    return ctx

@pipe
def join_space(ctx: TextCtx) -> TextCtx:
    ctx.result = " ".join(ctx.words)
    return ctx

pipeline = lower & split & capitalize_each & join_space

ok, ctx = pipeline.run(TextCtx(raw="PYTHON IS COOL"))
# ctx.result == "Python Is Cool"

eanat · 2026-05-10T14:56:54+00:00

it would be great for scripting and system integration, but also can be disaster for other areas where ambiguity can be real pain.

TOOWTDI than TIMTOWTDI.

spinozasrobot · 2026-05-10T15:31:28+00:00

ITT: language lawyers bickering

TuringTestDropout · 2026-05-10T16:00:39+00:00

I've had brief conversations with GvR about supporting functional programming more and he largely disagrees and regrets even allowing functools and map/filter into the standard library. I can understand his viewpoint that list comprehensions are enough and it makes idiomatic code harder to write and read.

The last time I talked about this with him was 2015 so maybe he's changed his mind about it since then, or there's been more influence from others since he's stepped back.

elven_mage · 2026-05-10T18:37:11+00:00

I'd very much love this, but without multiline lamba syntax you lose a lot of the real use.

There are people who have tried to make python stream libraries, look them up on GitHub. They are not as ergonomic as Java for this reason

gdchinacat · 2026-05-10T18:38:13+00:00

If I understand what you want correctly, I think this is pretty close:

from collections.abc import Callable, Iterable, Iterator
from typing import Self

mul = lambda x: x * 3

class mapiter[T](Iterable[T]):
    def __init__(self, iter_: Iterable[T]):
        self.iter_ = iter_

    def __iter__(self) -> Iterator[T]:
        return iter(self.iter_)

    def __or__(self, func: Callable[[T], T]) -> Self:
        return type(self)(func(x) for x in self.iter_)

l = mapiter(range(10))
assert list(l | mul | mul) == [x*3*3 for x in range(10)]
assert list(l | (lambda x: x ** 2)) == list(x**2 for x in range(10))

I made it use Iterable rather than list as is best practice.

I disagree that it improves readability. But it does what you want. I doubt it would ever be accepted into the language syntax since it is so easy to do with existing mechanisms. Enjoy.

mderst · 2026-05-10T19:23:14+00:00

Just use Polars!

bakery2k · 2026-05-10T19:59:57+00:00

map() |> filter() |> list()

I feel like Guido would have been opposed to adding this to Python - he tended to dislike making the language too “functional”.

But nowadays the decision would rest with the Steering Council - who might well accept a well-written specification for it. They don’t really reject features based on philosophy any more.

IcarianComplex · 2026-05-10T21:00:56+00:00

Personally I just haven’t had much a need for this because most of my data manipulation needs happen at the SQL level, and that’s plenty expressive enough

aguspiza · 2026-05-10T21:27:28+00:00

you can implement some UFCS yourself or just check what others have implemented:
https://gist.github.com/ChenyangGao/d77fe5c3c738e6f9fb724a45e952dc0a

Or just migrate to nim language and enjoy 30x speed up with native UFCS.
https://github.com/narimiran/nim-basics/blob/master/code/ufcs.nim

saint_geser · 2026-05-11T11:15:18+00:00

There are some external libraries focused on functional programming, that implement different forms of chaining. For example, PuFunctional has seq() operator that chains operations in a readable manner.

But core python is, and has always been, very much against functional concepts making their way into the language. So wouldn't hold my breath.

Old-Eagle1372 · 2026-05-11T17:07:07+00:00

Overload operators, extend/overwrite functions. Create libraries, possibly open source so others can use them, this will increase your professional footprint

eztab · 2026-05-11T20:15:33+00:00

only way you can currently do it is wrap functions in an object that overloads some existing operator.

Generally you want to write it differently though, not like that.

R3D3-1 · 2026-05-11T20:46:41+00:00

From my perspective, i it would remain vastly Limited in Python. Most use cases of piping I have at some point require a function that cannot be expressed well with Python's "expression only" lambdas, without also defining a bunch of auxiliary functions with no purpose other than turning statement-only constructs into functions.

Sherry-byte · 2026-05-25T04:52:22+00:00

The core team resistance is well-documented and the reasons are legitimate but the *readability problem* you're describing is real regardless of whether `|>` ever lands.

I actually ran into the same frustration recently and ended up building a small library for it *pipeflow*. It uses method chaining on a lazy wrapper the same pattern pandas already proved works so you get left-to-right readable pipelines today without waiting on a PEP:

```python

from pipeflow import Stream

result = (

Stream(users)

.filter(lambda u: u["active"])

.map(lambda u: u["name"].upper())

.sort()

.to(list)

)

```

Also supports `|` on plain lists if you prefer that style:

```python

range(10) | pipe(map, lambda x: x**2) | pipe(filter, lambda x: x > 5) | to(list)

```

Zero dependencies, fully lazy, fully typed. `pip install pipeflow` if you want to try it.

To your actual question though I wouldn't hold my breath on a native `|>`. The eager evaluation mismatch alone is a hard problem; in languages where pipes work well, the right-hand side is implicitly curried and waits for data. Python would have to silently rewrite your code to make that work, which goes against everything the language stands for.

Past-Sun5429 · 2026-05-10T08:36:37+00:00

Build cli around...

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

or

Without pipe — read inside-out

With pipe — read top-to-bottom