1

如何从 Python 中促进延续传递风格？

（我认为这是正确的术语）

我的代码开始变得乱七八糟，我有mapsfilter和 s 链，lambda如下所示：

(lambda a,b: (lambda c:(lambda d: d*d)(c-b))(a*b))(5,6)

“管道表达式”可以在多种语言中找到，例如：

F#解决方案（例如|>：）

let complexFunction =
    2                            (* 2 *)
    |> ( fun x -> x + 5)         (* 2 + 5 = 7 *)
    |> ( fun x -> x * x)         (* 7 * 7 = 49 *)
    |> ( fun x -> x.ToString() ) (* 49.ToString = "49" *)

Haskell解决方案（例如：do、管道）

 main = do
     hSetBuffering stdout NoBuffering
     str <- runEffect $
         ("End of input!" <$ P.stdinLn) >-> ("Broken pipe!" <$ P.stdoutLn)
     hPutStrLn stderr str

JavaScript（例如：async.js）：

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
      // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'    
});

但是我知道最后一个策略更多的是用于异步函数响应解析（请参阅：回调地狱）。

如何在单个 Python 表达式/行中呈现我处理的所有阶段？

4

1 回答 1

2

AFAIK，Python 中没有标准功能可以做到这一点。

有一个名为Pipe的模块覆盖了 operator |，但它被合理地认为是有害的（在改变其语义的同时覆盖了 operator）。

但是，您可以为此实现简单的Fluent 接口。这是一个例子：

class P:
    def __init__(self, initial):
        self.result = initial

    def __call__(self, func, *args, **kwargs):
        self.result = func(self.result, *args, **kwargs)
        return self

    def map(self, func):
        self.result = map(func, self.result)
        return self

    def filter(self, func):
        self.result = filter(func, self.result)
        return self

    def get(self):
        return self.result

x = P(2)(lambda x: x + 5)(lambda x: x * x)(lambda x: str(x)).get()
z = P(range(10)).map(lambda x: x * 3).filter(lambda x: x % 2 == 0).get()
print(x, list(z))       # prints 49 [0, 6, 12, 18, 24]
于 2015-03-20T09:51:14.053 回答