Python fluent过滤器、地图等

Question

我喜欢蟒蛇。但是，让我有点烦恼的一件事是，我不知道如何像 javascript 中的罐头那样以流畅的方式格式化功能活动。

例子（现场随机创建）：能不能帮我把这个转换成python看起来流利的样子？

var even_set = [1,2,3,4,5]
.filter(function(x){return x%2 === 0;})
.map(function(x){
    console.log(x); // prints it for fun
    return x;
})
.reduce(function(num_set, val) {
    num_set[val] = true;
}, {});

我想知道是否有流动选项？也许是一个图书馆。

一般来说，我一直在对大多数事情使用列表推导，但如果我想打印，这是一个真正的问题

例如，如何使用列表理解在 python 2.x 中打印 1 - 5 之间的每个偶数（Python 3 print() 作为函数，但 Python 2 没有）。构造并返回列表也有点烦人。我宁愿只是 for 循环。

Answer 1

我现在正在寻找一个更接近问题核心的答案：

fluentpyhttps://pypi.org/project/fluentpy/：

这是 streams 程序员（scala、java 等）会喜欢的集合的方法链接：

import fluentpy as _
(
  _(range(1,50+1))
  .map(_.each * 4)
  .filter(_.each <= 170)
  .filter(lambda each: len(str(each))==2)
  .filter(lambda each: each % 20 == 0)
  .enumerate()
  .map(lambda each: 'Result[%d]=%s' %(each[0],each[1]))
  .join(',')
  .print()
)

而且效果很好：

Result[0]=20,Result[1]=40,Result[2]=60,Result[3]=80

我现在正在尝试这个。如果它如上所示工作，今天将是非常美好的一天。

更新：看看这个：也许python可以开始更合理的一行shell脚本：

python3 -m fluentpy "lib.sys.stdin.readlines().map(str.lower).map(print)"

这是它在命令行上的作用：

$echo -e "Hello World line1\nLine 2\Line 3\nGoodbye" 
         | python3 -m fluentpy "lib.sys.stdin.readlines().map(str.lower).map(print)"

hello world line1

line 2

line 3

goodbye

还有一个额外的 newline 应该清理掉 - 但它的要点很有用（无论如何对我来说）。

更新这是另一个库/选项：我改编自 gist 并在 pipy 上作为 infixpy 提供：

from infixpy import *
a = (Seq(range(1,51))
     .map(lambda x: x * 4)
     .filter(lambda x: x <= 170)
     .filter(lambda x: len(str(x)) == 2)
     .filter( lambda x: x % 20 ==0)
     .enumerate()                                            Ï
     .map(lambda x: 'Result[%d]=%s' %(x[0],x[1]))
     .mkstring(' .. '))
print(a)

Answer 2

生成器、迭代器和itertools 为链接和过滤操作提供了额外的功能。但与其记住（或查找）很少使用的东西，我更倾向于帮助函数和理解。

例如在这种情况下，使用辅助函数来处理日志记录：

def echo(x):
    print(x)
    return x

使用推导式的if 子句可以轻松选择偶数值。而且由于最终输出是字典，所以使用这种理解：

In [118]: d={echo(x):True for x in s if x%2==0}
2
4

In [119]: d
Out[119]: {2: True, 4: True}

或者要将这些值添加到现有字典中，请使用update。

new_set.update({echo(x):True for x in s if x%2==0})

另一种编写方式是使用中间生成器：

{y:True for y in (echo(x) for x in s if x%2==0)}

或者在一个生成器中组合回声和过滤器

def even(s):
    for x in s:
        if x%2==0:
            print(x)
            yield(x)

后面是使用它的 dict comp：

{y:True for y in even(s)}

Answer 3

理解是python处理filter/map操作的流畅方式。

您的代码将类似于：

def evenize(input_list):
    return [x for x in input_list if x % 2 == 0]

理解不适用于控制台日志记录等副作用，因此请在单独的循环中进行。链接函数调用在 python 中并不是那么常见的习语。不要指望这会成为你的面包和黄油。 Python 库倾向于遵循“改变状态或返回值，但不是两者兼而有之”的模式。存在一些例外情况。

编辑：从好的方面来说，python 提供了多种类型的推导式，非常棒：

列表理解：[x for x in range(3)] == [0, 1, 2]

集合理解：{x for x in range(3)} == {0, 1, 2}

字典理解：` {x: x**2 for x in range(3)} == {0: 0, 1: 1, 2: 4}

生成器理解（或生成器表达式）：(x for x in range(3)) == <generator object <genexpr> at 0x10fc7dfa0>

使用生成器理解，尚未评估任何内容，因此它是防止在大型集合上进行流水线操作时内存使用量激增的好方法。

例如，如果您尝试执行以下操作，即使使用 range 的 python3 语义：

for number in [x**2 for x in range(10000000000000000)]:
    print(number)

在尝试构建初始列表时会出现内存错误。另一方面，将列表推导式更改为生成器推导式：

for number in (x**2 for x in range(1e20)):
    print(number)

并且没有内存问题（它只需要永远运行）。发生的情况是构建了范围对象（它只存储了开始、停止和步长值（0、1e20 和 1））对象被构建，然后 for 循环开始迭代 genexp 对象。实际上，for循环调用

GENEXP_ITERATOR = `iter(genexp)`
number = next(GENEXP_ITERATOR)
# run the loop one time
number = next(GENEXP_ITERATOR)
# run the loop one time
# etc.

（请注意，GENEXP_ITERATOR 对象在代码级别是不可见的）

next(GENEXP_ITERATOR) 尝试从 genexp 中取出第一个值，然后开始迭代 range 对象，取出一个值，将其平方，然后将值作为第一个 number。下一次 for 循环调用 next(GENEXP_ITERATOR) 时，生成器表达式从范围对象中提取第二个值，将其平方并生成它以用于 for 循环的第二次传递。第一组数字不再保存在内存中。

这意味着无论生成器理解中有多少项目，内存使用量都保持不变。您可以将生成器表达式传递给其他生成器表达式，并创建从不消耗大量内存的长管道。

def pipeline(filenames):
    basepath = path.path('/usr/share/stories')
    fullpaths = (basepath / fn for fn in filenames)
    realfiles = (fn for fn in fullpaths if os.path.exists(fn))
    openfiles = (open(fn) for fn in realfiles)
    def read_and_close(file):
        output = file.read(100)
        file.close()
        return output
    prefixes = (read_and_close(file) for file in openfiles)
    noncliches = (prefix for prefix in prefixes if not prefix.startswith('It was a dark and stormy night')
    return {prefix[:32]: prefix for prefix in prefixes}

在任何时候，如果您需要某个数据结构，您可以将生成器推导传递给另一个推导类型（如本示例的最后一行），此时，它将强制生成器评估所有他们留下的数据，但除非你这样做，否则内存消耗将仅限于生成器单次传递中发生的情况。

Answer 4

您编写的代码最大的问题是 Python 不支持多行匿名函数。 filter 或 map 的返回值是一个列表，因此如果您愿意，可以继续链接它们。但是，您要么必须提前定义函数，要么使用 lambda。

Answer 5

尽管反对这样做的论据，这里是您的 JS 代码的 Python 翻译。

from __future__ import print_function
from functools import reduce

def print_and_return(x):
    print(x)
    return x

def isodd(x):
    return x % 2 == 0

def add_to_dict(d, x):
    d[x] = True
    return d

even_set = list(reduce(add_to_dict,
                map(print_and_return,
                filter(isodd, [1, 2, 3, 4, 5])), {}))

它应该适用于 Python 2 和 Python 3。

Answer 6

有一个库已经完全符合您的要求，即流畅的语法、惰性求值和操作顺序与其编写方式相同，以及更多其他好东西，如多进程或多线程 Map/减少。 它被命名为pyxtension，它已准备好并在PyPi 上维护。 您的代码将以这种形式重写：

from pyxtension.strams import stream
def console_log(x):
    print(x)
    return x
even_set = stream([1,2,3,4,5])\
    .filter(lambda x:x%2 === 0)\
    .map(console_log)\
    .reduce(lambda num_set, val: num_set.__setitem__(val,True))

将map 替换为mpmap 用于多处理映射，或fastmap 用于多线程映射。

Answer 7

我们可以为此使用Pyterator（免责声明：我是作者）。

我们定义了打印和返回的函数（我相信你可以完全省略）。

def print_and_return(x):
    print(x)
    return x

然后

from pyterator import iterate

even_dict = (
    iterate([1,2,3,4,5])
    .filter(lambda x: x%2==0)
    .map(print_and_return)
    .map(lambda x: (x, True))
    .to_dict()
)
# {2: True, 4: True}

我已将您的 reduce 转换为可以转换为字典的元组序列。