python 函数

函数

函数分类

• 内置函数
• 自定义函数

函数的作用：

• 通过函数，可以对功能进行详细的划分，在需要使用功能时，就可以调用该函数。
• 通过函数，可以避免代码的重复，实现代码的重用。

1. 内置函数

• print
• input
• abs
• max
• min
• 其他见过的类型转换函数等等

2. 函数的定义

函数是具有一定功能的代码块，该代码块可以重复的执行。

函数的定义方式如下：

def 函数名(参数列表)：
函数体
返回值

2.1 关键字pass的使用

   既然我们学习的函数，在程序设计时，我们就可以先把程序划分成若干个功能，具体的实现可以后续再完成。可是，在Python中，函数不允许没有函数体，此时，我们就可以使用pass来进行占位。
  pass表示空语句，用在函数中用来进行占位。不过，pass也可以放在选择与循环体中。

2.2 函数的参数

变量参数可以如下定义

def hum(name,age,**ke):
return name,age,ke
print(hum(“json”,“18”,mm=“a”,nn=“b”))
结果：(‘json’, ‘18’, {‘mm’: ‘a’, ‘nn’: ‘b’})
**代表定义变量的参数

3. 参数类型

3.1 位置的参数

   比如：当我们的实现了一个打印五角星*的需求，这个时候又来了新的需求：这次，不仅可以自由的打印行数，连打印的内容也不能局限于星号，而是可以灵活的指定。并且，之前的功能已经普遍使用了，不允许我们影响现有的完成的功能。
   实现这个功能并不繁琐，只需要增加一个参数就可以了。

def printStar(line, char):

   然而，问题在于，如果这样修改，会影响现有的功能，导致程序不再可用。因为我们为函数增加了一个形式参数，那在调用函数的时候，就必须也要传递两个实际参数才行。
   对于以上问题，我们可以使用参数默认值来解决，也就是，我们依然提供两个参数，只不过，在第二个参数char上增加默认值，格式如下：

def printStar(line, char=‘*’):

3.2 默认值参数

如果形参含有默认值，则在函数定义时，含有默认值的形参一定要定义在不含默认值的形参之后。

这是因为，如果形参含有默认值，则意味着，该参数是一个可选参数，在函数调用时，可以选择性的进行传值。如果允许含有默认值的形参定义在不含默认值的形参前面，就会造成混淆。例如：

def f(length=3, width, height=4):

f(5, 8)

不要使用不可变对象作为默认值

3.3 命名关键字参数

除了位置参数之外，我们还可以使用命名关键字参数。所谓命名关键字参数，就是在调用函数时，显式指定“参数名=参数值”的形式，即指定要给哪一个形参传递值。

同时，我们也可以在调用函数时，混合使用位置参数与关键字参数。但是位置参数放在前面。

关键字参数的作用
关键字参数具有如下优势：

• 关键字参数能够增加程序的可读性。
• 关键字参数可以不用考虑传递的顺序。
• 当多个形参存在默认值时，关键字参数能够指定赋值给哪个形参。
• 增加程序的可读性

假设如下的函数：

def box_volume(length, width, height):

我们可以使用位置参数调用：

box_volume(10, 20, 30)

这样是没有问题的，不过，当参数较多的时候，可能会降低程序的可读性，因为我们需要确定每个参数具体代表的含义（此时可能就得重新查看一下函数的定义）。但是，使用关键字参数进行调用，就会变得清晰，增加了程序的可读性：

box_volume(length=10, width=20, height=30)

不用考虑传递顺序

其次，如果使用位置参数，则必须严格要求按照顺序进行传递，如果使用关键字参数，则无此限制，我们完全可以任意颠倒参数的顺序：

box_volume(width=20, length=10, height=30)

指定为哪一个形参赋值

再者，当函数存在多个默认值时：

def box_volume(length=3, width=4, height=5):

如果我们使用位置参数进行调用：

box_volume(10)

则实际参数10会赋值给length，然而，我们的原意未必总是想指定length，如果我们想指定width或height，而让另外两个参数取默认值，或者，想显式指定其中的两个，另外一个取默认值，该怎样实现呢？此时，我们就可以使用关键字参数来实现需求了。

box_volume(width=10)

注意事项

在进行参数传递时，我们需要注意以下几点：

• 位置参数必须出现在关键字参数的前面。
• 同一个参数不能传递多次。（位置参数与关键字参数，或多个关键字参数）
• 关键字参数的顺序可以颠倒，但是提供的参数名必须存在。
• 强制使用关键字参数

之间我们介绍到，使用关键字参数可以显式指定实参要赋值给哪一个形参，这样就可以提高程序的可读性。通常情况下，对于可选的参数（含有默认值的参数），因为其存在的不确定性，因此，如果需要为可选参数传值，在调用时往往使用关键字参数是一种好的选择。

不过，到底使用位置参数，还是关键字参数，完全取决于函数的调用者，函数的定义者并没有能力进行控制。也就是说，程序员A在调用函数时，可能会使用关键字参数，而程序员B却使用位置参数。为了能够增强程序的可读性，同时实现编程风格的一致性，函数的定义者可以使用“”语法，来限制“”后面的所有参数必须都是以关键字参数的形式传递。

说明：

强制使用关键字往往针对的是具有默认值的参数，但从语法的角度讲，对于不含默认值的参数，也是可以的。

3.4 可变参数

可变参数（*），也可以叫收集参数。

函数调用时，位置可变参数（形参）可以用来接收所有未匹配的位置参数（实参）并封装成元组传递给函数。

3.5 关键字参数

关键字可变参数（形参）可以用来接收所有未匹配的关键字参数（实参）。所有未匹配的关键字参数会打包成一个字典。

对于关键字可变参数，可以用来接收一些可选的选项，设置等。对于选项较多时，如果将每个选项都用一个关键字参数来接收时，会显得函数定义特别庞大，此时，就可以使用一个关键字可变参数来实现。例如，在Requests库中，get函数定义为：

requests.get(url, params=None, **kwargs)

其中，kwargs可以接收很多选项，例如data，headers，cookies，files等。

对于可变参数，我们需要注意如下事项：

• 可变参数只能接收未匹配的（剩下的）实际参数，如果实际参数已经匹配某形式参数，则不会由可变参数接收。
• 在参数位置上，关键字可变参数必须位于函数参数列表的最后。
• 在位置可变参数后面定义的参数，将自动成为关键字参数。（为什么）
• 位置可变参数与关键字可变参数各自最多只能定义一个。

def f(a, *v, **kv)

• 定义的时候 **打包
• 调用的时候 **拆包

3.6 参数组合

几种参数可以组合使用，可变参数和命名关键字参数不可混合（两个单独带*的）。

其余参数的顺序必须是：必选参数，默认参数，命名关键字参数/ *args, **kwargs（万能参数）

位置参数>命名关键字参数/可变参数 >关键字参数

4. 参数与返回值

4.1​​​​​​​ 函数的返回值

函数也是可以具有返回值，该返回值会返回给函数的调用端。语法上，使用return来实现。

当调用函数时，可以近似的认为是函数的返回值替换掉了函数的调用。

如果在函数内没有显式使用return返回值，则返回值为None。

4.2 返回多个值

在函数中，当执行到return语句时，函数就会终止执行，返回给函数的调用端，这就是说，return之后的语句不会再执行。因此，函数体中不能通过执行多个return，返回多个值。然而，函数返回多个值的需求却是普遍存在的，例如，我们要返回两个数的和，差，积，商（4个值），该如何实现呢？

实际上，我们可以通过将多个值放入元组（列表或字典）中，从而返回多个值。

5. 参数传递

• 可变类型的值传递
  当调用函数后，会将可变类型的对象的值改变

• 不可变类型的值传递
  当调用函数后，不会改变不可变类型的值

6. 命名空间与作用域

6.1 命名空间

命名空间，可以认为就是保存命名的一个容器，当我们定义变量，函数，类等结构时，相关的名称就保存在相应的命名空间中。

根据名称在当前模块（文件）中定义的位置，我们可以将名称分为两类：

局部名称：定义在函数内的名称（函数的参数，变量，嵌套函数等）。
全局名称：定义在函数、类外的名称（处于当前模块的顶级）。
全局（局部）变量，顶层函数，嵌套函数。

命名空间可以分为如下几类：

• 内建命名空间：保存内建的名称。例如，print，sum等内建函数。内建命名空间在Python解释器启动时就会创建，直到程序运行结束。
• 全局命名空间：保存当前模块（文件）中出现在顶层位置的名称。例如：全局变量，顶层函数等。全局命名空间与模块相关，在读取模块定义时创建，直到程序运行结束。
• 局部命名空间：保存局部名称。例如，局部变量，函数参数，嵌套函数等。局部命名空间在函数执行时创建，在函数执行结束后销毁。

由此可知，我们定义的变量，函数等，其名称处于哪个命名空间，完全是由其定义的位置决定的，对于变量，定义的位置就是变量第一次赋值的位置。对于函数，定义的位置就是def出现的时刻。

说明

要访问某个名称，必须要在该名称定义后才能访问

6.2 作用域

作用域，就是命名空间的有效区域。在命名空间的作用域内，我们可以直接访问命名空间中的名称。关于作用域，有如下说明：

• 内建命名空间，作用域为所有模块（文件）。即在任何模块（文件）中均可直接访问内建命名空间内的名称。
• 全局命名空间，作用域为当前模块（文件）。在当前模块（文件）中可直接访问全局命名空间内的名称，在其他模块（文件）中，需要先导入该模块，然后才能访问（模块导入的内容后面介绍）。
• 局部命名空间，作用域为当前函数，在函数内可访问局部命名空间内的名称，在函数外则无法访问。

6.3 LEGB原则

在访问名称时，会根据LEGB的顺序来搜索名称，即搜索顺序为L -> E -> G -> B。描述如下：

L（Local）：本地作用域，即包含所访问名称的最小作用域（当前函数的局部命名空间）。
E（Enclosing）外围作用域，当函数嵌套时会存在这种情况，即访问外层函数的作用域，如果没有找到，并且外层函数依然还有外层函数（函数多层嵌套），则会继续搜索更外层的函数，直到顶层函数位置（对应外层函数的局部命名空间）。
G（Global）全局作用域，当前模块的作用域（全局命名空间）。
B（Build-in）内建作用域，所有内建的名称（内建命名空间）。
对名称的访问以下情况：

• 读取名称的值
• 为名称赋值
• 删除名称

几种情况下，效果是不同的。名称既可以是变量，也可以是函数。

读取名称的值

当读取变量的值时，如果该变量在当前作用域没有发现，则会按照LEGB的方式依次进行查找，以先找到的为准。如果到最后也没有找到，则会产生NameError错误。

为名称赋值

当为变量赋值时，行为有所不同，此时只会在程序执行处的最小作用域内寻找变量，如果变量存在，则修改该变量的绑定，如果该变量不存在，则不会再按照LEGB的顺序查找，而是在当前作用域的命名空间中，新建名称，并绑定所赋予的值。这也就是说，我们无法修改其他命名空间中名称的绑定。

nonlocal与global

但是，有时候我们确实期望对外部作用域的名称进行修改，例如，嵌套函数中修改外围函数中定义的名称，或者是修改全局名称。此时，前者，我们可以使用nonlocal，后者，我们可以使用global。

细节：nonlocal指定的名称不存在，会产生错误，而global指定的名称不存在则不会产生错误，但是该名称也不会自动创建，如果访问该名称，依然会产生错误。

vars，locals与globals函数

• locals
• vars
• globals

7. Lambda表达式

对于函数而言，函数名也是一个名称，该名称绑定函数对象。因此，我们也可以像变量那样，对函数名进行相应操作，这包括：

函数名可以赋值给一个变量。
函数名可以作为实际参数，传递给其他函数。
函数名可以作为另外一个函数的返回值。
不过，用于排序的函数过于简单，为了这么一个简单的功能，单独定义一个函数，总有些“杀鸡用牛刀”的意味，我们可以使用Lambda表达式来创建函数，能够实现同样的功能。

Lambda表达式的语法为：

lambda [参数]: 表达式

其中，参数是可选的，表达式的结果值，就是函数的返回值。lambda表达式的函数体仅能存在一条语句，故lambda表达式适用于功能简单的函数。也因为lambda表达式创建的函数没有名字，因此也称为匿名函数。

8. 递归

8.1 递归的含义

递归，就是一个函数直接或者间接调用自身的过程。如果函数A在其函数体内直接调用其自身，则称为直接递归，如果函数A调用函数B，而函数B又调用了函数A（或者函数B再调用其他函数，而其他函数调用函数A），则称为间接递归。不过，函数如果无条件的调用自身，这是没有意义的，最终也会导致超过最大递归深度而产生错误。因此，我们必须能够找出，让递归终止的条件。

递归，我们可以分为递推与回归。所谓递推，就是解决问题，逐层的进行推理，得出递归的终止点。而回归，则是利用刚才递推取得终止点的条件，再一层层返回，最终取得答案的过程。

8.2 循环与递归

循环与递归具有一定的相似度，二者往往可以实现相同的效果。理论上，能够通过循环解决的问题，使用递归也能够实现。然而，二者还是有一定的差别的。从思想的角度讲，循环是重复性的执行一件相同或者相似的事情，进而得出结果。而递归则是将问题分解为更小的问题，直到该问题能够解决，然后再由最小问题的答案，逐步回归，从而解决更大的问题，最终解决整个问题的过程。

以求阶乘的程序为例，对于循环，则是对数据集中的每个数据，依次取出，重复性执行相同的累乘运算，最终得到阶乘的结果。而递归则是，将n的阶乘分解为更小数值的阶乘：

n! = n * (n – 1)

这个过程会一直进行分解，直到分解成可以解决的问题（递推），即

1! = 1

然后，根据最小问题的答案，逐步解决更大问题（2，3，4的阶乘等），最终推导出最后的结果，即n的阶乘。

对于递归而言，其实现的是函数的逐层调用，而每调用一次函数，就会为函数分配额外的空间资源（自己调用自己也不例外），因此，从效率角度来说，递归不如循环高效。然而，对于一些复杂的问题（例如即将介绍的汉诺塔递归），递归可以更有效的将问题进行分解，以更容易理解的方式解决问题，从这个角度讲，递归优于循环。

8.3 汉诺塔

汉诺塔问题不管在任何编程语言里都是经典问题，是采用递归算法的经典案例，该问题可以抽象如下：

1. 3根圆柱A，B，C，其中A上面串了n个圆盘

2. 这些圆盘从上到下是按从小到大顺序排列的，大的圆盘任何时刻不得位于小的圆盘上面

3. 每次移动一个圆盘，最终实现将所有圆盘移动到Ｃ上

利用Python语言接近自然语言的特性，开发者可以更容易的将递归算法翻译成程序语句，需要的代码量很小。汉诺塔问题的解决步骤用语言描述很简单，仅三步：

A，B，C三个圆柱，分别为初始位，过渡位，目标位，设A柱为初始位，C位为最终目标位

（1）将最上面的n-1个圆盘从初始位移动到过渡位

（2）将初始位的最底下的一个圆盘移动到目标位

（3）将过渡位的n-1个圆盘移动到目标位

对于递归算法中的嵌套函数f（n-1）来说，其初始位，过渡位，目标位发生了变化

具体代码如下：

def move(n,a,b,c):   #n为圆盘数，a代表初始位圆柱，b代表过渡位圆柱，c代表目标位圆柱
	if n==1:
		print(a,'-->',c)
	else:
		move(n-1,a,c,b)   #将初始位的n-1个圆盘移动到过渡位，此时初始位为a，上一级函数的过渡位b即为本级的目标位，上级的目标位c为本级的过渡位
		print(a,'-->',c)
        move(n-1,b,a,c)   #将过渡位的n-1个圆盘移动到目标位，此时初始位为b，上一级函数的目标位c即为本级的目标位，上级的初始位a为本级的过渡位

8.4 递归的深度

递归的默认深度为1000。

sys.getrecursionlimit()
sys.setrecursionlimit()
该方法名多少有些误解，我们应该将其理解为最大函数调用限制，可能会更好一些。

9. 函数描述

9.1 函数说明文档

我们可以为函数编写说明文档。所谓说明文档，就相当于是函数的使用说明书，在文档中可以用来说明函数的功能，参数，返回值类型以及相关注意事项，使用示例等。要为函数编写说明文档，可以在函数体的上方，使用字符串进行标记。按照惯例，作为说明文档的字符串使用三个双引号界定，并且第一行为函数的一个简要说明，接下来是一个空行，然后是函数的具体说明。

def fun():

"""这里是函数的简要说明。



这是是函数的具体功能说明。（注意存在一个空行）

"""

# 函数语句

也许大家会有所疑问，这好像就是普通的注释啊。效果上很像，但实则不是。如果是注释内容，则解释器会忽略，但是，作为函数文档，我们可以通过函数的__doc__属性获取这些说明，方便我们进行查看。同时，我们使用help函数来获取帮助时，返回的就是函数的说明文档信息。这就能够让我们在不打开函数所在的文件时，也能够方便的获取函数的帮助信息，如果是注释，则必须要定位到相应的函数，才能查看。

9.2 函数注解

在Python中，因为变量是没有类型的，因此对于函数来说，我们无法像C或Java语言那样，只要观看函数的定义，就可以轻松的确定函数的参数与返回值类型。为了弥补这种不足，使代码更具有可读性与易用性，我们可以使用函数注解来进行标注，显式指定函数参数或返回值的类型。

def add(a: int, b: int=3) ->int:

参数的说明是在参数后面加上一个：然后给出参数的类型。根据惯例，：与其后的类型使用一个空格分隔。返回值说明是在参数列表的)后，使用->指出。

我们可以使用函数对象的__annotations__属性获取函数的注解信息。该属性是一个字典类型。