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中。