2012年6月3日星期日

旁观者清 Python与Ruby各有千秋


【51CTO独家特稿】关于Ruby和Python之间的对比在网上有太多的口水,但我却没有发现真正有用的讨论,因为大家总是围绕双方的功能差异进行争辩,这样下去显得毫无意义,其实该有的双方都会有,要不然有一方肯定早已被另一方消灭。
虽然我个人更喜欢Python,但并不代表Python就比Ruby功能要多,要比Ruby强大,也无法教唆其他人也跟我一样选择Python,因为每个人的口味都不一样。因此,客观地列出双方的不同点能够有效地避免大量的口水之争,注意我们不谈语法上的差异,那完全没有意思,另外,如果你觉得本文列出的项目有带有主观色彩的,你也可以谈谈你的看法。
Ruby在类主体中有类引用
在Ruby中,你可以引用类主体中的类(self),在Python中就不行。Ruby代码示例:
  1. class Kaka  
  2.   puts self  
  3. end 
这里的self是一个类,上面这串代码将会输出“KaKa”,在Python中,没有办法输出类名或从类定义主体中访问类。
Ruby中的所有类都是可变的
它允许你为核心类开发扩展,下面是一个rails扩展示例:
  1. class String  
  2.   def starts_with?(other)  
  3.     head = self[0, other.length]  
  4.     head == other  
  5.   end  
  6. end 
Python(假设没有’’.startwith方法):
  1. def starts_with(s, prefix):  
  2.     return s[:len(prefix)] == prefix 
你可以在任何序列(不只是字符串)上使用它,但必须明确地导入它,如:
  1. from some_module import starts_with
  2.  
Ruby有类似Perl的脚本功能
Ruby有一个regexps类,$-变量,awk/perl逐行输入循环和其它功能使它更适合编写小型shell脚本。
Ruby有类延续
Ruby有这个特性都是得益于callcc语句。在Python中,你可以用多种不同的技术创建延续,但语音本身并没有内置支持这项特性。
Ruby有块
使用do语句,你可以在Ruby中创建多行匿名函数,它将会作为一个参数传递给do前面的方法。在Python中,你可以传递一个方法或使用发生器实现同样的目的。
  1. Ruby:  
  2.  
  3. amethod { |here|  
  4.     many=lines+of+code  
  5.     goes(here)  
Python(Ruby块与Python中不同的构造对应):
  1. with amethod() as here: # `amethod() is a context manager  
  2.     many=lines+of+code  
  3.     goes(here) 
  1. for here in amethod(): # `amethod()` is an iterable  
  2.     many=lines+of+code  
  3.     goes(here) 
  1. def function(here):  
  2.     many=lines+of+code  
  3.     goes(here)  
  4.  
  5. amethod(function)  # `function` is a callback 
有趣的是,Ruby中调用块的语句叫做“yield”,在Python中它将创建一个发生器。
Ruby:
  1. def themethod  
  2.     yield 5  
  3. end  
  4.  
  5. themethod do |foo|  
  6.     puts foo  
  7. end 
Python:
  1. def themethod():  
  2.     yield 5  
  3.  
  4. for foo in themethod():  
  5.     print foo  
虽然原理不一样,但结果非常类似的。
Ruby支持更容易的功能性编程(管道式)
  1. myList.map(&:description).reject(&:empty?).join("\n") 
  2.  
Python:
  1. descriptions = (f.description() for f in mylist)  
  2. "\n".join(filter(len, descriptions)) 
     Python内置有发生器(和Ruby中的块用法类似)
Python支持发生器,在Ruby中,你也可以使用发生器模块,但要使用延续从一个块创建一个发生器,或者使用块/proc/lambda,此外,Ruby 1.9中的纤程(Fibers)也可以作为发生器使用。docs.python.org提供了发生器示例:
  1. def reverse(data):  
  2.     for index in range(len(data)-1, -1, -1):  
  3.         yield data[index] 
请与上面的块示例代码对比。
Python有灵活的命名空间处理方法
在Ruby中,当你使用require导入一个文件时,文件中定义的所有项目将会在你的全局命名空间中结束,这会导致命名空间污染,解决办法是Ruby模块,但如果你使用模块创建了一个命名空间,你必须使用该命名空间访问包含的类。
在Python中,文件也是一个模块,你可以使用“from themodule import *”导入它包含的名字,虽然这样也会污染命名空间,但可以使用“from themodule import aname, another”或简单地“import themodule”导入选择的名字,然后使用“themodule.aname”访问名字。
Python有文档字符串(docstrings)
文档字符串是附加到模块、函数和方法的字符串,它有助于创建帮助命令和自动化文档。
  1. def frobnicate(bar):  
  2.     """frobnicate takes a bar and frobnicates it  
  3.  
  4.        >>> bar = Bar()  
  5.        >>> bar.is_frobnicated()  
  6.        False  
  7.        >>> frobnicate(bar)  
  8.        >>> bar.is_frobnicated()  
  9.        True  
  10.     """  
Ruby的与Javadocs类似,它们可以在运行时使用1.9的“方法#源位置”从文件检索。
Python有更多的库
Python有大量的模块和绑定的库。
Python有多重继承
Ruby没有多重继承。它作为抽象类类型重复使用模块。
Python有列表/字典理解能力
Python:
  1. res = [x*x for x in range(1, 10)] 
  2.  
Ruby :
  1. res = (0..9).map { |x| x * x } 
  2.  
Python:
  1. >>> (x*x for x in range(10))  
  2. <generator object <genexpr> at 0xb7c1ccd4> 
  3. >>> list(_)  
  4. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 
Ruby:
  1. p = proc { |x| x * x }  
  2. (0..9).map(&p) 
Python 2.7+:
  1. >>> {x:str(y*y) for x,y in {1:2, 3:4}.items()}  
  2. {1: '4', 3: '16'} 
Ruby:
  1. >> Hash[{1=>2, 3=>4}.map{|x,y| [x,(y*y).to_s]}]  
  2. => {1=>"4", 3=>"16"} 
Python有装饰器
与Ruby中创建的装饰器类似,但Ruby中的装饰器不像Python中那样重要,它是非必需的。
原文作者:Lennart Regebro
原文名:What does Ruby have that Python doesn’t, and vice versa?
原文地址:http://stackoverflow.com/questions/1113611/what-does-ruby-have-that-python-doesnt-and-vice-versa
【编辑推荐】
  1. Python编程语言与Ruby之间的比较
  2. 捕捉Ruby正则表达式用法精髓
  3. Python等动态语言企业应用面面观 
  4. Python线程编程比ruby应用的优点

没有评论:

发表评论