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, 2, 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 函数名(普通参数，默认参数，不定长参数，不定长有名参数):
    # 函数体
    ...

建议：

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

6，函数做为参数

因为函数 也是一种数据类型，因此函数也能够做为函数参数传递给函数，而后在函数内部，再调用该函数。

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, b, c

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

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

咱们也能够用三个变量去接收这个返回值，这时返回值会被自动解包：

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

自动解包时，若是变量的个数与返回值的个数不一样，会抛出ValueError异常：

a, b = test(1, 2, 3)        # 变量少于返回值，抛出异常
a, b, c, d = test(1, 2, 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), ('b', 2), ('a', 3)]

（完。）

---

推荐阅读：

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

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

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

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

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

---

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