函数
当代码出现有规律的重复的时候,便可以用函数来解决麻烦的事情,基本上所有的高级语言都支持函数,Python也不例外。Python中除了灵活地自定义函数外,本事内置了很多有用的函数,可以直接调用。
函数是最基本的一种代码抽象的方式。
调用函数
数据类型转换
Python 内置了很多有用的函数,我们可以直接调用。
要调用一个函数,需要知道函数的名称和参数。
Python中内置的常用函数包括数据类型转换函数。
abs(-20) # 绝对值函数
20
int(“123”) # 字符串转换为整型
123
int(12.34) # 浮点型数转换为整型
12
float('12.34') # 字符串转换为浮点型
12.34
str(1.23) # 转换为字符串
'1.23'
bool(1) # 布尔型
True
bool('')
False
函数名其实就是指向一个函数对象的引用,完全可以把函数名赋给一个
变量,相当于给这个函数起了一个“别名”:
a = abs # 变量 a 指向 abs 函数
a(-1) # 所以也可以通过 a 调用 abs 函数
1
定义函数
在 Python 中,定义一个函数要使用 def 语句,依次写出函数名、括号、
括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值
用 return 语句返回。
空函数
定义一个什么事也不做的空函数,可以用pass语句。
def nop():
pass
pass用来作为占位符,比如现在没想好怎么写函数的代码,可以先放一个pass。
参数检查
数据类型检查可以用内置函数isinstance()实现。
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
添加了参数检查后,如果传入错误的参数类型,函数就可以抛出一个错
误:
my_abs('A')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in my_abs
TypeError: bad operand type
返回多个值
Python的返回值是一个tuple!
在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多个值其实就是返回一个tuple,但写起来更方便。
函数参数
定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了。对于函数的调用者来说,只需要知道如何传递正确的函数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用者无需了解。
位置参数
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
如例,power(x, n)函数有两个参数,这两个参数都是位置参数,调用函数时,传入的两个值按照位置顺序依次赋给参数x和n。
默认参数
def power(x, n=2): # 此处将幂的默认值设定为2
s = 1
while n > 0:
n = n - 1
s = s * x
return s
将例子中的参数n默认值设定为2,可以简化函数的调用。
设置默认参数时,有几点要注意:
1.必选参数在前,默认参数在后,否则 Python 的解释器会报错(思
考一下为什么默认参数不能放在必选参数前面);
2.如何设置默认参数
当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。
变化小的参数就可以作为默认参数。
使用默认参数有什么好处?最大的好处是能降低调用函数的难度
有多个默认参数时,调用的时候既可以按顺序提供默认参数,也可以不按顺序。当不按顺序提供部分默认参数时,需要把参数名写上。
默认参数必须指定不变对象!
可变参数
在 Python 函数中,还可以定义可变参数。顾名思义,可变参数就是传
入的参数个数是可变的,可以是 1 个、2 个到任意个,还可以是 0 个。
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,要调用一个可变参数怎么办?可以这样
做:
nums = [1, 2, 3]
calc(nums[0], nums[1], nums[2]
14
这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple
前面加一个*号,把 list 或 tuple 的元素变成可变参数传进去:
nums = [1, 2, 3]
calc(*nums)
14
关键字参数
可变参数允许你传入 0 个或任意个参数,这些可变参数在函数调用时自
动组装为一个 tuple。而关键字参数允许你传入 0 个或任意个含参数名的
参数,这些关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
函数 person 除了必选参数 name 和 age 外,还接受关键字参数 kw。
在调用该函数时可以只传入必选参数:
>>> person('Michael', 30)
name: Michael age: 30 other:
也可以传入任意个数的关键字参数:
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
关键字参数有什么用?
它可以扩展函数的功能。比如,在 person 函数里,我们保证能接收到 name 和 age 这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了
用户名和年龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。
和可变参数类似,也可以先组装出一个 dict,然后,把该 dict 转换为关
键字参数传进去:
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
当然,上面复杂的调用可以用简化的写法:
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
**extra 表示把 extra 这个 dict 的所有 key-value 用关键字参数传入到函
数的**kw 参数,kw 将获得一个 dict,注意 kw 获得的 dict 是 extra 的一份
拷贝,对 kw 的改动不会影响到函数外的 extra。
命名关键字参数
如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收 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
命名关键字参数必须传入参数名,这和位置参数不同。如果没有传入参数名,调用将报错:
>>> 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参数。
使用命名关键字参数时,要特别注意,*不是参数,而是特殊分割符。如果缺少 *,Python解释器将无法识别位置参数和命名关键字参数。
参数组合
在 Python 中定义函数,可以用必选参数、默认参数、可变参数、关键 字参数和命名关键字参数,这 5 种参数都可以组合使用,除了可变参数
无法和命名关键字参数混合。但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数/命名关键字参数和关键字参数。
对于任意函数,都可以通过类似 func(*args, **kw)的形式调用它,无论它的参数是如何定义的。
args 是可变参数,args 接收的是一个 tuple;
**kw 是关键字参数,kw 接收的是一个 dic。
可变参数既可以直接传入:func(1, 2, 3),又可以先组装 list 或 tuple,再通过args 传入:func((1, 2, 3));关键字参数既可以直接传入:func(a=1, b=2),又可以先组装
dict,再过kw 传入:func({‘a’: 1, ‘b’: 2})。
使用args 和**kw 是 Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名,同时可以提供默认值。定义命名的关键字参数不要忘了写分隔符*,否则定义的将是位置参数。
递归函数
在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。
计算阶乘 n! = 1 x 2 x 3 x … x n,用函数 fact(n)表示,可以看出:
fact(n) = n! = 1 x 2 x 3 x … x (n-1) x n = (n-1)! x n = fact(n-1) x n
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
使用递归函数的优点是逻辑简单清晰,缺点是过深的调用会导致栈溢出。针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的,没有循环语句的编程语言只能通过尾递归实现循环。
尾递归是指,在函数返回的时候,调用自身本身,并且,return 语句不能包含表达式。这样,编译器或者解释器就可以把尾递归做优化,使递归本身无论调用多少次,都只占用一个栈帧,不会出现栈溢出的情况。
Python 标准的解释器没有针对尾递归做优化,任何递归函数都存在栈溢出的问题。
# 利用递归函数移动汉诺塔:
def move(n, a, b, c):
if n == 1:
print('move', a, '-->', c)
else:
move(n-1, a, c, b)
move(1, a, b, c)
move(n-1, b, a, c)
move(4, 'A', 'B', 'C')