最近在写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)}
