不多说，直接上代码。
from functools import partial class F(partial): def __ror__(self, other): if isinstance(other, tuple): return self(*other) return self(other) 使用样例。
range(10) | F(filter, lambda x: x % 2) | F(sum) 更详细的前因后果介绍，可以看 https://aber.sh/articles/Python-Pipe/ ，实在是懒得复制到 V2EX 调样式了。有兴趣的就看看，没兴趣的就复制代码去用就完事。
小小的得瑟一下，这是最近几天写的最满意、最有用的代码。妙手偶得之~
自动柯里化的工作量就太大了，因为 Py 里存在 *args 和 **kwargs 。我是想不到有什么好办法能实现的。所以我选择让程序员自己柯里化一次（也就是使用 F 包裹一次）。
就比如说明希想要的那个，可以用
def fp(func):
def _(*args, **kwargs):
return F(func, *args, **kwargs)
return _
折中实现一下，强制 double call 才能实际调用。
而你要做的这个，既要支持 direct call 又要支持
double call……那就得第一次调用之后延迟计算，判断如果是走管道，调第二次，判断直接赋值的话再去计算。CPython 应该做不到，可以考虑做个超集语言，在编译期做。
[1, 2, 3].map(lambda x: x**2)
@admirez 可以，此管道可以用在任何 Python 代码里。我就是在处理数据的时候想到的这个。
@sapocaly 你说的这个不就是上推荐的那个库吗？你喜欢的话可以去试试，上面有链接。我个人喜欢 | F(…) 这么用。没有黑魔法，工作原理简单，对 debug 友好，最重要的优点是每一次管道运算都是真实的运算出了结果，我可以在任何一次运算之后拿去用，而不需要特意标识一个 END 或者其他什么的。
>>> [1, 2 , 3] | F(filter, lambda x: x % 2) | F(list)
[1, 3]
>>> list(filter( lambda x: x % 2,(1,2,3)))
[1, 3]
@iqxd @xuboying 因为我希望能传递多个参数给被 F 包裹的函数。一般来说，函数返回多值是 return x, y, z 这样，它的实际类型是一个 tuple 。
比如
def fa(…): return a, b, c
def fb(a, b, c, d, e): return y
就可以直接 data | F(fa) | F(fb), 而不是 data | F(fa) | F(lambda args: F(fb(*args))) 这样写。
F = type(“F”, (partial,), {“__ror__”: lambda self, other: self(other)})
range(10) | F(filter, lambda x: x & 1) | F(sum) | F(print)
“`python
from functools import partial
class F(partial):
def __init__(self, func):
self.__func = func
def __ror__(self, other):
if isinstance(other, tuple):
return self(*other)
return self(other)
def __call__(self, *args, **kwargs):
return self.__func(*args, **kwargs)
def pipefy(func):
return F(func)
“`
秒啊~
$ cat foo.py
from functools import partial
class F(partial):
def __ror__(self, rhs):
return self(rhs)
def __rrshift__(self, rhs):
return self(*rhs)
$ python -i foo.py
>>> (1, 2 , 3) | F(filter, lambda x: x % 2) | F(list)
[1, 3]
>>> (14, ‘#b’) >> F(format)
‘0b1110’
>>>
@geebos 你的 __init__ 和 __call__ 的功能已经被 partial 实现了……
https://docs.python.org/zh-cn/3.7/reference/expressions.html#operator-precedence
还真是，没有符号和 | 优先级相同。
我发现 partial 的类很特殊，不能简单继承，或者前面有人提到了 Filter=F(filter)似乎也是不行的。
希望有高人能帮忙简化一下我的写法。
···
$ cat foo.py
from functools import partial
class P(partial):
“””Pipe.”””
def __ror__(self, rhs):
return self(rhs)
class X(partial):
“””Xargs.”””
def __ror__(self, rhs):
return self(*rhs)
class Filter(P):
def __new__(cls, *args, **kwargs):
return super(__class__, cls).__new__(cls, filter, *args, **kwargs)
class Map(P):
def __new__(cls, *args, **kwargs):
return super(__class__, cls).__new__(cls, map, *args, **kwargs)
$ python -i foo.py
>>> (1, 2 , 3) | Map(lambda x : x+2 ) | Filter(lambda x: x % 2) | X(divmod) | P (set)
{0, 3}
···
总结： 哗众取宠，毫无意义
我已经 抛弃 python 了
工业应用，各种炫技代码，不是 平铺直述 的代码， 我全部都是 review 不通过的
如果一个 语言 写了 4 年 还能从 语法上玩出花样， 或者 一个语言 写了 4 年 还没掌握全部的语言特性
（ c++除外， 特定领域 和 高性能 是别人的卖点）
那么 在这种语言上 浪费时间是 毫无意义的
什么是好语言：
1. 语法 几天 学完
2. 语言特性 几个月 完全掌握
3. 有强力的 IDE 支持
4. 强类型，编译检查错误
5. 如果运行效率高最好
6. 如果容易的支持并行最好
python 一样都没占上
连最基本的 语言特性， 我敢说 这个帖子里 没有一个人 完全掌握了 python 的特性
所以， 自己玩玩可以