python变量的值的传递方式

在编程语言中，变量的值的传递方式有两种：值传递和引用传递

值传递，就是先定义一个变量a，再定义变量b 等于变量a，无论a的值如何变化，变量b的值还是被定义时的变量a的值

引用传递，就是先定义一个变量a，再定义变量b 等于变量a，无论a的值如何变化，变量b的值总等于变量a的值

那么在python中呢？

不可变类型

不可变类型包括 int，float，str，tuple，不可变类型的变量传递规则相同

a = 1
b = a
print(id(a) == id(b))
print(f'a:{a}')
print(f'b:{b}')
print('-' * 15)

a = a + 1
print(f'a:{a}')
print(f'b:{b}')
print(id(a) == id(b))

# 运行结果
# True
# a:1
# b:1
# ---------------
# a:2
# b:1
# False

可以发现，变量a发生变化之后，变量b的值没有发生变化

详细的传递规则是这样的：

首先，定义a=1

之后定义 b=a

此时，a与b指向同一个内存地址

可以理解为一个内存地址就是一个python的对象

当 a=a+1 时，a的数值发生了变化，因为int是不可变类型，所以python在内存地址中重新申请一个地址来保存a的新的数值：2，

但此时b的数值没有发生变化，所以b的内存地址不变

python中不可变对象，简单的赋值只能改变一个变量的值，其余的变量的值不变

python中一切皆对象

不可变对象包括：int,float,str,tuple

可变数据类型

可变数据类型如 list，dict，set 的传递规则相同

l1 = [1, 2, 3]
l2 = l1
l1.append(4)

print(f'l1:{l1}')
print(f'l2:{l2}')
print(id(l1) == id(l2))

# 结果
# l1:[1, 2, 3, 4]
# l2:[1, 2, 3, 4]
# True

可以发现，l1 添加元素4之后，l2的数值也随着变化

首先，变量l1和l2指向同一个内存地址

之后，因为这个内存地址的数据类型是一个list，属于可变类型，所以，l1添加元素4，不会改变内存地址

再来尝试一下字典

a_dict = {'one':1}
b_dict = a_dict

a_dict['two']=2
print(f"a_dict:{a_dict}")
print(f"b_dict:{b_dict}")

# 结果
# a_dict:{'one': 1, 'two': 2}
# b_dict:{'one': 1, 'two': 2}

可以发现，第一个字典发生改变，第二个字典随着发生改变

对于可变对象的改变，指向该对象的变量会随着发生改变

可变对象包括：list，dict，set

函数中参数的传递

刚才演示的是函数外变量的传递，那么在函数中参数是如何传递的呢？

def fun1(list2):
    list2.append(4)

list1 = [1,2,3]
fun1(list1)

print(list1)
# 结果
# [1, 2, 3, 4]

可见，函数中的参数，仍然为引用传递，即与函数外变量的传递规则相同

再来试一下不可变参数

def fun2(b):
    b=2

a = 1
fun2(a)

print(a)

# 结果
# 1

python函数的参数的传递，也是引用传递

为了避免因为函数的参数的传递规则而产生bug，我们通常会在函数中添加一个return语句

def fun(my_list):
    my_list.append(5)
    return my_list


a_list = [1,2,3]
a_list = fun(a_list)

print(a_list)

# 结果
# [1, 2, 3, 5]

对象的赋值和改变

对象的赋值，是指一个对象的内存地址不变，例如列表中添加、删除元素，如：

a = [1, 2, 3]
print(f'the id of a is :{id(a)}')

a.append(4)
print(f'the id of a is :{id(a)}')

# 结果
# the id of a is :2405345026696
# the id of a is :2405345026696

列表a添加元素前后内存地址不变

对象的改变，是指重新创建对象，如：

a = [1,2,3]
b = [1,2,3]

print(id(a)==id(b))
# False

创建的列表a，列表b是两个对象，内存地址不同

+= 与 =+ 的区别

=+ 是重新创建对象

+= 对于可变对象而言，是对象的赋值；对于不可变对象而言，是对象的改变

def demo1(array):
    # 对象的赋值
    array += [4, 5]
    return array


def demo2(array):
    # 对象的改变
    array = array + [4, 5]
    return array

a = [1, 2, 3]
b = [1, 2, 3]

c = demo1(a)
print('a list is {}\nc list is {}\na is c :{}'.format(a, c, a is c))  # True
# 输出结果
# a list is [1, 2, 3, 4, 5]
# c list is [1, 2, 3, 4, 5]
# a is c :True

print()
d = demo2(b)
print('b list is {}\nd list is {}\nb is d :{}'.format(b, d, b is d))  # False
# 输出结果
# b list is [1, 2, 3]
# d list is [1, 2, 3, 4, 5]
# b is d :False

总结

在python中

对于可变对象的改变，所有指向该对象的变量数值随之改变

对于不可变对象的改变，其他变量的数值不变