python vs ruby

1.python是弱对象语言， 而ruby是纯对象语言
python可以没有对象运行，但是ruby的根基就是Object。
而且python对于封装的约束比较弱，而ruby相对较强。
比如一个class的实例dog。
python：dog.name = "dogy" 相当于给dog赋予了一个属性
ruby: dog.name = "dogy" 报错，dog没有name属性。

2.继承的实现不同
python的结构就是一个dictionary， 不论是class还是function，只要不是基本数据类型，内部的就够都是key，value形成的字典结构。函数是数据，也是函数。
比如：
class Dog():
    name = "didi"
    def spark(self):
       print "i am a dog"

Dog.name 和 Dog.spark 都是数据，一个是字符串，一个是unbunded method。
如果在spark后加上（），就是call spark方法。
用dir(Dog)可以看到它的字典里有什么。

对于function也是一样的。 这和javascript很像。

class Cat(Dog):
pass

Cat继承了Dog内部整个的dict，Dog有的东西，Cat全有。

而ruby就不一样了

ruby根基就是Object。
Object中包括了属性，对象方法和实例方法。
这些东西都是区别对待的，而不是一股脑的都放到dict中去。
class不能直接调用实例方法，只能调用自己的方法（又称为静态方法）
而继承的时候，也只有实例方法被子类继承，父类自己的方法不被继承。


3.class 和module

python 和ruby中的module都是可以定义类和function。
但是ruby module可以被class include 进去，把function mixin进去。而python的module不能。
ruby的module也有instance method 和object method之分。

4.ruby是单继承， python是多继承
但是ruby的mixin功能实际上提供了多继承的实现。

5. python和ruby的metaprogramming也有一些不同

ruby对于class 的重复定义的处理是叠加，而python而是后定义的class冲掉前面的同名class。

而对于function的操作比较类似，可以定义新的function，和修改现有的function，从而实现AOP。

python aop 实现：
# usually , decrator is the tools to modify existing method
def trace(function):
def new(self, *tuple, **dict):
print "called here"
function(self)
return new


class Dog():
@trace
def spark(self):
print " I  am qiang qiang! "


#actually, decrator is just a nice way to modify function.
#bwlow is the more understandable way to do it.

class Dog():
def spark(self):
print " I  am qiang qiang! "
spark = trace(spark)

Dog().spark()
# or
# Dog.spark(Dog(), (), a = "a")

ruby AOP实现
require 'permission_filter'

class Dog
  attr_accessor :errors
 
  def spark word
    return word
  end
 
  def validate_spark word
    if word.size > 6
      return "length too lone"
    end
  end
end

class Dog
  include PermissionFilter
  check_permission_of :spark, :validator => "validate_spark"
end

module PermissionFilter
  def self.included base
    base.extend PermissionMethods
  end
end

module PermissionMethods
  def check_permission_of action, args = {}
    validator = args[:validator]
    old_action = "old" + action.to_s
    alias_method old_action.to_sym, action.to_sym
    self.class_eval %Q{
      def #{action} *args
        error = self.send("#{validator}".to_sym, *args)
        if error.nil?
          self.send("#{old_action}".to_sym, *args)
        else
          self.errors ||= []
          self.errors << error
        end
      end
    }
  end
end

#通过alias_method或者define_method来实现。

5.ruby的module和文件的名字没有关系.而python的module就是文件的名字（python2.5），folder就是package,还要求每一个pakcage下面要有一个__init__文件告诉python这是一个pakcage。


结论：ruby比python更加优雅，并且提供了不逊色于python的灵活性。
而python非常灵活，但是从OO的角度讲，灵活的有点过了。这些不能怪她，人家本来就不是纯OO的语言。应该说是纯module的语言。因为就算直接定义了一个方法， 该方法也是在__main__这个module中运行的。biult_in 方法存在于__biult-in__module中。

python可以说是动态的强类型语言

看到第一点就有问题
ruby 在对象外部只能通过方法与对象通信
dog.name="dogy"你看起来像是属性，其实是调用方法name=("dogy"

我的意思是，python的class，class实例，module和function内部都有自己的dict结构，可以在对象的外部给对象添加属性，就像dog.name='dogy'.
而ruby不能直接在外部修改对象的iv_table.

这样的比较意思不大.
不多说了.
1.python是弱对象语言， 而ruby是纯对象语言
这个为什么?
Python中,一切皆对象; 大道至简.

以前曾经翻译过一篇guido 的访谈，可以看看

http://blog.csdn.net/koalant/archive/2007/05/10/1602982.aspx



实际上 guido 这段说的也不全对， ruby 也可以在 module 定义函数，不一定非在类中定义。

ruby在理想的世界是理想的
python在现实的世界是理想的

python好是好，就是语法很别扭，有点像vb