对不可变对象的引用的 Python 集合答案

【问题标题】：Python collection of references to immutables对不可变对象的引用的 Python 集合
【发布时间】：2019-09-13 12:32:54
【问题描述】：

有没有办法在 python 中获取引用列表？意思是，当我更改其中一个内部事物时会自动更改的事物集合，而无需引用集合本身。

允许我在示例中展示的内容

# What happens
a = 1
b = 2
L = [a, b]
print(L) # [1, 2]

b = 3
print(L) # [1, 2]


# I would like to have something like
a = 1
b = 2
ra = ref(a)
rb = ref(b)
L = [ra, rb]
print(L) # [1, 2]

b = 3
print(L) # [1, 3]

编辑如果数字在 python 中是可变的，我的第一个示例会工作。 IE。如果重新分配（例如：b = 3）意味着“改变我们通过标签'b'引用的对象的内存”。

我的第一个示例使用列表的可变元素（例如，如果我构建一个列表列表，然后变异 - 无需重新分配！ - 内部列表）。

因此，更具体地说，我的问题是：当集合包含不可变元素时，我们是否有机会发生这种行为？

（特别是我对可调用列表感兴趣）。

【问题讨论】：

您基本上回答了您自己的问题 - Python 已经通过引用引用了每个对象。问题是当您重新分配不可变对象的对象引用，或者只是没有使用可变对象的可用方法时。当您处理不可变元素的集合时，您应该直接使用集合本身。
您可能也会对此感兴趣：stackoverflow.com/questions/44935204/…

标签： python reference mutation

【解决方案1】：

在打印L的新值之前，将值b再次存储在L中，请找到以下代码：

a = 1
b = 2
L = [a, b]
print(L) # [1, 2]
b = 3
L=[a, b]
print(L) # [1, 3]

但是这种方法效率不高。列表项的更新方式只有索引。如下：

a = 1
b = 2
L = [a, b]
print(L) # [1, 2]
b = 3
L[1]=b
print(L) # [1, 3]

我们无法像您尝试在 Python 中使用引用那样做到这一点。当您将整数放入列表中时，列表会保存该整数的副本。整数最初是变量、文字值、函数调用的结果还是其他东西都没有关系；当列表看到它时，它只是一个整数值。

【讨论】：

我的要求是我想改变 L 内部的内容，不再再次引用 L。这就是拥有一组引用的意义，所以如果我有 L[a, b, a, a, a, c, a, d]，我可以说“更改 a”和 L 中的所有 a将会改变。此外，我编辑了我的问题以使其更具体，因为它实际上只是关于不可变集合的集合。
[a,b,a,a,b,c] - 这将构造一个可变的列表。整数本质上是不可变的。当您遍历此列表时，您可以更改列表的内容，因为列表是可变的，但是，整数本身不会更改，因为它们是不可变的。 Python 在这里（幕后）所做的是创建一个值为 1 的新整数对象，并将指针切换到该新对象。
谢谢。正如我在之前的评论中所说，我正在寻找一种解决方法，以解决我无法访问不可变集合的引用但仍想更改它的情况。或者，即使我拥有它，我也想要一种更符合人体工程学的方式来更改依赖于某个变量的所有值（例如，它可能在集合中出现多次）。请参阅我的答案以了解实现此解决方法的方法。

【解决方案2】：

好的，找到方法了。我只是用可变包装器包装不可变。

例如，如果我们想要有可变整数：

class mut_int:
    def __init__(self, data):
        self.data = data

    def mutate(self, new_data):
        self.data = new_data

    def __repr__(self):
        return repr(self.data)

a = mut_int(1)
L = [a, a]
print(L) # [1, 1]

# from now on, we assume we don't have access to L anymore

a.mutate(2) # simulating the mutable a = 2
print(L) # [2, 2] # we changed L without accessing it directly, nice!

对于可变的可调用对象，类似地：

class mut_callable:
    def __init__(self, func):
        self.func = func

    def mutate(self, new_func):
        self.func = new_func

    def __repr__(self):
        return repr(self.func)

    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)

f = mut_callable(lambda x: x)
L = [f, lambda x: f(x) + f(x), lambda x: f(f(x))]
print([g(2) for g in L])
# Out: [2, 4, 2] 
# i.e. [identity(2), 2+2, identity(identity(2))]

# from now on, we assume we don't have access to L anymore

f.mutate(lambda x: x**2)
print([g(2) for g in L])
# Out: [4, 8, 16]
# i.e. [square(2), 2+2, square(square(2))]

不幸的是，这有点脆弱，因为 python 的动态特性并且不可能重载赋值 (a = 3) 运算符。一旦对可变包装器使用通常的赋值，包装器就会丢失，我们又回到了原点。

a = mut_int(1)
L = [a, a]
print(L) # [1, 1]
a.mutate(2)
print(L) # [2, 2] good so far

a = 3 # !ACHTUNG! We did not stick to the api, and a is no more a mut_int!
print(L) # still [2, 2] :(
a.mutate(4) # AttributeError

如果有人找到更优雅和/或符合人体工程学和/或稳健的解决方案，我仍然很期待！

【讨论】：