RubyにはPythonにはないものがあり、その逆は何ですか？
Python対Rubyについては多くの議論がありますが、機能Xが言語Yを吸う理由や、言語YがXを持たないという主張をすべて好転させるため、私は皆、まったく役に立たないと思います実際にはそうです。私がPythonを好む理由も正確に知っていますが、それは主観的であり、私と同じ開発趣味を持っていない可能性があるため、選択する人を助けることはありません。
したがって、違いを客観的にリストすることは興味深いでしょう。だから、「Pythonのラムダはダメ」。代わりに、RubyのラムダがPythonでできないことを実行できることを説明します。主観性なし。サンプルコードは良いです！
1つの答えにいくつかの違いがないようにしてください。そして、あなたが正しいと知っているものに投票し、あなたが知っているものは間違っている（または主観的）ものに投票してください。また、構文の違いは興味深いものではありません。 Pythonはインデントで、Rubyは角括弧と終了で、そして@はPythonではselfと呼ばれます。
更新：これはコミュニティWikiになったため、ここに大きな違いを追加できます。
Rubyにはクラス本体にクラス参照があります
Rubyには、クラス本体に既にクラス（自己）への参照があります。 Pythonでは、クラスの構築が完了するまで、クラスへの参照がありません。
例：
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（''.startswithメソッドがないことを想像してください）：
def starts_with(s, prefix):
return s[:len(prefix)] == prefix
（文字列だけでなく）任意のシーケンスで使用できます。使用するには、明示的にインポートする必要があります。例：from some_module import starts_with。
RubyにはPerlのようなスクリプト機能があります
Rubyには、ファーストクラスの正規表現、$変数、行ごとのawk/Perl入力ループ、およびテキストファイルを変更したり、他のプログラムのグルーコードとして機能する小さなシェルスクリプトの作成に適したその他の機能があります。
Rubyにはファーストクラスの継続があります
Callccステートメントに感謝します。 Pythonでは、さまざまな手法で継続を作成できますが、言語に組み込まれたサポートはありません。
Rubyにはブロックがあります
「do」ステートメントを使用すると、Rubyで複数行の匿名関数を作成できます。この関数は、doの前のメソッドに引数として渡され、そこから呼び出されます。 Pythonでは、代わりにメソッドを渡すか、ジェネレーターを使用してこれを行います。
ルビー：
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でジェネレーターを作成します。
ルビー：
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にはジェネレーターが組み込まれています（上記のRubyブロックのように使用されます）
Pythonは、言語のジェネレーターをサポートしています。 Ruby 1.8では、継続を使用してブロックからジェネレーターを作成するジェネレーターモジュールを使用できます。または、block/proc/lambdaを使用できます！さらに、Ruby 1.9では、ファイバーはジェネレーターであり、ジェネレーターとして使用できます。Enumeratorクラスは組み込みジェネレーターです 4
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で名前にアクセスすることもできます。名前空間にさらにレベルが必要な場合は、モジュールと__init__.pyファイルを含むディレクトリであるパッケージを使用できます。
Pythonにはdocstringがあります
Docstringは、モジュール、関数、およびメソッドに添付される文字列であり、実行時に内観することができます。これは、ヘルプコマンドや自動ドキュメントなどの作成に役立ちます。
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のMethod＃source_location example use を使用して、実行時にファイルから取得できます。
Pythonには複数の継承があります
Rubyは（「目的で」-RubyのWebサイトを参照してください Rubyでの実行方法を参照 ）モジュールの概念を抽象クラスの一種として再利用します。
Pythonにはリスト/ dict内包表記があります
Python：
res = [x*x for x in range(1, 10)]
ルビー：
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]
ルビー：
p = proc { |x| x * x }
(0..9).map(&p)
Python2.7 +：
>>> {x:str(y*y) for x,y in {1:2, 3:4}.items()}
{1: '4', 3: '16'}
ルビー：
>> Hash[{1=>2, 3=>4}.map{|x,y| [x,(y*y).to_s]}]
=> {1=>"4", 3=>"16"}
Pythonにはデコレータがあります
デコレーターに似たものもRubyで作成でき、Pythonほど必要ではないと主張することもできます。
構文の違い
Rubyでは、すべてのスコープを閉じるために「end」または「}」が必要ですが、Pythonは空白のみを使用します。 Rubyには、空白のみのインデントを許可する最近の試みがありました http://github.com/michaeledgar/seamless
RubyとPythonの両方のクラス定義にコードを含めることができます。ただし、Rubyには、クラス（自己）への参照があります。 Pythonでは、クラスがまだ定義されていないため、クラスへの参照がありません。
例：
class Kaka
puts self
end
この場合のselfはクラスであり、このコードは「Kaka」を出力します。 Pythonのクラス定義本体からクラス名を出力したり、他の方法でクラスにアクセスしたりする方法はありません。
Rubyにはblocksの概念があり、これは本質的にコードのセクションを囲む構文糖です。これらはクロージャーを作成し、ブロックを使用する場合と使用しない場合がある別のメソッドに渡す方法です。ブロックは、後でyieldステートメントを介して呼び出すことができます。
たとえば、eachのArrayメソッドの簡単な定義は次のようになります。
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には匿名関数/クロージャー/ラムダがありますが、便利な構文糖の一部が欠落しているため、ブロックはありません。ただし、アドホックな方法で取得する方法が少なくとも1つあります。たとえば、 here を参照してください。
Pythonの例
関数はPythonのファーストクラス変数です。関数を宣言し、オブジェクトとして渡し、それを上書きできます。
def func(): print "hello"
def another_func(f): f()
another_func(func)
def func2(): print "goodbye"
func = func2
これは、現代のスクリプト言語の基本的な機能です。 JavaScriptとLuaもこれを行います。 Rubyは、この方法で関数を処理しません。関数に名前を付けると、それが呼び出されます。
もちろん、Rubyでこれらのことを行う方法はありますが、それらはファーストクラスの操作ではありません。たとえば、関数をProc.newでラップして変数として扱うことができますが、それでは関数ではなくなります。 「呼び出し」メソッドを持つオブジェクトです。
Rubyの関数はファーストクラスのオブジェクトではありません
Ruby関数はファーストクラスのオブジェクトではありません。関数を渡すにはオブジェクトでラップする必要があります。結果のオブジェクトを関数のように扱うことはできません。関数を一流の方法で割り当てることはできません。代わりに、コンテナオブジェクトの関数を呼び出して変更する必要があります。
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の構文が好きです。ただし、Rubyの真の美しさを見つけるには、構文よりも少し深く掘り下げる必要があります。 Rubyの一貫性には、禅のような美しさがあります。これを完全に説明できる些細な例はないかもしれませんが、私が意味することを説明するためだけにここで考えてみます。
この文字列の単語を逆にします。
sentence = "backwards is sentence This"
あなたがそれをどうするかについて考えるとき、あなたは次のことをするでしょう：
- 文を単語に分割する
- 言葉を逆にする
- 単語を再び結合して文字列に戻す
Rubyでは、次のようにします。
sentence.split.reverse.join ' '
まさにあなたがそれについて考えるように、同じシーケンスで、次々にメソッドを呼び出します。
Pythonでは、次のようになります。
" ".join(reversed(sentence.split()))
理解するのは難しいことではありませんが、同じフローはまったくありません。主題（文）は真ん中に埋まっています。操作は、関数とオブジェクトメソッドの組み合わせです。これは取るに足らない例ですが、Rubyを実際に操作して理解するとき、特に重要でないタスクで多くの異なる例を発見します。
Pythonには「私たちはみんな大人です」という考え方があります。したがって、Rubyには定数のようなものがあり、Pythonにはないことがわかります（ただし、Rubyの定数は警告を発するだけです）。 Pythonの考え方では、何かを一定にしたい場合は、変数名をすべて大文字に変えて変更しないでください。
たとえば、Ruby：
>> PI = 3.14
=> 3.14
>> PI += 1
(irb):2: warning: already initialized constant PI
=> 4.14
Python：
>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006
Pythonのモジュールから特定の関数のみをインポートできます。 Rubyでは、メソッドのリスト全体をインポートします。 Rubyでそれらを「インポート解除」することもできますが、それがすべてではありません。
編集：
このRubyモジュールを見てみましょう：
module Whatever
def method1
end
def method2
end
end
コードに含める場合：
include Whatever
あなたは両方が表示されます method1 そして method2 名前空間に追加されました。インポートのみできません method1。両方をインポートするか、まったくインポートしません。 Pythonでは、選択したメソッドのみをインポートできます。これに名前がある場合、選択的インポートと呼ばれるでしょうか？
Rubyの website から：
類似点Pythonと同様、Rubyでも...
- インタラクティブプロンプト（irbと呼ばれる）があります。
- コマンドラインでドキュメントを読むことができます（pydocの代わりにriコマンドを使用）。
- 特別な行終端記号はありません（通常の改行を除く）。
- 文字列リテラルは、Pythonの三重引用符で囲まれた文字列のように複数行にまたがることができます。
- 括弧はリスト用、括弧は辞書用です（Rubyでは「ハッシュ」と呼ばれます）。
- 配列は同じように機能します（追加すると1つの長い配列になりますが、このように構成すると
a3 = [ a1, a2 ]に配列の配列が得られます）。- オブジェクトは強く動的に型付けされます。
- すべてがオブジェクトであり、変数はオブジェクトへの単なる参照です。
- キーワードは少し異なりますが、例外はほぼ同じように機能します。
- 埋め込まれたドキュメントツールがあります（Rubyはrdocと呼ばれます）。
Pythonとは異なり、Rubyでは...
- 文字列は変更可能です。
- 定数（値を変更しない変数）を作成できます。
- いくつかの強制的な慣習があります（例：クラス名は大文字で始まり、変数は小文字で始まります）。
- リストコンテナは1種類（配列）のみであり、可変です。
- 二重引用符で囲まれた文字列により、エスケープシーケンス（\ tなど）および特別な「式置換」構文（Ruby式の結果を "add" + "文字列なしで他の文字列に直接挿入できます） 「+」一緒に）。一重引用符で囲まれた文字列は、Pythonのr「生の文字列」のようなものです。
- 「新しいスタイル」と「古いスタイル」のクラスはありません。たった1種類。
- 属性に直接アクセスすることはありません。 Rubyでは、すべてのメソッド呼び出しです。
- メソッド呼び出しの括弧は通常オプションです。
- Pythonの
_voluntary_ underscore __convention__の代わりに、アクセスを強制するためのパブリック、プライベート、および保護があります。- 多重継承の代わりに「ミックスイン」が使用されます。
- 組み込みクラスのメソッドを追加または変更できます。どちらの言語でも、いつでもクラスを開いて変更できますが、Pythonはビルトインの変更を禁止しますが、Rubyは変更できません。
- TrueとFalseの代わりにtrueとfalseがあります（Noneの代わりにnil）。
- 真偽をテストすると、falseとnilのみがfalse値に評価されます。それ以外はすべて真です（0、0.0、 ""、[]を含む）。
- Elifではなくelsifです。
- インポートの代わりに必要です。それ以外の場合、使用法は同じです。
- （その下のdocstringの代わりに）上の行の通常スタイルのコメントは、ドキュメントの生成に使用されます。
- 覚えておくべきことはたくさんありますが、すぐに習得できるショートカットがいくつかあります。彼らはRubyを楽しくて非常に生産的にする傾向があります。
「RubyにはXがあり、Pythonにはないが、PythonにはYがあり、Rubyにはない」と考えるのが最も便利な方法ではないそれで。これらは非常によく似た言語であり、多くの共有機能を備えています。
大きな違いは、言語がエレガントで読みやすいものにすることです。取り上げた例を使用すると、理論的には両方にラムダがありますが、Pythonプログラマーはそれらを避ける傾向があり、それらを使用して作成されたコンストラクトはRubyほど読みやすく慣用的ではありません。そのため、Pythonでは、実際にisがより良い方法であるという理由だけで、優れたプログラマーはRubyの場合とは異なる方法で問題を解決したいと思うでしょう。
RubyがPythonよりも優れているのは、そのスクリプト言語機能です。このコンテキストでのスクリプト言語は、シェルスクリプトの「グルーコード」と一般的なテキスト操作に使用されることを意味します。
これらは主にPerlと共有されます。一流の組み込み正規表現、$変数、Perl（-a、-e）などの便利なコマンドラインオプション.
簡潔でありながら洗練された構文とともに、この種のタスクに最適です。
Pythonは、動的に型付けされたビジネス言語であり、非常に簡単に学習でき、構文もきちんとしています。 Rubyほど「クール」ではありませんが、すっきりしています。 PythonがRubyを超えているのは、他のライブラリの膨大な数のバインディングです。 Qtおよびその他のGUIライブラリ、多くのゲームサポートライブラリ、およびandへのバインディング。 Rubyははるかに少ないです。多く使用されているバインディングデータベースの品質は良好です。同じライブラリにPythonバインディングもある場合でも、Rubyでニッチライブラリがより適切にサポートされていることがわかりました。
そのため、両方の言語に用途があり、どちらを使用するかを定義するのはタスクです。どちらも簡単に習得できます。私はそれらを並べて使用します。 Rubyはスクリプト用、Pythonはスタンドアロンアプリ用です。
「RubyにはPythonにはないものがあり、その逆は何ですか？」という元の質問の変形を提案したいと思います。 「さて、Intercalでは行えないRubyまたはPythonで何ができますか？」 PythonとRubyは両方ともチューリング近似であるという王位にある広大な王室の一部であるため、そのレベルには何もありません。
しかし、これはどうですか：
Pythonで優雅にうまくできることは、Rubyではできませんが、そのような美しさと優れたエンジニアリング、またはその逆ですか？
それは単なる機能比較よりもはるかに興味深いかもしれません。
「大文字で始まる変数は定数になり、変更できません」
違う。彼らはできます。
行う場合にのみ警告が表示されます。
Pythonには、リストの理解とジェネレーターのための明示的な組み込み構文がありますが、Rubyではマップブロックとコードブロックを使用します。
比較する
list = [ x*x for x in range(1, 10) ]
に
res = (1..10).map{ |x| x*x }
恥知らずにコピー/貼り付け： Alex Martelli に答える" PythonよりもRubyの方が良い ]からのスレッド comp.lang.python メーリングリスト。
2003年8月18日、午前10時50分、Erik Max Francisは次のように書いています。
「ブランドンJ.ヴァンエブリィ」はこう書いています。
RubyのほうがPythonより優れているのは何ですか？私は何かがあると確信しています。それは何ですか？
Ruby人々ではなく、Python人々にこれを尋ねる方がはるかに理にかなっていないでしょうか？
たとえば、目的がPythonコミュニティの「社会学的研究」を含む場合、そのコミュニティに質問をすることで、次の情報が明らかになる可能性があります。それを、他の場所に置くよりも:-)。
個人的には、前回のOSCONでのデイブトーマスの1日のRubyチュートリアルを喜んで利用しました。シンタックスの違いの薄いベニアの下で、RubyとPythonが驚くほど似ていることがわかります-ほぼすべての言語セット間で最小スパニングツリーを計算している場合、私はかなり確信していますPythonとRubyは、中間ノードに合体する最初の2つのリーフになります:-)。
確かに、Rubyでは、各ブロックの最後に愚かな「終了」を入力するのに疲れます（単にインデントを解除するのではなく）-しかし、その後、私は等しく愚かな「：」which Pythonは、各ブロックのstartで必要となるため、ほとんどウォッシュです:-)。 「@foo」と「self.foo」などの構文の違い、またはRubyとPythonの大文字小文字の重要性は、実際には私とほとんど関係ありません。
他の人は間違いなくそのような問題に基づいてプログラミング言語の選択を行い、最も熱い議論を生み出していますが、それは私にとってパーキンソンの法則の1つの例にすぎません（問題の議論の量は問題の反比例に反比例します実際の重要性）。
Edit（2010年6月19日午前11時45分まで）：これは「painting the bikeshed」（または略して「bikeshedding」としても知られています） "）-ここでも、「ささいなトピックに関する熱い議論」の典型的な例として、「自転車小屋をペイントする色についての議論」を行ったノースコートパーキンソンを参照しています。 （編集の終わり）。
私が重要だと思う構文の違いの1つは、Pythonの好意によりますが、他の人々は間違いなくその逆を考えるでしょう-「パラメーターを取らない関数をどのように呼び出すか」です。 Python（Cのように）では、関数を呼び出すために、常に「呼び出し演算子」を適用します-呼び出しているオブジェクトの直後に末尾の括弧（末尾の括弧内に渡す引数が入ります）呼び出しで-引数を渡さない場合、括弧は空です）。これにより、特別な場合、例外、アドホックルールなどを伴わずに、あらゆるコンテキストでany objectの単なる言及が、オブジェクトへの参照を意味する、演算子を含まずに残されます。 Ruby（Pascalのように）では、引数を付けて関数を呼び出すには、引数を渡します（通常は括弧で囲みますが、常にそうではありません）-ただし、関数が引数を取らない場合は、関数は暗黙的に呼び出します。これは、多くの人々（少なくとも、間違いなく、プログラミングの以前の経験がPascal、またはVisual Basicなどの同様の「暗黙の呼び出し」を持つ他の言語であった人々）の期待に応えることができます-しかし、私にとっては、オブジェクトの単なる言及は、オブジェクトのタイプに応じて、オブジェクトへの参照、ORオブジェクトへの呼び出しを意味する場合があります。また、オブジェクトへの参照を取得できない場合それに言及するだけで、明示的に「これへの参照をください、それを呼ばないでください！」を使用する必要があります。それ以外の場合は必要ない演算子。これは、関数（またはメソッド、または他の呼び出し可能なオブジェクト）の「一流」に影響を与え、オブジェクトをスムーズに交換する可能性に影響を与えます。したがって、私にとって、この特定の構文の違いはRubyに対する深刻な黒いマークですが、他の理由で他の人がそうする理由を理解しています。
構文の下で、基本的なセマンティクスにいくつかの重要な違いがあります。たとえば、Rubyの文字列は可変オブジェクト（C++など）であり、Pythonの文字列は可変ではありません（ Javaのように、または私はC＃を信じています）。繰り返しますが、主に既に慣れていることで判断する人は、これがRubyのプラスだと思うかもしれません（もちろんJavaまたはC＃に慣れていない限り:-) 。私は、不変の文字列は素晴らしいアイデアだと思います（そして、Javaが独立して、すでにPythonにあったアイデアを再発明したことは驚くことではありません）が、「可変文字列バッファ」タイプも気にしません（理想的には、Java独自の「文字列バッファー」よりも使いやすいもの）。そして、Javaを勉強する前にallデータが不変であり、私が知っていたすべての言語が変更可能な文字列を持っていたのを除いて、Javaを学ぶ前にこの判断をしません。 Java（Pythonを学ぶ前によく学んだ）の不変文字列のアイデアは、すぐに優れたものとして印象付けられ、高レベルのプログラミング言語の参照セマンティクスに非常によく適合しました（マシンに近い言語やアプリケーションから遠い言語（Cなど）に最適な値セマンティクス。一流の組み込み（および非常に重要な）データ型として文字列を使用します。
Rubyには基本的なセマンティクスにいくつかの利点があります。たとえば、Pythonの「リストとタプル」の非常に微妙な区別の削除です。しかし、ほとんどのスコア（私がそれを保持するように、単純さで大きなプラスと微妙な、巧妙な区別は顕著なマイナス）はRubyに対するものです（例えば、aと表記されたクローズとハーフオープンの両方の間隔を持つ）。 .bとa ... b [誰もがそれがobvious which is which？-）]であると主張したい、ばかげている-もちろん私見！）。繰り返しになりますが、言語の中心に似ているが微妙に異なるものがたくさんあると考える人は、マイナスではなくプラスになります。もちろん、これらの「逆」を数える方法から数えます:-)。
これらの比較に惑わされて、2つの言語がvery違うと思うようにしないでください。そうではありません。しかし、「capelli d'angelo」と「spaghettini」を比較するように頼まれた場合、これらの2種類のパスタは誰とでも区別がつかず、あなたが準備するかもしれないどんな料理でも互換性があると指摘した後、必然的に長さや直径がわずかに異なる方法、ある場合にはストランドの端がどのようにテーパー状になり、他の場合にはテーパー状にならないかなどの顕微鏡検査に進むために-私が個人的にむしろカペリのほうが好きな理由を説明しようとするアンジェロはあらゆる種類のスープのパスタとして使用されますが、パスタスティウッタとしてスパゲッティニは、このような細長いパスタの形に適したソース（オリーブオイル、ニンニクのミンチ、赤唐辛子のミンチ、アンチョビの細かく挽いたものなど）ニンニクと唐辛子を刻む代わりにスライスした後、スパゲッティニのより薄いエバネッセンスではなく、スパゲッティのより健全なボディを選択する必要があります。アチョビを控えて、代わりに新鮮な春のバジルを追加することをお勧めします。 -私は異端者です...！ -ライトミント...]葉-料理を出す直前の最後の瞬間）。おっと、申し訳ありませんが、それは私が海外に旅行していて、パスタをしばらく食べていないことを示しています。しかし、アナロジーはまだかなり良いです！-）
それで、PythonとRubyに戻って、2つの大事な問題に取り組みます（適切な言語の観点から、ライブラリと、ツールや環境などの重要な付属品、各言語の埋め込み/拡張方法、等、現在のところ、それらはとにかく各言語のすべての実装には適用されません。たとえば、Jython vs Classic PythonはPython言語の2つの実装です！ ）：
RubyのイテレーターとコードブロックとPythonのイテレーターとジェネレーター。
能力を含む、Rubyの総計、自由な「動的性」
すべての組み込みクラスを含む既存のクラスを「再オープン」し、実行時にその動作を変更します-対Pythonの広大ですがboundedの動的性。既存の組み込みクラスとそのインスタンス。個人的には、 1 ウォッシュを検討します（違いは非常に深いので、どちらか一方に近づき敬意を払う人々を簡単に見ることができますが、私の個人的なスケールではプラスとマイナスがほぼ均等に増加します）; 2 重大な問題-Rubyを「いじくり回し」にはるかに適したものにする問題、しかしPythonは同様に大規模な本番アプリケーションでの使用により適しています。面白いことに、両方の言語は他のほとんどの言語よりもはるかに動的であるため、POVとの重要な違いは最終的にはそれによって決まるはずです-Ruby "goes to 11"この点で（ここでの参照は、もちろん「Spinal Tap」です）。 Rubyでは、私の創造性に制限はありません-すべての文字列比較で大文字と小文字を区別しないようにする必要があると判断した場合I CAN DO THAT！つまり、組み込みの文字列クラスを動的に変更して、a = "Hello World" b = "hello world" if a == b print "equal！\ n" else print "different！\ n" end WILL print "等しい"。 Pythonでは、それを行う方法はありません。メタプログラミング、実験的フレームワークの実装などの目的のために、Rubyのこの驚くべき動的能力はextremely魅力的です。しかし、多くの人々によって開発され、さまざまなソースからのすべての種類のライブラリを含むさらに多くによって維持される大規模なアプリケーションについて話している場合、クライアントサイトでの生産に入る必要があります...まあ、私はしたくないとても動的な言語です。ありがとうございました。私は、それらの文字列が異なることに依存している他の無関係なライブラリを無意識に壊すいくつかのライブラリのアイデアを嫌います-それは一種の深くて深く隠された「チャネル」、LOOKが分離し、SHOULD BEが分離するコードの断片の間で、死を綴ります大規模プログラミング。モジュールが他の「ひそかに」動作に影響を与えることにより、組み込み型のセマンティクスを変更する機能は、いじくり回すのがクールであるように、本番アプリケーションプログラミングにとっては悪い考えです。
このような大規模なアプリケーションにRubyを使用しなければならなかった場合、コーディングスタイルの制限、多くのテスト（何かが変更されるたびに再実行される-まったく関係のないものであっても... ）など、この言語機能の使用を禁止します。しかし、私の意見では、最初に機能を持たないことはさらに良いです。つまり、特定の数のビルトインを「固定」できれば、Python自体がアプリケーションプログラミングにとってさらに優れた言語になるのと同じです。 「だから、たとえば、len（ "ciao"）が4であることを知っていた（誰かがbuiltinsモジュール...）。最終的にPythonがその組み込みを「ネイルダウン」することを願っています。
ただし、ビルトインの再バインドは非推奨であり、Pythonでのまれなプラクティスであるため、問題はマイナーです。 Rubyでは、他の言語のマクロ機能あまりにも強力（たとえばDylanなど）が私の意見では同様のリスクを提示するのと同じように、私はメジャーだと思います（Python「言語自体に埋め込まれた独自のドメイン固有の小さな言語を定義させる」という魅力にかかわらず、このような強力なマクロシステムを取得することはありません-それは、アプリケーションプログラミングに対するPythonの素晴らしい有用性を損なうでしょうすべてのプログラマーの心に潜む意志のあるいじくり手に「魅力的な迷惑」を提示します...）。
アレックス
インフラストラクチャ側でもう少し：
PythonはC++との統合がはるかに優れています（ Boost.Python 、 SIP 、および Py ++ など）。 RubyインタープリターAPI（もちろんPythonでも実行できますが、どちらの場合でもそうするのは低レベルで退屈でエラーが発生しやすいためです。 ）またはSWIGを使用します（多くの言語をサポートしたい場合は動作しますが、間違いなく素晴らしいですが、Boost.PythonやC++をバインドする場合はSIPほど素敵ではありません）。
Pythonには多数のWebアプリケーション環境（Django、Pylons/Turbogears、web.py、おそらく少なくとも半ダース）がありますが、Ruby（事実上）はRailsです。 （他のRuby Webフレームワークは存在しますが、Railsに対して大きな牽引力を得るのに苦労しているようです）。この側面は良いですか、悪いですか？言うのは難しく、おそらくかなり主観的です。 Pythonの状況がより良く、Rubyの状況がより良いという議論を簡単に想像できます。
文化的には、PythonとRubyコミュニティは多少異なるように見えますが、Rubyコミュニティとやり取りする経験があまりないので、これを示唆することしかできません。 。私はこれを主に、両方の経験が豊富な人がこの声明を増幅（または拒否）できることを期待して追加しています。
他の一部：
http://www.Ruby-lang.org/en/documentation/Ruby-from-other-languages/to-Ruby-from-python/
（そのページが更新されてからRuby側で何かを誤解したり、これらのいずれかが変更された場合、誰かが自由に編集できます...）
文字列はPython（「変更」によって新しい文字列が作成される）ではなく、Rubyで変更可能です。
Rubyにはいくつかの強制的なケース規則がありますが、Pythonにはありません。
Pythonにはリストとタプル（不変リスト）の両方があります。 RubyにはPythonリストに対応する配列がありますが、それらの不変のバリアントはありません。
Pythonでは、オブジェクト属性に直接アクセスできます。 Rubyでは、常にメソッドを使用します。
Rubyでは、メソッド呼び出しの括弧は通常オプションですが、Pythonではそうではありません。
Rubyには、アンダースコアと名前のマングリングを使用するPythonの規則の代わりに、アクセスを強制するためにパブリック、プライベート、および保護があります。
Pythonには複数の継承があります。 Rubyには「ミックスイン」があります。
そして非常に関連性の高い別のリンク：
http://c2.com/cgi/wiki?PythonVsRuby
特に、Alex Martelliによる別の良いものにリンクしています。彼はここSOにも多くの素晴らしいものを投稿しています：
http://groups.google.com/group/comp.lang.python/msg/028422d70751228
これはよく分からないので、最初に回答として追加します。
Pythonは非バインドメソッドを関数として扱います
つまり、theobject.themethod()のようなメソッドを呼び出すことも、TheClass.themethod(anobject)で呼び出すこともできます。
編集：メソッドと関数の違いはPythonでは小さく、Python 3には存在しませんが、単にRubyにはないので、Rubyには存在しません関数。関数を定義するとき、実際にはオブジェクトのメソッドを定義しています。
ただし、1つのクラスのメソッドを関数として呼び出して呼び出すことはできません。呼び出したいオブジェクトに再バインドする必要があり、これははるかに困難です。
オブジェクトから属性への「通信」をカスタマイズできるPython記述子APIに言及したいと思います。また、Pythonでは、__getattribute__メソッドのデフォルト実装で指定されたデフォルトをオーバーライドすることにより、代替プロトコルを自由に実装できることも注目に値します。前述の詳細について説明します。記述子は、__get__、__set__、および/または__delete__メソッドを持つ通常のクラスです。インタプリタがanObj.anAttrのようなものに遭遇すると、以下が実行されます：
anObjの__getattribute__メソッドが呼び出されます__getattribute__はクラスdictからanAttrオブジェクトを取得します- abAttrオブジェクトに
__get__、__set__、または__delete__呼び出し可能オブジェクトがあるかどうかをチェックします - コンテキスト（つまり、呼び出し側オブジェクトまたはクラス、およびセッターがある場合は後者の代わりの値）が呼び出し可能オブジェクトに渡されます
- 結果が返されます。
前述のように、これはデフォルトの動作です。 __getattribute__を再実装することにより、プロトコルを自由に変更できます。
この手法は、デコレータよりもはるかに強力です。
この段階では、PythonのUnicodeサポートは依然として優れています
Rubyには、callccを使用した継続サポートが組み込まれています。
したがって、 amb-operator のようなクールなものを実装できます
Rubyには、コマンドラインからの入力ファイル（ '-n'フラグ）に対する行ごとのループがあるため、AWKのように使用できます。このRubyワンライナー：
Ruby -ne 'END {puts $.}'
aWKワンライナーのような行をカウントします：
awk 'END{print NR}'
Rubyは、Perlを介してこの機能を取得します。Perlは、AWKから、システム管理者をPerlで処理する方法として取り入れました。
私のpythonは錆びているので、これらのいくつかはpythonにあるかもしれません。
空白
Rubyは、まったく異なる空白を処理します。まず、インデントする必要はありません（つまり、4つのスペースまたは1つのタブを使用してもかまいません）。また、スマートな行継続も行うため、次のことが有効です。
def foo(bar,
cow)
基本的に、演算子で終了すると、何が起こっているのかがわかります。
ミックスイン
Rubyには、完全なクラスの代わりにインスタンスを拡張できるミックスインがあります。
module Humor
def tickle
"hee, hee!"
end
end
a = "Grouchy"
a.extend Humor
a.tickle » "hee, hee!"
列挙型
これがジェネレーターと同じかどうかはわかりませんが、Ruby 1.9列挙体としてRubyなので、
>> enum = (1..4).to_enum
=> #<Enumerator:0x1344a8>
リファレンス： http://blog.nuclearsquid.com/writings/Ruby-1-9-what-s-new-what-s-changed
「キーワード引数」
そこにリストされている項目は両方ともRubyでサポートされていますが、そのようなデフォルト値をスキップすることはできません。あなたは順番に行くことができます
def foo(a, b=2, c=3)
puts "#{a}, #{b}, #{c}"
end
foo(1,3) >> 1, 3, 3
foo(1,c=5) >> 1, 5, 3
c >> 5
C = 5は実際に呼び出しスコープの変数cに値5を割り当て、パラメーターbに値5を設定することに注意してください。
または、2番目の問題に対処するハッシュでそれを行うことができます
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
参照：The Pragmatic Progammer's Guide to Ruby
Pythonにはdocstringがあり、Rubyにはありません...または、ない場合は、Pythonほど簡単にアクセスできません。
追伸間違っている場合は、例を残してください。私は非常に簡単にクラスに猿パッチすることができるという回避策を持っていますが、「ネイティブな方法」でちょっとした機能のdocstringを持ちたいです。
構文はささいなことではなく、私たちの考え方に直接影響します。また、使用するシステム用に作成するルールにも直接影響します。例として、数学の方程式や文を書く方法のために、操作の順序があります。数学の標準的な表記法により、人々は複数の方法でそれを読み、同じ方程式を与えられた異なる答えに到達することができます。プレフィックス表記またはポストフィックス表記を使用していた場合、値を計算する順序のルールだけではなく、操作する数値が何であるかを区別するルールを作成していました。
標準的な表記法により、私たちが話している数字が分かりやすくなり、数字を計算する順序があいまいになります。接頭辞と接尾辞の表記法は、数字をあいまいにする一方で、計算する順序を明確にします。 Pythonは、構文上の空白に起因する困難がなければ、すでに複数行のラムダを持っています。 （必ずしも明示的なブロック区切り文字を追加せずに、この種のものを引き出すための提案が存在します。）
条件がfalseの場合、何かを発生させたい条件を書く方が簡単です。セマンティック上同等の「if-not」よりも、Rubyのexceptステートメントで書く方がはるかに簡単です。 Rubyまたは他の言語での構築。現在人々が使用しているほとんどの言語のパワーが等しい場合、各言語の構文を些細なことと見なすにはどうすればよいでしょうか？ブロックや継承メカニズムなどの特定の機能の後、構文は言語の最も重要な部分であり、ほとんど表面的なものではありません。
表面的なのは、私たちが構文に帰する美の美的性質です。美学は、認知がどのように機能するかとは関係ありませんが、構文はそうです。
Rubyの「メソッドが見つからない」メカニズムについて言及されていないことに驚いた。その言語機能の力の例として、Railsのfind_by _...メソッドの例を示します。私の推測では、似たようなものをPythonで実装できると思いますが、私の知る限り、ネイティブにはありません。
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とRubyの間のラムダのもう1つの違いは、Paul Grahamの Accumulator Generator の問題によって示されています。ここに転載：
数値nを取り、数値iを取り、iをインクリメントしたnを返す関数を返す関数fooを作成します。注：（a）整数ではなく数値、（b）プラスではなくインクリメントされます。
Rubyでは、これを行うことができます：
def foo(n)
lambda {|i| n += i }
end
Pythonでは、nの状態を保持するオブジェクトを作成します。
class foo(object):
def __init__(self, n):
self.n = n
def __call__(self, i):
self.n += i
return self.n
一部の人々は、多少冗長であっても、明示的にPythonアプローチを概念的に明確にすることを好むかもしれません。あなたは他の何かのために行うように状態を保存します。呼び出し可能なオブジェクトのアイデアに頭を包むだけです。しかし、審美的にどのアプローチを好むかに関係なく、RubyラムダがPythonよりも強力な構造であるという点を示しています。
Rubyにはドキュメントが埋め込まれています：
=begin
You could use rdoc to generate man pages from this documentation
=end
Rubyでは、requireを使用してファイルをインポートすると、そのファイルで定義されているすべてのものがグローバルネームスペースに格納されます。
Cargo を使用すると、「名前空間を乱雑にすることなくライブラリを要求できます」。
# foo-1.0.0.rb
class Foo
VERSION = "1.0.0"
end
# foo-2.0.0.rb
class Foo
VERSION = "2.0.0"
end
>> Foo1 = import（ "foo-1.0.0"） >> Foo2 = import（ "foo-2.0.0"） >> Foo1 :: VERSION => "1.0.0" >> Foo2 :: VERSION => "2.0.0"
RubyおよびPythonメソッド呼び出しの動作方法の根本的な違いが気に入っています。
Rubyメソッドは、「メッセージパッシング」という形式で呼び出され、明示的にファーストクラスの関数である必要はありません（ liftメソッド から「適切な」関数オブジェクトへの方法があります）-この点でRubyはSmalltalkに似ています。
PythonはJavaScript（またはPerl）のように動作し、メソッドは直接呼び出される関数です（保存されたコンテキスト情報もありますが...）
これは「小さな」詳細のように思えるかもしれませんが、実際にはRubyとPythonのデザインが異なる方法の表面にすぎません。 （一方で、それらもまったく同じです:-)
実用的な違いの1つは、Rubyのmethod_missingの概念です（良くも悪くも、いくつかの一般的なフレームワークで使用されているようです）。 Pythonでは、__ getattr __/__ getattribute__を使用して（少なくとも部分的に）動作をエミュレートできますが、非定型ではありません。
Rubyのブロックの詳細
Rubyのブロックは、Pythonのコンテキストマネージャーによって「置換」される可能性があることが示唆されています。実際、ブロックはPythonのコンテキストマネージャーができる以上のことを許可します。
ブロックの受信メソッドは、何らかのオブジェクトのコンテキスト内でブロックを実行することができます。これにより、ブロックが到達できないメソッドを呼び出すことができます。 Pythonのジェネレータもそれを行うことはできません。
簡単な例が役立ちます：
class Proxy
attr_accesor :target
def method &block
# Ruby 1.9 or in Rails 2.3
target.instance_exec &block
end
end
class C
private
def hello
puts "hello"
end
end
p = Proxy.new
c = C.new
p.target = c
p.method { hello }
この例では、ブロック{ hello }内のメソッド呼び出しは、ターゲットオブジェクトcのコンテキストで真の意味を持ちます。
この例は、説明のみを目的としています。この種の実行を別のオブジェクトのコンテキストで使用する実際の作業コードは珍しいことではありません。たとえば、監視ツールGodmはそれを使用します。
誰かが与えたネストされたレキシカルスコープの例には、いくつかの利点があります。
- 「より安全な」グローバル
- これは、DSLをプログラムに埋め込む1つの方法です。
これは、2つの言語の違いの非常に良い例だと思います。 Rubyは単純に柔軟性があります。 Pythonは柔軟な場合がありますが、そこに到達するには極端なゆがみが必要になることが多く、手間をかける価値はありません。
元の回答の下に投稿しないで申し訳ありません、私はそれを行う権限を持っていないと思います。