最近在写Python脚本的时候遇到一个问题，我在函数中修改函数的参数值，发现代码的执行效果没有跟我预想的一样。起初我一直以为Python的函数参数是可以直接修改的，直到今天我才意识到自己的错误。
Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
其中：
不可变数据（3 个）：
Number（数字）
String（字符串）
Tuple（元组）
可变数据（3 个）：
List（列表）
Dictionary（字典）
Set（集合）
下面对各个数据类型进行传参修改测试：
Number（数字）类型

number=10
print("数据类型：{}".format(type(number)))
def fun(n):
    n+=1 #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(number))
    fun(number)
    print("调用fun函数后的值：{}".format(number))

可以看到当函数参数的数据类型为Number（数字）类型时，函数内无法修改参数

数据类型：<class 'int'>
没调用fun函数前的值：10
fun函数内参数的值：11
调用fun函数后的值：10

String（字符串）

txt="Hello Python"
print("数据类型：{}".format(type(txt)))
def fun(n):
    n+=",My Love"  #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(txt))
    fun(txt)
    print("调用fun函数后的值：{}".format(txt))

可以看到当函数参数的数据类型为String（字符串）类型时，函数内无法修改参数

数据类型：<class 'str'>
没调用fun函数前的值：Hello Python
fun函数内参数的值：Hello Python,My Love
调用fun函数后的值：Hello Python

Tuple（元组）

myTuple=(1,2,3)
print("数据类型：{}".format(type(myTuple)))
def fun(n):
    n+=(4,5,6) #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(myTuple))
    fun(myTuple)
    print("调用fun函数后的值：{}".format(myTuple))

可以看到当函数参数的数据类型为Tuple（元组）类型时，函数内无法修改参数

数据类型：<class 'tuple'>
没调用fun函数前的值：(1, 2, 3)
fun函数内参数的值：(1, 2, 3, 4, 5, 6)
调用fun函数后的值：(1, 2, 3)

List（列表）

myList=[1,2,3]
print("数据类型：{}".format(type(myList)))
def fun(n):
    n+=[4]  #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(myList))
    fun(myList)
    print("调用fun函数后的值：{}".format(myList))

可以看到当函数参数的数据类型为List（列表）类型时，函数内可以修改参数

数据类型：<class 'list'>
没调用fun函数前的值：[1, 2, 3]
fun函数内参数的值：[1, 2, 3, 4]
调用fun函数后的值：[1, 2, 3, 4]

Dictionary（字典）

myDict= {"one":1,"two":2}
print("数据类型：{}".format(type(myDict)))
def fun(n):
    n["three"]=3  #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(myDict))
    fun(myDict)
    print("调用fun函数后的值：{}".format(myDict))

可以看到当函数参数的数据类型为Dictionary（字典）类型时，函数内可以修改参数

数据类型：<class 'dict'>
没调用fun函数前的值：{'one': 1, 'two': 2}
fun函数内参数的值：{'one': 1, 'two': 2, 'three': 3}
调用fun函数后的值：{'one': 1, 'two': 2, 'three': 3}

Set（集合）

mySet= {1,2,3}
print("数据类型：{}".format(type(mySet)))
def fun(n):
    n.add(4)  #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(mySet))
    fun(mySet)
    print("调用fun函数后的值：{}".format(mySet))

可以看到当函数参数的数据类型为Set（集合）类型时，函数内可以修改参数

数据类型：<class 'set'>
没调用fun函数前的值：{1, 2, 3}
fun函数内参数的值：{1, 2, 3, 4}
调用fun函数后的值：{1, 2, 3, 4}

总结
当需要在函数内修改参数而参数类型又是不可变数据类型时，可以使用可变数据类型来代替，这样就可以实现函数内修改参数。例，使用Dictionary（字典）数据类型来代替Number（数字）,String（字符串）,Tuple（元组）三种不可变数据类型。
使用字典代替数字：

myDict_Number = {"value": 1}
def fun(n):
    print("用字典类型代替的数据类型：{}".format(type(n["value"])))
    n["value"] += 1  #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(myDict_Number))
    fun(myDict_Number)
    print("调用fun函数后的值：{}".format(myDict_Number))
没调用fun函数前的值：{'value': 1}
用字典类型代替的数据类型：<class 'int'>
fun函数内参数的值：{'value': 2}
调用fun函数后的值：{'value': 2}

使用字典代替字符串：

myDict_String = {"value": "Hello "}
def fun(n):
    print("用字典类型代替的数据类型：{}".format(type(n["value"])))
    n["value"] += "World"  #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(myDict_String))
    fun(myDict_String)
    print("调用fun函数后的值：{}".format(myDict_String))
没调用fun函数前的值：{'value': 'Hello '}
用字典类型代替的数据类型：<class 'str'>
fun函数内参数的值：{'value': 'Hello World'}
调用fun函数后的值：{'value': 'Hello World'}

使用字典代替元组：

myDict_Tuple = {"value": (1,2)}
def fun(n):
    print("用字典类型代替的数据类型：{}".format(type(n["value"])))
    n["value"]+=(3,4) #修改函数参数
    print("fun函数内参数的值：{}".format(n))

if __name__ == '__main__':
    print("没调用fun函数前的值：{}".format(myDict_Tuple))
    fun(myDict_Tuple)
    print("调用fun函数后的值：{}".format(myDict_Tuple))
没调用fun函数前的值：{'value': (1, 2)}
用字典类型代替的数据类型：<class 'tuple'>
fun函数内参数的值：{'value': (1, 2, 3, 4)}
调用fun函数后的值：{'value': (1, 2, 3, 4)}