54

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

1.should_equal(1)

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

更新：与其谈论猴子补丁的不同定义，我只想关注上面的例子。正如你们中的一些人回答的那样，我已经得出结论，它不能做到。但我想更详细地解释为什么它不能完成，如果 Python 中可用的话，也许有什么功能允许这样做。

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

 item.price.should_equal(19.99)

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

should_equal(item.price, 19.99)

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

4

14 回答 14

76

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

但是，在 Python 代码中定义的类可能会被猴子补丁，因为它们是该解释器的本地类。

于 2008-10-10T20:01:31.990 回答
45

你说的猴子补丁到底是什么意思？有几个略有不同的定义。

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

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

但是您不能对某些内置类执行此操作，例如intor float。这些类的方法是用 C 实现的，为了使实现更容易和更高效，牺牲了一些抽象。

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

于 2008-10-10T19:15:42.207 回答
31 
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")

玩得开心 ;）

于 2010-10-26T15:37:39.423 回答
30

你可以做到这一点，但它需要一点黑客攻击。幸运的是，现在有一个名为“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)

你可以走了！还有一个“反向”功能可以删除已修补的方法。

于 2013-06-22T00:33:56.370 回答
14

正如其他用户指出的那样，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 风格的猴子补丁相比，这种方法的一个可能优势是should_equal()可以轻松地对任何类型进行比较，而不仅仅是intor float。但也许我过于关注您碰巧提供的特定示例的细节。

于 2008-10-11T04:50:58.223 回答
8

您无法在 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)
于 2011-05-13T06:35:19.300 回答
4

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

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

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

import TelnetConnection

将其更改为：

import TelnetConnectionExtended as TelnetConnection

然后在代码中引用 TelnetConnection 的任何地方实际上都会引用 TelnetConnectionExtended。

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

于 2008-10-10T19:09:16.760 回答
4

这是一个实现的示例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)
于 2009-05-08T02:36:45.263 回答
1

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

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

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

于 2008-10-10T19:13:08.173 回答
1

做什么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)

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

于 2009-05-06T15:15:39.107 回答
1

看来你真正想写的是：

assert item.price == 19.99

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

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

于 2011-06-05T20:22:55.243 回答
0

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

于 2008-10-10T18:57:11.403 回答
0

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

您可以将 int 子类化，尽管它很重要，但您可能必须重写__new__.

您还有语法问题：

1.somemethod()  # invalid

然而

(1).__eq__(1)  # valid
于 2012-12-20T11:19:35.087 回答
-1

这是我实现 .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 上。

于 2012-06-05T03:38:45.557 回答