Python3 函数

Python3 函数

目录

Python3 函数

调用函数

自定义函数

语法

空函数

返回多个值

参数

位置参数

默认参数

不定长参数

关键字参数

命名关键字参数

匿名函数

---

调用函数

Python3内置了很多有用的函数，可以直接调用。Python3 内置函数

要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，只有一个参数。

也可以在交互式命令行通过help(abs)查看abs函数的帮助信息。

调用函数的时候，如果传入的参数数量不对，或者参数的类型不对，会报TypeError的错误。例如：

>>> abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)  # abs()有且仅有1个参数，但给出了两个

>>> abs('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'  # str是错误的参数类型

---

自定义函数

我们可以创建一个满足特定功能的函数，这样的函数通常被称为自定义函数。

语法

Python3 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

函数的返回值用return语句返回。

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

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

---

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

pass还可以用在其他语句里，比如：

if age >= 18:
    pass

缺少了pass，代码运行就会有语法错误。

---

返回多个值

函数可以返回多个值：

比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：

import math

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

import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。

然后，我们就可以同时获得返回值：

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

事实上，Python返回的是一个含有多个值元素的tuple：

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值.所以，Python的函数返回多值其实就是返回一个tuple。

---

参数

位置参数（args）

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，在调用函数时，必须要传入两个值，并且这两个值会按照位置顺序依次赋给参数x和n。

---

默认参数

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

此时的参数n为默认参数，其默认值为2。当调用power函数时，若不指定参数n的值，则会使用其默认值。

>>> power(5)
25
>>> power(5, 2)
25

设置默认参数时，有几点要注意：

一是，必选参数在前，默认参数在后，否则Python的解释器会报错；

二是，如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

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

当有多个默认参数时，在调用的时候，既可以按顺序提供默认参数，比如调用enroll('Bob', 'M', 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。

也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。

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

---

不定长参数

顾名思义，不定长参数是指传入的参数个数是不确定的，可以是1个、2个到任意个，还可以是0个。

在参数名前面加上一个*号，就是定义了一个不定长参数：

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

 调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(1, 2)
5
>>> calc()
0

在函数内部，不定长参数numbers接收到的其实是一个tuple。

将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的所有元素用不定长参数传入到函数的*nums参数。这种写法相当有用，而且很常见。

---

关键字参数

不定长参数允许你传入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。

---

命名关键字参数

命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数 ：

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

调用方式如下：

>>> 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

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

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

命名关键字参数可以有缺省值，从而简化调用：

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

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

---

匿名函数

例如，匿名函数lambda x: x * x实际上就是：

def f(x):
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y