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

Question

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

1.should_equal(1)

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

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

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

 item.price.should_equal(19.99)

这更像是英文，清楚地表明哪个是测试值，哪个是预期值，应该是：

should_equal(item.price, 19.99)

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

Answer 1

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中实现，并且为了使实现更容易和更有效，牺牲了某些抽象。

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

Answer 2

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

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

Answer 3

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

玩得开心;）

Answer 4

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

找到它

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)

你很高兴去！还有一个“反向”的用于删除修补方法的函数。

Answer 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

那就是说，在你给出的具体例子中，我不相信在 item.price （或其他地方）中继承 float 的可能性很大Pythonic要做的事情。我可以轻易想象有人决定将 price_should_equal（）方法添加到 item （如果这是主要用例）;如果一个人正在寻找更一般的东西，也许使用命名参数使意图更明确的意义更有意义，如

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

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

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

Answer 7

这是一个实现 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)

Answer 8

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

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

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

import TelnetConnection

将其更改为：

import TelnetConnectionExtended as TelnetConnection

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

可悲的是，这假设您可以访问该类，并且“as”可以访问该类。只在该特定文件中运行（它不是全局重命名），但我发现它不时有用。

Answer 9

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

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

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

Answer 10

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

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

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

Answer 12

你真正想写的似乎是：

assert item.price == 19.99

（当然比较浮点数是否相等，或者使用浮点数来计算价格）是一个坏主意，所以你要写断言item.price ==十进制（19.99）或你用于价格的任何数字类。）

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

Answer 13

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

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

您还有语法问题：

1.somemethod()  # invalid

然而

(1).__eq__(1)  # valid

Answer 14

以下是我如何实现.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上。