Ruby 與 Python 之間的差異在很大程度上可通過for循環看出本質。

Python 擁有for語句。對象告訴for如何進行協作，而for的循環體會處理對象返回的內容。

Ruby 則相反。在 Ruby 中，for本身(通過each)是對象的一個方法。調用者將for循環體傳遞給這個方法。

[[437079]]

在 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 希望程序員對領域進行建模，而不是對編程環境進行建模，這對于許多工作來說，似乎是正確的方法。

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