对python中引用的理解

数据的在内存中的地址就是数据的引用。
如果两个变量为同一个引用，那么这两个变量对应的数据一定相同；
如果两个变量对应的数据相同，引用不一定相同。
通过id(数据）可以查看数据对应的地址，修改变量的值，其实是在修改变量的引用。                                                           关于【引用】，分可变类型与不变类型，且python中参数传递的方式是【址传递方式】，传递数据,传递的是数据对应的地址。                                                         

+= 和append()方法对数据引用的修改效果一样！

数据可以分为：可变类型与不变类型
　　可变类型:
　　　　　　如果修改了数据的内容,数据的地址没有发生改变.
　　　　　　有列表,字典,set集合
　　不可变类型:
　　　　　　如果修改了数据的内容,数据的地址发生改变.
　　　　　　有字符串,元组,数字
　　当python解释器首次启动时,会把小数字(-5~256)和短字符串(长度小于21)缓存到缓冲区中，当在程序中使用这些数字和字符串时,就直接从缓存区中取。
　　　　m = 300
　　　　n = 300
　　　　print(id(m)) # 1811121856
　　　　print(id(n)) # 1811121856
　　　　不在小数字或者小字符串范围内的数据,会在第一次使用时缓存起来
　　　　m = 300
　　　　n = 300
　　　　print(id(m)) # 2345027009360
　　　　print(id(n)) # 2345027009360

几个小案例帮助理解
1.

不可变数据类型
变量a实际存储的是1的引用（地址）（在程序执行过程中a被编译为一条指令）

a = 1
b = a
print(id(a)) # 1820749280
print(id(b)) # 1820749280
a =2 # 修改不可变类型（的引用）
print(id(a)) # 1820749312 a的id已经改变
print(id(b)) # 1820749280
print(a,b)

可变数据类型

a = [1, 2,[3,5]]
b = a
print(id(a)) # 1758314288776
print(id(b)) # 1758314288776
# a.append(3)
a[0] = 6
a[2][0] = 1
b[2][1] = 6
print(id(a)) # 1758314288776 注意a与b始终指向同一个地址
print(id(b)) # 1758314288776
print(a) # [6, 2, [1, 6]]
print(b) # [6, 2, [1, 6]]

2. 

list = []
dict = {"name":"wangjie","age":23}
print(id(dict))
a = 10
list.append(dict) # 把dict的引用加入到list中 0x111 的内容是（指向）{"name":"wangjie","age":23}
list.append(a) # 把a的引用加入到list中 0x222 的内容是（指向）10
print(list) # list[0] 为0x111 ，内容是（指向）数据{"name":"wangjie","age":23}，list[1]的内容0x222，内容是（指向）数据10
a = 20 # 修改了a的值 a的引用发生的变化 0x333
　　　# 但不影响list中的引用指向的值 还是指向0x111 指向{"name":"wangjie","age":23}
　　　# 和0x222 指向 10
print(list)
dict["name"] = "lili" #修改了dict的值 dict为可变数据类型，dict的引用不变，但0x111的内容已经变为{'name': 'lili', 'age': 23}
print(list) # list[0]的内容是 0x111 ， 指向数据{'name': 'lili', 'age': 23}，list[1]的内容为0x222指向数据 10

3. 

list = []
list2 = []
m = 10
def func():
　　global m
　　m =20
　　list2 = [1,2] # 不属于修改，修改需要通过方法，这种是覆盖全局变量list2
　　list.append(1) # 通过append 方法修改，list的引用不变
　　print(list2) # [1, 2]
print(list) # []
print(m) # 10
print(id(m)) # 1811115776

func() # [1, 2]

print(list) # [1]
print(list2) # []
print(m) # 20
print(id(m)) # 1811116096

4.

a = [1, 2]
b = [3, 4]
a.append(b) # [1,2,[3,4]]
b.append(a)
print(a) # [1, 2, [3, 4, [...]]]
print(b) # [3, 4, [1, 2, [...]]]

5.

传递数据,传递的是数据对应的地址.

a = [[]] * 5 
print(a) [[],[],[],[],[]]
print(id(a)) # 2132205131400
print(id(a[0])) # 2132205131592
print(id(a[1])) # 2132205131592
a.append(1)
print(id(a)) # 2132205131400
print(a) # [[],[],[],[],[],1]
a[0].append(2)
print(id(a[0])) # 2132205131592
print(a) # [[2],[2],[2],[2],[2],1]
a[1].append(3)
print(id(a[1])) # 2132205131592
print(a) # [[2,3],[2,3],[2,3],[2,3],[2,3],1]

6.

>>> def selfAdd(a):
　　　　"""自增"""
　　　　a += a
>>> a_int = 1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1,2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2]

7.

修改了b[0] ,则b[0] 的引用发生改变，但b的引用没发生变化　

a = [1,2]
b = a * 2
print(b)  # [1,2,1,2]
print(id(b))  # 2745079031688
b[0] = 55
print(b)  # [55,2,1,2]
print(id(b))  # 2745079031688
print(a)  # [1,2]

8.

　　第一种情况：

　　def func(x,l = []):

　　　　for i in range(x):

　　　　　　l.append(i+1)

　　　　print(l)
　　func(3)  #  [1,2,3]

　　func(2)  # [1,2,3,1,2]

　　第二种情况：

　　def func(x,l = []):

　　　　for i in range(x):

　　　　　　l.append(i+1)

　　　　print(l)

　　list = [1,2]

　　func(3，list)  # [1,2,1,2,3]

　　func(2)  #  [1,2]

函数有默认参数，定义时即为默认参数分配地址了，也只分配这一个地址，所以第一种情况，用的全是l这个列表；第二种调用func(3,list)，将list变为了[1,2,1,2,3],然后调用func(2），l又指向了原先的已经定义好的空列表，所以结果为[1,2]。

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