Что есть у Ruby, чего нет у Python, и наоборот?

существует много обсуждений Python vs Ruby, и я все нахожу их совершенно бесполезными, потому что все они оборачиваются, почему функция X сосет язык Y, или что язык Y не имеет X, хотя на самом деле это так. Я также точно знаю, почему я предпочитаю Python, но это также субъективно и не поможет никому выбрать, так как у них могут быть разные вкусы в развитии, как у меня.

не имеют несколько различий в одном ответе, пожалуйста. И голосуйте за тех, кого вы знаете, правильными, и вниз те, кого вы знаете, неверны (или субъективны). Кроме того, различия в синтаксисе не интересно. Мы знаем, что Python делает с отступом то, что Ruby делает с скобками и концами, и что @ называется self в Python.

обновление: Теперь это Вики сообщества, поэтому мы можем добавить большие различия здесь.

Ruby имеет ссылку на класс в теле класса

в Ruby у вас есть ссылка на класс (self) уже в теле класса. В Python у вас нет ссылки на класс до тех пор, пока построение класса не будет завершено.

пример:

class Kaka
  puts self
end

self в этом случае является классом, и этот код распечатает "Кака". Нет способа распечатать класс имя или другими способами доступ к классу из тела определения класса в 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 имеет regexps первого класса, $ - переменные, цикл ввода awk/perl по строкам и другие функции, которые делают его более подходящим для написания небольших скриптов оболочки, которые munge текстовые файлы или действуют как код клея для других программ.

Ruby имеет первый класс продолжения

благодаря заявлению callcc. В Python вы можете создавать продолжения различными техники, но нет никакой поддержки, встроенной в язык.

Руби блоки

С помощью оператора "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

интересно, что оператор convenience в 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 имеет встроенные генераторы (которые используются как рубиновые блоки, как отмечалось выше)

Python поддерживает генераторы на языке. В Ruby 1.8 вы можете использовать модуль генератора, который использует продолжения для создания генератора из блока. Или вы можете просто использовать block/proc / lambda! Кроме того, в Ruby 1.9 волокна являются и могут использоваться как генераторы, а класс перечислителя является встроенным генератором 4

docs.python.org имеет этот пример генератора:

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

сравните это с приведенными выше примерами блоков.

Python имеет гибкую обработку пространства имен

в Ruby, когда вы импортируете файл с require, все вещи, определенные в этом файле, окажутся в вашем глобальном пространстве имен. Это вызывает загрязнение пространства имен. Решение этого-модули Rubys. Но если вы создаете пространство имен с модулем, то вы должны использовать это пространство имен для доступа к содержащимся классам.

в Python файл является модулем, и вы можете импортировать его содержащиеся имена с помощью from themodule import *, тем самым загрязняя пространство имен, если вы хотите. Но вы также можете импортировать только выбранные имена с from themodule import aname, another или вы можете просто import themodule и затем получить доступ к именам с themodule.aname. Если вы хотите больше уровней в пространстве имен вы можете иметь пакеты, каталоги с модулями и .

Python имеет docstrings

Docstrings-это строки, которые прикреплены к модулям, функциям и методам и могут быть интроспекция во время выполнения. Это помогает создавать такие вещи, как команда help и автоматическая документация.

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#source_location пример использования

Python имеет множественное наследование

Ruby не делает ("нарочно" -- см. веб-сайт Ruby,см. здесь, как это делается в 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)

Python 2.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

264
python ruby

30 ответов

Ruby имеет понятия блоки, которые по существу являются синтаксическим сахаром вокруг раздела кода; они являются способом создания замыканий и передачи их другому методу, который может или не может использовать блок. Блок может быть вызван позже через yield заявление.

например, простое определение each метод on 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 имеет анонимные функции / замыкания / лямбды, но у него не совсем есть блоки, так как ему не хватает некоторого полезного синтаксического сахара. Тем не менее, есть по крайней мере один способ получить его ad-hoc. См., например, здесь.

34

Пример Python

функции являются первоклассными переменными в Python. Вы можете объявить функцию, передать ее как объект и перезаписать ее:

def func(): print "hello"
def another_func(f): f()
another_func(func)

def func2(): print "goodbye"
func = func2

это фундаментальная особенность современных скриптовых языков. JavaScript и Lua тоже это делают. Ruby не обрабатывает функции таким образом; именование функции вызывает его.

конечно, есть способы сделать эти вещи в Ruby, но это не первоклассные операции. Например, вы можете обернуть функции Тез.Докл.новый, чтобы рассматривать его как переменную,но тогда это больше не функция; это объект с методом "вызова".

функции 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!"
28

В конечном итоге все ответы будут субъективными на каком-то уровне, и ответы, опубликованные до сих пор, в значительной степени доказывают, что вы не можете указать на какую-либо одну функцию, которая не выполнима на другом языке одинаково хорошо (если не похожа), так как оба языка очень лаконичны и выразительны.

мне нравится синтаксис Python. Однако вам нужно копнуть немного глубже, чем синтаксис, чтобы найти истинную красоту Ruby. Есть zenlike красоты в последовательности Руби. Пока нет банальный пример можете возможно, объясните это полностью, я попытаюсь придумать один здесь, чтобы объяснить, что я имею в виду.

переверните слова в этой строке:

sentence = "backwards is sentence This"

когда вы думаете о том, как вы это сделаете, вы сделаете следующее:

  1. разделить предложение на слова
  2. изменить слова
  3. повторно присоединить слова обратно в строку

в Ruby вы бы сделали это:

sentence.split.reverse.join ' '

именно так, как вы думаете о это, в той же последовательности, один вызов метода за другим.

в Python, это будет выглядеть примерно так:

" ".join(reversed(sentence.split()))

это не трудно понять, но это не совсем тот же поток. Субъект (предложение) похоронен посередине. Операции представляют собой сочетание функций и методов объекта. Это тривиальный пример, но при работе с Ruby и понимании Ruby обнаруживается много разных примеров, особенно в нетривиальных задачах.

26

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
19

можно импортировать только определенные функции из модуля в Python. В Ruby вы импортируете весь список методов. Вы могли бы "унести" их в Ruby, но это не то, о чем речь.

EDIT:

давайте возьмем этот модуль Ruby:


module Whatever
  def method1
  end

  def method2
  end
end

Если вы включите его в свой код:


include Whatever

вы увидите, что как method1 и метода Method2 добавленные в пространство имен. Вы не можете импортировать только method1. Вы либо импортируете их оба, либо вообще не импортируете. В Python можно импортировать только методы по вашему выбору. Если бы у этого было имя, возможно, это называлось бы выборочным импортом?

18

от Руби сайт:

сходство Как с Python, в Ruby...

  • есть интерактивная подсказка (называется irb).
  • вы можете читать документы в командной строке (с помощью команды ri вместо pydoc).
  • нет специальных линейных Терминаторов (кроме обычной новой строки).
  • строковые литералы могут охватывать несколько строк, таких как строки с тройными кавычками Python.
  • скобках для списков, а фигурные скобки для диктов (которые в Ruby называются "хэшами").
  • массивы работают одинаково (добавление их делает один длинный массив, но составление их так a3 = [ a1, a2 ] дает вам массив массивов).
  • объекты сильно и динамически типизированы.
  • все является объектом, а переменные-ссылки на объекты.
  • хотя ключевые слова немного отличаются, исключения работают примерно одинаково.
  • у вас есть встроенные инструменты doc (Ruby's называется rdoc).

различия В отличие от Python, в Ruby...

  • строки изменчивы.
  • вы можете создавать константы (переменные, значение которых вы не собираетесь изменять).
  • существуют некоторые принудительные соглашения о случаях (ex. имена классов начинаются с заглавной буквы, переменные начинаются с строчной буквы).
  • есть только один вид списка контейнер (массив), и он изменчив.
  • строки с двойными кавычками позволяют escape-последовательности (например, \t) и специальный синтаксис" подстановки выражений "(который позволяет вставлять результаты выражений Ruby непосредственно в другие строки без необходимости "добавлять" + "строки" + "вместе"). Строки с одинарными кавычками похожи на R"сырые строки"Python.
  • нет классов "новый стиль" и "старый стиль". Только один вид.
  • вы никогда не сможете открыть атрибуты. С Ruby это все вызовы методов.
  • скобки для вызовов методов обычно являются необязательными.
  • есть публичный, частный и защищенный для обеспечения доступа, а не Python _voluntary_ underscore __convention__.
  • "mixin" используются вместо множественного наследования.
  • вы можете добавлять или изменять методы встроенных классов. Оба языка позволяют открывать и изменять классы в любой момент, но Python предотвращает модификацию встроенных модулей-Ruby делает не.
  • у вас есть true и false вместо True и False (и nil вместо None).
  • при проверке на истинность только false и nil оценивают значение false. Все остальное верно (включая 0, 0.0, "" и []).
  • это elsif операторы вместо Элиф.
  • это требует вместо импорта. В противном случае, использование то же самое.
  • комментарии обычного стиля в строке (- ах) над вещами (вместо docstrings под ними) являются используется для создания документов.
  • есть несколько ярлыков, которые, хотя и дают вам больше запомнить, вы быстро учитесь. Они, как правило, делают Ruby веселым и очень продуктивным.
16

то, что Ruby имеет над Python, - это его возможности языка сценариев. Язык сценариев в этом контексте означает, что он будет использоваться для" клеевого кода " в сценариях оболочки и общих текстовых манипуляциях.

Они в основном разделяются с Perl. Первоклассные встроенные регулярные выражения, $ - переменные, полезные параметры командной строки, такие как Perl (-a,- e) и т. д.

вместе со своим кратким, но эпксрессивным синтаксисом он идеально подходит для таких задач.

Python для меня больше динамически типизированные бизнес-язык, который очень прост в освоении и имеет изящный синтаксис. Не так "круто", как Руби, но аккуратно. То, что Python имеет над Ruby для меня, - это огромное количество Привязок для других библиотек. Привязки к Qt и другим GUI-библиотекам, многие библиотеки поддержки игр и и И. У Руби гораздо меньше. Хотя многие используемые привязки, например, к базам данных, имеют хорошее качество, я обнаружил, что нишевые библиотеки лучше поддерживаются в Python, даже если для той же библиотеки есть привязка Ruby.

Итак, я бы сказал оба языка имеют свое использование, и это задача, которая определяет, какой из них использовать. И то и другое достаточно легко усвоить. Я использую их бок о бок. Ruby для сценариев и Python для автономных приложений.

12

Я не думаю, что "Ruby имеет X, а Python нет, в то время как Python имеет Y, а Ruby нет" - это самый полезный способ взглянуть на него. Это очень похожие языки, со многими общими способностями.

в значительной степени разница заключается в том, что язык делает элегантный и читаемый. Чтобы использовать пример, который вы подняли, оба теоретически имеют лямбды, но программисты Python, как правило, избегают их, а конструкции, сделанные с их помощью, не выглядят так читабельно или идиоматично, как в Рубин. Поэтому в Python хороший программист захочет пойти другим путем к решению проблемы, чем в Ruby, просто потому, что это на самом деле is лучший способ сделать это.

12

Я хотел бы предложить вариант исходного вопроса: "что у Ruby есть, чего нет у Python, и наоборот? что допускает неутешительный ответ: "Ну, что вы можете сделать с Ruby или Python, чего нельзя сделать в Intercal?- Ничего на этом уровне, потому что Питон и Руби-члены огромной королевской семьи, восседающей на троне приближенных Тьюринга.

а как насчет этого:

что можно сделать изящно и хорошо в Python, который не может быть сделано в Ruby с такой красотой и хорошей техники, или наоборот?

Что может быть намного интереснее, чем простое сравнение.

12

Python имеет явный, встроенный синтаксис для понимания списка и генераторов, тогда как в Ruby вы бы использовали блоки карты и кода.

сравнить

list = [ x*x for x in range(1, 10) ]

to

res = (1..10).map{ |x| x*x }
11

"переменные, начинающиеся с заглавной буквы, становятся константами и не могут быть изменены"

неправильно. Они могут.

вы получите предупреждение, только если вы это сделаете.

11

несколько больше на стороне инфраструктуры:

  • Python имеет гораздо лучшую интеграцию с C++ (через такие вещи, как импульс.Питон, SIP и Py++), чем Ruby, где параметры, похоже, либо пишут непосредственно против API интерпретатора Ruby (что вы можете сделать с Python, конечно, но в обоих случаях это низкоуровневый, утомительный и подверженный ошибкам), либо используют SWIG (который, в то время как он работает и определенно отлично, если вы хотите поддерживать многие языки, это не так приятно, как Boost.Python или SIP, если вы специально хотите связать C++).

  • Python имеет ряд сред веб-приложений (Django, пилоны / Turbogears, web.py, вероятно, по крайней мере полдюжины других), тогда как у Ruby (эффективно) есть один: Rails. (Другие веб-фреймворки Ruby существуют, но, похоже, им трудно получить большую тягу к рельсам). Хорошо это или плохо? Трудно сказать, и, вероятно, довольно субъективно; я легко могу представить аргументы о том, что ситуация Python лучше и что ситуация Ruby лучше.

  • культурно сообщества Python и Ruby выглядят несколько иначе, но я могу только намекнуть на это, поскольку у меня нет большого опыта взаимодействия с сообществом Ruby. Я добавляю это в основном в надежде, что кто-то, у кого есть большой опыт работы с обоими, может усилить (или отклонить) это утверждение.

11

бесстыдно копировать / вставлять из: Алекс Мартелли ответ "что лучше о Ruby, чем Python" нить от comp.ленг.питон список рассылки.

Aug 18 2003, 10: 50 am Erik Max Francis написал:

"Брэндон Дж. Ван Эвери" написал:

Что лучше в Ruby, чем Python? Уверен, что-то есть. Что это?

не было бы гораздо разумнее спросить Ruby people об этом, а не Люди питона?

может, или не может, в зависимости от цели-например, если цели включают в себя " социологический исследование" сообщества Python, затем задавать вопросы этому сообществу-это вероятно, окажется более показательным информация об этом, чем выкладывать их в другом месте:-).

лично я с удовольствием взял возможность следовать за Дэйвом Томасом однодневный учебник Ruby наконец-то OSCON. Под тонкой облицовкой синтаксиса различия, я нахожу Ruby и Python удивительно похоже - если бы я был вычисление минимального связующего дерева среди почти любого набора языков, Я уверен, что Python и Ruby будет будьте первым двум листья сливаются в промежуточный узел:-).

конечно, я устаю, в Ruby, набрав глупый "конец" в конце каждый блок (а не просто unindenting) ... но потом я избегайте ввода одинаково глупых':' какой Python требуется в старт каждого блока, так что почти мыть:-). Другой синтаксис различия, такие как "@foo " против "я".foo', или высшее значение случая в Ruby vs Python, действительно для меня это тоже не имеет значения.

другие Без сомнения основывают свой выбор языки программирования на таких проблемы, и они порождают самые горячие дебаты ... для меня это просто пример одного из законов Паркинсона меры (сумма на обсуждение вопрос обратно пропорционален актуальное значение вопроса).

редактировать (by AM 6/19/2010 11: 45): это также известно как " картина bikeshed "(или, для краткости, "bikeshedding") -- ссылка, и снова Норткот Паркинсон, дали " дебаты о том, какой цвет красить фар велосипеда" в качестве типичного примера "горячие дебаты на тривиальные темы". (конец редактирования).

одно синтаксическое различие, которое я нахожу важно и в пользу Python -- но другие люди, без сомнения, кажется как раз наоборот -- это "как ты вызывать функцию, которая принимает не параметры." В Python (как в C), для вызова функции вы всегда применяете "оператор вызова" -- trailing скобки сразу после объекта ты зовешь (внутри этих следов. скобки идут args вы проходите в вызове, если вы не параметр args, тогда скобки пустые). Это оставляет простое упоминание о любой объект, без участия оператора, как означающий только ссылку к объекту -- в любом контексте, без особых случаев, исключения, специальные правила и тому подобное. в Ruby (как в Pascal), чтобы вызвать функцию С аргументами вы передаете args (обычно в скобках, хотя это это не всегда так) - но если функция не принимает аргументы, то просто неявное упоминание функции называть это. Это может встретить ожидания многих людей (по крайней мере, без сомнения, те, чьи только предыдущие опыт программирования с Pascal, или другие языки с похожие "неявные вызовы", такие как Visual Basic) -- но для меня это означает простое упоминание объекта может Либо означает ссылку на объект, Или вызов объекта, в зависимости от тип объекта-и в этих случаях, когда я не могу получить ссылку на объект, просто упоминая его будет нужно использовать явное "дайте мне ссылка на это, не называйте это!" операторы, которые не нужны иначе. Я чувствую, что это влияет на "первый-classness" функций (или методы, или другие вызываемые объекты) и возможность взаимообмена объекты плавно. Поэтому мне, это специфическое различие синтаксиса серьезная черная метка против Руби ... Я понимаю, почему другие вещи в противном случае, хотя я едва мог не соглашайтесь более яростно с их.)-:

ниже синтаксиса мы попадаем в некоторые важные различия в элементарных семантика -- например, строки в Ruby-изменяемые объекты (например, в C++), в то время как в Python они не являются mutable (как на Java, или я считаю С.)# Опять же, люди, которые судят в первую очередь тем, что они уже знакомый с может подумать, что это плюс для Ruby (если они не знакомы с Java или C#, конечно:-). Я, я думаю неизменяемые строки-отличные идея (и я не удивлен, что Java, самостоятельно я думаю, что идея, которая уже была в Python), хотя я бы не отказался тип "изменяемый строковый буфер" (и в идеале один с лучше простота использования, чем собственная "строка Java буферы"); и я этого не даю суждение из-за знакомства -- перед изучением Java, помимо функциональные языки программирования, где все данные неизменяемы, все языки, которые я знал, имели изменяемые строки -- еще когда я сначала увидел идею неизменяемой строки в Java (которую я научился задолго до того, как узнал Python), это сразу же поразило меня, как отлично, очень хорошо подходит для reference-семантика более высокого уровня язык программирования (в отличие от семантика значения, которая лучше всего соответствует языки ближе к машине и дальше от приложений, таких как C) со строками в качестве первоклассного, встроенные (и довольно важные) данные тип.

Ruby имеет некоторые преимущества в элементарная семантика - например, удаление списков Python vs кортежи " чрезвычайно тонкие различие. Но в основном счет (как Я держу его, с простотой большой плюс и тонкие, умные отличия заметный минус) против Рубина (например, как закрытый, так и полуоткрытый интервалы, с обозначениями a..b и ля...b [кто-нибудь хочет заявить, что это очевидно что есть что?-)], есть глупо - ИМХО, конечно!). Снова, люди, которые считают много из похожие, но тонко разные вещи в ядро языка a плюс, скорее чем минус, конечно посчитаем эти "наоборот" от того, как Я считаю их:-).

Не заблуждайтесь на эти сравнения в мышление два языка очень разные, заметь. Это не так. Но если меня попросят сравнить "capelli d'Angelo" в " spaghettini", после указания на то, что эти два виды пасты как раз о неразличимый для никто и взаимозаменяемые в любом блюде вы могли бы хочу подготовиться, я бы тогда неизбежно придется переехать в микроскопическое исследование как длины и диаметры незаметно различаются, как концы прядей сплющены в одном случае и не в другое, и так далее-попытаться объяснить почему лично я предпочел бы capelli d'Angelo как паста в любом вроде бульон, но предпочел бы spaghettini как pastasciutta идти с подходящими соусами для таких длинный тонкие макаронные формы (оливковое масло, фарш чеснок, измельченный красный перец, и мелко например, анчоусы, но если ты порезал чеснок и перец. вместо мясорубки их, то вам выберите эхолот тело спагетти, а не тоньше мимолетность спагетти, и хорошо советую отказаться от achovies и добавьте вместо этого немного свежей весны Бэзил (или даже ... я еретик...! -- легкая мята...] листья -- у самого последний момент перед подачей блюдо.) Упс, прости, это показывает, что я ... путешествовал за границу и не ел макарон думаю, на какое-то время. Но аналогия все еще довольно хорошо!-)

Итак, вернемся к Python и Ruby, мы приходим на два больших (с точки зрения собственно язык -- оставляя библиотеки, и другие важные вспомогательные средства, такие как инструменты и среды, как встраивать / расширять каждый язык и т. д., и т. д., Пока что из него -- они не будут применяться ко всем реализациям каждого языка в любом случае, например, Jython против классического Python будучи двумя реализациями Язык Python!):

  1. итераторы и кодовые блоки Ruby против итераторов и генераторов Python;

  2. Рубиновая полная, необузданная "динамичность", включая способность
    "открыть" любой существующий класс, включая все встроенные, и изменить свое поведение во время ... против Питон огромный, но ограниченном динамичность, которая никогда изменения поведение существующего встроенного классы и их экземпляры.

лично я считаю 1 мойка (с различия настолько глубоки, что я мог легко увидеть людей, ненавидящих либо подходите и почитайте другого, но на моих личных весах плюсы и минусы минусы почти сравнялись); и 2 a ключевой вопрос - тот, который делает Ruby гораздо больше подходит для " возиться", Но Python одинаково больше подходит для использовать в больших применениях продукции. Это забавно, в каком-то смысле, потому что и то и другое языки гораздо более динамичны чем большинство других, что в конце концов ключевое отличие между ними от моего POV должен зависеть от этого ... этого Рубина "идет к одиннадцати" в этом отношении (the ссылка здесь на "спинной кран", of курс.) В Ruby нет ограничений за мое творчество - если я решу, что все сравнения строк должны стать без учета регистра, Я МОГУ! То есть, Я могу ... динамически изменять встроенный класс string, чтобы a = " Hello World" b = " hello world" если a == b печать "равных!\северный" еще печать "по-разному!\северный" end выведет "equal". В python я не могу этого сделать. Для целей метапрограммирования, осуществление экспериментальных рамок, и тому подобное, Эта удивительная динамика способность Рубина очень привлекательный. Но ... если мы говорим о больших применениях, начатых от много людей и поддерживается даже больше, включая все виды библиотек из различных источников, и перейти в производство на клиентских сайтах... ну, мне не нужен язык, который Очень динамично, большое спасибо. Мне ненавистна сама мысль о какой-то библиотеке. невольно ломая других те, которые полагаются на эти строки по-другому - это глубоко. и глубоко скрытый "канал", между фрагменты кода, которые выглядят раздельно и ДОЛЖНО БЫТЬ отдельно, что заклинания d-e-a-t-h в крупномасштабном программировании. Позволяя любой модуль влияет на поведение любого другого "скрытно", способность мутировать семантику встроенные типы-это просто плохая идея Программирование производственных приложений, так же, как это круто для возни.

Если бы мне пришлось использовать Ruby для такого большого применение, я бы попытался положиться на ограничения в стиле кодирования, множество тесты (для повторного запуска, когда что-либо изменения-даже то, что должно быть полностью несвязанный...), и тому подобное, запретить использование этой языковой функции. Но не имея функции в первое место даже лучше, в моем мнение - так же, как и сам Python еще лучше язык прикладное программирование, если количество встроенных модулей может быть " прибито вниз", поэтому я знал, что, например,, len ("ciao") - 4 (вместо того, чтобы иметь подсознательно беспокоиться о том, кто-то изменил привязку имя "лен" в builtins модуль...). Я надеюсь, что в конечном итоге Python "гвоздь вниз" его встроенные.

но проблема незначительна, так как rebinding встроенные довольно устаревшая, а также редкая практика в Python. В Ruby, мне кажется, майор ... прямо как слишком мощный макрообъекты других языков (например, как, скажем, Дилан) present similar риски по моему собственному мнению (я надеюсь что Python не получает такой мощный макросистема, независимо от очарования "позволять людям определять свои собственные доменный мало языков встроенные в сам язык" - это будет, ИМХО, ухудшить замечательный Python полезность для применения Программирование, путем представления "привлекательная помеха" для потенциальных клиентов лудильщик, который скрывается в каждом сердце программиста...).

Алекс

11

некоторые другие из:

http://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-python/

(Если я неправильно истолковал что-либо или любое из них изменилось на стороне Ruby с момента обновления этой страницы, кто-то может редактировать...)

строки изменяются в Ruby, а не в Python (где новые строки создаются "изменениями").

Ruby имеет некоторые принудительные соглашения о случаях, Python делает не.

Python имеет как списки, так и кортежи (неизменяемые списки). Ruby имеет массивы, соответствующие спискам Python, но не неизменяемый их вариант.

в Python вы можете напрямую обращаться к атрибутам объектов. В Ruby, это всегда через методы.

в Ruby скобки для вызовов методов обычно являются необязательными, но не в Python.

Ruby имеет public, private и protected для обеспечения доступа вместо соглашения Python об использовании подчеркиваний и имени искажение.

Python имеет множественное наследование. Рубин "миксины."

и еще одна очень важная ссылка:

http://c2.com/cgi/wiki?PythonVsRuby

, который, в частности, ссылки еще один хороший Алекс Мартелли, который также публикует много отличных вещей здесь на SO:

http://groups.google.com/group/comp.lang.python/msg/028422d707512283

9

Я не уверен в этом, поэтому сначала добавляю его в качестве ответа.

Python рассматривает несвязанные методы как функции

это означает, что вы можете вызвать метод либо как theobject.themethod() или TheClass.themethod(anobject).

Edit: хотя разница между методами и функциями невелика в Python и не существует в Python 3, Она также не существует в Ruby, просто потому, что Ruby не имеет функций. Когда вы определяете функции, вы фактически определяете методы на Объект.

но вы все равно не можете взять метод одного класса и вызвать его как функцию, вам нужно будет повторно привязать его к объекту, который вы хотите вызвать, что гораздо более упрямо.

8

я хотел бы упомянуть API дескриптора Python, который позволяет настраивать объект-атрибут "связь". Также примечательно, что в Python можно реализовать альтернативный протокол путем переопределения значения по умолчанию, заданного с помощью реализации по умолчанию __getattribute__ метод. Позвольте мне подробнее рассказать об этом. Дескрипторы являются регулярными классами с __get__, __set__ и/или __delete__ методы. Когда переводчик встречает что-то вроде anObj.anAttr следующая выполняется:

  • __getattribute__ метод anObj вызывается
  • __getattribute__ извлекает объект anAttr из класса dict
  • он проверяет, имеет ли объект abAttr __get__, __set__ или __delete__ вызываемые объекты
  • контекст (т. е. вызывающий объект или класс и значение вместо последнего, если у нас есть сеттер) передается вызываемому объекту
  • результат возвращается.

как уже было сказано, это является поведением по умолчанию. Можно изменить протокол, повторно реализовав __getattribute__.

эта техника намного мощнее, чем декораторы.

7

Ruby имеет встроенную поддержку продолжения с помощью callcc.

следовательно, вы можете реализовать классные вещи, как amb-оператор

6

на данном этапе Python по-прежнему имеет лучшую поддержку unicode

6

Python имеет docstrings, а ruby-нет... Или, если это не так, они не доступны так легко, как в python.

Ps. Если я ошибаюсь, пожалуйста, оставьте пример? У меня есть обходной путь, который я мог бы monkeypatch в классы довольно легко, но я хотел бы иметь docstring своего рода функцию в "native way".

5

Ruby имеет строчный цикл по входным файлам (флаг'- n') из командной строки, поэтому его можно использовать как AWK. Этот рубиновый однострочный:

ruby -ne 'END {puts $.}'

будет считать строки, такие как AWK one-liner:

awk 'END{print NR}'

Ruby получает эту функцию через Perl, который взял ее из AWK как способ получения системных администраторов на борту с Perl без необходимости изменять способ их работы.

5

Руби сигилы и twigils, питона не так.

редактировать: и одна очень важная вещь, которую я забыл (в конце концов, предыдущий был просто немного пламени: - p):

Python имеет JIT-компилятор (Psyco), язык более низкого уровня для написания более быстрого кода (Pyrex) и возможность добавления встроенного кода C++ (плетение).

5

мой python ржавый, поэтому некоторые из них могут быть в python, и я просто не помню/никогда не учился в первую очередь, но вот первые несколько, о которых я подумал:

пробел

Ruby обрабатывает пробелы совершенно по-другому. Для начала вам не нужно ничего отступать (что означает, что не имеет значения, используете ли вы 4 пробела или 1 вкладку). Он также делает продолжение smart line, поэтому допустимо следующее:

def foo(bar,
        cow)

в основном, если вы закончите с оператор, он выясняет, что происходит.

Mixins

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.

или вы можете сделать это с помощью хэшей, которые касаются второй проблемы

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

5

вы можете иметь код в определении класса как в Ruby, так и в Python. Однако в Ruby у вас есть ссылка на класс (self). В Python у вас нет ссылки на класс, А класс еще не определен.

пример:

class Kaka
  puts self
end

self в этом случае является классом, и этот код распечатает "Kaka". Невозможно распечатать имя класса или другими способами получить доступ к классу из тела определения класса в Python.

5

синтаксис-это не мелочь, он напрямую влияет на то, как мы думаем. Это также имеет прямое влияние на правила, которые мы создаем для систем, которые мы используем. В качестве примера мы имеем порядок операций из-за того, как мы пишем математические уравнения или предложения. Стандартная нотация для математики позволяет людям читать ее более чем одним способом и получать разные ответы на одно и то же уравнение. Если бы мы использовали префиксную или постфиксную нотацию, мы бы создали правила, чтобы различать, что числа, которыми нужно было манипулировать, были не только правилами для порядка вычисления значений.

стандартная нотация дает понять, о каких числах мы говорим, делая порядок их вычисления неоднозначным. Префиксная и постфиксная нотация делают порядок вычисления простым, делая числа неоднозначными. Python уже имел бы многострочные лямбды, если бы не трудности, вызванные синтаксическими пробелами. (Предложения существуют для вытягивания такого рода вещей без обязательного добавления явных разделителей блоков.)

Мне легче писать условия, в которых я хочу, чтобы что-то произошло, если условие false гораздо проще писать с помощью оператора unless в Ruby, чем семантически эквивалентную конструкцию "if-not" в Ruby или других языках, например. Если большинство языков, которые люди используют сегодня, равны по силе, как можно считать синтаксис каждого языка тривиальная вещь? После определенных функций, таких как блоки и механизмы наследования и т. д. синтаксис-самая важная часть языка, едва ли поверхностная вещь.

поверхностными являются эстетические качества красоты, которые мы приписываем синтаксису. Эстетика не имеет ничего общего с тем, как работает наше познание, синтаксис.

4

удивлен, что ничего не упоминается о механизме "метод отсутствует" Рубина. Я бы привел примеры find_by_... методы в Rails, как пример мощности этой языковой функции. Я думаю, что нечто подобное может быть реализовано в Python, но насколько мне известно его там нет изначально.

3

другое различие в лямбдах между Python и Ruby продемонстрировано Полом Грэмом Аккумулятор Генератор

3

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 в объявлении функции-это аффектация, которая всегда добавляется.

3

Ruby имеет встроенную документацию:

 =begin

 You could use rdoc to generate man pages from this documentation

 =end
2
2

в Ruby, когда вы импортируете файл с требовать, все вещи определенные в этот файл будет в конечном итоге в глобальной пространство имен.

С груз вы можете "требуются библиотеки без загромождения пространства имен".

# 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"
2