a += a 与 a = a + a 的区别
可变类型a = a + a 的示例
In [58]: a = [11,22]
In [59]: id(a)
Out[59]: 140702917607688
In [60]: a = a + a
In [61]: a
Out[61]: [11, 22, 11, 22]
In [62]: id(a)
Out[62]: 140703006930440
In [63]: # 注意id的结果不同
分析以上的代码:
第一步:计算赋值运算符右边的代码 [11,22]+[11,22] = [11,22,11,22]
第二步:将计算的新结果开辟了新的内存保存
第三步:让a指向了新的内存
可变类型的a += a示例
In [63]: a = [11,22]
In [64]: id(a)
Out[64]: 140702994655880
In [65]: a += a
In [66]: id(a)
Out[66]: 140702994655880
In [67]: a
Out[67]: [11, 22, 11, 22] #注意id的值没变
分析以上的代码:
a += a 是在原来a的指向的内存里修改值 a的指向并没有修改
注意以上是可变类型 下面看一下不可变类型
In [68]: a = 1
In [69]: id(a)
Out[69]: 10914368
In [70]: a += a
In [71]: id(a)
Out[71]: 10914400
In [72]: a
Out[72]: 2
====================================================
In [76]: a = 1
In [77]: id(a)
Out[77]: 10914368
In [78]: a = a + a
In [79]: id(a)
Out[79]: 10914400
In [80]: a
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
不可变类型示例:
In [81]: a = 1
In [82]: id(a)
Out[82]: 10914368
In [83]: a += 1
In [84]: a
Out[84]: 2
In [85]: id(a)
Out[85]: 10914400
总结:
python中的不可变数据类型,不允许变量的值发生变化,如果改变了变量的值,相当于是新建了一个对象;
可变类型示例:
In [89]: a = [11,22]
In [90]: b = [11,22]
In [91]: id(a)
Out[91]: 140702995536840
In [92]: id(b)
Out[92]: 140702918106696
In [93]: a.append(33)
In [94]: id(a)
Out[94]: 140702995536840
In [95]: a
Out[95]: [11, 22, 33]
In [96]: # 注意a的值变了地址没有发生变化
总结:
可变数据类型,允许变量的值发生变化,即如果对变量进行append、+=(注意除了 a = a+a这种形式)等这种操作后,只是改变了变量的值,而不会新建一个对象,变量引用的对象的地址也不会变化,不过对于相同的值的不同对象,在内存中则会存在不同的对象,即每个对象都有自己的地址,相当于内存中对于同值的对象保存了多份,这里不存在引用计数,是实实在在的对象。
可变类型对于相同的值而对象不同的示例:
In [1]: a = [11,22]
In [2]: b = [11,22]
In [3]: id(a)
Out[3]: 140404737889544
In [4]: id(b)
Out[4]: 140404737846984
In [5]: # 相同的值而不同的对象保存了多份
引用传参
• 可变类型与不可变类型的变量分别作为函数参数时,会有什么不同吗?
• Python有没有类似C语言中的指针传参呢?
示例
>>> def selfAdd(a):
... """自增"""
... a += a
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1 # 注意结果没有变化
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2] # 注意结果发生了变化
总结:
Python中函数参数是引用传递(注意不是值传递)。对于不可变类型,因变量的值不能修改,所以运算不会影响到变量自身;而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量的值。