Python 中的调用是如何工作的？ [复制]

对于我正在开发的一个项目，我正在实现一个链表数据结构，它基于对的概念，我将其定义为：

class Pair:
    def __init__(self, name, prefs, score):
        self.name = name
        self.score = score
        self.preferences = prefs
        self.next_pair = 0
        self.prev_pair = 0

where self.next_pair and self.prev_pair分别是指向上一个和下一个链接的指针。

为了设置链接列表，我有一个如下所示的安装函数。

def install(i, pair):
    flag = 0
    try:
        old_pair = pair_array[i]
        while old_pair.next_pair != 0:
            if old_pair == pair:
                #if pair in remainders: remainders.remove(pair)
                return 0
            if old_pair.score < pair.score:
                flag = 1
                if old_pair.prev_pair == 0: # we are at the beginning
                    old_pair.prev_pair = pair
                    pair.next_pair = old_pair
                    pair_array[i] = pair
                    break
                else: # we are not at the beginning
                    pair.prev_pair = old_pair.prev_pair
                    pair.next_pair = old_pair
                    old_pair.prev_pair = pair
                    pair.prev_pair.next_pair = pair
                    break
            else:
                old_pair = old_pair.next_pair
        if flag==0:
            if old_pair == pair:
                #if pair in remainders: remainders.remove(pair)
                return 0
            if old_pair.score < pair.score:
                if old_pair.prev_pair==0:
                    old_pair.prev_pair = pair
                    pair.next_pair = old_pair
                    pair_array[i] = pair
                else:
                    pair.prev_pair = old_pair.prev_pair
                    pair.next_pair = old_pair
                    old_pair.prev_pair = pair
                    pair.prev_pair.next_pair = pair
            else:
                old_pair.next_pair = pair
                pair.prev_pair = old_pair
        except KeyError:
            pair_array[i] = pair
            pair.prev_pair = 0
            pair.next_pair = 0

在该程序的过程中，我正在建立这些链接列表的字典，并从其中一些链接中删除链接并将它们添加到其他链接列表中。在修剪和重新安装之间，链接存储在中间数组中。

在调试这个程序的过程中，我逐渐意识到我对 Python 将参数传递给函数的方式的理解是有缺陷的。考虑我写的这个测试用例：

def test_install():
    p = Pair(20000, [3, 1, 2, 50], 45)
    print p.next_pair
    print p.prev_pair
    parse_and_get(g)
    first_run()
    rat = len(juggler_array)/len(circuit_array)
    pref_size = get_pref_size()
    print pref_size
    print install(3, p)
    print p.next_pair.name
    print p.prev_pair             

当我运行此测试时，我得到以下结果。

0
0
10
None
10108
0

我不明白的是为什么第二次打电话p.next_pair产生不同的结果（10108）比第一次调用（0). install不返回Pair可以覆盖传入的对象（它返回None），这并不是说我正在通过install一个指针。

我对按值调用的理解是解释器复制传递到函数中的值，使调用者的变量保持不变。例如，如果我说

def foo(x):
     x = x+1
     return x

baz = 2
y = foo(baz)
print y
print baz

Then 3 and 2应分别打印。事实上，当我在 Python 解释器中测试它时，结果就是这样。

如果有人能在这里指出正确的方向，我将非常感激。

在Python中，一切都是对象。简单的分配存储参考到指定对象名称中的指定对象。因此，将 Python 变量视为分配给对象的名称，而不是存储在命名位置的对象，会更直接。

例如：

baz = 2

... 商店位于baz指向整数对象的指针或引用2存储在其他地方。 （由于类型int是不可变的，Python 实际上有一个小整数池并重用相同的2对象无处不在，但这是一个实现细节，我们不需要太关心。）

你打电话时foo(baz), foo()的局部变量x也指向整数对象2首先。那就是foo()-本地名称x和全局名称baz是同一对象的名称，2. Then x = x + 1被执行。这改变了x指向不同的对象：3.

重要的是要理解：x不是一个可以容纳的盒子2, and 2然后增加到3. No, x最初指向2然后该指针更改为指向3。当然，既然我们没有改变什么对象baz指向，它仍然指向2.

另一种解释方式是，在 Python 中，所有参数传递都是按值传递的，但所有值都是对对象的引用。

与直觉相反的结果是，如果一个对象是可变的，则可以通过任何引用对其进行修改，并且所有引用都将“看到”更改。例如，考虑一下：

baz = [1, 2, 3]

def foo(x):
   x[0] = x[0] + 1

foo(baz)
print baz
>>> [2, 2, 3]

This seems与我们的第一个例子非常不同。但实际上，争论是通过同样的方式进行的。foo()接收到一个指向baz以...之名x然后对其执行操作以更改它（在这种情况下，列表的第一个元素指向不同的int目的）。区别在于名字x永远不会指向一个新对象；这是x[0]被修改为指向不同的对象。x本身仍然指向同一个对象baz。 （事实上​​，在幕后分配给x[0]变成方法调用：x.__setitem__()。） 所以baz“看到”列表的修改。怎么可能不呢？

对于整数和字符串，您不会看到这种行为，因为您无法更改整数或字符串；它们是不可变类型，当您修改它们时（例如x = x + 1）您实际上并没有修改它们，而是将变量名称绑定到完全不同的对象。如果你改变baz到一个元组，例如baz = (1, 2, 3)，你会发现foo()给你一个错误，因为你不能分配给元组的元素；元组是另一种不可变类型。 “更改”元组需要创建一个新元组，然后赋值将变量指向新对象。

您定义的类的对象是可变的，因此您的Pair实例可以通过传入它的任何函数进行修改——也就是说，可以添加、删除属性或将属性重新分配给其他对象。这些都不会重新绑定任何指向您的对象的名称，因此当前指向它的所有名称都将“看到”更改。