你能在Python中对核心类型使用修补程序方法吗？

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

1.should_equal(1)

item.price_should_equal(19.99)

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

更新：我不想谈论猴子补丁的不同定义，我只想关注上面的例子。我已经得出结论，正如你们中的一些人所回答的那样，这是不可能做到的。但我想更详细地解释为什么不能这样做，如果Python中提供了什么特性，可能会允许这样做

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

 item.price.should_equal(19.99)

这读起来更像英语，清楚地表明哪一个是测试值，哪一个是预期值，假设为：

should_equal(item.price, 19.99)

---

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

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

如果你真的真的想在Python中做一个猴子补丁，你可以用“导入Foo为bar”技术来做一个（SoToof）黑客攻击。 如果您有一个类，比如TelnetConnection，并且您想要扩展它，那么在一个单独的文件中对它进行子类化，并将其称为TelnetConnectionExtended

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

import TelnetConnection

将其更改为：

import TelnetConnectionExtended as TelnetConnection

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

---

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

没有，但您有UserDict UserString和UserList，它们正是在考虑这一点的情况下创建的

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

---

一般来说，与Ruby相比，Python中较少使用monkey补丁。

这里的monkey补丁到底是什么意思？有

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

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模块在同一进程中的多个口译员之间共享，因此对它们进行修补也会影响同一进程中的无关口译员。（同一过程中的多个解释器可以通过，并且已经朝着使它们在Python级别可用的方向发展。）

---

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

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'

也不需要将

MyInt

子类公开；也可以直接在构造实例的函数或方法中内联定义它

当然，有些情况下，精通这一习语的Python程序员认为这类子类是正确的。例如，

os.stat（）

>>> 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
进行子类化很可能被认为是python式的做法。我可以很容易地想象有人决定在
项目
中添加一个
price\u should\u equal（）
方法，如果这是主要用例的话；如果一个人在寻找更一般的东西，也许使用命名的参数来使意图更清晰更有意义，如

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

或者类似的东西。这有点冗长，但毫无疑问可以改进。与Ruby风格的monkey补丁相比，这种方法的一个可能优势是
should_equal（）
可以轻松地对任何类型执行比较，而不仅仅是
int
或
float
。但也许我太过关注您碰巧提供的特定示例的细节。
什么是
应该_equal
做的？它是返回
True
还是
False
的布尔值？在这种情况下，它的拼写是：

item.price == 19.99

没有考虑到品味，但是没有一个普通的python开发人员会说它的可读性不如您的版本

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

1.should_equal(1)

item.price_should_equal(19.99)

或者这个：

item.should_equal('price', 19.99)

并在item的类或超类上定义适当的方法。
下面是一个实现
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)

玩得开心；）
 不能在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)

<
assert item.price == 19.99

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

1.somemethod()  # invalid

(1).__eq__(1)  # valid

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