python 中的赋值操作，与c/c++的对比

def foo(l):

      l += 'b'

l = 'abc'

foo(l)

print(l)        #result   'abc' not 'abcb'

l = ['abc']

foo(l)

print(l)       #result ['abc','b']

作个总结，网上已经有相关的内容了，这里方便记忆。也许有理解错误的地方：）

先看后一种情况，python中的所有变量传递都是传递引用（感觉类似c中的指针，即传递对象的地址)，类似java中的非内置类型。所以引用本身不可变，但是被引用的内容是可以变化的。

所以list l中的内容在执行foo(l)后变化了。

个人暂时理解，python,java中不支持引用的引用吧，类似c中的二级指针，例如如何实现下面的函数呢

createTree(Node *&root)

感觉不能实现，虽然createTree可以利用返回值用其它的方式实现但是上面的形式似乎无法在python,java中实现。

那么对于上面的代码，第一种情况，为什么内容不变呢，

个人认为可以暂时这么理解，内存中有个地址x，存储'abc‘

l 是'abc'的一个引用（类似c中 int *l; l = x)，在foo(l)的时候产生一个临时变量 它也指向 'abc'

但问题在于python中的string,int等是不可变的，

也就是说 'abc' + 'b'会在内存中新开一个地址，存储 'abcb' ，然后 foo作用域的l被重新赋值，作为'abcb'的引用，但是foo执行完，glbal域的l依然指向'abc'依然是 'abc'的引用，同时脱离foo作用域后，'abcb'所占用的空间应该已经被系统回收了。

这就是所谓对于函数的中变量赋值所带来的引用所指的内容可以变，引用本身不变，而偏偏string 是不可变的 'abc' + 'b'并没有改变'abc'而是新开空间存储了'abcb'同时赋值给local l 这个赋值并不改变global

中的l.

所以这也就解释了，为什么python,java中要实现类似c++中的swap

void swap(int &a, int &b)

需要采取一些work around的方法了。

所以

python，java中一切参数传递都是引用的传递，也可理解为传地址，对象的内容可以变，地址却不会变。

所以传过去的变量，其内容可以变化，但是地址不变。

def foo(a):

     a.left = 3

     a.right = 4

     b = A()

     b.left = 5

     b.right = 6

     a = b

#初始

a.left = 1

a.right = 1

#调用foo(a)

foo(a)

#之后a.left = 3 , a.right = 4

如果传过去的变量a的类型为A，可以理解为

struct A{

   int left;

   int right;

}

void foo(A *a)  

   

void foo(A *a)

    a->left = 3

    a->right = 4

    A *b = new A;

    b->left = 5

    b->right = 6

    a = b

运行完 foo(a)

a->left = 3, a->right = 4

那么考虑c++引用

void foo(A &a)

        a.left = 3

        a.right = 4

        A b;

        b.left = 5

        b.right = 6

        a = b

运行完 foo(a) a.left = 5, a.right = 6

这里体现的c++与python的不同在 a = b

python中只是引用的赋值，可以理解为对象地址的赋值，而C++这里 a = b是内容的赋值，是内容拷贝了（浅拷贝，严格复制内容）。

所以完成后a.left = 5,a.right = 6.而foo中的b运行完 foo就已经不存在了。

而python 只是引用赋值，并且利用引用计数的技术，一个对象对它的引用为0后会被回收。

如果要实现c++的引用效果，

swap(int &a, int &b)

只能采用 外包一个类如s s.a s.b

swap(s)

   temp = s.a

   s.a = s.b

   s.b = temp

s.a = a

s.b = b

swap(s)

a = s.b

b = s.a

或者用list 封装 a, b

最简单的写法 [a, b] = [b, a]

对于createTree(Node *&root)

createTree(Node *&root)

    root = new Node()

    createTree(root->left())

    createTree(root->right())

将 root 作为函数返回值

如果有多个 &，如 &num, &sum，那么也应该按list封装，或者封装到类中传类对象即可。

嗯，感觉在这种情况，c++写起来更方便写，不过python,java的处理也有它的道理，所有的传递都是传对象地址，统一处理，

传过去的变量，只会使其的内部内容变化，不会是它本身改变，本质上传递的参数还是要作为右值的，可读不可写（写无意义），

不会莫名其妙的运行一个函数后原来函数作用域的变量莫名其妙变化了。我们传递参数为了使用它而不是改变它。

当然代价是失去c++在这里处理方式的灵活性了。

09.9.14

另外补充下，

1. 在C++中其实大部分传递引用的函数例如下面，其实应该是只读的，如下

void TestSkipList(DeterminSkipList<T> &skip_list, ifstream &in, ofstream &out)

函数里面会有skip_list.insert()等，也可能会改变skip_list所指向的对象的

内容，所以不可加 const 限制符。这里用引用是和python中传递引用是完全一致的概念情形，如果不传递引用就好有临时对象拷贝的产生，但是注意c++唯一的不同是

理论上skip_list = another_list 是对象拷贝，而对于python 是引用拷贝。所以会出现不同情形，注意区分即可。

 #include <iostream>
2 using namespace std;
3 
4 class list {
5     public:
6         list(int a = 3): data(a){}
7        
8         int data;
9 };
10 
11 void foo(list &l)
12 {
13     l.data = 4;
14    
15     list b(5);
16 
17     l = b;
18 }
19 
20 
21 int main(int argc, char *argv[])
22 {
23     list a;
24 
25     list* pl = &a;
26 
27     foo(a);
28 
29     list* pl2 = &a;
30 
31     cout << a.data << endl;
32 
33     cout << (pl == pl2) << endl;
34     return 0;
35 }

c++运行结果

5

1

class list():
    def __init__(self, a = 3):
        self.data = a

def foo(l):
    l.data = 4
    b = list(5)
    l = b

a = list()
foo(a)
print(a.data)

python运行结果

4

所以结果不同就体现在l = b的赋值，c++是对象内容拷贝， python是对象引用赋值，而局部变量的变化不会影响到被传递的变量值。

类似的java代码结果也应该是4.

2. 那么对于一些python不好模拟的情况，如rec(int n, int &a, int &b)其实这里的a,b是作为一个类似全局变量的概念的，注意是类似，其实和python 3.x提出的nonlocal概念是一致的，很多时候会在C++中写递归函数中用到类似rec(int n, int &a, int &b)的写法，用，

a,和b记录递归过程中的全局变量，对每个递归函数都可见，而不是像n，每个递归函数看到的都是local的拷贝。

这种情况下rec函数其实一般都是一个helper函数，外面用户调用的时候其实调用一个其它的接口如foo(n)

int foo(int n) {

//调用rec

int a = 3;

int b = 4;

rec(n, a, b);

}

那么其实可以把rec看成foo的内部实现所需要的一个helper 函数。在python中我们可以用嵌套函数来实现，而对于python3.x，利用

nonlocal变量，可以完全模拟c++的行为。注意的是python2.x不支持nonlocal

下面给出代码,运行结果都是22

C++

 #include <iostream>
2 using namespace std;
3 
4 
5 void rec(int n, int &a, int &b) {
6     if (n == 0)
7         return;
8     a += 1;
9     b += 2;
10     rec(n - 1, a, b);
11 }
12 
13 int foo(int n) {
14     int a = 3;
15     int b = 4;
16     rec(n, a, b);
17     return a + b;
18 }
19 
20 
21 int main(int argc, char *argv[])
22 {
23     cout << foo(5) << endl;
24     return 0;
25 }

python

 def foo(n):
2     def rec(n):
3         if n == 0:
4             return
5         nonlocal a
6         nonlocal b
7         a += 1
8         b += 2
9         rec(n - 1)
10     a = 3
11     b = 4
12     rec(n)
13     return a + b
14 
15 print(foo(5))

最后贴一下upenn的课件关于python变量的部分