Ruby有什么东西是Python没有的，反之亦然？
有很多关于Python和Ruby的讨论，我都觉得它们完全没有帮助，因为它们都改变了为什么功能X在语言Y中很糟糕，或者说语言Y没有X，尽管事实上确实有。我也知道为什么我更喜欢Python，但这也是主观的，对任何人的选择都没有帮助，因为他们在开发方面可能没有我的品味 因此，客观地列出这些差异是很有意思的。因此，没有Python的lambdas很糟糕。相反，解释Ruby的lambdas可以做什么，Python不能做什么。没有主观性。示例代码很好 请不要在一个答案上有几个不同。对那些你知道正确的投赞成票，对那些你知道不正确或主观的投反对票。此外，语法上的差异也不有趣。我们知道Python对缩进的处理方式与Ruby对括号和结尾的处理方式相同，在Python中，@被称为self 更新：这现在是一个社区wiki，因此我们可以在这里添加重大差异 Ruby在类主体中有一个类引用 在Ruby中，类主体中已经存在对类self的引用。在Python中，直到类构造完成后，才有对类的引用 例如：Ruby有什么东西是Python没有的，反之亦然？,python,ruby,Python,Ruby,有很多关于Python和Ruby的讨论，我都觉得它们完全没有帮助，因为它们都改变了为什么功能X在语言Y中很糟糕，或者说语言Y没有X，尽管事实上确实有。我也知道为什么我更喜欢Python，但这也是主观的，对任何人的选择都没有帮助，因为他们在开发方面可能没有我的品味 因此，客观地列出这些差异是很有意思的。因此，没有Python的lambdas很糟糕。相反，解释Ruby的lambdas可以做什么，Python不能做什么。没有主观性。示例代码很好 请不要在一个答案上有几个不同。对那些你知道正确的投赞成票
class Kaka
puts self
end
class Kaka
puts self
end
class String
def starts_with?(other)
head = self[0, other.length]
head == other
end
end
with amethod() as here: # `amethod() is a context manager
many=lines+of+code
goes(here)
def themethod():
yield 5
for foo in themethod():
print foo
descriptions = (f.description() for f in mylist)
"\n".join(filter(len, descriptions))
res = [x*x for x in range(1, 10)]
>>> (x*x for x in range(10))
<generator object <genexpr> at 0xb7c1ccd4>
>>> list(_)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006
def themethod():
yield 5
for foo in themethod():
print foo
descriptions = (f.description() for f in mylist)
"\n".join(filter(len, descriptions))
res = [x*x for x in range(1, 10)]
>>> (x*x for x in range(10))
<generator object <genexpr> at 0xb7c1ccd4>
>>> list(_)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
def frobnicate(bar):
"""frobnicate takes a bar and frobnicates it
>>> bar = Bar()
>>> bar.is_frobnicated()
False
>>> frobnicate(bar)
>>> bar.is_frobnicated()
True
"""
def themethod():
yield 5
for foo in themethod():
print foo
descriptions = (f.description() for f in mylist)
"\n".join(filter(len, descriptions))
res = [x*x for x in range(1, 10)]
>>> (x*x for x in range(10))
<generator object <genexpr> at 0xb7c1ccd4>
>>> list(_)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006
def themethod():
yield 5
for foo in themethod():
print foo
descriptions = (f.description() for f in mylist)
"\n".join(filter(len, descriptions))
res = [x*x for x in range(1, 10)]
>>> (x*x for x in range(10))
<generator object <genexpr> at 0xb7c1ccd4>
>>> list(_)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006
Ruby需要end或}来关闭其所有作用域，而Python只使用空格。最近在Ruby中有人尝试只允许空格缩进Ruby和Python中的类定义中都有代码。然而，在Ruby中，您有一个对类self的引用。在Python中，您没有对该类的引用，因为该类尚未定义 例如：
class Kaka
puts self
end
class Kaka
puts self
end
class Array
def each
for i in self
yield(i) # If a block has been passed, control will be passed here.
end
end
end
# Add five to each element.
[1, 2, 3, 4].each{ |e| puts e + 5 }
> [6, 7, 8, 9]
Python有匿名函数/closures/lambdas，但它没有很多块，因为它缺少一些有用的语法糖。然而，至少有一种方法可以以特别的方式获得它。例如，请参见.Python有docstring，ruby没有。。。或者，如果没有，它们也不像python中那样容易访问
如果我错了，请留下一个例子？我有一个变通方法，可以很容易地将monkeypatch添加到类中，但我希望以原生方式使用docstring这一特性。Ruby优于Python的是它的脚本语言功能。本文中的脚本语言意味着用于shell脚本中的粘合代码和一般文本操作 这些主要与Perl共享。第一类内置正则表达式、$变量、有用的命令行选项，如Perl-a、-e等 再加上简洁而有力的语法，它非常适合此类任务 Python对我来说更像是一种动态类型的业务语言，非常容易学习，语法简洁。没有红宝石那么酷，但是很整洁。 Python对我来说比Ruby更重要的是其他lib的大量绑定。绑定到Qt和其他GUI库、许多游戏支持库和。Ruby没有那么多。虽然常用的绑定（例如到数据库的绑定）质量很好，但我发现在Python中更好地支持小生境libs，即使对于同一个库也有Ruby绑定
所以，我想说两种语言都有它的用途，这是定义使用哪种语言的任务。两者都很容易学习。我把它们并排使用。Ruby用于脚本编写，Python用于独立应用程序。我认为Ruby没有X，Python没有，而Python有Y，Ruby没有是最有用的方法。它们是非常相似的语言，有许多共同的能力
在很大程度上，不同之处在于语言使其优雅易读。以您提到的一个示例为例，理论上两者都有lambda，但Python程序员倾向于避免使用它们，并且使用它们生成的构造看起来不像Ruby中那样可读或惯用。因此，在Python中，一个好的程序员会希望采用与Ruby不同的方法来解决问题，因为这实际上是更好的方法。Python有一种“我们都是成年人”的心态。因此，您会发现Ruby有常数之类的东西，而Python没有，尽管Ruby的常数只会发出警告。Python的思维方式是，如果要使某个对象保持常量，应该将变量名放在所有大写字母中，而不是更改它 例如，Ruby：
>> PI = 3.14
=> 3.14
>> PI += 1
(irb):2: warning: already initialized constant PI
=> 4.14
def themethod():
yield 5
for foo in themethod():
print foo
descriptions = (f.description() for f in mylist)
"\n".join(filter(len, descriptions))
res = [x*x for x in range(1, 10)]
>>> (x*x for x in range(10))
<generator object <genexpr> at 0xb7c1ccd4>
>>> list(_)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006
Ruby有符号和twigil，Python没有 编辑：还有一件非常重要的事我忘了，那就是之前的那件事只是稍微激动一下：-p:
Python有一个JIT编译器，一种美观的低级语言，用于编写更快的代码和添加内联C++代码的能力。
< P> Ruby已经使用Calcc.U/P>构建了继续支持。因此，您可以实现一些很酷的东西，比如Python有一个用于列表理解和生成器的显式内置语法，而在Ruby中，您可以使用映射和代码块 比较
list = [ x*x for x in range(1, 10) ]
我不确定这一点，所以我先添加它作为答案 Python将未绑定的方法视为函数 这意味着您可以像Object.themethod那样调用方法，也可以通过class.themethodanobject调用方法 编辑：虽然方法和函数之间的区别在Python中很小，在Python3中不存在，但它在Ruby中也不存在，因为Ruby没有函数。定义函数时，实际上是在对象上定义方法 但是您仍然不能将一个类的方法作为函数调用，您必须重新绑定 它指向您要调用的对象，这是一个非常困难的问题。其他人来自： 如果我误解了Ruby页面更新后，Ruby方面的任何内容或其中任何内容发生了更改，那么有人可以自由编辑 在Ruby中，字符串是可变的，而在Python中，新字符串是通过更改创建的 Ruby有一些强制的大小写约定，Python没有 Python同时具有列表和元组不可变列表。Ruby有对应于Python列表的数组，但没有不变的变体 在Python中，可以直接访问对象属性。在Ruby中，它总是通过方法实现的 在Ruby中，方法调用的括号通常是可选的，但在Python中不是 Ruby具有public、private和protected来强制访问，而不是Python使用下划线和名称篡改的惯例 Python具有多重继承。鲁比有混血儿 还有一个非常相关的链接： 特别是Alex Martelli的另一篇好文章，他也在这里发布了很多很棒的东西，所以：
您只能从Python中的模块导入特定函数。在Ruby中，导入整个方法列表。你可以在Ruby中消除它们的影响，但这不是它的全部 编辑： 让我们以这个Ruby模块为例：
module Whatever
def method1
end
def method2
end
end
include Whatever
您将看到method1和method2都已添加到您的命名空间中。您不能只导入method1。要么两者都导入，要么根本不导入。在Python中，只能导入所选的方法。如果它有一个名称，可能会被称为选择性导入？Ruby在输入文件上有一个逐行循环，即命令行中的“-n”标志，因此它可以像AWK一样使用。此Ruby one liner：
ruby -ne 'END {puts $.}'
awk 'END{print NR}'
def func(): print "hello"
def another_func(f): f()
another_func(func)
def func2(): print "goodbye"
func = func2
def func; p "Hello" end
def another_func(f); method(f)[] end
another_func(:func) # => "Hello"
def func2; print "Goodbye!"
self.class.send(:define_method, :func, method(:func2))
func # => "Goodbye!"
method(:func).owner # => Object
func # => "Goodbye!"
self.func # => "Goodbye!"
python已经命名了可选参数
def func(a, b=2, c=3):
print a, b, c
>>> func(1)
1 2 3
>>> func(1, c=4)
1 2 4
AFAIK Ruby只定位了参数，因为函数声明中的b=2是一个总是附加的矫揉造作的变量。以大写字母开头的变量成为常量，无法修改 错。他们可以
只有在这样做的情况下才会收到警告。我想提到Python描述符API，它允许自定义对象到属性的通信。还值得注意的是，在Python中，可以通过覆盖通过_getattribute__方法的默认实现给出的默认值来自由实现替代协议。 让我详细介绍一下上述情况。 描述符是带有uuuu get uuuuuuuuuuuuuuuuuuuuuuuuuuu和/或uuuuuuuu delete uuuuuuuuu方法的常规类。 当解释器遇到类似anObj.anAttr的情况时，将执行以下操作： __调用anObj的getattribute_uu方法 __getattribute_uuu从类dict检索anAttr对象 它检查abAttr对象是否具有可调用的对象 上下文（即调用方对象或类）和值（而不是后者，如果我们有setter）被传递给可调用对象 返回结果。 如前所述，这是默认行为。一个是通过重新实现uu getattribute_uu来自由更改协议
这项技术比decorators强大得多。惊讶地发现ruby的方法中没有提到缺少机制。我会给大家举一个例子。。。方法，作为该语言功能强大的一个示例。我的猜测是，类似的东西可以在Python中实现，但据我所知，它不是本地实现的。Ruby有嵌入式文档：
=begin
You could use rdoc to generate man pages from this documentation
=end
我的python已经生锈了，所以其中一些可能是用python编写的，我只是一开始就不记得/从来没有学过，但下面是我想到的最初几个： 空白 Ruby处理空白的方式完全不同。首先，您不需要缩进任何内容，这意味着使用4个空格或1个制表符并不重要。它还可以进行智能线路延续，所以 以下各项有效：
def foo(bar,
cow)
module Humor
def tickle
"hee, hee!"
end
end
a = "Grouchy"
a.extend Humor
a.tickle » "hee, hee!"
>> enum = (1..4).to_enum
=> #<Enumerator:0x1344a8>
def foo(a, others)
others[:b] = 2 unless others.include?(:b)
others[:c] = 3 unless others.include?(:c)
puts "#{a}, #{others[:b]}, #{others[:c]}"
end
foo(1,:b=>3) >> 1, 3, 3
foo(1,:c=>5) >> 1, 2, 5
参考：Ruby实用编程指南我想提出一个原始问题的变体，Ruby有什么Python没有的，反之亦然？这承认了一个令人失望的答案，好吧，你能用Ruby或Python做什么，而Intercal做不到？在这一层面上没有什么，因为Python和Ruby都是坐在图灵逼近者宝座上的庞大王室的一部分 但是这个呢： 在Python中，有什么事情可以优雅而出色地完成，而在Ruby中，有什么事情是无法做到的呢 这可能比单纯的功能比较有趣得多。来自Ruby： 相似性 与Python一样，在Ruby中 有一个叫做irb的交互式提示。 您可以使用ri命令而不是pydoc在命令行上读取文档。 除了通常的换行符外，没有特殊的换行符。 字符串文字可以跨越多行，就像Python的三引号字符串一样。 括号表示列表，大括号表示dict，在Ruby中称为“哈希”。 数组的工作原理是一样的，添加它们可以生成一个长数组，但是像这样组合它们a3=[a1，a2]可以生成一个数组。 对象是强类型和动态类型的。 一切都是一个对象，变量只是对对象的引用。 虽然关键字有点不同，但异常的工作原理大致相同。 您已经拥有了嵌入式文档工具，Ruby的称为rdoc。 分歧 与Python不同，在Ruby中 字符串是可变的。 您可以创建不希望更改其值的常量和变量。 有一些强制的大小写约定，例如，类名以大写字母开头，变量以小写字母开头。 数组中只有一种列表容器，它是可变的。 双引号字符串允许转义序列，如\t和特殊的“表达式替换”语法，该语法允许您将Ruby表达式的结果直接插入到其他字符串中，而无需将+字符串+添加到一起。单引号字符串类似于Python的rraw字符串。 没有“新风格”和“旧风格”课程。只有一种。 您从不直接访问属性。在Ruby中，所有方法调用都是如此。 方法调用的括号通常是可选的。 有public、private和protected来强制访问，而不是Python的u自愿uuu下划线uu约定uu。 使用“mixin”代替多重继承。 您可以添加或修改内置类的方法。这两种语言都允许您随时打开和修改类，但Python阻止了对内置的修改，Ruby则没有。 你得到了真与假而不是真与假，零而不是无。 当测试真值时，只有false和nil评估为假值。其他一切都是正确的，包括0、0.0和[]。 是艾尔希夫而不是伊莱夫。
这是必需的，不是进口的。但除此之外，用法是相同的。 用于生成文档的是物品上方行上的常规样式注释，而不是物品下方的docstring。 有很多捷径，虽然能让你记住更多，但你很快就能学会。他们倾向于让Ruby变得有趣和高效。
在基础设施方面有更多内容： < Python通过C++之类的东西，比Ruby更好地集成了C++，其中选项似乎直接写入Ruby解释器API，当然也可以使用Python来编写，但是在这两种情况下，这样做都是低级别、乏味和容易出错的，或者使用SWIG，如果你想支持多种语言，它是有效的，而且肯定很棒，如果你想绑定C++，，它就不如Booost。python或SIP好。 Python有许多web应用程序环境Django、Pylons/Turbogears、web.py，可能至少有六个，而Ruby实际上有一个：Rails。其他RubyWeb框架确实存在，但似乎很难获得Rails的支持。这方面是好还是坏？很难说，而且可能相当主观；我可以很容易地想象Python的情况更好，Ruby的情况更好 在文化上，Python和Ruby社区似乎有些不同，但我只能暗示一下，因为我没有太多与Ruby社区交互的经验。我加上这句话主要是希望有人对bo有很多经验 他可以放大或拒绝这种说法
Python和Ruby之间lambdas的另一个区别是paulgraham的问题。此处转载： 编写一个函数foo，它接受一个数字n并返回一个接受一个数字i的函数，然后返回n乘以i的增量。 注意：a是数字，不是整数，b是递增的，不是加号。 在Ruby中，您可以执行以下操作：
def foo(n)
lambda {|i| n += i }
end
class foo(object):
def __init__(self, n):
self.n = n
def __call__(self, i):
self.n += i
return self.n
在这个阶段，Python仍然有更好的unicode支持最终，所有的答案在某种程度上都是主观的，到目前为止发布的答案几乎证明，你不能以同样好的方式（如果不是类似的方式）指出任何一个在另一种语言中不可行的特性，因为两种语言都非常简洁和富有表现力 我喜欢Python的语法。然而，您必须比语法更深入地挖掘，才能找到Ruby的真正魅力。在Ruby的一致性中有着天籁般的美。虽然没有一个简单的例子可以完全解释这一点，但我会尝试在这里提出一个例子来解释我的意思 颠倒此字符串中的单词：
sentence = "backwards is sentence This"
sentence.split.reverse.join ' '
" ".join(reversed(sentence.split()))
这并不难理解，但它的流程并不完全相同。主题句被埋葬在中间。这些操作是函数和对象方法的混合。这是一个微不足道的例子，但是当你真正使用和理解Ruby时，你会发现许多不同的例子，特别是在非平凡的任务上。语法不是一件小事，它直接影响我们的思维方式。它还直接影响我们为使用的系统创建的规则。例如，我们有运算顺序，因为我们写数学方程或句子的方式。数学的标准符号允许人们以多种方式阅读，并根据同一等式得出不同的答案。如果我们使用前缀或后缀符号，我们将创建规则来区分要处理的数字，而不仅仅是计算值的顺序规则 标准的表示法使我们清楚地知道我们谈论的是什么数字，同时确定了使用的顺序 计算它们是不明确的。前缀和后缀符号使计算顺序变得简单，同时使数字变得不明确。如果不是因为语法空白造成的困难，Python可能已经有了多行lambda。有人建议在不必添加显式块分隔符的情况下完成这类工作 我发现在条件为false时编写条件更容易，使用Ruby中的除非语句编写条件要比使用Ruby或其他语言（例如）中语义等价的if not构造容易得多。如果人们现在使用的大多数语言在功能上是平等的，那么每种语言的语法怎么能被认为是一件小事呢？除了诸如块和继承机制等特定功能之外，语法是语言最重要的部分，几乎不是表面的东西
表面上看，我们把美的审美品质归因于句法。美学与我们的认知方式无关，语法与之无关。你能为你的第一点提供更多的细节吗？示例代码是个好主意，我补充说，即使这个例子很小。@SilentGhost:我现在想不出一个不是很模糊的例子您可以在python中访问类内的类名：class foo:def init__self:print self.\u_class.\u_name__@txwikinger:是的，但不在类的主体内，它与class语句同时执行。@Lennart:除了您的示例非常可怕之外，它在语法上也是错误的。@unbeknow:A，对。但如果这是一个函数而不是一个打印，它就会工作。在Python3中，这是有效的：[printe+5代表[1,2,3,4]中的e]当谈到可怕时，我认为上面的ruby代码是可怕的，因此这显然是主观的，因此不是这个问题的一部分@约翰，我不是说它是等价的，我是说它与你的例子的区别不明显@巴斯蒂安，不，但是你可以做相似的事情并不意味着它们是一样的。这里的差异应该列出，即使有其他方法可以做到这一点。我是一个Python程序员。我想看一个例子，说明Ruby块如何帮助您编写比Python更简洁、更漂亮的东西，因为它没有块。您的示例可以写成：对于[1,2,3,4]中的i:printi+5。它不使用块，但简洁美观，每个示例都有ruby。@Manuel，procs用于将函子附加到非平凡的数据结构树、图。。。它不能是“for循环”的，因此需要特殊的迭代器来执行。块是匿名过程，允许您在一个表达式中实现函子，而不是定义然后实现，这大大加快了编码过程并澄清了意图。例如，如果您正在创建一个图形数据结构，您可以定义一个“each”迭代器，然后混入Enumerable，这将立即允许您访问几十个迭代器sort、all？、any？、grep。现在你把一个块叫做…@RommeDeSerieux，因为它需要一个语言名称！此外，它是一个函数对象，而不是函数。让我们看看Ruby文档：Proc对象是绑定到一组局部变量的代码块，因此匿名Proc就是这个块，当然不仅仅是一个函数！没有docstring，但是有RDoc。所以，是的，不容易访问，但不是100%隐藏。Ruby不使用DocString。Omar：是的，我知道rdoc，但顺便说一句，它们不像python的docstring那样容易访问。例如，如果我有一个类，并且我想从该类中输出rdoc文档，那么这将是一项非常繁重的工作。我所做的是生成我试图保存的ri文档，然后获取该信息vi ri本身。显然没有达到python的docstrings的级别。docstrings可用于提供doctest。Ruby有类似的东西吗？是的，它叫Ruby Doctest。就doctest而言，真正重要的是您在某个地方有可读的文档，其中包含可测试的代码片段——无论是在docstring中还是在注释中都没有区别。我同意lambda的范围有限，在很多情况下都没有用。但是，我不认为说Python程序员像躲避瘟疫一样避开它们是公平的，我同意Lambda经常与Python一起使用，比如map、filter、reduce。最大的区别似乎是Python lambda仅限于表达式，而Ruby块可以是多行的，并且包含语句。从我读到的关于Ruby的内容中，我的总体印象是，Ruby的这一特性特别让Ruby开发者倾向于DSL方法，而Python开发者更倾向于创建API。不过，我对Ruby的了解仍然很肤浅。@Lennart:Ruby中经常使用多行块，这比我在惯用Python代码中看到的lambdas要频繁得多
很好。有关常见示例，请参见。@Lennart:不，它不使用yield。Ruby的收益率与Python完全不同——它不返回生成器。在回应中为格式而写是没有意义的。respond_to方法没有返回任何有意义的内容——它只是响应当前的HTTP请求。response_to do中的do是块的开始。在这个例子中，我们讨论了一个标记为format的临时对象，该对象实现了一个非常基本的DSL，用于响应HTTP请求。您能否针对生成器“mixin Enumerable”，并立即获得30个新的优秀迭代器？在理解为什么block/proc很棒之前，你需要从整体上看一下语言。没错，但这只是语法。如果你想走这条路的话：它们都是图灵完备的。其他一切都只是语法。是的，还有一个重要的语法差异-如果你写@foo或self.foo有多重要？@Jörg：好吧，那就把它叫做语法以外的东西吧。关键是@foo和self.foo做的是同一件事，它实际上不是Ruby拥有的功能，Python没有。一个还不了解Ruby的人问：$变量是什么意思？你是说全局变量吗？如果是这样，在Python中，在类或函数之外的模块中定义的变量是全局变量。如果没有-区别是什么？Anon：如果在代码中的任何地方声明$variable，它是全局的，因为前缀。因此，定义在哪里并不重要，它始终是全局的，并且总是这样。不完全是，实际上我指的是预定义的变量，如$\u、$1等。这些变量由ruby本身自动填充值。$\u是最后一行$1、$2等是上次匹配的正则表达式匹配项。请看这里的完整列表：它基本上是一种对紧凑脚本的攻击。您也可以通过API调用获取所有信息，但使用$variables更简洁。这种类型的变量不适合Python的风格，他们故意忽略了它们。感谢Zensider链接-一直在寻找类似的东西来快速体验Ruby。哦，对了！Python喜欢名称空间。Ruby不是这样吗？您不需要导入bla；Ruby中的bla.foo？只能导入函数a，不能导入其中的所有函数。例如，如果您包含一个声明3个非静态函数的Ruby模块，那么它们都将包含在您的命名空间中。在python中，您必须从module import*进行编写。这是否会导致大量名称空间混乱？我认为确实如此。这就是我讨厌Ruby模块的原因。Ruby实际上没有一个与python相同的模块系统。require的工作原理基本上是作为文本包含，并在其中检查二聚体包含。您可以滥用模块作为名称空间，但模块实际上有点用词不当。模块基本上是没有新的分配方法的类。它们最好的工作方式是在每个类/对象的基础上共享代码，而不是作为分区库或跨程序共享代码的机制。也就是说，class.instance\u方法：method.bindanobject.call将是等效的ruby.Oh。因此，当你定义一个不在显式类上的函数时，会有某种神奇的主类？是的，在顶层定义的方法是Object.FWIW的私有方法，在Python中，函数和方法实际上是相同的类型，它们的不同行为来自描述符：。但是如果你将它绑定到一个对象，那它就没有解开。Duh.：-它们在Python中也是一样的。只是Ruby实际上没有函数。这意味着我的陈述是正确的。可以像调用Python中的函数一样调用未绑定方法。这实际上很有用，比如说，你可以在一个没有类的对象上调用一个在类上定义的方法，这有时很有用。关于多重继承，只说Ruby没有是不真实的。我想不出在Python中使用多重继承可以做什么，而在ruby中使用modules/mixin继承不能做什么。甚至有争议的是，只包含普通模块就是多重继承。你可以用其他方式做同样的事情，这是一个不成立的论点。你可以在这里用其他方式做任何事。因为模块不是类，所以它不是多重继承。欢迎您提供Pythons多重继承与Rubys模块的代码示例。模块不是类，但类是模块。%ruby-e'p Class
ude是多重继承。任何人想质疑这一点，认为它在语义上与多重继承不同，那就是学究。如果效果相同且同样容易实现，那么不一样的东西又有什么意义呢？没有区别的区别哈。。这只是提醒我，至少在Python2.*中，您能够执行True，False=False，True。。。我相信他们已经在python 3.0中正确地修复了这个问题。。。就个人而言，我喜欢该语言强制执行的严格准则，因为它使所有用该语言编写的代码保持一致。它迫使您遵循指导原则，而阅读您的代码的开发人员可以一目了然。虽然大多数Python程序员使用相同的通用风格，但我看到了Ruby中不可能出现的一些相当大的不一致性。@bias-我不知道你为什么要否决我。这个答案不同意或不同意python的做事方式。这只是事实陈述。@Jason我们都是成年人，这是事实陈述吗？我认为这是一种围绕某个功能的观点，因此投票结果是否定的。@bias-说我们都是成年人并不是轻蔑的意思。这是一个非官方的Python座右铭，我认为这里最好解释一下：列表理解如何不是一个简单的Python？Python中也有一个映射函数，但是RubyPython中没有列表理解语法：res=maplambda x:x*x，range1,10Python:res=map2。除了缺少自动循环之外，您不能将两条语句放在一行中，并将其作为单个字符串命令行参数传递给解释器。至少我没能做到。你当然可以。但是你会像使用任何otehr语言一样需要用引号括起来。Python不是用来在命令行上使用的，因为如果你想用Python-c import sys；打印lenlistsys.stdinI希望我能理解callcc。你能给出一个比麦卡锡的模棱两可的操作符更普通的应用场景来欣赏它的merrits吗？我指的是真实世界的东西，不是那些时髦的CS的东西？！时髦的CS是真的。花点时间来学习：Python有get_属性，它基本上完成了与Ruby的method_missing相同的事情。为什么每当提到Ruby时，Python开发人员总是受到如此大的伤害？您不能否认这不是真的。在某些情况下，可以在Python中模拟method_missing：类M:def\uu getattr\uu self，n:return lambda:missing！+N你好。但是，有一些细微的区别，我怀疑它在Python中是否惯用：-@DJTripleThreat:我否认这是真的。docstring最终成为您设置它们的方法/类的一部分。因此，您可以使用helpclass，它将向您显示docstring等。Ruby只定位了参数，因为函数声明中的b=2是一种做作，总是附加甚至意味着什么？不知道您生活在哪个星球上，但def my_methodparam1，optional=false在Ruby 1.8.6、1.8.7和大概1.9中起作用！邪恶的跳蚤，还有那些对他的评论投了赞成票的人，你没有仔细看这个例子。他可以跳过func调用中的b参数，它仍然保持默认值。也就是说，b是签名中的第二个参数，但他可以通过在第二个参数前面加上c=，跳过它。Ruby使用散列来模拟这一点，但并不完全相同。您的第二个示例foo1，c=5并不像您认为的那样。Ruby没有命名参数。Python在括号内有隐式行继续符，[或]{在ruby中，您可以简单地冻结数组，将其更改为不可变的。Alex Martelli的优秀帖子：您非常困惑。第一类对象是通过赋值：x=y分配的，而不是通过调用self.class.send:define_method，：func，method:func2分配的。您的反例显示了ruby的函数不是第一类的。如果您不同意，请随意发布您自己的答案；不要把您的困惑放在我的问题上。def…end在ruby中定义的东西不是函数。它们是内核中您定义它们的方法。方法可以使用method方法解除绑定，然后是对象。ruby与函数最接近的东西是Proc实例，它们也是对象，并且可以可以传递或调用。正如John Feminella所讨论的，它还有一种特殊的语法，用于将单个回调过程传递给一个方法。@Glenn：我明白你的意思，但我要反驳的是，Ruby的重新定义函数-方法是一个独立的语义概念。如果你想玩定义游戏，最重要的代码是p过程，而不是函数。我并不是故意刁难，只是我相信定义和精确性很重要。我同意操纵一个未绑定的方法可能是一个空想。@Glenn:美在旁观者的眼里。尽管如此，方法通过实现
在这个例子中，我指的是维基百科的定义。也许，你对头等舱还有别的定义？他们需要白金飞行常客卡才能升到头等舱吗？@Glenn请查看常见问题解答部分，以便其他人可以编辑我的资料这是一个社区维基。你的第二点充其量是误传的。您应该从查看Rack和SinatraI开始，明确指出存在其他Rails堆栈；我只是不认为有人真的在使用它们。检查Sinatra和Rack并没有完全改变这种印象。你真的认为，比如说，Sinatra 94个问题总数，或者Camping 2个问题总数，或者其他任何一个，实际上有一个真正的用户群/社区吗？据我所知，他们中的大多数甚至没有现实生活中的用户。与Django 4K+或Rails 7K+相比，甚至与web.py相比，Sinatra实际上因其DSL而在不同的轻量级任务中相当受欢迎。因为Rail的MVC提供了更多的功能，所以它很少被使用。Rails实际上是建立在机架上的——这就是Phusion Passenger的可行性所在。在Python中不能增加数字，所以这种限制毫无意义。在Python中，数字是不可变的。如果我们改为加号，那么这个类就没有必要了。因此，这并没有证明任何关于lambda差异的东西，而是数字如何工作的差异。当然，除非您创建一个可变数字类：限制是为了澄清所需的行为。这个问题要求的是：f=foo10f2>>12f3>>15。。。lambda{i | n+i}给出：f=foo10f2>>12f3>>13。。。数字在Ruby中也是不可变的——例如，不能说2+=1。在常规Python函数中，n+=1也可以，但在lambda函数中则不行。因此，问题在于n是什么，它是在调用函数并形成lambda时创建的，可以在lambda中赋值，而不仅仅是在表达式中赋值，并且它可以在多次调用中保存n的值。我认为在Python中不需要这么长的长度。可以在其他函数中定义函数。def foon:def fi:return n+i return f。尽管如此，它仍然不相同，您的示例与上面注释中的Python lambda是等效的。Ruby版本创建一个lambda，它在调用之间保持状态。您发布的示例允许您为n配置一个起始值，但是foo返回的函数将始终具有该起始值。Ruby版本会递增。让我们假设f=foo10。Python版本：f1=>11，f1=>11。Ruby版本f.call1=>11，f.call1=>12.def foon:L=[n]def fi:L[0]+=i返回L[0]返回f。在Python3中，你可以使用非本地关键字。我同意。Ruby在我写它的时候似乎是自然流畅的，所以zenlike是一个很好的术语。这应该是一个评论，而不是一个新的答案。这个评论的长度是评论中允许的长度的三倍，不管代表是什么。这对我来说实际上是一个很好的答案。这是一个注释位。它是必需的，而不是导入。但除此之外，用法是相同的。似乎完全不准确。Ruby中也有人们很少使用的集合，但它们是内置的。所以我可以说，stuff\u in\u backpack=Set.new；如果一个语言给你一个操作的警告，我认为你很好地认为操作是不可能的。其他任何事情都是疯狂的，充其量只是一句评论。还是我的+1