你能在python的核心类型上使用monkey补丁方法吗?

你说的猴子补丁到底是什么意思?有 several slightly different definitions .

如果您的意思是,“您能在运行时更改类的方法吗?”,那么答案是肯定的:

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语言中实现的,为了使实现更容易和更高效,需要牺牲一些抽象。

我不太清楚 为什么? 您无论如何都希望更改内置数值类的行为。如果你需要改变他们的行为,把他们分成子类!!

不,你不能。在Python中,C扩展模块(包括内置模块)中定义的所有数据(类、方法、函数等)都是不可变的。这是因为C模块在同一进程中在多个口译员之间共享,所以MonkeyPatching它们也会影响同一进程中不相关的口译员。(同一进程中的多个口译员可以通过 C API 而且 some effort 使它们在Python级别上可用。)

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

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

玩得开心;

你可以这样做,但这需要一点黑客。幸运的是,有一个模块现在被称为“禁果”,它让您能够非常简单地修补内置类型的方法。你可以在

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)

你真是太好了!还有一个“reverse”函数可以删除修补后的方法。

正如其他用户指出的那样,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 或者,子类public;我们也可以直接在构造实例的函数或方法中定义它。

当然,在某些情况下,能够熟练使用习惯用法的Python程序员会认为这种子类化方法是正确的。例如, os.stat() 返回A 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 (或其他地方)很有可能被认为是蟒蛇的事。我 可以 很容易想象某人决定添加 price_should_equal() 方法到 item 如果这是主要的用例;如果一个人在寻找更一般的东西,那么使用命名的参数来使预期的含义更清晰可能更有意义,如

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

或者沿着这些线。它有点冗长,但毫无疑问它可以改进。与Ruby风格的猴子修补相比,这种方法的一个可能优势是 should_equal() 可以轻松地对任何类型进行比较,而不仅仅是 int 或 浮动 . 但也许我太沉迷于你提供的具体例子的细节了。

不能在Python中修补核心类型。 但是,您可以使用pipe编写更具人类可读性的代码:

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 尽管我在实际程序中使用十进制而不是浮点:

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中做一个monkey补丁,可以使用“import foo as bar”技术进行一次(排序)黑客攻击。

如果您有一个类,比如telnetconnection,并且您想要扩展它,那么可以在一个单独的文件中对它进行子类化,并将其称为类似telnetconnectionextended的类。

然后,在代码顶部,您通常会说:

import TelnetConnection

将其更改为:

import TelnetConnectionExtended as TelnetConnection

然后,您引用telnetconnection的代码中的任何地方实际上都将引用telnetconnectionextended。

遗憾的是,这假定您可以访问该类,“a s”只在该特定文件中运行(它不是全局重命名),但我发现它有时很有用。

不,但您有userdict userstring和userlist,它们都是基于这一点创建的。

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

一般来说,monkey补丁在python中的使用要比在ruby中少。

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

您可以将int子类化,尽管它非常重要,但是您可能需要重写 __new__ .

您还存在语法问题:

1.somemethod()  # invalid

然而

(1).__eq__(1)  # valid

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

什么? should_equal 怎么办?是布尔返回吗 True 或 False ?在这种情况下,它的拼写是:

item.price == 19.99

没有考虑到味道,但是没有一个普通的Python开发人员会说它比您的版本更不可读。

做 应该平等 而是设置某种验证器?(为什么验证器只限于一个值?为什么不设置值,然后不更新它呢?)如果您想要一个验证器,这无论如何都不会起作用,因为您打算修改一个特定的整数或者所有的整数。(需要 18.99 平等 19.99 将永远失败。)相反,您可以这样拼写:

item.price_should_equal(19.99)

或者:

item.should_equal('price', 19.99)

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

看来你真正想写的是:

assert item.price == 19.99

(当然,比较浮点数是否相等,或者使用浮点数表示价格)是 a bad idea ,所以你要写 assert item.price == Decimal(19.99) 或者是你用来计算价格的数字类。)

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

以下是我如何实现的。应该做些什么…行为:

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

the(result).should.equal(42)

或

the(result).should_NOT.equal(41)

我包括一个decorator方法,用于在运行时在独立方法上扩展此行为:

@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

它也在Pypi上的Pypecs下。