Python 简明教程 --- 15，Python 函数

微信公众号：码农充电站pro
个人主页：https://codeshellme.github.io

测试只能证明程序有错误，而不能证明程序没有错误。
—— Edsger Dijkstra

目录

本节我们来介绍函数，在前边的章节我们已经接触了挺多函数了，比如print()，len() 等。

函数是编程语言中非常重要的概念，函数是一段可重复利用的，提供特定功能的代码段。

函数是一种模块化的手段，可提高代码的利用率，避免重复代码，便于使用，便于维护。

Python 中，不仅提供了许多现成可用的内建函数，用户还可以根据自己的需求，定义自己的函数。

在Python 中，内建函数用builtin_function_or_method 表示，自定义函数用function 表示。

函数也属于一种数据类型，可用type() 查看：

>>> type(len)         # len() 是内建函数
<class 'builtin_function_or_method'>
>>> 
>>> type(print)       # print() 是内建函数
<class 'builtin_function_or_method'>
>>> 
>>> def test(): pass  # 自定义函数 test()，并没有实质功能
... 
>>> 
>>> type(test)        # test() 是自定义函数
<class 'function'>

提示：
内建函数就是Python 原生支持，自带的函数（比如print()），用于区分用户自定函数。

1，函数的定义

函数定义的格式如下：

def fun_name(参数列表...):
    # 函数体
    ...

首先，定义函数需要用到def 关键字，后跟函数名，然后是参数列表，参数列表写在小括号()内，再往后是一个冒号:，函数体一般写在下一行，注意要有缩进。

例如，我们定义一个简单的函数：

def hello_python():
    print('hello python.')

该函数值输出一个字符串hello python.，其中：

• hello_python 为函数名
• 参数列表为空，调用该函数时，不需要任何参数
• 函数体只有一句代码print('hello python.')

文档字符串

我们可以在函数体的第一行，写一段该函数的说明，此说明用三引号''' 或 """ 引住，这被称为文档字符串。如下：

def hello_python():
    '''这是函数的一段说明'''
    print('hello python.')

要想查看这段说明，可以使用格式函数名.__doc__ 来访问，如下：

>>> hello_python.__doc__
'这是函数的一段说明'

我们也可以访问内建函数的文档字符串，比如len() 函数：

>>> len.__doc__
'Return the number of items in a container.'

2，调用函数

调用函数时，只需要用函数名和参数列表就行，比如上面的函数，调用如下：

hello_python()  # 输出 hello python.

其实，在Python 中，函数也是一种类型，函数名就是一个函数类型的变量。

因此，可以将一个函数名赋值给一个变量，如下：

abc = hello_python
print(type(abc))      # 输出 <class 'function'>
abc()                 # 就像调用 hello_python() 一样

3，函数参数

定义函数时，可以传给函数一些数据，这些数据叫做函数参数。

定义一个带参数的函数，如下：

def hello(string):
    print('hello %s.' % string)

其中的string 就是函数参数，函数参数可以有多个，这里我们只写了一个参数。

此时，调用该函数时，就需要给函数传递参数了，如下：

hello('python')  # 输出 hello python.
hello('java')    # 输出 hello java.
hello('html')    # 输出 hello html.

如果参数传递出现错误，则会出现TypeError 异常，参数传递错误包括：

• 参数个数不对
• 参数类型不适用

4，默认参数

定义参数时，可以包含默认参数，默认参数可以有多个。

默认参数就是，这个参数可以传递，也可以不传递：

• 传递时，该参数就是你传递的值
• 不传递时，该参数有默认值

如下，我们定义了一个带有默认参数的函数：

def sum(a,b=0,c=1):
    n = a + b + c
    print(n)

默认参数必须写在普通参数的后边，默认参数后边不能再有普通参数。

其中，参数a 是普通参数，参数b 和c都是默认参数，用赋值语句 赋予了它们默认值。

参数b的默认值是0，参数c 的默认值是1 。

当没有传递b 时，b 为0，当没有传递c 时，c 为 1。

我们可以这样调用sum 函数：

sum(2)              # 只传递了 a，b 和 c 都是默认值
sum(2,3)           # 传递了 a 和 b，c 是默认值
sum(2,3,5)        # a，b，c 都传递了
sum(a=2,b=5)       # 传递参数时，普通参数和默认参数都可以加上参数名
sum(2,c=7)         # 传递了a 和 c，b 是默认值
sum(2,b=2,c=7)    # 传递默认参数时，可以加上参数名
sum(c=2,a=2,b=7)  # 传递参数时，如果有参数名，参数的顺序可以随意

需要注意的是：

• 传递参数时，普通参数和默认参数都可以加上参数名
• 传递参数时，如果有写参数名，参数的顺序可以随意
• 传递参数时，如果没有写参数名，参数的顺序必须按照函数定义的顺序来写

默认参数不要是可变类型

默认参数可以是任意类型的数据，但是建议不要是可变类型数据，否则容易出现不可预料的结果。

比如代码：

def test(l=[]):
    l.append(1)
    return l

当调用该函数时，如果传递了参数，这种情况下一般不会出现什么问题：

>>> test([])
[1]
>>> test([2])
[2,1]

但是，如果没有传递参数，而是使用的默认参数，结果可能不是你想象的：

>>> test()
[1]
>>> test()
[1,1]
>>> test()
[1,1,1]

如上代码，我们连续调用了三次test()，都使用的是默认参数。

第一次调用似乎还是正常的，但后两次的结果显示，函数返回的结果，应该是累计了前边调用。

这是因为，当使用默认参数时，函数记录了默认参数的一开始的变量地址，这个变量地址始终是不会改变的，但是如果这个变量类型是可变类型的数据（比如例子中的列表类型），那么其中的值是有可能改变的。

这就是出现以上情况的原因，所以，建议在使用默认参数时，不要使用可变类型的参数，容易出问题。

5，不定长参数

当你不知道函数的参数有几个的时候，你可以使用不定长参数。

不定长参数的格式，是在普通参数之前加一个星号*，如下：

def print_num(*num):
    print(num)

此时，在函数内部，num 实际上是一个元组类型。所以，我们以元组的方式来操作num 即可。

我们可以给该函数传递不同个数的参数：

print_num(1)        # 传递了 1 个参数，num = (1)
print_num(1,2)     # 传递了 2 个参数，num = (1,2)
print_num(1,2,3)  # 传递了 3 个参数，num = (1,3)

有名参数

不定长的有名参数，是在普通参数之前加两个星号**，如下：、

def print_num(**num):
    print(num)

此时，在函数内部，num 实际上是一个字典类型。所以，我们以字典的方式来操作num 即可。

我们可以给该函数传递不同个数的有名参数，参数名被解析成了字符串类型：

print_num(a=1)        # 传递了 1 个参数，num = {'a': 1}
print_num(a=1,b=2)   # 传递了 2 个参数，num = {'a': 1,'b': 2}

各种参数的顺序

如果一个函数中各种参数都有的话，它们的顺序是有要求的：如下：

def 函数名(普通参数，默认参数，不定长参数，不定长有名参数):
    # 函数体
    ...

建议：

不要使用太多的参数组合，不便于理解

由于函数 也是一种数据类型，所以函数也可以作为函数参数传递给函数，然后在函数内部，再调用该函数。

def sum(a,b): 
    return a + b 

def test(fun):
    n = fun(1,2)
    print(n)

test(sum)

上面代码中，sum 与 test 都是函数。

sum() 函数，计算两个参数之和，并将结果返回。

test() 函数，接收一个参数 fun，该参数是一个函数类型。在函数体内，用代码n = fun(1,2) 进行调用。

代码test(sum)，将函数sum 作为参数传递给test()。

以上就是函数作为函数参数的用法。

7，函数返回值

函数可以有返回值，也可以没有返回值。

函数的返回值，需要用到return 关键字，当函数的执行遇到return 时，函数的执行就会结束，并且返回一个值。

如果一个函数没有调用return，那么在函数执行完毕后，会默认返回None：

def test():
    print('hello python.')
    # 没有使用 return

ret = test() # ret 为 None

如果一个函数调用了return，但是return 后边没有值，那么此时的含义是，表示函数立马返回，且返回值为None：

def test():
    print('hello python.')
    return 
    # return 后边的语句永远不会被执行到
    print('hello java.')

ret = test() # ret 为 None

你可以在return 后边跟一个任意类型的值，作为函数的返回值：

def test(flag):
    if flag:
        return True  # 返回 True
    else:
        return False # 返回 False

ret = test(True)     # ret 为 True 
ret = test(False)    # ret 为 False

函数返回多个值

函数不仅可以返回一个值，也可以返回多个值：

def test(a,b,c):
    return a,c

实际上这个时候，a,c 被自动打包到了一个元组里边，我们用一个变量去接收返回值：

ret = test(1,3)
print(ret)             # ret 为 (1,3)
print(type(ret))       # <class 'tuple'>

我们也可以用三个变量去接收这个返回值，这时返回值会被自动解包：

a,c = test(1,3)
# a 为 1
# b 为 2
# c 为 3

自动解包时，如果变量的个数与返回值的个数不同，会抛出ValueError异常：

a,b = test(1,3)        # 变量少于返回值，抛出异常
a,c,d = test(1,3)  # 变量多于返回值，抛出异常

8，匿名函数

Python 中的匿名函数使用 lambda 关键字，也称为lambda 表达式。

lambda 表达式虽然也是函数，但是一般只包含简单的逻辑，它是普通函数的一种简写形式。一般常作为函数参数，传递给函数。

格式如下：

lambda 参数列表 : 表达式

lambda 后跟一个参数列表，然后是一个冒号:，最后是一个表达式，表达式的计算结果会作为匿名函数的返回值（不需要用return）。

可以将lambda 表达式赋值给一个变量，格式如下：

变量名 = lambda 参数列表 : 表达式

示例：

sum = lambda x,y : x + y

该匿名函数接收两个参数x，y，然后计算结果 x + y，并将结果返回。

通过type(sum) 查看其类型：

>>> type(sum)
<class 'function'>

上面这个lambda 表达式就相当于如下函数：

def sum(x,y):
    return x + y

我们可以像调用普通函数一样，调用该lambda 表达式：

>>> sum(1,2)  # 返回 1 + 2
3
>>> sum(2,3)  # 返回 2 + 3
5

匿名函数的应用场景

在介绍Python 列表的时候，我们介绍过一个L.sort() 函数，该函数的原型如下：

L.sort(key=None,reverse=False) -> None

其中的key 参数就是一个函数类型参数，这种情况下就可以使用匿名函数。如下：

>>> l.sort(key = lambda x: x[0])
>>> l
[('a',3),('b',2),('c',1)]
>>> 
>>> l.sort(key = lambda x: x[1])
>>> l
[('c',1),('a',3)]

（完。）

推荐阅读：

Python 简明教程 --- 10，Python 列表

Python 简明教程 --- 11，Python 元组

Python 简明教程 --- 12，Python 字典

Python 简明教程 --- 13，Python 集合

Python 简明教程 --- 14，Python 数据结构进阶

欢迎关注作者公众号，获取更多技术干货。

（编辑：北几岛）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!