Python参数传递
Python参数传递
1、传递方式：通过自动将对象赋值给本地变量实现的
不可变对象通过“值”进行传递，在函数内部改变形参的值，只是让其引用了另一个对象；
可变参数通过“指针”进行传递，在函数内部改变形参的值，将直接修改应用的对象；
2、避免可变参数被函数修改的方式1).直接传递可变对象的副本：testfunc(A,B[:])
2).在函数内部创建可变参数的副本：B=B[:]
3、传递机制
默认情况下，参数通过其位置进行传递，从左至右，所以必须精确的传递和函数头部定义中一样多的参数。
可以通过关键字参数、默认参数或参数容器等改变这种传递机制；
参数传递示例：
例1：参数传递示例
In [1]:def f1():
...: x = 666
...: def f2():
...: y = "hello world"
...: print x,y
...: return f2
...:
In [2]:f1()
Out[2]:
In [3]: a1= f1()
In [4]:type(a1)
Out[4]:function
In [5]:a1()
666 helloworld:
In [6]:def f2(x,y):
...: print x+y
...:
In [7]:f2(3,4)
7
In [8]:f2('hello','world')
helloworld
例2、不可变对象参数传递示例
In [11]: m= 3;n =4
In [12]:def f3(x,y):
....: x -= 1
....: print x,y
....:
In [13]:f3(m,n)
24
In [14]:print m,n
34
例3：可变对象参数传递示例
In [1]: l1= [1,2,3,4]
In [2]:def f4(x):
...: x.pop()
...: print x
...:
In [3]:f4(l1)
[1, 2,3]
In [4]:print l1
[1, 2,3]
例4：避免可变参数被函数修改的方式示例
In [5]:f4(l1[:])
[1,2]
In [6]:print l1
[1, 2,3]
4、改变默认传递机制方式位置参数：从左向右
关键字参数：使用“name=value”语法按关键字参数名称匹配；
混用位置、关键字两种方式：调用时所有位置参数必须在前，而后才是所有的关键字参数
默认参数：有默认值的参数，定义函数时使用“name=value”语法为变量赋值，从而传入的参数可以少于参数个数；
混用有默认和无默认值的参数：定义时无默认值放前面，而后才是所有的默认参数
可变参数：定义函数时使用*开头的参数，可用于收集任意多位置或关键字参数；
调用函数时使用可变参数要求：定义时可变参数放在其他参数后面
定义函数时使用*：收集位置参数，不可使用“name=value”调用。
定义函数时使用**:收集关键字参数，收集到的参数都当做字典处理
可变参数解包：参数分解，调用函数时，使用*开头的参数，可用于将参数集合打散，从而传递任意多基于位置或关键字的参数
l1 = ["Sun","Mon","Tue"]
x,y,z = l1
print x -->Sun
print x,y,z -->SunMon Tue
例1：位置参数示例（自左而右）
In [7]:def f5(x,y):
...: print x,y
...:
In [8]:m=3;n=4
In [9]:f5(m,n)
34
In [10]:f5(n,m)
43
In [11]:f5(m)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in()
----> 1f5(m)
TypeError:f5() takes exactly 2 arguments (1 given)
In [12]:f5(m,n,l1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in()
----> 1f5(m,n,l1)
TypeError:f5() takes exactly 2 arguments (3 given)
#分别传递一个、三个参数时报错，个数必须精确匹配；
例2：关键字参数示例：混用位置、关键字两种方式时，调用时所有位置参数必须在前，而后才是所有的关键字参数
In [13]:def f6(x,y,z):
....: print x,y,z
....:
In [14]:f6(m,n,l1)
3 4 [1, 2,3]
In [15]:f6(m,y=n,z=l1)
3 4 [1, 2,3]
例3：默认参数示例：混用有默认和无默认值的参数时：定义时无默认值放前面，而后才是所有的默认参数
In [16]:def f7(x,y,z='Default'):
....: print x,y,z
....:
In [17]:f7(m,n,l1)
3 4 [1, 2,3]
In [18]:f7(m,n)
3 4Default
例4：使用可变参数：收集位置参数示例
In [20]:def f9(*x):
....: print x
....:
In [21]:f9(m)
(3,)
In [22]:f9(m,n,l1,5)
(3, 4, [1,2, 3], 5)
In [23]:f9(m,n,l1,z=5)
---------------------------------------------------------------------------
TypeError Traceback(most recent call last)
in()
----> 1f9(m,n,l1,z=5)
TypeError:f9() got an unexpected keyword argument 'z'
#定义函数传入为可变参数时，不能混用默认参数传递
例5：使用可变参数：收集关键字参数示例，构建字典
In [24]:def f10(**x):
....: print x
....:
In [25]:f10(x=1,y=2,z=3)
{'y': 2,'x': 1, 'z': 3}
例6：混用各种参数示例
In [32]:def f11(x,y=666,*z,**k):
....: print x,y,z,k
....:
In [33]:f11(m,n,a=1,b=3,c=6)
3 4 (){'a': 1, 'c': 6, 'b': 3}
In [34]:f11(m,n,l1,a=1,b=3,c=6)
3 4 ([1,2, 3],) {'a': 1, 'c': 6, 'b': 3}
In [43]:def f12(x,y=666,*z,**k):
....: print x
....: print y
....: print z
....: print k
....:
In [44]:f12(m,n,l1,m,n,a=1,b=3,c=6)
3
4
([1, 2,3], 3, 4)
{'a': 1,'c': 6, 'b': 3}
In [45]:f12(m,n,a=1,b=3,c=6)
3
4
()
{'a': 1,'c': 6, 'b': 3}
例7：参数解包示例
In [50]:l1 = ["Sun","Mon","Tue"]
In [51]:def f13(x,y,z):
....: print x,y,z
....:
In [52]:f13(*l1)
Sun MonTue
In [53]:def f15(x,*y,**z):
....: print x
....: print y
....: print z
....:
In [54]:a=666;b=["Sun","Mon","Tue","Wed"];c={'Mon':2,'Tue':3,'Wed':4}
In [55]:f15(a,*b,**c)
666
('Sun','Mon', 'Tue', 'Wed')
{'Tue': 3,'Mon': 2, 'Wed': 4}
In [56]:f15(a,b,m,n,l1,**c)
666
(['Sun','Mon', 'Tue', 'Wed'], 3, 4, ['Sun', 'Mon', 'Tue'])
{'Tue': 3,'Mon': 2, 'Wed': 4}
In [57]:f15(a,b,m,n,l1,str1='hello',str2='world',str3='!')
666
(['Sun','Mon', 'Tue', 'Wed'], 3, 4, ['Sun', 'Mon', 'Tue'])
{'str3':'!', 'str2': 'world', 'str1': 'hello'}