Python自定义函数及函数参数

Python函数的定义实例如下：

def funA(a,b):
"函数描述性文字"
s=a+b
print(s)
return s
使用__doc__能够访问函数开头的"函数描述性文字"，例如funA.__doc__就会输出：'函数描述性文字'
可以给函数的参数设置默认值，如果需要为函数的参数设置默认值，则采用如下定义：
def funB(a,b=0):
"函数描述性文字"
s=a+b
print(s)
return s
则在调用funA的时候，没有为b赋值的情况下，b会默认为0，并且含有默认值的参数必须放在无默认值的参数的后面否则如下函数所示
def
funC(a,b=
0,c):
[align=left]print(a)[/align]
[align=left]print(b)[/align]
[align=left]print(c)[/align]
以上定义方式在控制台会产生如下错误：
[align=left]def funA(a,b=0,c):[/align]
[align=left]^[/align]
[align=left]SyntaxError: non-default argument follows default argument[/align]

Python函数调用有两种方式

一种是按照没有默认值的参数的顺序，为参数一一赋值，例如：funA(1,2)，funB(1)；
不按照参数的顺序为参数赋值，funA(b=2,a=1)效果和funA(1,2)一样。

在Python的参数里面还有有带*和**的参数出现。

带*的参数：

有时候在函数实际使用的时候，参数的数量是不能在定义函数的时候就确定的，例如定义输出函数的时候。这个时候我们可以给函数定义一个带有*的参数，用来表示可变参数，例子如下：

def funD(a,b=0,*c):
"函数描述性文字"
print(a)
print(b)
print(c)
funA(1,2,3,4,5,6)
以上的例子输出的结果如下：

[align=left]1[/align]
[align=left]2[/align]
[align=left](3, 4, 5, 6)[/align]

c接受了剩下的4个参数，并且把4个参数当做一个tuple保存在了c中。

带**的参数：

带**的参数和带*的参数有相似的地方，都是可以用来表示可变参数，针对Python函数的两种调用方法，带**的参数可以接受调用函数时采用键值对方式出现的可变参数，带**的参数将多余的键值对参数保存成一个dict，例子如下：

def funE(a,b=0,*c,**d):
"函数描述性文字"
print(a)
print(b)
print(c)
print(len(d))
funE(1,2,3,4,5,6,h=2,y=3)
以上的例子输出结果如下：

[align=left]1[/align]
[align=left]2[/align]
[align=left](3, 4, 5, 6)[/align]
[align=left]2[/align]

在定义一个Python函数的时候，无默认值的参数，带默认值的参数，带*号的参数，带**号的参数必须按照顺序摆放，否则Python在执行的时候就会报错，在调用函数的时候也是，需要将含有键值对的参数放在参数列表的最后面，否则Python也会报错。

可以使用tuple或者list保存调用函数的参数列表，在调用函数的时候，直接将list或tuple作为参数传入，为函数的多个参数直接赋值，在使用这种方法的时候需要注意，要在传入的参数列表前面加'*'，否则函数会把整个参数列表单做一个列表参数用以下的例子进行说明：

def
A(a,*b):
print(
'a = ',a)
print(
'b = ',b)

lis = [1,
2,
3,
4]
tup = (1,
2,
3,
4)
print('A(
lis):'
)
[align=left]A(lis)[/align]
print('A(*
lis):'
)
[align=left]A(*lis)[/align]
print('A(
tup):'
)
[align=left]A(tup)[/align]
print('A(*
tup):'
)
[align=left]A(*tup)[/align]

输出的结果如下所示：

[align=left]A(lis):[/align]
[align=left]a = [1, 2, 3, 4][/align]
[align=left]b = ()[/align]
[align=left]A(*lis):[/align]
[align=left]a = 1[/align]
[align=left]b = (2, 3, 4)[/align]
[align=left]A(tup):[/align]
[align=left]a = (1, 2, 3, 4)[/align]
[align=left]b = ()[/align]
[align=left]A(*tup):[/align]
[align=left]a = 1[/align]
[align=left]b = (2, 3, 4)[/align]

同理，我们还可以得到参数字典和带‘**’参数的函数的关系，看下例：

def
B(a,**b):
print(
'a = ',a)
print(
'b = ',b)

dict= {
'b'
:2
,
'a':
9,
'c':
3,
'd':
4}
print('B(
dict):'
)
[align=left]B(dict)[/align]
print('B(**
dict):'
)
[align=left]B(**dict)[/align]

输出的结果如下所示：

[align=left]A(dict):[/align]
[align=left]a = {'c': 3, 'd': 4, 'a': 9, 'b': 2}[/align]
[align=left]b = {}[/align]
[align=left]A(**dict):[/align]
[align=left]a = 9[/align]
[align=left]b = {'c': 3, 'd': 4, 'b': 2}[/align]

注意：函数B中的参数'a'在'dict'中的位置不用放在第一个，放在任意位置函数都能自动检索到。

函数嵌套示例
def yao1(a=1,b=32):

def yao2(c=54):

def yao3(d=3):

def yao4(e=10):

return a+b+c+d+e

return yao4

return yao3

return yao2

print(yao1)输出:<function yao1 at 0x014934B0>
print(yao1())输出：<function yao1.<locals>.yao2 at 0x0148B780>
print(yao1()())输出：<function yao1.<locals>.yao2.<locals>.yao3 at 0x006BB270>
print(yao1()()())输出：<function yao1.<locals>.yao2.<locals>.yao3.<locals>.yao4 at 0x01C4B780>
print(yao1()()()())输出：100

print yao(1,1)(1)(1)(1)输出：5