Python传参拷贝问题

1. ——python中的函数调用传参，如果不涉及参数修改，传递的是否为引用，如果涉及修改，是否为深拷贝。

在Python中，函数调用传参的方式是通过引用传递。这意味着函数参数接收的是原始对象的引用，而不是对象本身的副本。因此，如果函数内部对参数进行修改，会影响原始对象的值。

如果函数涉及参数的修改，Python并不会进行深拷贝。深拷贝是指创建一个新的对象，该对象与原始对象具有相同的值，但是在内存中存储的位置不同。在Python中，如果需要进行深拷贝，可以使用copy模块中的deepcopy函数。

下面是一个示例来说明这个问题：

def modify_list(lst):
    lst.append(4)
    print("Inside function:", lst)

my_list = [1, 2, 3]
print("Before function call:", my_list)
modify_list(my_list)
print("After function call:", my_list)

输出结果为：

Before function call: [1, 2, 3]
Inside function: [1, 2, 3, 4]
After function call: [1, 2, 3, 4]

可以看到，函数内部对参数进行修改后，原始列表的值也发生了变化。这是因为函数接收的是原始列表的引用，所以对引用进行的修改会影响原始对象。

如果我们想要在函数内部修改参数而不影响原始对象，可以使用深拷贝来创建一个新的对象。例如：

import copy

def modify_list(lst):
    new_lst = copy.deepcopy(lst)
    new_lst.append(4)
    print("Inside function:", new_lst)

my_list = [1, 2, 3]
print("Before function call:", my_list)
modify_list(my_list)
print("After function call:", my_list)

输出结果为：

Before function call: [1, 2, 3]
Inside function: [1, 2, 3, 4]
After function call: [1, 2, 3]

可以看到，原始列表的值没有发生变化，因为我们在函数内部使用了深拷贝创建了一个新的对象。

2. ——下面这段程序中并没有修改x的值是为什么：

def modify_x(x):
    x += 1
    print("Inside function:", x)

x = 1
print("Before function call:", x)
modify_list(x)
print("After function call:", x)

 在这段程序中，`x`是一个整数对象，而整数是不可变类型。不可变类型的对象在进行运算或修改时，会创建一个新的对象来存储结果，而不会修改原始对象本身。

在函数`modify_x`中，`x += 1`实际上是创建了一个新的整数对象，并将新的对象赋值给了局部变量`x`。这个新的对象的值是原始对象的值加1。因此，函数内部的修改不会影响原始对象。

下面是修改后的程序：

def modify_x(x):
    x += 1
    print("Inside function:", x)

x = 1
print("Before function call:", x)
modify_x(x)
print("After function call:", x)

输出结果为：

Before function call: 1
Inside function: 2
After function call: 1

可以看到，原始对象`x`的值没有发生变化，因为函数内部的修改只影响了局部变量`x`，而不会修改原始对象本身。

3. ——python的数据类型中，哪些属于可变类型，哪些属于非可变类型 ?

在Python中，可变类型是指可以在原地修改的数据类型，而非可变类型是指不能在原地修改的数据类型。以下是Python中常见的可变类型和非可变类型：

可变类型：

• 列表（list）
• 字典（dict）
• 集合（set）

非可变类型：

• 数字（int, float, complex）
• 字符串（str）
• 元组（tuple）
• 布尔值（bool）

可变类型的对象可以通过原地修改来改变其值，而非可变类型的对象则无法通过原地修改来改变其值。这意味着对于非可变类型的对象，如果需要修改其值，实际上是创建了一个新的对象，并将新的对象赋值给变量。

下面是一个示例来说明这个问题：

def modify_list(lst):
    lst.append(4)
    print("Inside function:", lst)

def modify_string(s):
    s += " World"
    print("Inside function:", s)

my_list = [1, 2, 3]
print("Before function call:", my_list)
modify_list(my_list)
print("After function call:", my_list)

my_string = "Hello"
print("Before function call:", my_string)
modify_string(my_string)
print("After function call:", my_string)

输出结果为：

Before function call: [1, 2, 3]
Inside function: [1, 2, 3, 4]
After function call: [1, 2, 3, 4]

Before function call: Hello
Inside function: Hello World
After function call: Hello

可以看到，对于可变类型的对象（如列表），函数内部的修改会影响原始对象的值。而对于非可变类型的对象（如字符串），函数内部的修改不会影响原始对象的值，因为实际上是创建了一个新的对象。