•  

  Python支持发生器，在Ruby中，你也可以使用发生器模块，但要使用延续从一个块创建一个发生器，或者使用块/proc/lambda，此外，Ruby 1.9中的纤程（Fibers）也可以作为发生器使用。docs.python.org提供了发生器示例：

        
  
         
  
          
           
            def reverse(data):  
           
          
         
         
  
          
               for index in range(len(data)-1, -1, -1):  
          
         
         
  
          
                   yield data[index] 
          
         
        
       

  请与上面的块示例代码对比。

  Python有灵活的命名空间处理方法

  在Ruby中，当你使用require导入一个文件时，文件中定义的所有项目将会在你的全局命名空间中结束，这会导致命名空间污染，解决办法是Ruby模块，但如果你使用模块创建了一个命名空间，你必须使用该命名空间访问包含的类。

  在Python中，文件也是一个模块，你可以使用“from themodule import *”导入它包含的名字，虽然这样也会污染命名空间，但可以使用“from themodule import aname, another”或简单地“import themodule”导入选择的名字，然后使用“themodule.aname”访问名字。

  Python有文档字符串（docstrings）

  文档字符串是附加到模块、函数和方法的字符串，它有助于创建帮助命令和自动化文档。

        
  
         
  
          
           
            def frobnicate(bar):  
           
          
         
         
  
          
               """frobnicate takes a bar and frobnicates it  
          
         
         
  
          
            
          
         
         
  
          
                  
          
          
           >
          
          
           >
          
          
           >
          
          
            
          
          
           bar
          
          
            = 
          
          
           Bar
          
          
           ()  
          
         
         
  
          
                  
          
          
           >
          
          
           >
          
          
           >
          
          
            bar.is_frobnicated()  
          
         
         
  
          
                  False  
          
         
         
  
          
                  
          
          
           >
          
          
           >
          
          
           >
          
          
            frobnicate(bar)  
          
         
         
  
          
                  
          
          
           >
          
          
           >
          
          
           >
          
          
            bar.is_frobnicated()  
          
         
         
  
          
                  True  
          
         
         
  
          
               """  
          
         
        
       

  Ruby的与Javadocs类似，它们可以在运行时使用1.9的“方法#源位置”从文件检索。

关于Ruby和Python之间的对比 在网上有太多的口水，但我却没有发现真正有用的讨论，因为大家总是围绕双方的功能差异进行争辩，这样下去显得毫无意义，其实该有的双方都会有，要不然有一方肯定早已被另一方消灭。

51CTO推荐阅读： Python线程编程比Ruby应用的优点

虽然我个人更喜欢 Python ，但并不代表Python就比 Ruby 功能要多，要比Ruby强大，也无法教唆其他人也跟我一样选择Python，因为每个人的口味都不一样。因此，客观地列出双方的不同点能够有效地避免大量的口水之争，注意我们不谈语法上的差异，那完全没有意思，另外，如果你觉得本文列出的项目有带有主观色彩的，你也可以谈谈你的看法。

Ruby在类主体中有类引用

在Ruby中，你可以引用类主体中的类（self），在Python中就不行。Ruby代码示例：

    

     

      
       
        class Kaka  
       
      
     
     

      
         puts self  
      
     
     

      
       end 
      
     
    
   

这里的self是一个类，上面这串代码将会输出“KaKa”，在Python中，没有办法输出类名或从类定义主体中访问类。

Ruby中的所有类都是可变的

它允许你为核心类开发扩展，下面是一个rails扩展示例：

    

     

      
       
        class String  
       
      
     
     

      
         def starts_with?(other)  
      
     
     

      
           
      
      
       head
      
      
        = 
      
      
       self
      
      
       [0, other.length]  
      
     
     

      
           
      
      
       head
      
      
        == other  
      
     
     

      
         end  
      
     
     

      
       end 
      
     
    
   

Python（假设没有’’.startwith方法）：

    

     

      
       
        def starts_with(s, prefix):  
       
      
     
     

      
           return s[:len(prefix)] == prefix 
      
     
    
   

你可以在任何序列（不只是字符串）上使用它，但必须明确地导入它，如：

    

     

      
       
        from some_module import starts_with
       
      
     
     

      
       
         
       
      
     
    
   

Ruby有类似Perl的脚本功能

Ruby有一个regexps类，$-变量，awk/perl逐行输入循环和其它功能使它更适合编写小型shell脚本。

Ruby有类延续

Ruby有这个特性都是得益于callcc语句。在Python中，你可以用多种不同的技术创建延续，但语音本身并没有内置支持这项特性。

Ruby有块

使用do语句，你可以在Ruby中创建多行匿名函数，它将会作为一个参数传递给do前面的方法。在Python中，你可以传递一个方法或使用发生器实现同样的目的。

    

     

      
       
        Ruby：  
       
      
     
     

      
        
      
     
     

      
       amethod { |here|  
      
     
     

      
           
      
      
       many
      
      
       =
      
      
       lines
      
      
       +of+code  
      
     
     

      
           goes(here)  
      
     
     

      
       } 
      
     
    
   

Python（Ruby块与Python中不同的构造对应）：

    

     

      
       
        with amethod() as here: # `amethod() is a context manager  
       
      
     
     

      
           
      
      
       many
      
      
       =
      
      
       lines
      
      
       +of+code  
      
     
     

      
           goes(here) 
      
     
    
   

或

    

     

      
       
        for here in amethod(): # `amethod()` is an iterable  
       
      
     
     

      
           
      
      
       many
      
      
       =
      
      
       lines
      
      
       +of+code  
      
     
     

      
           goes(here) 
      
     
    
   

或

    

     

      
       
        def function(here):  
       
      
     
     

      
           
      
      
       many
      
      
       =
      
      
       lines
      
      
       +of+code  
      
     
     

      
           goes(here)  
      
     
     

      
        
      
     
     

      
       amethod(function)  # `function` is a callback 
      
     
    
   

有趣的是，Ruby中调用块的语句叫做“yield”，在Python中它将创建一个发生器。

Ruby：

    

     

      
       
        def themethod  
       
      
     
     

      
           yield 5  
      
     
     

      
       end  
      
     
     

      
        
      
     
     

      
       themethod do |foo|  
      
     
     

      
           puts foo  
      
     
     

      
       end 
      
     
    
   

Python：

    

     

      
       
        def themethod():  
       
      
     
     

      
           yield 5  
      
     
     

      
        
      
     
     

      
       for foo in themethod():  
      
     
     

      
           print foo  
      
     
    
   

虽然原理不一样，但结果非常类似的。

Ruby支持更容易的功能性编程（管道式）

    

     

      
       
        myList.map(&:description).reject(&:empty?).join("\n") 
       
      
     
     

       
     
    
   

Python：

    

     

      
       
        descriptions
       
       
         = (f.description() for f in mylist)  
       
      
     
     

      
       "\n".join(filter(len, descriptions)) 
      
     
    
   

Python有更多的库

Python有大量的模块和绑定的库。

Python有多重继承

Ruby没有多重继承。它作为抽象类类型重复使用模块。

Python有列表/字典理解能力

Python：

    

     

      
       
        res
       
       
         = [x*x for x in range(1, 10)] 
       
      
     
     

       
     
    
   

Ruby ：

    

     

      
       
        res
       
       
         = (0..9).map { |x| x * x } 
       
      
     
     

       
     
    
   

Python：

    

     

      
       
        >
       
       
        >
       
       
        >
       
       
         (x*x for x in range(10))  
       
      
     
     

      
       <
      
      
       generator
      
      
        object 
      
      
       <
      
      
       genexpr
      
      
       >
      
      
        at 0xb7c1ccd4
      
      
       >
      
      
        
      
     
     

      
       >
      
      
       >
      
      
       >
      
      
        list(_)  
      
     
     

      
       [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 
      
     
    
   

Ruby：

    

     

      
       
        p
       
       
         = 
       
       
        proc
       
       
         { |x| x * x }  
       
      
     
     

      
       (0..9).map(&p) 
      
     
    
   

Python 2.7+：

    

     

      
       
        >
       
       
        >
       
       
        >
       
       
         {x:str(y*y) for x,y in {1:2, 3:4}.items()}  
       
      
     
     

      
       {1: '4', 3: '16'} 
      
     
    
   

Ruby：

    

     

      
       
        >
       
       
        >
       
       
         Hash[{
       
       
        1
       
       
        =
       
       
        >
       
       
        2, 
       
       
        3
       
       
        =
       
       
        >
       
       
        4}.map{|x,y| [x,(y*y).to_s]}]  
       
      
     
     

      
       =
      
      
       >
      
      
        {
      
      
       1
      
      
       =
      
      
       >
      
      
       "4", 
      
      
       3
      
      
       =
      
      
       >
      
      
       "16"} 
      
     
    
   

Python有装饰器

与Ruby中创建的装饰器类似，但Ruby中的装饰器不像Python中那样重要，它是非必需的。

原文作者：Lennart Regebro

原文名：What does Ruby have that Python doesn’t, and vice versa?

来源

呵呵，反正我只会一些ruby，各有特点，自己喜欢就好。