关于ruby：你可以在Python中的核心类型上修补补丁方法吗？


Can you monkey patch methods on core types in Python?

Ruby可以向Number类和其他核心类型添加方法以获得如下效果：

1
1.should_equal(1)

但似乎Python无法做到这一点。 这是真的？ 如果是这样，为什么？ 是否与类型无法修改的事实有关？

更新：我不想谈论猴子修补的不同定义，而是只关注上面的例子。 我已经得出结论，由于你们中的一些人已经回答，所以无法做到。 但是我想更详细地解释为什么不能这样做，也许如果Python中有什么功能允许这样做。

回答你们中的一些人：我可能想要这样做的原因只是美学/可读性。

1
 item.price.should_equal(19.99)

这更像是英语，并清楚地表明哪个是测试值，哪个是预期值，如下所示：

1
should_equal(item.price, 19.99)

这个概念就是Rspec和其他一些Ruby框架所基于的。

相关讨论

你不能。在Python中，C扩展模块(包括内置函数)中定义的所有数据(类，方法，函数等)都是不可变的。这是因为C模块在同一进程中的多个解释器之间共享，因此monkeypatching它们也会影响同一进程中不相关的解释器。 (通过C API可以在同一个过程中使用多个解释器，并且已经做了一些努力使它们在Python级别可用。)

但是，Python代码中定义的类可能是monkeypatched，因为它们是该解释器的本地。

相关讨论

Monkey Patch在这里究竟是什么意思？有几个略有不同的定义。

如果你的意思是"你能在运行时改变一个类的方法吗？"，那么答案显然是肯定的：

1
2
3
4
5
6
7
class Foo:
  pass # dummy class

Foo.bar = lambda self: 42

x = Foo()
print x.bar()

如果你的意思是"你能在运行时更改类的方法，并使该类的所有实例在事后发生变化吗？"那么答案也是肯定的。只需稍微改变顺序：

1
2
3
4
5
6
7
8
class Foo:
  pass # dummy class

x = Foo()

Foo.bar = lambda self: 42

print x.bar()

但是你不能为某些内置类(如int或float)执行此操作。这些类的方法在C中实现，并且为了使实现更容易和更有效，牺牲了某些抽象。

我不清楚你为什么要改变内置数值类的行为。如果你需要改变他们的行为，请将它们子类化!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def should_equal_def(self, value):
    if self != value:
        raise ValueError,"%r should equal %r" % (self, value)

class MyPatchedInt(int):
    should_equal=should_equal_def

class MyPatchedStr(str):
    should_equal=should_equal_def

import __builtin__
__builtin__.str = MyPatchedStr
__builtin__.int = MyPatchedInt

int(1).should_equal(1)
str("44").should_equal("44")

玩得开心 ;)

相关讨论

你可以做到这一点，但它需要一点点黑客攻击。幸运的是，现在有一个名为"Forbidden Fruit"的模块，它可以让您非常简单地修补内置类型的方法。你可以找到它

http://clarete.github.io/forbiddenfruit/?goback=.gde_50788_member_228887816

要么

https://pypi.python.org/pypi/forbiddenfruit/0.1.0

使用原始问题示例，在您编写"should_equal"函数之后，您就可以了

1
2
from forbiddenfruit import curse
curse(int,"should_equal", should_equal)

你很高兴去！还有一个"反向"功能来删除修补方法。

相关讨论

其他用户指出，Python的核心类型在设计上是不可变的：

1
2
3
4
>>> int.frobnicate = lambda self: whatever()
Traceback (most recent call last):
  File"<stdin>", line 1, in <module>
TypeError: can't set attributes of built-in/extension type 'int'

您当然可以通过创建子类来实现您描述的效果，因为默认情况下Python中的用户定义类型是可变的。

1
2
3
4
5
6
7
8
9
>>> class MyInt(int):
...   def frobnicate(self):
...     print 'frobnicating %r' % self
...
>>> five = MyInt(5)
>>> five.frobnicate()
frobnicating 5
>>> five + 8
13

也没有必要公开MyInt子类;也可以直接在构造实例的函数或方法中内联定义它。

在某些情况下，熟练使用成语的Python程序员可以考虑将这种类型的子类化为正确的事情。例如，os.stat()返回一个添加命名成员的tuple子类，正是为了解决您在示例中引用的可读性问题。

1
2
3
4
5
6
7
8
>>> import os
>>> st = os.stat('.')
>>> st
(16877, 34996226, 65024L, 69, 1000, 1000, 4096, 1223697425, 1223699268, 1223699268)
>>> st[6]
4096
>>> st.st_size
4096

也就是说，在你给出的具体例子中，我不认为item.price(或其他地方)中的子类float很可能被认为是Pythonic要做的事情。我很容易想象有人决定将price_should_equal()方法添加到item，如果这是主要的用例;如果一个人正在寻找更一般的东西，也许使用命名参数使意图更清晰，就像在

1
should_equal(observed=item.price, expected=19.99)

或类似的规定。它有点冗长，但毫无疑问它可以改进。这种方法相对于Ruby式猴子修补的一个可能的优点是should_equal()可以轻松地在任何类型上执行其比较，而不仅仅是int或float。但也许我对你碰巧提供的特定例子的细节太过了解。

你不能在python中修补核心类型。
但是，您可以使用管道编写更易读的代码：

1
2
3
4
5
6
7
8
9
10
11
12
from pipe import *

@Pipe
def should_equal(obj, val):
    if obj==val: return True
    return False

class dummy: pass
item=dummy()
item.value=19.99

print item.value | should_equal(19.99)
相关讨论

这是一个实现item.price.should_equal的例子，虽然我在实际程序中使用Decimal而不是float：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Price(float):
    def __init__(self, val=None):
        float.__init__(self)
        if val is not None:
            self = val

    def should_equal(self, val):
        assert self == val, (self, val)

class Item(object):
    def __init__(self, name, price=None):
        self.name = name
        self.price = Price(price)

item = Item("spam", 3.99)
item.price.should_equal(3.99)

如果你真的真的想在Python中做一个猴子补丁，你可以用"import foo as bar"技术做一个(sortof)hack。

如果您有一个类，如TelnetConnection，并且您想要扩展它，请将其子类化为一个单独的文件，并将其称为TelnetConnectionExtended。

然后，在代码的顶部，您通常会说：

1
import TelnetConnection

改变是：

1
import TelnetConnectionExtended as TelnetConnection

然后，您引用TelnetConnection的代码中的每个地方实际上都会引用TelnetConnectionExtended。

遗憾的是，这假设您可以访问该类，并且"as"仅在该特定文件中运行(它不是全局重命名)，但我发现它不时有用。

不，但你有UserDict UserString和UserList，正是考虑到这一点。

如果你谷歌你会找到其他类型的例子，但这是内置的。

一般来说，猴子补丁在Python中的使用比在Ruby中少。

不，遗憾的是，您无法在运行时扩展在C中实现的类型。

你可以继承int，虽然它是非平凡的，你可能必须覆盖__new__。

您还有语法问题：

1
1.somemethod()  # invalid

然而

1
(1).__eq__(1)  # valid

看来你真正想写的是：

1
assert item.price == 19.99

(当然比较浮点数是否相等，或者使用浮点数来表示价格，这是一个坏主意，所以你要编写assert item.price == Decimal(19.99)或者你用于价格的任何数字类。)

您还可以使用py.test之类的测试框架来获取有关测试中失败断言的更多信息。

should_equal做什么？它是一个返回True或False的布尔值吗？在那种情况下，拼写：

1
item.price == 19.99

没有考虑到品味，但没有常规的python开发人员会说它的可读性低于你的版本。

是否should_equal设置了某种验证器？ (为什么验证器会被限制为一个值？为什么不设置值而不在之后更新它？)如果你想要一个验证器，那么无论如何这都无法工作，因为你建议修改一个特定的整数或全部整数。 (需要18.99等于19.99的验证器总是会失败。)相反，你可以拼写它：

1
item.price_should_equal(19.99)

或这个：

1
item.should_equal('price', 19.99)

并在item的类或超类上定义适当的方法。

不，你不能用Python做到这一点。我认为这是件好事。

这是我如何实现.should_something ...行为：

1
2
3
result = calculate_result('blah') # some method defined somewhere else

the(result).should.equal(42)

要么

1
the(result).should_NOT.equal(41)

我在一个独立的方法中包含了一个装饰器方法，用于在运行时扩展此行为：

1
2
3
4
5
6
7
8
9
10
@should_expectation
def be_42(self)
    self._assert(
        action=lambda: self._value == 42,
        report=lambda:"'{0}' should equal '5'.".format(self._value)
    )

result = 42

the(result).should.be_42()

你必须要了解一些内部结构，但它确实有效。

这是来源：

https://github.com/mdwhatcott/pyspecs

它也是在pyspecs下的PyPI上。