Question

在Python 3中，一切都应该是一个对象，甚至是数字，但它们是不可变的。

是否可以为数字创建包装器对象，例如浮点数，除非它必须是可变的，否则它的行为与普通数字完全相同？

我想知道使用内置的类型函数是否可行，方法是创建从float派生的匿名包装器对象，但将其行为更改为可变。

>>> f = lambda x : type('', (float,), dict())(x)
>>> a = f(9)
>>> a
9.0

我必须更改哪些参数 f 才能使 a 数字变为可变？

我如何验证数字是否可变：

我必须能够创建这样的函数 f ，它将从整数值创建一个浮点值，在浅复制后，它将按以下方式运行：

>>> list_1 = [f(i) for i in [1, 2, 3, 4]]
>>> list_1
[1.0, 2.0, 3.0, 4.0]
>>> list_2 = copy.copy(list_1)
>>> list_1[0] *= 100
>>> list_1
[100.0, 2.0, 3.0, 4.0]
>>> list_2
[100.0, 2.0, 3.0, 4.0]

修改第一个列表，已经改变了它们。

也许我必须在dict（）中添加一些字段，或添加额外的基类来强制实现可变性？

Answer 1

值是不可变的。他们是柏拉图式的。像5 := 3这样的表达式是荒谬的。可变的是locations，通常称为地址或指针。 Python没有那些，但是我们可以使用类似list的容器类型伪造它，它实际上是引用其他位置的位置。

这是一个可变数值类型的部分实现，通过使用list来存储一个位置，我们将保留数字的值，并在应该更改时更改该位置的值，并且因为所有副本一个可变数字将共享该位置，所有副本将看到更改

import copy

# Convenience to work with both normal and mutable numbers
def _get_value(obj):
    try:
        return obj.value[0]
    except:
        return obj

class mutable_number(object):
    def __init__(self, value):
        # Mutable storage because `list` defines a location
        self.value = [value]

    # Define the comparison interface
    def __eq__(self, other):
        return _get_value(self) == _get_value(other)

    def __ne__(self, other):
        return _get_value(self) != _get_value(other)

    # Define the numerical operator interface, returning new instances
    # of mutable_number
    def __add__(self, other):
        return mutable_number(self.value[0] + _get_value(other))

    def __mul__(self, other):
        return mutable_number(self.value[0] * _get_value(other))

    # In-place operations alter the shared location
    def __iadd__(self, other):
        self.value[0] += _get_value(other)
        return self

    def __imul__(self, other):
        self.value[0] *= _get_value(other)
        return self

    # Define the copy interface
    def __copy__(self):
        new = mutable_number(0)
        new.value = self.value
        return new

    def __repr__(self):
        return repr(self.value[0])

x = mutable_number(1)
y = copy.copy(x)
y *= 5
print x

list_1 = [mutable_number(i) for i in [1, 2, 3, 4]]
list_2 = copy.copy(list_1)
list_1[0] *= 100
print list_1
print list_2

如果有任何不清楚的地方，请告诉我，我可以添加更多文档

Answer 2

也许你需要一个像下面这样的包装器。

# To solve scope issues. See
# <https://stackoverflow.com/questions/3431676/creating-functions-in-a-loop>
# for details.
def make_new_method(self, method_name):
    def new_method(self, *a, **aa):
        method = getattr(self._type, method_name)
        return method(self._heart, *a, **aa)
    return new_method


class Mutable():
    def __init__(self, obj):
        self._heart = obj
        self._type = type(obj)

        for attr_name in dir(self._type):
            if attr_name not in dir(Mutable):
                if callable(getattr(self._type, attr_name)):
                    new_attr = make_new_method(self, attr_name)
                    setattr(Mutable, attr_name, new_attr)
                else:
                    attr_value = getattr(self._heart, attr_name)
                    setattr(self, attr_name, attr_value)

    def set(self, new_value):
        if self._type is type(new_value):
            self._heart = new_value
        else:
            self.__init__(new_value)

    def __repr__(self):
        return f'Mutable({repr(self._heart)})'

当您编写 mutable3 = Mutable(3) 时，它会将您希望可变的值（在本例中为 3）存储在 _heart 类的实例的属性 Mutable 中并重新映射其方法直接与实例本身一起使用。例如，它允许做

In [1]: a = list(map(Mutable, range(3)))

In [2]: a
Out[2]: [Mutable(0), Mutable(1), Mutable(2)]

In [3]: b = a[1]

In [4]: b.set('hello')

In [5]: a
Out[5]: [Mutable(0), Mutable('hello'), Mutable(2)]

在我看来，这听起来像是在变量之间创建“符号链接”，我们可以使用 C 等低级语言中的指针来实现这种行为。

是否可以为数字创建包装对象，例如漂浮，让它变得可变？

2 个答案: