Python 中的参数传递、返回值、浅拷贝、深拷贝

参数传递

Python中的参数传递可以分为可变对象和不可变对象两种情况。

对于不可变对象，例如数字、字符串、元组等等，传递参数时会创建其副本，以避免函数内部对参数的修改影响到函数外的变量。

对于可变对象，例如列表、字典等等，传递参数时会将引用传递给函数，函数内部对参数的修改同样会影响到函数外的变量。

下面是一些示例说明：

示例1 - 不可变对象

def change_num(num):
    num += 1
    return num

a = 1
b = change_num(a)
print(a)  # 1
print(b)  # 2

在这个例子中，参数a是一个int类型的不可变对象，change_num函数中对传入的参数num进行了加1操作，返回了修改后的值。但是对于外部的变量a，它的值并没有被修改，因为传递时创建了一个副本，而函数内部的修改只影响了这个副本。

示例2 - 可变对象

def append_list(lst):
    lst.append('d')
    return lst

my_list = ['a', 'b', 'c']
new_list = append_list(my_list)
print(my_list)  # ['a', 'b', 'c', 'd']
print(new_list)  # ['a', 'b', 'c', 'd']

在这个例子中，参数my_list是一个list类型的可变对象，append_list函数中对传入的参数lst进行了append操作，也就是在原列表中添加了元素'd'，并返回了修改后的列表。由于传参时是传递引用，所以函数内部的修改同样影响了外部变量my_list。

返回值

Python中的函数可以有返回值，通过return语句来返回一个值。如果没有return语句，则默认返回None。

可以在调用函数时将返回值赋值给一个变量来接收它。也可以直接调用函数，但是如果不接收返回值，那么返回值就会被忽略。

下面是一些示例说明：

示例3 - 有返回值

def calc_sum(lst):
    return sum(lst)

my_list = [1, 2, 3, 4, 5]
result = calc_sum(my_list)
print(result)  # 15

在这个例子中，calc_sum函数接收一个列表参数lst，计算列表中所有元素的和，并通过return语句将结果返回。调用函数时将其返回值赋值给result变量来接收它，最终输出结果为15。

示例4 - 无返回值

def say_hello(name):
    print('Hello, ' + name + '!')

say_hello('Bob')  # Hello, Bob!

在这个例子中，say_hello函数接收一个字符串参数name，输出一句问候语。在调用函数时直接传入参数，函数内部的输出语句也会执行，但是没有返回值可以接收。

浅拷贝

Python中的浅拷贝是指复制一个可变对象时，只复制了最外层的容器对象，而其内部的元素对象仍是原对象中的引用。这样，在新对象和原对象之间共享的对象不再是最初的对象，而是这些对象的副本。

浅拷贝可以使用Python中的copy()或者[:]操作符来完成。

下面是一些示例说明：

示例5 - 列表浅拷贝

lst1 = [[1, 2], [3, 4]]
lst2 = lst1.copy()

lst1[0][1] = 5
print(lst1)  # [[1, 5], [3, 4]]
print(lst2)  # [[1, 5], [3, 4]]

在这个例子中，lst2是lst1的浅拷贝。在lst1的第一个元素列表中修改了其第二个元素为5后，输出发现lst2的第一个元素列表也同样做出了修改，这是因为lst1和lst2中的元素列表实际上是原始列表中同一个列表对象的引用。

示例6 - 字典浅拷贝

dict1 = {'a': [1, 2], 'b': [3, 4]}
dict2 = dict1.copy()

dict1['a'][1] = 5
print(dict1)  # {'a': [1, 5], 'b': [3, 4]}
print(dict2)  # {'a': [1, 5], 'b': [3, 4]}

在这个例子中，dict2是dict1的浅拷贝。在dict1中将'a'对应的列表的第二个元素修改为5后，输出发现dict2中的'a'对应的列表也同样被修改了，这是因为dict1和dict2中的列表实际上也是原始字典中同一个列表对象的引用。

深拷贝

Python中的深拷贝是指复制一个可变对象时，不仅复制最外层的容器对象，而且对其内部的元素对象也进行递归复制，这样就可以得到两个相互独立的完全相同的对象。

深拷贝可以使用Python中的copy模块中的deepcopy()函数来完成。

下面是一些示例说明：

示例7 - 列表深拷贝

import copy

lst1 = [[1, 2], [3, 4]]
lst2 = copy.deepcopy(lst1)

lst1[0][1] = 5
print(lst1)  # [[1, 5], [3, 4]]
print(lst2)  # [[1, 2], [3, 4]]

在这个例子中，lst2是lst1的深拷贝。在lst1的第一个元素列表中修改了其第二个元素为5后，输出发现lst2的第一个元素列表并未发生变化，这是因为lst1和lst2中的元素列表是两个完全独立的对象。

示例8 - 字典深拷贝

import copy

dict1 = {'a': [1, 2], 'b': [3, 4]}
dict2 = copy.deepcopy(dict1)

dict1['a'][1] = 5
print(dict1)  # {'a': [1, 5], 'b': [3, 4]}
print(dict2)  # {'a': [1, 2], 'b': [3, 4]}

在这个例子中，dict2是dict1的深拷贝。在dict1中将'a'对应的列表的第二个元素修改为5后，输出发现dict2中的'a'对应的列表并未发生变化，这是因为dict1和dict2中的列表也是两个完全独立的对象。