Если исправление обезьяны разрешено и в Ruby, и в Python, почему это вызывает больше споров в Ruby?

Как программист Python, который попробовал Ruby (и ему он нравится), я думаю, что есть какая-то ироническая параллель с тем временем, когда Python начал становиться популярным.

Программисты, работающие на языках C и Java, «кричали» Python, заявляя, что это не настоящий язык, и что динамическая природа его типов была бы опасной, и позволяла людям создавать «плохой» код. По мере того, как Python становился все более популярным, становились очевидными преимущества его быстрого времени разработки, не говоря уже о менее подробном синтаксисе:

// Java
Person p = new Person();

# Python
p = Person()

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

С некоторой забавой я увидел одну из ключевых гибких возможностей Ruby - Monkey Patching, которую толпа Python называла опасной. Начав преподавать Ruby студентам в этом году, я думаю, что возможность «исправить» реализацию существующего класса, даже того, который является частью системы, очень эффективна.

Конечно, вы можете сильно облажаться, и ваша программа может вылететь. Я тоже довольно легко могу выполнить segfault в C. А Java-приложения могут умереть пламенной смертью.

По правде говоря, я рассматриваю Monkey Patching как следующий шаг в динамическом и метапрограммировании. Забавно, поскольку он появился еще со времен Smalltalk.

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

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

Языки могут разрешить это, но ни одно сообщество не одобряет эту практику. Monkeypatching не одобряется ни на одном из языков, но вы чаще слышите об этом в Ruby, потому что форма открытого класса, которую он использует, позволяет очень и очень легко обновлять monkeypatch, и поэтому это более приемлемо в сообществе Ruby, но все еще осуждается. Патчинг обезьян просто не так распространен и не так прост в Python, поэтому вы не услышите таких же аргументов против него в этом сообществе. Python не делает ничего из того, что не делает Ruby, чтобы предотвратить такую ​​практику.

Причина, по которой вы чаще слышите / читаете об этом в Ruby, заключается в том, что это в Ruby:

class MyClass
  def foo
    puts "foo"
  end
end

class MyClass
  def bar
    puts "bar"
  end
end

предоставит вам класс, содержащий два метода, foo и bar, тогда как это в Python:

class MyClass:
    def foo(self):
        print "foo"

class MyClass:
    def bar(self):
        print "bar"

оставит вас с классом, который содержит только метод bar, поскольку переопределение класса полностью уничтожает предыдущее определение. Чтобы обезьянничать в Python, вам действительно нужно написать это:

class MyClass:
    def foo(self):
        print "foo"

def bar(self):
    print "bar"
MyClass.bar = bar

что сложнее, чем версия на Ruby. Уже одно это делает код Ruby намного проще для monkeypatch, чем код Python.

«Включает ли Python различные типы защиты, чтобы минимизировать риски, связанные с этой функцией?»

да. Сообщество отказывается это делать. Защита полностью социальная.

На самом деле в Python несколько сложнее изменять базовые типы.

Например, представьте, что вы переопределяете целое число.

Рубин:

class Fixnum 
   def *(n)
      5 
   end 
end

Теперь 2 * 2 дает 5.

Python:

>>> class int(int):
    def __mul__(self, x):
        return 5


>>> 2*2
4
>>> int(2)*int(2)
5

В Python любой литерал ("", {}, 1.0 и т. Д.) Создает экземпляр стандартного класса, даже если вы пытались исправить его и переопределить соответствующий класс в пространстве имен.

Это просто не сработает так, как вы планировали:

class str():
    # define your custom string type
    ...

a = "foo"      # still a real Python string
a = str("foo") # only this uses your custom class

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

Обычно программисты Python знают, как ведет себя класс или метод. Они знают, что класс xxx действует определенным образом.

Когда вы обезьяны исправляете класс или метод, вы меняете его поведение. Другие программисты Python, использующие этот класс, могут быть очень удивлены, если этот класс ведет себя иначе.

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

Если вы хотите сделать некоторые исправления обезьяны в Python, это относительно просто, если вы не изменяете встроенный тип (int, float, str).

class SomeClass:
    def foo(self):
        print "foo"

def tempfunc(self):
    print "bar"
SomeClass.bar = tempfunc
del tempfunc

Это добавит метод bar в SomeClass, и даже существующие экземпляры этого класса смогут использовать этот внедренный метод.