python函数讲座

妖狐艹你老母 2022-11-30 04:10 434阅读 0赞

### **python****函数讲座** ###

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。简单地说，在Python中，函数是一组执行特定任务的相关语句。

Python 中函数的应用非常广泛，前面讲座中我们已经使用过过多个函数，比如 input() 、print()、range()函数等等，这些都是 Python 的内置函数，可以直接使用。

除了可以直接使用的内置函数外，Python 还支持自定义函数，即将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。

**注意**：和C语言、Visual Basic语言等函数定义不可以嵌套，调用可以嵌套不同，python函数定义和调用都可以嵌套，这一点和JavaScript函数一样。

Python函数的一般分类

（1）内置函数。Python语言内置了若干常用的函数，例如abs()、len()等等，在程序中可以直接使用。

（2）标准库函数。Python语言安装程序同时会安装若干标准库，例如math、random等等。通过import语句，可以导入标准库，然后使用其中定义的函数。

（3）第三方库函数。Python社区提供了许多其他高质量的库，如Python图像库等等，需要下载安装。下载安装这些库后，通过import语句，可以导入库，然后使用其中定义的函数。

（4）用户自定义函数。本讲座将讨论函数的定义和调用方法。

自定义函数的简单规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()和冒号：。

任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

函数内容（函数体）缩进。

Python 定义函数的语法格式

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

def 函数名(\[参数列表\]):

\["""docstring"""\]

函数体

\[return \[返回值\]\]

各部分的含义如下：

其中\[ \]表示其内的部分是可选的即不一定有——可写有可不写，\[ \]本身不写。

关键字def标志这一个函数头部的开始。

函数名：其实就是一个符合 Python 语法的标识符，但不建议读者使用 a、b、c 这类简单的标识符作为函数名，函数名最好能够体现出该函数的功能。

参数列表：是可选的。设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。即使函数不需要参数，也必须保留括号（）。

一个冒号(:)是标志着函数头部的结束。

docstring：是documentation string的缩写。它用来简单地解释函数的作用。

函数体：由一个或多个有效python语句组成。语句必须有相同的缩进(通常是4个空格)。

\[return \[返回值\] \]：整体作为函数的可选参参数，用于设置该函数的返回值。也就是说，一个函数，可以用返回值，也可以没有返回值，是否需要根据实际情况而定。函数体中没有 return 语句时，函数运行结束会隐含返回一个 None 作为返回值，类型是 NoneType，与 return 、return None 等效，都是返回 None。

函数中可以有多条return语句，只要执行了一条return语句，程序返回到调用程序。

注意，在创建函数时，即使函数不需要参数，也必须保留一对空的“()”，否则 Python 解释器将提示“invaild syntax”错误。

函数中使用Docstring（文档字符串）的例子

示例中，我们在函数标头下方有一个文档字符串。 我们通常使用三引号，以便文档字符串可以扩展到多行。 该字符串可以作为函数的\_\_doc\_\_属性使用,我们可以使用\_\_doc\_\_查看函数中使用Docstring（文档字符串）,例如

def greet(name):  
     """This function greets to the person passed in as parameter"""

print(greet.\_\_doc\_\_)  \# 查看函数中使用Docstring（文档字符串）

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

例、\#定义一个比较字符串大小的函数

\#函数的定义（声明）

def s\_max(s1,s2):

if s1>s2:

return s1

else:

return s2

Python函数的调用

python函数的应用一般需要：先定义（声明）、后调用，函数调用函数例外，详见 [ https://blog.csdn.net/couragehope/article/details/83031932][https_blog.csdn.net_couragehope_article_details_83031932]。

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。要调用函数，只需键入带有适当参数的函数名。

调用函数一方，可以使用变量来接收函数的返回结果。

s1= s\_max('li','wang')  \#函数的调用

print(s1)

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1][]

**函数参数**

常见的**普通参数**也叫必须参数、位置参数，前面的例子就是。实参和形参在顺序上和数量上必须要保持一致，否则可能造成异常，具体而言：实参和形参数量不同时将抛出异常报错；，实参和形参在顺序上不一致时，若实参和形参类型不一致将抛出异常报错，若实参和形参类型一致，虽然不抛出异常报错，但会产生结果与预期不符。

**关键字参数**指调用函数时使用形参的名字来确定传入的参数值**，**即调用函数时使用 **形参名=值** 这样的形式，这种情形不需要在乎参数的位置顺序。

可以将上例中s1= s\_max('li','wang')  \#函数的调用

改为：s1= s\_max(s1='li', s2='wang')  \#函数的调用

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2][]

这种方式，参数从左至右的关系已不再重要了，因为参数是通过变量名进行传递的，而不是通过其位置，例如：

def f(a,b,c):

print(a,b,c)

f(c=3,a=1,b=2)   \#函数的调用

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3][]

函数的定义和调用示例2、计算并返回第n阶调和数（1 + 1/2 + 1/3 + … + 1/n）的函数，输出前n个调和数

def harmonic(n):    \#自定义函数：计算n阶调和数（1 + 1/2 + 1/3 + … + 1/n）

total = 0.0

for i in range(1, n+1):

total += 1.0 / i

return total

n = int(6)     \#调用前用定义的函数

for i in range(1, n+1):   \#输出前n个调和数的值

print(harmonic(i))

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4][]

参数的作用

函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据。

1.在函数内部，把参数当作变量使用，进行需要的数据处理。

2.函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递。

形式参数（简称形参）和实际参数（简称实参）

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用。

实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的。

声明函数时声明的形式参数，等同于函数体中的局部变量，在函数体中的任何位置都可以使用。

局部变量和形式参数变量的区别在于，局部变量在函数体中绑定到某个对象；而形式参数变量则绑定到函数调用代码传递的对应实际参数对象。

Python 中，根据实际参数的类型不同，函数参数的传递方式可分为 2 种：**值传递**和**引用（地址）传递**：

值传递：参数类型应为不可变类型（字符串、数字、元组）；

引用（地址）传递：参数类型应为可变类型（列表，字典）；

【可变(mutable)与不可变(immutable)的含义

在 python 中，strings, tuples, 和 numbers 是不可变（不可更改）的对象，而 list,dict 等则是可变的对象。

不可变对象就是那些一旦被创建，它们的状态就不能被改变的对象，每次对它们的改变都是产生了新的对象。

可变对象就是那些创建后，状态依然可以被改变的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。即一旦试图更改其值，将会构造一个新的对象而非对原来的值进行更改。

可变类型：变量赋值 la=\[1,2,3,4\] 后再赋值 la\[2\]=5 则是将列表 la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。即其值可以被更改。】

值传递和引用传递的区别是，函数参数进行值传递后，若形参的值发生改变，不会影响实参的值；而函数参数继续引用传递后，改变形参的值，实参的值也会一同改变。

下面程序演示了函数参数**值传递**的情况：

def swap(a , b) :

\# 下面代码实现a、b变量的值交换

a, b = b, a

print("swap函数里，a的值是", \\

a, "；b的值是", b)

a = 6

b = 9

swap(a , b)

print("交换结束后，变量a的值是", \\

a , "；变量b的值是", b)

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5][]

下面程序演示了函数参数**引用传递**的情况：

def swap(dw):

\# 下面代码实现dw的a、b两个元素的值交换

dw\['a'\], dw\['b'\] = dw\['b'\], dw\['a'\]

print("swap函数里，a元素的值是",\\

dw\['a'\], "；b元素的值是", dw\['b'\])

dw = \{'a': 6, 'b': 9\}

swap(dw)

print("交换结束后，a元素的值是",\\

dw\['a'\], "；b元素的值是", dw\['b'\])

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6][]

在Python中要让函数修改某些数据，则可以通过把这些数据包装成列表、字典等可变对象，然后把列表、字典等可变对象作为参数传入函数，在函数中通过列表、字典的方法修改它们，这样才能改变这些数据。

【Python中函数参数的传递机制补充说明：

不可变参数通过“值”进行传递。像元组、字符串这样的对象是通过对象引用而不是拷贝进行传递的，但是你不可能在原处修改来改变不可变对象，实际效果像是创建了一份拷贝。

可变对象通过"指针"进行传递：像列表和字典这样的对象也是通过对象引用进行传递的，但是由于你可以在原处修改可变对象，类似于C语言使用指针进行传递的情况。

本质上，Python的参数传递都是通过引用来进行传递的，由于不可变对象和可变对象的修改机制不同，造成了不同的结果。这本身不是bug，而是Python的工作方式。

对于不可变对象，如int类型，元组和字符串等，参数名称可能最初共享传递的对象（实质上是指向这些对象的指针），但只是临时的，仅当函数第一次调用的时候如此。只要对参数名重新赋值，这种关系就结束了。因为不可变对象不支持在原处修改。我们可以看出，在函数调用结束时，number变量和num函数参数引用了不同的对象。

对于可变对象，当参数传递项列表和字典这样的可修改对象的时候，就需要注意，对这样的对象的原处修改，可能在函数退出后依然有效，并由此影响到调用者。】

变量的作用域

局部变量、全局变量和类型成员变量

局部变量是在函数内部定义的变量，只能在函数内部使用，临时保存函数内部需要使用的数据，函数执行结束后，函数内部的局部变量，会被系统回收。

不同的函数，可以定义相同的名字的局部变量，但是各用各的不会产生影响。

如果在一个函数中定义的局部变量（或形式参数变量）与全局变量重名，则局部变量（或形式参数变量）优先，即函数中定义的变量是指局部变量（或形式参数变量），而不是全局变量。

全局变量：在一个源代码文件中，在函数和类定义之外声明的变量。

全局变量的作用域为其定义的模块，从定义的位置起，直到文件结束位置。

全局变量是在函数外部定义的变量，(没有定义在某一个函数内)，所有函数内部都可以使用这个变量。

通过import语句导入模块，也可以通过全限定名称“模块名.变量名”访问。或者通过from…import语句导入模块中的变量并访问。

例、

\#局部变量全局变量的例子

num = 100      \#全局变量

def f():

num = 105    \#局部变量

print("输出函数内的局部变量的值：",num)

\#测试代码

f()

print("输出函数外的全局变量的值：",num)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7][]

在函数体中，可以引用全局变量，但如果函数内部的变量名是第一次出现且在赋值语句之前（变量赋值），则解释为定义局部变量（不存在），参见下例：

m = 100

n = 200

def f():

print(m+10)  \#引用全局变量m

n =n + 10 \#注意这句错误

\#测试代码

f()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8][]

变量的作用域是程序中识别变量的部分。函数内部定义的参数和变量从外部看不到。因此，它们具有局部作用域。一旦我们从函数返回，它们就会被销毁。因此，函数不记得以前调用的变量的值。

下面例子来说明函数中变量的作用域：

def my\_func():

x = 10

print("Value inside function:",x)

x = 20

my\_func()

print("Value outside function:",x)

运行之，输出参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 9][]

下面的例子来说明函数中变量的作用域：

def my\_func():

x = 10

print("Value inside function:",x)

x = 20

my\_func()

print("Value outside function:",x)

运行之，输出参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 10][]

这里，我们可以看到x的初始值是20。尽管函数my\_func（）将x的值更改为10，但它不会影响函数外部的值。这是因为函数内部的变量x与外部的变量x不同，虽然它们有相同的名称，但它们是两个不同的变量，具有不同的作用域。

类成员变量

类成员变量是在类中声明的变量，包括静态变量和实例变量，其有效范围（作用域）为类定义体内。

在外部，通过创建类的对象实例，然后通过“对象.实例变量”访问类的实例变量，或者通过“类.静态变量”访问类的静态变量。

这部分内容将在面向对象程序设计讲座介绍。

python函数参数的进一步介绍

现在介绍默认参数、可变参数（\*开头的参数、\*\*开头的参数）。

默认参数

默认参数就是定义函数时，形参给定一个缺省默认值。

下面给出一个求幂的例子

由于我们经常计算x2，所以，可以把第二个参数n的默认值设定为2，当我们调用power(5)时，相当于调用power(5, 2)。

def power(x, n=2):

s = 1

while n > 0:

n = n - 1

s = s \* x

return s

print("power(3,2)=",power(3,2))

print("power(3,2)=",power(3))

print("power(3,4)=",power(3,4))

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 11][]

可以改变默认参数的值，如果没有给默认形参一个值作为实参，那么就会调用默认形参的值作为实参，因此会得到默认的值；如果我们在调用函数时输入了一个非默认形参值，这时候默认形参的值会发生变化，变为输入的那个值！

\*开头的参数——可变数量参数（不定长参数）

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。带有\*的形参，可以容纳很多个参数（包括0个参数）。

def change(\*str):

for i in str:

print(i)

return

change("王一民","中国山东","软件开发爱好者")

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 12][]

带有\*的形参，本例中是\*str，调用该函数时，可以传入任意个参数，包括0个参数。

\*\*开头的参数

带有\*\*的形参，允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict类型数据——会将多个值转成一个字典来处理。

例

def show\_three(\*\*kw):

print(type(kw))

print(kw)

show\_three(name='张三',age='20',sex='男')

运行情况参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 13][]

组合参数，就是使用多种参数，定义函数时参数时的顺序有要求：普通参数（必须参数）、默认值参数、\*开头的参数、\*\*开头的参数。下面给出一个例子：

\#函数定义

def hs(a1,a2,a3=10,\*a4,\*\*cs):

print('a1=', a1, 'a2=',a2, 'a3=',a3, '\*4a=',a4, '\*\*cs=',cs)

xx=\{'name':'xiaozhi','age':'18','interesting':'basketball'\}

hs(1,2,3,4,5,6,7,m=26,n=25,\*\*xx)  \#第一次调用

tu=(1,2,3,4,5,6,7,8,'zhao')

zd=\{'m':26, 'n':25, 'x':'wang'\}

hs(\*tu, \*\*zd) \#第二次调用

运行情况参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 14][]

在第一次调用函数时，1、2分别给a1，a2，形参a3=10，但是传入实参为3，改变了原来的值，因此a3=3，\*a4 是不定长参数，因此4、5、6、7给\*a4，以元组的形式输出，m、n以及\*\*xx 的值给\*\*cs，以字典形式输出。

在第二次调用函数时，tu为一个元组，用\*tu调用时输出 a1=1，a2=2，a3=3，\*4a=(4,5,6,7,8, 'zhao')，用\*\*zd调用时以字典形式输出\{'m': 26, 'n': 25, 'x': 'wang'\}。

再给出一个例子：

def myFun(args, \*args1, \*\*args2):

print(args)

print(args1)

print(args2)

myFun('测试：','李明', 9, '小学生', name='刘美媚', job='软件测试', Gender='女')

运行情况参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 15][]

**匿名函数（Anonymous Function）**

匿名函数格式：

lambda \[参数列表\]: 表达式

说明

Python语言使用lambda关键字来创建匿名函数。

参数列表不需要小括号，多个参数之间用英文逗号分隔。无参就不写参数。

冒号用来分割参数列表和表达式部分。

不需要使用return。表达式的值，就是匿名函数的返回值。表达式中不能出现等号。

lambda表达式（匿名函数）只能写在一行上。

匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数，如果有参数，将对应的参数放进括号。

所谓匿名，即不再使用def语句这样标准的形式定义一个函数，没有函数名字。

匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量。

匿名函数调用方式

1）直接赋值给一个变量,然后再像一般函数调用，如：

c = lambda x,y,z: x\*y\*z

print(c(2,3,4))   \#输出 24

2）直接后面传递实参，如：

print((lambda x,y: x if x> y else y)(101,102)) \#输出 102

下面给出例子并运行之。

f = lambda x: x \* x  
print(f(3))

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 16][]

也可以把匿名函数作为别的函数的返回值返回。例：  
def build(x, y):  
    return lambda: x \* x + y \* y

f=build(1, 2)  \# 调用  
print(f())  \# 注意这句

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 17][]

**递归函数（Recursive function）**

递归算法（Recursive algorithm）在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。递归算法是一种直接或者间接调用自身函数或者方法的算法。

运用递归的条件：每一步进行的操作基本相同，并且问题规模逐渐减小。

**递归的过程**

递归，顾名思义，其包含了两个意思：递 和 归，这正是递归思想的精华所在。递归就是有去（递去）有回（归来），用递归求4！如下图所示:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 18][]

递归函数（Recursive function），一个函数在内部调用自己，那么这个函数是递归函数。递归会反复使用本身，每递归一次，越接近最终的值。当一个问题可以由许多相似的小问题解决， 可以考虑使用递归函数。随着递归的深入，问题规模相比上次都应所减小。return函数本身的方法保证了递归的持续进行，但是如果没有明确的结束条件，递归会无限进行下去。所以当已经到了问题解决的程度， 应该告诉函数结束递归，这就需要明确的结束条件。

下面是用递归求阶乘的python代码

def fun(n):  
    if n == 0 or n == 1:  
        return 1  
    else:  
        return (n \* fun(n - 1))

num = int(input("请输入一个正整数: "))  
a = fun(num)  
print(a)

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 19][]

经典递归问题

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。此问题等价于：

设a,b,c是3个柱子。开始时，在柱子a上有一叠共n个圆盘，这些圆盘自下而上，由大到小地叠在一起。各圆盘从小到大编号为1,2,…,n,现要求将柱子a上的圆盘移到柱子c上，在移动圆盘时可以借助b柱子，但应遵守以下移动规则：

规则1：每次只能移动1个圆盘；

规则2：任何时刻都不允许将较大的圆盘压在较小的圆盘之上；

规则3：在满足移动规则1和2的前提下，可将圆盘移至a,b,c中任一柱子上。

![2020091510175863.png][]

目标：把a柱子上的n个盘子移动到c柱子

递归的思想就是把这个目标分解成三个子目标

子目标1：将前n-1个盘子从a移动到b上

子目标2：将最底下的最后一个盘子从a移动到c上

子目标3：将b上的n-1个盘子移动到c上

然后每个子目标又是一次独立的汉诺塔游戏，也就可以继续分解目标直到N为1

用递归求汉诺塔的python代码

def hanoi(n, a, b, c):  
    if n == 1:  
        print(a, '-->', c)  
    else:  
        hanoi(n - 1, a, c, b)  
        hanoi(1    , a, b, c)  
        hanoi(n - 1, b, a, c)  
\# 调用  
n = int(input("请输入汉诺塔的层数并回车："))  
hanoi(n, 'A', 'B', 'C')

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 20][]

**嵌套函数（Nested function）和闭包（closure）**

Python允许函数的嵌套定义，即在函数体中可以定义函数，内部的函数为**嵌套函数**（nested function），也叫内部函数（inner function）。为了执行内部函数，必须调用外部函数。 如果不调用外部函数，内部函数将永远不会执行。

怎么在函数外部调用内部函数？不能直接调用内部函数，需要先调用外部函数，在调用内部函数，否则出错，请留意下面例子调用的写法。

例子1、

def f1(x):

print("from f1",x)

def f2(y):

print("from f2",y)

f2("xyz")  \# 调用内层函数f2，f2("xyz") 和return f2("xyz")效果是一样

f1(123)  \#调用

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 21][]

请注意嵌套函数的访问顺序，在上面的示例中，f2()是在 f1()内部定义的，因此它是一个内部函数。 要调用 f2() ，我们必须先调用 f1()； 然后，f1()将继续调用在其中定义的 f2()。

对上例，对调用的写法适当修改，请仔细对比：

def f1(x):

print("from f1",x)

def f2(y):

print("from f2",y)

return f2  \#\# 调用内层函数f2，f2 和return f2效果是一样,都无（）部分

f1(123)("xyx")  \#\#调用 ,本句可换为res=f1(123)和res("xyz")这两句，效果是一样

print("---------")

res=f1(123)

res("xyz")

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 22][]

本例具有这样的特点：外部函数返回值是内部函数——在外部函数的内部（或者说在外部函数的函数体中）使用 return 内部函数名，注意不带括号（）部分，调用时可用**双括号方式**，也可用**先外后内方式**。

下面介绍闭包（closure）。

在一个外部函数内定义了一个内部函数，内部函数里运用了外部函数的临时变量，并且外部函数的返回值是内部函数的引用，这样就构成了一个闭包。【如果一个内部函数访问外部函数作用域的变量，并返回值是这个内部函数，则这个内部函数就是闭包。】

以下是在 Python 中创建闭包所需满足的条件：

必须是嵌套函数。

内部函数必须引用在封闭范围（enclosing scope）中定义的值——内部函数必须引用外部函数中的变量（自由变量）。

内部函数需要被返回。

计算一个数的 n 次幂，用闭包可以写成下面的代码：

\#闭包函数，其中 exponent 称为自由变量

def nth\_power(exponent):

def exponent\_of(base):

return base \*\* exponent

return exponent\_of \# 返回值是 exponent\_of 函数，注意不能带括号

square = nth\_power(2) \# 计算一个数的平方

cube = nth\_power(3) \# 计算一个数的立方

print(square(2))  \# 计算 2 的平方

print(cube(2)) \# 计算 2 的立方

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 23][]

在执行完 square = nth\_power(2) 和 cube = nth\_power(3) 后，外部函数 nth\_power() 的参数 exponent 会和内部函数 exponent\_of 一起赋值给 squre 和 cube，这样在之后调用 square(2) 或者 cube(2) 时，程序就能顺利地输出结果，而不会报错说参数 exponent 没有定义。

一篇中英文对照好文What is a Nested Function?

[https://zhuanlan.zhihu.com/p/53116610][https_zhuanlan.zhihu.com_p_53116610]

**附录**：

**1****、\_\_closure\_\_ 属性**

Python闭包比普通的函数相比，特有一个 \_\_closure\_\_ 属性，该属性记录着自由变量的地址。当闭包被调用时，系统就会根据该地址找到对应的自由变量，完成整体的函数调用。

以上面提到的nth\_power() 为例，当其被调用时，可以通过 \_\_closure\_\_ 属性获取自由变量（也就是程序中的 exponent 参数）存储的地址，例如：

def nth\_power(exponent):

def exponent\_of(base):

return base \*\* exponent

return exponent\_of

square = nth\_power(2)

\#查看 \_\_closure\_\_ 的值

print(square.\_\_closure\_\_)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 24][]

【自由变量（free variable）

If a name is bound in a block, it is a local variable of that block, unless declared as nonlocal. If a name is bound at the module level, it is a global variable. (The variables of the module code block are local and global.) If a variable is used in a code block but not defined there, it is a free variable.

如果名称绑定在块中，则它是该块的局部变量，除非声明为非局部的。如果名称在模块级别绑定，则它是全局变量。（模块代码块的变量是局部和全局的。）如果一个变量在代码块中使用但没有在那里定义，那么它是一个自由变量。】

内部函数可以使用外函数绑定来的临时变量，但是如果想修改外部函数变量，就要用专门的关键字 nonlocal了，一般部推荐这样做。

**2****、global和nonlocal语句**

global关键字用来在函数或其他局部作用域中使用全局变量， nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量。在嵌套函数中，如果要为定义在上级函数体的局部变量赋值，可以使用nonlocal语句，表明变量不是所在块的局部变量，而是在上级函数体中定义的局部变量。

global的用法

global关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字。

先看一个例子：

gcount = 0

def global\_test():

gcount+=1

print (gcount)

global\_test()

以上代码会报错：第一行定义了全局变量，在内部函数中又对外部函数进行了引用并修改，那么python会认为它是一个局部变量，有因为内部函数没有对其gcount进行定义和赋值，所以报错。

如果局部要对全局变量修改，则在局部声明该全局变量

gcount = 0

def global\_test():

global gcount

gcount+=1

print (gcount)

global\_test()

运行输出为：1

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 25][]

nonlocal的用法

nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量：

def outer\_func():

tax\_rate = 0.17          \#上级函数体中的局部变量

print('outer func tax rate =', tax\_rate) \#输出上级函数体中局部变量的值

def innner\_func():

nonlocal tax\_rate  \#不是所在块的局部变量，而是在上级函数体中定义的局部变量

tax\_rate = 0.05  \#上级函数体中的局部变量重新赋值

print('inner func tax rate =', tax\_rate) \#输出上级函数体中局部变量的值

innner\_func()                       \#调用函数

print('outer func tax rate =', tax\_rate)   \#输出上级函数体中局部变量的值（已更改）

outer\_func() \#测试代码

运行输出为：

outer func tax rate = 0.17

inner func tax rate = 0.05

outer func tax rate = 0.05

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 26][]

**附、**

关于Python的函数的几点特别说明 [https://blog.csdn.net/cnds123/article/details/115770008][https_blog.csdn.net_cnds123_article_details_115770008]

Python 函数支持返回多个值。参见 [https://www.php.cn/python-tutorials-417672.html][https_www.php.cn_python-tutorials-417672.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221124/199d80922a9541838a8af9557a618554.png
[https_blog.csdn.net_couragehope_article_details_83031932]: https://blog.csdn.net/couragehope/article/details/83031932
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1]: /images/20221124/b4f67e9d15d54799a5bf123ea69f4013.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2]: /images/20221124/27211475dc314ee29dfa3b539225e470.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3]: /images/20221124/1637758e67924fe4ae13a861351dacca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4]: /images/20221124/1f84f3b049e74e178b33c83723298c34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5]: /images/20221124/232e36d12f074001aa33d3be5a190524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6]: /images/20221124/eeb86f0c9733428b8f8d5a7e406014d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7]: /images/20221124/11d31d885da641de886c466ae3b44009.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8]: /images/20221124/8931b21879f94bd6a4ad2bc1b6062e54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 9]: /images/20221124/926e3a484e5c408d8a650309cb7f175a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 10]: /images/20221124/ee7275213ffd443cb1615027c2b56f91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 11]: /images/20221124/5fc8e12ad2584dfba905db470b466c48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 12]: /images/20221124/39b427d05f4b4234ad34d4d9a4988f0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 13]: /images/20221124/5eced5da55964bcdaae3167832ed631d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 14]: /images/20221124/faf89e7c61194c41a3bb0c1e85f15ba3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 15]: /images/20221124/8f91f793cf254eba8d6c82f6fa403f09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 16]: /images/20221124/d9493220c4d24cfebc28436934bc9216.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 17]: /images/20221124/a46c9d65883c4355869dc4dff3ccbf0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 18]: /images/20221124/b16b356529c242d6a0737080f12c23d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 19]: /images/20221124/8f4c34a43ef14c19bd4fb7edbf9dd13c.png
[2020091510175863.png]: /images/20221124/9604d64d99c6492e9f51a5845eeb7553.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 20]: /images/20221124/ff177e9e853748e88a1640f8758c2d44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 21]: /images/20221124/2d4e8445a2774cacbc173574ae6c8a0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 22]: /images/20221124/718bbe3e21254e84916f4ddc930d845e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 23]: /images/20221124/7f8bb0190bb548298ff140d11b461614.png
[https_zhuanlan.zhihu.com_p_53116610]: https://zhuanlan.zhihu.com/p/53116610
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 24]: /images/20221124/09278ca4e1814c00884036de33486fe7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 25]: /images/20221124/13cbd2a89ff64f8fb00ae970217d1b26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 26]: /images/20221124/d029e6b97d90430ba6f27c437c68c336.png
[https_blog.csdn.net_cnds123_article_details_115770008]: https://blog.csdn.net/cnds123/article/details/115770008
[https_www.php.cn_python-tutorials-417672.html]: https://www.php.cn/python-tutorials-417672.html