关于python:通过-for-循环比较-Python-与-Ruby-编程思想的差别

作者：Doug Turnbull

译者：豌豆花下猫 @Python 猫

原文：https://softwaredoug.com/blog/2021/11/12/ruby-vs-python-for-loop.html

Ruby 与 Python 之间的差别在很大水平上可通过 for 循环看出实质。

Python 领有 for 语句。对象通知 for 如何进行合作，而 for 的循环领会解决对象返回的内容。

Ruby 则相同。在 Ruby 中，for 自身（通过 each）是对象的一个办法。调用者将 for 循环体传递给这个办法。

在 Python 的语言习惯中，对象模型遵从于 for 循环。而在 Ruby 中，for 循环遵从于对象模型。

也就是说，在 Python 中，如果你想自定义迭代的过程，能够让对象通知解释器该如何作迭代：

class Stuff:
    def __init__(self):
        self.a_list = [1,2,3,4]
        self.position = 0
    def __next__(self):
        try:
            value = self.a_list[self.position]
            self.position += 1
            return value
        except IndexError:
            self.position = 0
            raise StopIteration
    def __iter__(self):
        return self

在这里，Stuff 应用 \_\_next\_\_ 和 \_\_iter\_\_ 魔术办法使本身可迭代（变为了可迭代对象）。

for data in Stuff():
    print(data)

然而，在 Ruby 的用法中，你要做的恰恰相反。你要将 for 创立成一个办法，它接管代码（body 体）来运行。Ruby 将过程代码放在代码块中，这样它们就能够被用于传递。

而后，在 each 办法中，应用 yield 与代码块进行交互，将值传递给代码块来做你须要做的事件（对于任何办法，代码块都是一种隐式参数）。

如果咱们重写下面的代码，会成这样：

class Stuff
  def initialize
    @a_list = [1, 2, 3, 4]
  end

  def each
    for item in @a_list
      yield item
    end
  end
end

应用 each 进行迭代：

Stuff.new().each do |item|
  puts item
end

不是将数据传给 for 循环（Python），而是将循环代码传给数据（Ruby）。

但区别还远不止于此：

Python 构建相似于 for 的构造，用于各种解决；Ruby 将数据处理工作放到办法中。

优良的 Python 代码应用列表和字典解析式来实现map 和filter，这些表达式的外围与 for/ 迭代的语义是雷同的。

In [2]: [item for item in Stuff()]
Out[2]: [1, 2, 3, 4]

In [3]: [item for item in Stuff() if item % 2 == 0]
Out[3]: [2, 4]

Ruby 则持续应用办法优先的形式，除了each 办法，还有一系列罕用于解决汇合的新办法，如下所示：

class Stuff
  ...

  def select
    out = []
    each do |e|
      # If block returns truthy on e, append to out
      if yield(e)
        out << e
      end
    end
    out
  end

  def map
    out = []
    # One line block syntax, append output of block processed on e to out
    each {|e| out << yield(e) } 
    out
end

puts Stuff.new().map {|item| item}
puts Stuff.new().select{|item| item.even?}

Python 说：“你通知咱们如何迭代你的实例，咱们将决定如何解决你的数据。”Python 有一些基于语言的用作迭代和解决的原语，如果要自定义迭代，只需将正确的代码增加到 for 循环体（或表达式）中。

Ruby 反转了剧本，赋予对象更深层的可定制性。是的，在某些状况下，咱们能够在代码块中增加更多的控制流。是的，咱们也能够把 each 办法用来做 map。然而 Ruby 容许对象们实现不同的 map 和 each（如果将“each”的实现用于“map”，可能会十分不现实，甚至不平安）。Ruby 的对象在解决其数据方面，有着更好的办法。

在 Ruby 中，对象管制着性能可见性。而在 Python 中，是语法做着管制。

纯粹的 Python 对数据处理有着强势的认识。Python 说：“看，90% 的代码都能很好地融入这些想法，只有听从它，实现工作就行了。”把你的对象变成能够 for- 循环的，别再烦我了。

然而 Ruby 说：“在一些重要的状况下，咱们不想给调用者太多能力。”所以 Ruby 让对象去管制它们被解决的形式，并要求开发人员遵循对象想要被交互的形式。Ruby 在数据处理上没那么强势。

Python 更像是基于 C 语言的“面向对象”编程的扩大。在基于 C 的 OO 中，就像 posix 文件描述符或 Win32 窗口句柄一样，语言并不强制将“办法”与对象自身绑定。相同，对象到办法的绑定只是基于约定。

Python 认为这个过程世界是能够进化的——它降级了这种思维形式，使之更平安。自在函数是存在的（Python 猫注：应该指的是内置函数，因不依赖于任何类对象，故是“自在的”），而且的确常常比对象办法更受举荐。对象是存在的，但以一种绝对犹豫的形式。

类办法接管“self”作为其第一个参数，简直与 Win32 或 Posix API 中的 C 函数承受句柄的形式雷同。当函数被传递时，它们简直被当作 C 函数指针来看待。

Python 认为程序范式（procedural paradigm）是最重要的，它是所有的要害根底，在它之上是面向对象的语义层。

然而，Ruby 却将其颠倒过去。Ruby 将面向对象作为金字塔的根底。Ruby 在代码块中蕴含了凌乱的过程世界，让对象应用这些过程块。

Ruby 并没有为了遵循语言的过程性根底而毁坏对象，而是使过程性代码适应对象的世界观。Ruby 有真正的公有办法，不像 Python 的公有办法 / 参数，只是出于约定。

毫无疑问，当我从零碎编程的角度接触 Python 时，它对我的观感来说是很天然的。具备着在必要的时候编写 C 语言的能力，它进化了，令那个世界更加平安。兴许这就是为什么它在系统资源密集的数值计算畛域中，找到了用武之地。

难怪 Ruby 很适宜开发人员构建更晦涩、兴许更平安的 API 和 DSL。Ruby 心愿程序员对畛域进行建模，而不是对编程环境进行建模，这对于许多工作来说，仿佛是正确的办法。