python生成器和装饰器_【Python学习】迭代器，生成器和装饰器

迭代器

一、概要

在了解Python的数据结构时，容器(container)、可迭代对象(iterable)、迭代器(iterator)、生成器(generator)、列表/集合/字典推导式(list,set,dict comprehension)众多概念参杂在一起，难免让人一头雾水，下面这幅图也许能让大家更清楚的理解他们之间的关系。

二、容器(container)

容器是一种把多个元素组织在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用 in , not in 关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中(也有一些特列并不是所有的元素都放在内存)在Python中，常见的容器对象有：

list

dict

set

tuple

str

尽管绝大多数容器都提供了某种方式来获取其中的每一个元素，但这并不是容器本身提供的能力，而是可迭代对象赋予了容器这种能力，当然并不是所有的容器都是可迭代的。

三、可迭代对象(iterable)

一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代(Iteration)。很多容器都是可迭代对象(比如：list、dict、tuple等)，此外，像打开的文件，也是可迭代对象。但凡可以返回一个迭代器的对象都可成为可迭代对象。

这里x是一个list，是一个可迭代对象。我们知道，list、dict、set、tuple、str都是可迭代对象，通过iter()或__iter__()，就可以转化为一个迭代器。所以，我们可以说：一个具有iter方法的对象就可以称为可迭代对象。

四、迭代器(iterator)

上图中，y和z就是两个独立的迭代器，它是通过iter()方法从可迭代对象转化而来的。它是一个带状态的对象，该状态用于记录当前迭代所在的位置，以便下次迭代的时候取到正确的元素。它能在你调用 next() 方法的时候返回容器中的下一个值，任何实现了 __next__() 或next()方法的对象都是迭代器。迭代器有一种具体的迭代器类型，比如 list_iterator、set_iterator、tuple_iterator、str_iterator等 。

五、for循环的内部实现

在大多数情况下我们都不会用next()方法去可迭代对象中去取值，而是会用：for i in (iterable)，如下图：

for循环内部做了3件事情：

调用iter()把可迭代对象转换成迭代器

不断的调用迭代器的next()方法

处理StopIteration异常，结束循环

六、isinstance

可以使用isinstance()判断一个对象是否是Iterator对象，如下：

1 from collections import Iterator,Iterable

2 l = [1,2,3,4,5]

3 d = iter(l)

4 print(isinstance(l,list)) # 判断是否是list

5 print(isinstance(l,Iterable)) # 判断是否是可迭代对象

6 print(isinstance(l,Iterator)) # 判断是否是迭代器

7 print(isinstance(d,Iterator)) # 判断是否是迭代器

8 # True

9 # True

10 # False

11 # True

生成器

一、列表生成式

如果要生成列表[1x1, 2x2, 3x3, ..., 10x10]怎么做？除了循环还可以用一行语句代替循环生成，如下：

1 s = [i*i for i in range(10)]

2 print(s) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

这种写法就是Python的列表生成式，写列表生成式时，把要生成的元素 i * i 放到前面，后面跟 for 循环，就可以把list创建出来。

二、生成器

1、通过列表生成式实现

通过列表生成式，我们可以直接创建一个列表。但受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，会占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

1 l = [i*i for i in range(10)]

2 print(l) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

3

4 g = (i for i in range(5))

5 print(g) # at 0x000001F1DFCE01A8>

创建l和g的区别仅在于最外层的[]和()，l是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值，如下：

1 g = (i for i in range(5))

2 print(next(g)) # 0

3 print(next(g)) # 1

4 print(next(g)) # 2

5 print(next(g)) # 3

6 print(next(g)) # 4

7 print(next(g)) # StopIteration

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)的用法，实际上很少这么用，正确的方法是使用for循环，因为generator也是可迭代对象，如下：

1 g = (i for i in range(5))

2 for i in g:

3 print(i)

4 # 0

5 # 1

6 # 2

7 # 3

8 # 4

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误

2、用函数实现

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列(Fibonacci)，除第一个和第二个数外，任意一个数都可由前两个数相加得到：

0,1, 1, 2, 3, 5, 8, 13, 21, 34, ...

1 def fib(max):

2 n,before,after = 0,0,1

3 while n <= max:

4 print(before)

5 before,after = after,before+after

6 n = n + 1

上面的函数输出的结果入下：

1 fib(8)

2 # 0

3 # 1

4 # 1

5 # 2

6 # 3

7 # 5

8 # 8

9 # 13

10 # 21

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(before)改为yield before就可以了，如下：

1 def fib(max):

2 n,before,after = 0,0,1

3 while n <= max:

4 yield before

5 before,after = after,before+after

6 n = n + 1

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator，如下：

1 g = fib(5)

2 print(g) #

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行，如下：

1 g = fib(5)

2 print(g) #

3

4 print(next(g)) # 1

5 print(next(g)) # 1

6 print('干点别的')# 干点别的

7 print(next(g)) # 2

8 print(next(g)) # 3

9 print(next(g)) # 5

在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代，如下：

1 g = fib(5)

2 print(g) #

3 for i in g:

4 print(i)

5 # 1

6 # 1

7 # 2

8 # 3

9 # 5

10 # 8

使用send方法给变成了generator的函数传值，如下：

1 def bar():

2 print('ok1')

3 count = yield 1

4 print(count)

5 print('ok2')

6 yield 2

7

8 b = bar()

9 s = b.send(None) # 等同于next(b),第一次send前如果没有next，只能传一个None

10 print(s) # 返回第一个yield后面的1

11 k = b.send('AAA') # 第二次send把参数的值赋给count

12 print(k) # 返回第二个yield后面的2

13 # ok1

14 # 1

15 # AAA

16 # ok2

17 # 2

第一次执行b.send(None)后进入函数体，先打印ok1，碰到yield返回1，中断函数执行。第二次执行b.send('AAA')后再次进入函数，把AAA付给count打印出来，然后接着往下走，打印ok2，再往下走碰到yield返回2。

文件读取：

1 def read_file(fpath):

2 BLOCK_SIZE = 1024

3 with open(fpath, 'rb') as f:

4 while True:

5 block = f.read(BLOCK_SIZE)

6 if block:

7 yield block

8 else:

9 return

如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取。

装饰器

一、函数的作用域

1、作用域介绍

Python中的作用域分为四种情况：

L：local，局部作用域，即函数中定义的变量；

E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

G：globa，全局变量，就是模块级别定义的变量；

B：built-in，系统固定模块里面的变量，比如int, bytearray等。

搜索变量的优先级顺序依次是：L –> E –> G –>B，即：局部作用域>外层作用域>当前模块中的全局>Python内置作用域。

1 x = int(2.9) # int built-in

2

3 g_count = 0 # global

4

5 def outer():

6 o_count = 1 # enclosing

7 def inner():

8 i_count = 2 # local

9 print(o_count)

10 print(i_count) # 找不到

11 inner()

12 outer()

13

14 print(o_count) #找不到

当然，local和enclosing是相对的，enclosing变量相对上层来说也是local。

2、作用域的产生

在Python中，只有函数(def、lambda)、类(class)以及模块(module)才会引入新的作用域，其它的代码块(如if、try、for等)是不会引入新的作用域的，如下代码：

1 if 2>1:

2 x = 1

3 print(x) # 1

if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用。

1 def test():

2 x = 2

3 print(x) # NameError: name 'x2' is not defined

上面这段代码则会报错，因为def、class、lambda是可以引入新作用域的。

3、变量的修改

1 x = 6

2 def f():

3 print(x)

4 x = 5

5 f()

6

7 # 错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=5(函数已经加载到内存),但x使用在声明前了,所以报错:

8 # local variable 'x' referenced before assignment.如何证明找到了x=5呢?简单:注释掉x=5,x=6,报错为:name 'x' is not defined

9

10 # 同理

11 x = 6

12 def f():

13 x += 1 # local variable 'x' referenced before assignment.

14 f()

4、global关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域(global作用域)上的，就要使用global先声明一下，代码如下：

1 count = 10

2 def outer():

3 global count

4 print(count) #10

5 count = 100

6 print(count) #100

7 outer()

8 print(count) #100

5、nonlocal关键字

global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域(enclosing作用域，外层非全局作用域)中的变量怎么办呢，这时就需要nonlocal关键字了，代码如下：

1 def outer():

2 count = 10

3 def inner():

4 nonlocal count

5 count = 20

6 print(count) #20

7 inner()

8 print(count) #20

9 outer()

6、作用域小结

变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；

只有函数、类以及模块才能引入新的作用域；

对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；

内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个 关键字，就能完美的实现闭包了；

二、函数即对象

在Python中，函数和之前学过的字符串、整型、列表等一样都是对象，而且函数是最高级的对象(对象是类的实例化，可以调用相应的方法，函数是包含变量的对象)。如下：

1 def foo():

2 print('i am the foo')

3 bar()

4

5 def bar():

6 print('i am the bar')

7

8 foo()

接着，我们再聊一下函数在内存的存储情况：

函数对象的调用仅仅比其它对象多了一个()而已！foo,bar与a,b一样都是个变量名。

既然函数是对象，那么自然满足下面两个条件：

1、函数可以被赋值给其他变量

1 def foo():

2 print('foo')

3 bar=foo

4 bar()

5 foo()

6 print(id(foo),id(bar)) #1386464801520 1386464801520

2、函数可以被定义在另外一个函数内(作为参数或者返回值)，类似于整型、字符串等对象

1 # *******函数名作为参数**********

2 def foo(func):

3 print('foo')

4 func()

5

6 def bar():

7 print('bar')

8

9 foo(bar)

10

11 # *******函数名作为返回值*********

12 def foo():

13 print('foo')

14 return bar

15

16 def bar():

17 print('bar')

18

19 b = foo()

20 b()

三、函数的闭包

如下一个函数：

1 def foo():

2 x = 1

3 def bar():

4 print(x)

5 return bar

我们想要调用bar函数，有什么办法呢？，如下：

1 # 方法一

2 foo()()

3

4 # 方法二

5 func = foo()

6 func()

那么以上两种调用方式，有什么区别吗？

貌似没什么区别，但是有一个疑问：函数foo已经调用执行完毕了，再调用bar函数时，为什么没有报错(直接调用bar函数时却报错了)？

因为：函数foo return的bar函数是一个闭包函数，有x这个环境变量。

1、闭包函数

定义：如果在一个函数里，对在外部作用域(但不是在全局作用域)的变量进行引用，那么内部函数就被认为是一个闭包函数；

如上实例，bar就是内部函数，bar里引用了外部作用域的变量x(x在外部作用域foo里面，不是全局作用域)，则这个内部函数bar就是一个闭包函数；

再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，bar就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x；

2、用途

用途一：

1 # 用途1：当闭包执行完后，仍然能够保持住当前的运行环境。

2 # 比如说，如果你希望函数的每次执行结果，都是基于这个函数上次的运行结果。我以一个类似棋盘游戏的例子

3 # 来说明。假设棋盘大小为50*50，左上角为坐标系原点(0,0)，我需要一个函数，接收2个参数，分别为方向

4 # (direction)，步长(step)，该函数控制棋子的运动。棋子运动的新的坐标除了依赖于方向和步长以外，

5 # 当然还要根据原来所处的坐标点，用闭包就可以保持住这个棋子原来所处的坐标。

6

7 origin = [0, 0] # 坐标系统原点

8 legal_x = [0, 50] # x轴方向的合法坐标

9 legal_y = [0, 50] # y轴方向的合法坐标

10 def create(pos=origin):

11 def player(direction,step):

12 # 这里应该首先判断参数direction,step的合法性，比如direction不能斜着走，step不能为负等

13 # 然后还要对新生成的x，y坐标的合法性进行判断处理，这里主要是想介绍闭包，就不详细写了。

14 new_x = pos[0] + direction[0]*step

15 new_y = pos[1] + direction[1]*step

16 pos[0] = new_x

17 pos[1] = new_y

18 #注意！此处不能写成 pos = [new_x, new_y]，原因在上文有说过

19 return pos

20 return player

21

22 player = create() # 创建棋子player，起点为原点

23 print (player([1,0],10)) # 向x轴正方向移动10步

24 print (player([0,1],20)) # 向y轴正方向移动20步

25 print (player([-1,0],10)) # 向x轴负方向移动10步

用途二：

1 # 用途2：闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以

2 # 修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先

3 # 要提取出这些特殊行。

4

5 def make_filter(keep):

6 def the_filter(file_name):

7 file = open(file_name)

8 lines = file.readlines()

9 file.close()

10 filter_doc = [i for i in lines if keep in i]

11 return filter_doc

12 return the_filter

13

14 # 如果我们需要取得文件"result.txt"中含有"pass"关键字的行，则可以这样使用例子程序

15 filter = make_filter("pass")

16 filter_result = filter("result.txt")

四、装饰器

装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

有如下一个函数：

1 def timer():

2 print('timer')

我们要测试这个函数的执行时间，该怎么做？

1 import time

2 def timer():

3 start_time = time.time()

4 print('timer')

5 time.sleep(1.22)

6 end_time = time.time()

7 print('执行时间为：%s'%(end_time-start_time))

8

9 timer() #1.230109453201294

如果有成百上千个函数需要测试的话，这样做工作量就太大了，那么可以这样做：

1 import time

2 def timer(func):

3 start_time = time.time()

4 func()

5 end_time = time.time()

6 print('执行时间为：%s'%(end_time-start_time))

7

8 def bar():

9 time.sleep(1.23)

10 print('bar')

11

12 timer(bar) #1.2442445755004883

这么做貌似没什么问题了，但是我们发现函数的调用发生了变化，之前我们调用bar函数只要bar()就行了，现在则要用timer(bar)来调用。如果很多代码已经是写好了的，那么我们还要去修改源代码，显然，这样的方法是不可取的。那么，还有什么更好的方法呢？就要正式用到装饰器了，如下：

1 import time

2 def timer(func):

3 def deco():

4 start_time = time.time()

5 func()

6 end_time = time.time()

7 print('执行时间为：%s'%(end_time-start_time))

8 return deco

9

10 def bar():

11 time.sleep(1.23)

12 print('bar')

13

14 bar = timer(bar)

15 bar()

函数timer就是装饰器，它把真正的业务方法func包裹在函数里面，看起来像bar被上下时间函数装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

1、简单的装饰器

上面这段代码基本实现了装饰器的功能，但和普通函数调用比起来，还多了一行：bar = timer(bar)，我们可以在需要调用的函数前面加上@timer来替代这一行，如下：

1 import time

2 def timer(func):

3 def deco():

4 start_time = time.time()

5 func()

6 end_time = time.time()

7 print('执行时间为：%s'%(end_time-start_time))

8 return deco

9

10 @timer # bar = timer(bar)

11 def bar():

12 time.sleep(1.23)

13 print('bar')

14

15 @timer # foo = timer(foo)

16 def foo():

17 time.sleep(2.23)

18 print('foo')

19

20 bar()

21 foo()

如上所示，这样我们就可以省去bar = timer(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

这里需要注意的问题：foo = timer(foo)其实是把deco引用的对象引用给了foo，而deco里的变量func之所以可以用，就是因为deco是一个闭包函数。

@timer帮我们做的事情就是当我们执行业务逻辑bar()时，执行的代码由红框部分转到蓝框部分，仅此而已。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

2、带参数的被装饰函数

1 import time

2 def timer(func):

3 def deco(a,b):

4 start_time = time.time()

5 func(a,b)

6 end_time = time.time()

7 print('执行时间为：%s'%(end_time-start_time))

8 return deco

9

10 @timer # bar = timer(bar)

11 def bar(a,b):

12 time.sleep(1.23)

13 print(a+b)

14

15 @timer # foo = timer(foo)

16 def foo(a,b):

17 time.sleep(2.23)

18 print(a-b)

19

20 bar(1,2)

21 foo(3,4)

3、不定长参数

1 import time

2 def timer(func):

3 def deco(*args,**kwargs):

4 start_time = time.time()

5 func(*args,**kwargs)

6 end_time = time.time()

7 print('执行时间为：%s'%(end_time-start_time))

8 return deco

9

10 @timer # bar = timer(bar)

11 def add(*args,**kwargs):

12 time.sleep(1.23)

13 sum = 0

14 for i in args:

15 sum += i

16 print(sum)

17

18 add(1,2,3,4,5,6,7,8,9,10) #55

4、带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@timer，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

1 import time

2 def time_logger(flag=0):

3 def timer(func):

4 def deco(*args,**kwargs):

5 start_time = time.time()

6 func(*args,**kwargs)

7 end_time = time.time()

8 print('执行时间为：%s'%(end_time-start_time))

9 if flag:

10 print('将这个函数的执行时间记录到日志当中')

11 return deco

12 return timer

13

14 @time_logger(3)

15 def add(*args,**kwargs):

16 time.sleep(1.23)

17 sum = 0

18 for i in args:

19 sum += i

20 print(sum)

21

22 add(1,2,3,4,5,6,7,8,9,10)

@time_logger(3) 做了两件事：

(1)time_logger(3)：得到闭包函数timer，里面保存环境变量flag

(2)@timer：add＝timer(add)

上面的time_logger是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器(一个含有参数的闭包函数)。当我 们使用@time_logger(3)调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。

我们可以通过装饰器time_logger中的参数flag的值来控制是否将函数的执行时间写入日志，比如：flag=0就不写入，flag!=0就写入。

5、类装饰器

相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

1 import time

2

3 class Foo(object):

4 def __init__(self,func):

5 self._func = func

6

7 def __call__(self):

8 start_time = time.time()

9 self._func()

10 end_time = time.time()

11 print('函数执行时间为：%s' % (end_time - start_time))

12

13 @Foo

14 def bar():

15 time.sleep(1.25)

16 print('bar')

17

18 bar()

可以看到，类装饰器没有嵌套关系了，直接使用类当中的__call__方法。

6、装饰器实例

用装饰器，写一个实例，判断用户是否登陆，逻辑是：运行程序，打印菜单，选择要进入的菜单，如果未登录，则要进行登录，如果是已登录则直接展示菜单。

1 import os

2 def login():

3 '''

4 登录函数，登录成功的话将username写入user文件当中

5 '''

6 username = input('username:')

7 passwd = input('passwd:')

8 if username == 'admin' and passwd == '123456':

9 with open('user','a+',encoding='utf-8') as f:

10 f.write(username)

11 print('登录成功')

12 else:

13 print('用户名或密码错误')

14

15 def auth(func):

16 '''

17 校验是否登录的装饰器

18 '''

19 def check(*args,**kwargs):

20 if os.path.exists('user'): # 判断user文件是否存在

21 func(*args,**kwargs) # 假设user文件存在就代表登录成功，执行函数

22 else:

23 print('您还未登录')

24 login() # 不存在则调用登录函数

25 func(*args, **kwargs) # 登录成功后再执行函数

26 return check

27

28 @auth

29 def home():

30 print('Welcome to Home Page!!')

31

32 @auth

33 def finance():

34 print('Welcome to Finance Page!!')

35

36 @auth

37 def add():

38 print('Welcome to AddProduct Page!!')

39

40 def menu(): # 打印菜单函数

41 msg = '''

42 1:首页

43 2:金融

44 3:添加商品

45 '''

46 print(msg)

47 m = {

48 "1":home,

49 "2":finance,

50 "3":add

51 }

52 choice = input('请输入您的选择：').strip()

53 if choice in m:

54 m[choice]() # 调用对应的函数

55 else:

56 print('输入错误')

57 menu()

58

59

60 if __name__ == '__main__':

61 menu()