你能在 Python 的核心类型上对方法进行 monkey patch 吗？-IT科技

摘要：问题描述：Ruby 可以向 Number 类和其他核心类型添加方法来获得如下效果：1.should_equal(1) 但 Python 似乎无法做到这一点。这是真的吗？如果是，为什么？这是否与类型无法修改有关？我不想讨论猴子补丁的不同定义，只想关注上面的例子。正如你们中的一些人回答的那样，我已经得出结论，这是...

问题描述：

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

1.should_equal(1)

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

我不想讨论猴子补丁的不同定义，只想关注上面的例子。正如你们中的一些人回答的那样，我已经得出结论，这是不可能做到的。但我想更详细地解释一下为什么不能这样做，也许 Python 中有什么特性可以实现这一点（如果可用的话）。

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

 item.price.should_equal(19.99)

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

should_equal(item.price, 19.99)

Rspec和其他一些 Ruby 框架均基于此概念。

解决方案 1：

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

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

解决方案 2：

这里的 Monkey Patch 到底是什么意思？有几种略有不同的定义。

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

class Foo:
  pass # dummy class

Foo.bar = lambda self: 42

x = Foo()
print x.bar()

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

class Foo:
  pass # dummy class

x = Foo()

Foo.bar = lambda self: 42

print x.bar()

但是对于某些内置类，例如int或，您无法执行此操作float。这些类的方法是用 C 实现的，并且为了使实现更容易、更高效，牺牲了某些抽象。

我不太清楚你为什么要改变内置数字类的行为。如果你需要改变它们的行为，就把它们子类化吧！

解决方案 3：

您可以这样做，但需要一点技巧。幸运的是，现在有一个名为“禁果”的模块，它可以让您非常轻松地修补内置类型的方法。您可以在以下位置找到它

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

或者

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

使用原始问题示例，在编写“should_equal”函数后，你只需执行

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

一切就绪！还有一个“反向”功能可以删除已修补的方法。

解决方案 4：

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")

玩得开心 ;）

解决方案 5：

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

>>> 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 中的用户定义类型默认是可变的。

>>> 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添加命名成员的子类，正是为了解决您在示例中提到的可读性问题。

>>> import os
>>> st = os.stat('.')
>>> st
(16877, 34996226, 65024L, 69, 1000, 1000, 4096, 1223697425, 1223699268, 1223699268)
>>> st[6]
4096
>>> st.st_size
4096

话虽如此，在您给出的具体示例中，我认为float在item.price（或其他地方）进行子类化不太可能被视为 Pythonic 的做法。我可以很容易地想象有人决定在中添加一个price_should_equal()方法，item如果这是主要用例；如果有人在寻找更通用的东西，也许使用命名参数来使预期含义更清晰可能更有意义，例如

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

或类似的东西。这有点冗长，但毫无疑问可以改进。这种方法相对于 Ruby 风格的 monkey-patching 的一个可能优势是，它should_equal()可以轻松地对任何类型执行比较，而不仅仅是int或float。但也许我太纠结于您恰好提供的特定示例的细节了。

解决方案 6：

您无法修补 Python 中的核心类型。但是，您可以使用管道来编写更易于阅读的代码：

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)

解决方案 7：

如果您真的真的真的想在 Python 中做一个 monkey patch，您可以使用“import foo as bar”技术进行（某种程度上的）破解。

如果您有一个像 TelnetConnection 这样的类，并且想要扩展它，请在单独的文件中对其进行子类化，并将其命名为 TelnetConnectionExtended 之类的名称。

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

import TelnetConnection

将其更改为：

import TelnetConnectionExtended as TelnetConnection

然后，代码中引用 TelnetConnection 的所有地方实际上都会引用 TelnetConnectionExtended。

遗憾的是，这假设您有权访问该类，并且“as”仅在该特定文件内运行（它不是全局重命名），但我发现它有时很有用。

解决方案 8：

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

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)

解决方案 9：

看来你真正想写的是：

assert item.price == 19.99

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

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

解决方案 10：

不，但是你有 UserDict UserString 和 UserList，它们正是为此而制作的。

如果你用谷歌搜索，你会发现其他类型的例子，但这些都是内置的。

总体来说，Python 中的 monkey patching 使用比 Ruby 中的少。

解决方案 11：

做什么should_equal？它是返回布尔值True还是False？如果是，则拼写为：

item.price == 19.99

没有人能解释为什么口味如此之差，但没有一个普通的 Python 开发人员会说它的可读性不如你的版本。

是否should_equal设置某种验证器？（为什么验证器仅限于一个值？为什么不直接设置该值，然后不更新它？）如果您想要一个验证器，这无论如何都行不通，因为您提议修改特定整数或所有整数。（需要18.99相等的验证器19.99将始终失败。）相反，您可以这样拼写：

item.price_should_equal(19.99)

或这样：

item.should_equal('price', 19.99)

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

解决方案 12：

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

您可以对 int 进行子类化，尽管这并不简单，但您可能必须覆盖__new__。

您还遇到语法问题：

1.somemethod()  # invalid

然而

(1).__eq__(1)  # valid

解决方案 13：

以下是我制作自定义字符串/整数/浮点数……等的方法：

class MyStrClass(str):

    def __init__(self, arg: str):
        self.arg_one = arg

    def my_str_method(self):
        return self.arg_one

    def my_str_multiple_arg_method(self, arg_two):
        return self.arg_one + arg_two

class MyIntClass(int):

    def __init__(self, arg: int):
        self.arg_one = arg

    def my_int_method(self):
        return self.arg_one * 2


myString = MyStrClass("StackOverflow")
myInteger = MyIntClass(15)

print(myString.count("a"))  # Output: 1
print(myString.my_str_method())  # Output: StackOverflow
print(myString.my_str_multiple_arg_method(" is cool!"))  # Output: StackOverflow is cool!
print(myInteger.my_int_method())  # Output: 30

这可能不是最好的解决方案，但是效果很好。

解决方案 14：

不，你不能在 Python 中这样做。我认为这是一件好事。

解决方案 15：

以下是我实现 .should_something... 行为的方法：

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

the(result).should.equal(42)

或者

the(result).should_NOT.equal(41)

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

@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 上。