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 代码使用列表和字典解析式来实现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 的对象在处理其数据方面，有着更好的方法。

地道的 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 希望程序员对领域进行建模，而不是对编程环境进行建模，这对于许多工作来说，似乎是正确的方法。

原文来自：

本文地址：//q13zd.cn/for-python-ruby.html编辑：xiangping wu，审核员：逄增宝

Linux大全：

Linux系统大全：

红帽认证RHCE考试心得：