函数

一、抽象

借助抽象，我们才能不关心底层的具体计算过程，而直接在更高的层次上思考问题。
函数就是最基本的一种代码抽象的方式。

二、调用函数

Python内置了很多有用的函数，比如求绝对值的函数abs()、数据类型转换函数 int()，我们可以直接调用。

要调用一个函数，需要知道函数的名称和参数，可以直接从 Python 的官方网站查看文档：http://docs.python.org/3/library/functions.html

数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

a = abs # 变量a指向abs函数
print(a(-1)) # 所以也可以通过a调用abs函数

三、定义函数

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。return None 可以简写为return。

def foo(name):
    print(name)

python 中还支持嵌套定义函数，即函数中定义函数：

def func(x, y):
    def square(x):
        return x * x
    return square(x) + y

print('嵌套函数：', func(3, 4))

1. 空函数

可以使用 pass 语句定义一个空函数：

def nop():
    pass

pass 语句的作用：在某些情况下，缺少了pass，代码运行就会有语法错误，所以可以用 pass 作为占位，使脚本可以正常执行。

2. 参数检查

如果有必要，可以在定义函数时，先对参数的数据类型做检查：

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

3. 返回“多个返回值”

函数可以同时返回多个值，但其实就是一个tuple：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

4. 默认参数

默认参数可以简化函数的调用。设置默认参数时，有几点要注意：

一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

设置默认参数时几个注意点：

有多个默认参数时，调用的时候，可以按顺序提供默认参数，后面的未提供的参数按默认值计算。
也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)

enroll('Sarah', 'F')
enroll('Bob', 'M', 7)  # 按顺序提供默认参数
enroll('Adam', 'M', city='Tianjin') # 不按顺序提供部分默认参数

注意：定义默认参数要牢记一点：默认参数必须指向不变对象！

5. 可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个，这些可变参数在函数调用时自动组装为一个tuple。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

calc(1, 2)
calc(1, 2, 3)

# *numbers 表示把 numbers 这个 list 的所有元素作为可变参数传进去
numbers = [1, 2, 3]
calc(*numbers)

6.关键字参数

6.1 定义关键字参数

与可变参数类似，关键字参数允许你传入0个或任意个含参数名的参数，不同的是这些关键字参数在函数内部自动组装为一个 dictionary 而不是 tuple。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', 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'}

# **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict
# 注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)

6.2 检查关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。

def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

7. 命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，和关键字参数 **kw 不同，命名关键字参数需要一个特殊分隔符 *，*后面的参数被视为命名关键字参数。

注意：

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。

只有在命名参数有默认值时，该参数值才是可选的。

例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):
    print(name, age, city, job)


person('Jack', 24, city='Beijing', job='Engineer')  # 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。
person('Jack', 24, city='Beijing')   # 这里会报错，提示少了一个必需参数 'job'

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

8. 参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。

但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

四、递归函数

1. 什么是递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

例如，计算阶乘n! = 1 x 2 x 3 x ... x n 的代码如下：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

2. 递归函数的缺点

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

3. 尾递归优化

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

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)

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

五、延伸

Python 标准库内置函数表（abs() 等）
Python 常见数据类型（float、int 等）
模块
异常和错误

六、参考

Python3 教程 - 廖雪峰的官方网站
《程序是怎样跑起来的》

3.4 Python 基础语法之函数 #3

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions