函数
通用函数
Python内置了很多有用的函数,我们可以直接调用。
用help()函数可以查看函数的帮助信息。
定义函数
在Python中,定义一个函数要使用
def
语句,依次写出函数名、括号、括号中的参数和冒号
:
,然后,在缩进块中编写函数体,函数的返回值用
return
语句返回。
如果你已经把
my_abs()
的函数定义保存为
abstest.py
文件了,那么,可以在该文件的当前目录下启动Python解释器,用
from abstest import my_abs
来导入
my_abs()
函数,注意
abstest
是文件名(不含
.py
扩展名)
请注意,函数体内部的语句在执行时,一旦执行到
return
时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有
return
语句,函数执行完毕后也会返回结果,只是结果为
None
。
return None
可以简写为
return
。
空函数
如果想定义一个什么事也不做的空函数,可以用
pass
语句:
def
nop
():
pass
pass
语句什么都不做,那有什么用?实际上
pass
可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个
pass
,让代码能运行起来。
pass
还可以用在其他语句里,比如:
if
age >=
18
:
pass
缺少了
pass
,代码运行就会有语法错误。
参数检查
调用函数时,如果参数个数不对,Python解释器会自动检查出来,并抛出
TypeError。
但是如果参数类型不对,Python解释器就无法帮我们检查。
返回多个值
函数可以返回多个值吗?答案是肯定的。
>>>
x, y = move(
100
,
100
,
60
, math.pi /
6
)
>>>
print(x, y)
151.96152422706632
70.0
但其实这只是一种假象,Python函数返回的仍然是单一值:
>>>
r = move(
100
,
100
,
60
, math.pi /
6
)
>>>
print(r)(
151.96152422706632
,
70.0
)
原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。
函数的参数
位置参数
与其他语言无异
默认参数
def
power
(x, n=
2
): s =
1
while
n >
0
: n = n -
1
s = s * x
return
s
这样,当我们调用
power(5)
时,相当于调用
power(5, 2)
:
>>>
power(
5
)
25
>>>
power(
5
,
2
)
25
而对于
n > 2
的其他情况,就必须明确地传入n,比如
power(5, 3)
。
从上面的例子可以看出,默认参数可以简化函数的调用。设置默认参数时,有几点要注意:
一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前面);
二是如何设置默认参数。
当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。
使用默认参数有什么好处?最大的好处是能降低调用函数的难度
默认参数很有用,但使用不当,也会掉坑里。默认参数有个最大的坑,演示如下:
先定义一个函数,传入一个list,添加一个
END
再返回:
def
add_end
(L=[]): L.append(
'END'
)
return
L
当你正常调用时,结果似乎不错:
>>>
add_end
([1, 2, 3])[1, 2, 3, 'END']>>>
add_end
(['x', 'y', 'z'])['x', 'y', 'z', 'END']
当你使用默认参数调用时,一开始结果也是对的:
>>>
add_end
()['END']
但是,再次调用
add_end()
时,结果就不对了:
>>>
add_end
()['END', 'END']>>>
add_end
()['END', 'END', 'END']
很多初学者很疑惑,默认参数是
[]
,但是函数似乎每次都“记住了”上次添加了
'END'
后的list。
原因解释如下:
Python函数在定义的时候,默认参数
L
的值就被计算出来了,即
[]
,因为默认参数
L
也是一个变量,它指向对象
[]
,每次调用该函数,如果改变了
L
的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的
[]
了。
定义默认参数要牢记一点:默认参数必须指向不变对象!
要修改上面的例子,我们可以用
None
这个不变对象来实现:
def
add_end
(L=None):
if
L
is
None
: L = [] L.append(
'END'
)
return
L
现在,无论调用多少次,都不会有问题:
>>>
add_end
()['END']>>>
add_end
()['END']
为什么要设计
str
、
None
这样的不变对象呢?因为不变对象一旦创建,对象内部的数据就不能修改,这样就减少了由于修改数据导致的错误。此外,由于对象不变,多任务环境下同时读取对象不需要加锁,同时读一点问题都没有。我们在编写程序时,如果可以设计一个不变对象,那就尽量设计成不变对象。
可变参数
在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。
我们以数学题为例子,给定一组数字a,b,c……,请计算a
2
+ b
2
+ c
2
+ ……。
要定义出这个函数,我们必须确定输入的参数。由于参数个数不确定,我们首先想到可以把a,b,c……作为一个list或tuple传进来,这样,函数可以定义如下:
def
calc
(numbers): sum =
0
for
n
in
numbers: sum = sum + n * n
return
sum
但是调用的时候,需要先组装出一个list或tuple:
>>>
calc([
1
,
2
,
3
])
14
>>>
calc((
1
,
3
,
5
,
7
))
84
如果利用可变参数,调用函数的方式可以简化成这样:
>>>
calc(
1
,
2
,
3
)
14
>>>
calc(
1
,
3
,
5
,
7
)
84
所以,我们把函数的参数改为可变参数:
def
calc
(*numbers): sum =
0
for
n
in
numbers: sum = sum + n * n
return
sum
定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个
*
号。在函数内部,参数
numbers
接收到的是一个tuple,因此,函数代码完全不变。但是,调用该函数时,可以传入任意个参数,包括0个参数:
>>>
calc(
1
,
2
)
5
>>>
calc()
0
如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做:
>>>
nums = [
1
,
2
,
3
]
>>>
calc(nums[
0
], nums[
1
], nums[
2
])
14
这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个
*
号,把list或tuple的元素变成可变参数传进去:
>>>
nums = [
1
,
2
,
3
]
>>>
calc(*nums)
14
*nums
表示把
nums
这个list的所有元素作为可变参数传进去。这种写法相当有用,而且很常见。
关键字参数
和可变参数类似,但传入的是dict
命名关键字参数
对于关键字参数,函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些,就需要在函数内部通过
kw
检查。
仍以
person()
函数为例,我们希望检查是否有
city
和
job
参数:
def
person
(name, age, **kw):
if
'city'
in
kw:
# 有city参数
pass
if
'job'
in
kw:
# 有job参数
pass
print(
'name:'
, name,
'age:'
, age,
'other:'
, kw)
但是调用者仍可以传入不受限制的关键字参数:
>>>
person(
'Jack'
,
24
, city=
'Beijing'
, addr=
'Chaoyang'
, zipcode=
123456
)
如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收
city
和
job
作为关键字参数。这种方式定义的函数如下:
def
person
(name, age, *, city, job): print(name, age, city, job)
和关键字参数
**kw
不同,命名关键字参数需要一个特殊分隔符
*
,
*
后面的参数被视为命名关键字参数。
调用方式如下:
>>>
person(
'Jack'
,
24
, city=
'Beijing'
, job=
'Engineer'
)Jack
24
Beijing Engineer
如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符
*
了:
def
person
(name, age, *args, city, job): print(name, age, args, city, job)
命名关键字参数必须传入参数名,这和位置参数不同。如果没有传入参数名,调用将报错:
>>> person('Jack', 24, 'Beijing', 'Engineer')Traceback (most recent call last): File "
<stdin>
", line 1, in
<module>
TypeError: person() takes 2 positional arguments but 4 were given
由于调用时缺少参数名
city
和
job
,Python解释器把这4个参数均视为位置参数,但
person()
函数仅接受2个位置参数。
命名关键字参数可以有缺省值,从而简化调用:
def
person
(name, age, *, city=
'Beijing'
, job): print(name, age, city, job)
由于命名关键字参数
city
具有默认值,调用时,可不传入
city
参数:
>>>
person(
'Jack'
,
24
, job=
'Engineer'
)Jack
24
Beijing Engineer
使用命名关键字参数时,要特别注意,如果没有可变参数,就必须加一个
*
作为特殊分隔符。如果缺少
*
,Python解释器将无法识别位置参数和命名关键字参数:
def
person
(name, age, city, job):
# 缺少 *,city和job被视为位置参数
pass
参数组合
在Python中定义函数,可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数,这5种参数都可以组合使用。但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
递归函数
递归函数容易出现栈溢出,解决递归调用栈溢出的方法是通过
尾递归
优化,事实上尾递归和循环的效果是一样的,所以,把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式。这样,编译器或者解释器就可以把尾递归做优化,使递归本身无论调用多少次,都只占用一个栈帧,不会出现栈溢出的情况。
上面的
fact(n)
函数由于
return n * fact(n - 1)
引入了乘法表达式,所以就不是尾递归了。要改成尾递归方式,需要多一点代码,主要是要把每一步的乘积传入到递归函数中:
def
fact
(n):
return
fact_iter(n,
1
)
def
fact_iter
(num, product):
if
num ==
1
:
return
product
return
fact_iter(num -
1
, num * product)