Python当中的a += a 与 a = a + a 的区别，可变类型与不可变类型的数据类型，引用传参

a += a 与 a = a + a 的区别

可变类型a = a + a 的示例

1. In [58]: a = [11,22]

2.  
3.  

4. In [59]: id(a)

5. Out[59]: 140702917607688

6.  
7.  

8. In [60]: a = a + a

9.  
10.  

11. In [61]: a

12. Out[61]: [11, 22, 11, 22]

13.  
14.  

15. In [62]: id(a)

16. Out[62]: 140703006930440

17.  
18.  

19. In [63]: # 注意id的结果不同

分析以上的代码：
　　第一步：计算赋值运算符右边的代码 [11,22]+[11,22] = [11,22,11,22]
　　第二步：将计算的新结果开辟了新的内存保存
　　第三步：让a指向了新的内存

可变类型的a += a示例

1. In [63]: a = [11,22]

2.  

3. In [64]: id(a)

4. Out[64]: 140702994655880

5.  

6. In [65]: a += a

7.  

8. In [66]: id(a)

9. Out[66]: 140702994655880

10.  

11. In [67]: a

12. Out[67]: [11, 22, 11, 22] #注意id的值没变

　

分析以上的代码：
　　a += a  是在原来a的指向的内存里修改值 a的指向并没有修改

注意以上是可变类型  下面看一下不可变类型

1. In [68]: a = 1

2.  

3. In [69]: id(a)

4. Out[69]: 10914368

5.  

6. In [70]: a += a

7.  

8. In [71]: id(a)

9. Out[71]: 10914400

10.  

11. In [72]: a

12. Out[72]: 2

13.  

14. ====================================================

15. In [76]: a = 1

16.  

17. In [77]: id(a)

18. Out[77]: 10914368

19.  

20. In [78]: a = a + a

21.  

22. In [79]: id(a)

23. Out[79]: 10914400

24.  

25. In [80]: a

26. Out[80]: 2

　　

总结：

　　如果a是一个可变类型，那么a += a 是在a指向的内存中直接修改，a = a+a 是指向了一个新的内存
　　  如果a是一个不可变类型，那么a += a 和a = a+a 的效果一样即：a指向了一个新的内存

 

 

 

可变类型与不可变类型的数据类型

 

可变类型，值可以改变：
　　• 列表 list
　　• 字典 dict

不可变类型，值不可以改变：
　　• 数值类型 int, long, bool, float
　　• 字符串 str
　　• 元组 tuple

 

不可变类型示例：

1. In [81]: a = 1

2.  

3. In [82]: id(a)

4. Out[82]: 10914368

5.  

6. In [83]: a += 1

7.  

8. In [84]: a

9. Out[84]: 2

10.  

11. In [85]: id(a)

12. Out[85]: 10914400　

总结：

　　python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象;

可变类型示例：

1. In [89]: a = [11,22]

2.  

3. In [90]: b = [11,22]

4.  

5. In [91]: id(a)

6. Out[91]: 140702995536840

7.  

8. In [92]: id(b)

9. Out[92]: 140702918106696

10.  

11. In [93]: a.append(33)

12.  

13. In [94]: id(a)

14. Out[94]: 140702995536840

15.  

16. In [95]: a

17. Out[95]: [11, 22, 33]

18.  

19. In [96]: # 注意a的值变了地址没有发生变化

 

总结：

　　可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=（注意除了 a = a+a这种形式）等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

可变类型对于相同的值而对象不同的示例：

1. In [1]: a = [11,22]

2.  

3. In [2]: b = [11,22]

4.  

5. In [3]: id(a)

6. Out[3]: 140404737889544

7.  

8. In [4]: id(b)

9. Out[4]: 140404737846984

10.  

11. In [5]: # 相同的值而不同的对象保存了多份

　　

引用传参

 

　　• 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
　　• Python有没有类似C语言中的指针传参呢？

 

　示例

 

1. >>> def selfAdd(a):

2. ... """自增"""

3. ... a += a

4. ...

5. >>> a_int = 1

6. >>> a_int

7. 1

8. >>> selfAdd(a_int)

9. >>> a_int

10. 1 # 注意结果没有变化

11. >>> a_list = [1, 2]

12. >>> a_list

13. [1, 2]

14. >>> selfAdd(a_list)

15. >>> a_list

16. [1, 2, 1, 2] # 注意结果发生了变化

 

　总结：　　

　　　　Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量的值不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量的值。