Python 中 Ruby 的 tap 习惯用法

Question

有一个有用的 Ruby 习惯用法，使用 tap ，它允许您创建一个对象，对其进行一些操作并返回它（我在这里仅使用列表作为示例，我的真实代码更复杂） :

def foo
  [].tap do |a|
    b = 1 + 2
    # ... and some more processing, maybe some logging, etc.
    a << b
  end
end

>> foo
=> [1]

Rails 有一个类似的方法，称为 returning，因此您可以这样写：

def foo
  returning([]) do |a|
    b = 1 + 2
    # ... and some more processing, maybe some logging, etc.
    a << b
  end
end

这不言而喻。无论你对对象进行多少处理，它仍然很明显是函数的返回值。

在 Python 中我必须这样写：

def foo():
  a = []
  b = 1 + 2
  # ... and some more processing, maybe some logging, etc.
  a.append(b)
  return a

我想知道是否有办法将这个 Ruby 习惯用法移植到 Python 中。我的第一个想法是使用 with 语句，但 return with 不是有效的语法。

Answer 1

如果你想要这个足够糟糕，你可以创建一个上下文管理器

class Tap(object):
    def __enter__(self, obj):
        return obj

    def __exit__(*args):
        pass

，你可以使用它，如下所示：

def foo():
    with Tap([]) as a:
        a.append(1)
        return a

没有办法绕过 return 语句，并且 with 在这里实际上不做任何事情。但你确实在开始时就有了 Tap ，它可以让你了解我认为该函数的含义。它比使用 lambda 更好，因为您不限于表达式，并且可以在 with 语句中拥有几乎任何您想要的内容。

总的来说，我想说，如果你想要点击那么糟糕，那么就坚持使用 ruby​​，如果你需要用 python 编程，请使用 python 来编写 python 而不是 ruby​​。当我开始学习 Ruby 时，我打算编写 Ruby ;)

Answer 2

我有一个想法使用函数装饰器来实现这一点，但由于Python中表达式和语句之间的区别，这最终仍然需要返回在最后。

根据我的经验，ruby 语法很少使用，而且其可读性远不如显式的 python 方法。如果 python 具有隐式返回或将多个语句包装成单个表达式的方法，那么这将是可行的 - 但它在设计上没有这些东西。

这是我的 - 有点毫无意义 - 装饰器方法，供参考：

class Tapper(object):
    def __init__(self, initial):
        self.initial = initial
    def __call__(self, func):
        func(self.initial)
        return self.initial

def tap(initial):
    return Tapper(initial)

if __name__ == "__main__":
    def tapping_example():
        @tap([])
        def tapping(t):
            t.append(1)
            t.append(2)
        return tapping

    print repr(tapping_example())

Answer 3

我部分同意其他人的观点，因为用 Python 实现这个没有多大意义。然而，恕我直言，Mark Byers 的方式就是方式，但为什么使用 lambda（以及它们附带的所有内容）？不能写一个单独的函数在需要的时候调用吗？

另一种方法可以实现基本相同的功能

map(afunction(), avariable)

，但据我所知，这个漂亮功能并不是 Python 3 中内置的。

Answer 4

几乎没有 Ruby 程序员以这种方式使用 tap。事实上，我认识的所有顶级 Ruby 程序员都说，tap 除了调试之外没有任何用处。

为什么不在你的代码中这样做呢？

[].push(1)

请记住 Array 支持流畅的接口，因此您甚至可以这样做：

[].push(1).push(2)

Answer 5

简短的回答：Ruby 鼓励方法链接，而 Python 则不然。

我想正确的问题是：Ruby 的 tap 有什么用处？

现在我对 Ruby 了解不多，但通过谷歌搜索，我得到的印象是 tap 在概念上作为方法链接很有用。

在 Ruby 中，样式：SomeObject.doThis().doThat().andAnotherThing() 非常惯用。例如，它是流畅界面概念的基础。 Ruby 的 tap 是这种情况的一个特例，它不是使用 SomeObject.doThis()，而是动态定义 doThis。

我为什么要解释这一切？因为它告诉我们为什么tap在Python中没有得到很好的支持。需要注意的是，Python 不执行调用链。

例如，Python 列表方法通常返回 None 而不是返回变异列表。像 map 和 filter 这样的函数不是列表方法。另一方面，许多 Ruby 数组方法确实返回修改后的数组。

除了某些 ORM 等某些情况之外，Python 代码不使用流畅的接口。

归根结底，这是惯用的 Ruby 和惯用的 Python 之间的区别。如果您要从一种语言转向另一种语言，则需要进行调整。

Answer 6

您可以按如下方式在 Python 中实现它：

def tap(x, f):
    f(x)
    return x

用法：

>>> tap([], lambda x: x.append(1))
[1]

但是，它在 Python 2.x 中的用途不会像在 Ruby 中那么多，因为 Python 中的 lambda 函数非常受限制。例如，您无法内联对 print 的调用，因为它是关键字，因此您不能将其用于内联调试代码。您可以在 Python 3.x 中执行此操作，尽管它不如 Ruby 语法清晰。

>>> tap(2, lambda x: print(x)) + 3
2
5