zoukankan      html  css  js  c++  java
  • PYTHON1.day10

    day09回顾:
       函数的参数:
         实参(给)
           传递方式:
             位置传参
                序列传参
             关键字传参
                字典关键字传参
         形参(接)
           缺省参数(default argument)
             def fx(a=0, b=2, c=3):
                 ...
           形参的定义方式(四种)
             位置形参
             星号元组形参
             命名关键字形参
             双星号字典形参

          def fx(a, b, *args, c, d, **kwargs):
                ...

    全局变量和局部变量
       局部变量 local

      全局变量 global
         创建用赋值语句
         销毁用del 语句

    两个函数 globals(), locals() 返回全局变量和局部变量的字典

    day10 笔记
    函数变量
       函数名是变量,它在创建函数时绑定一个函数

      示例:
         def f1():
            print("f1函数被调用")

        f2 = f1  # 两个变量同时绑定一个函数
         f2()     # f1函数被调用

      示例2:
    def f1():
         print("f1")

    def f2():
         print("f2")

    f1, f2 = f2, f1

    f1()  # f2


    一个函数可以作为另一个函数的实参传递
       示例见:
         function_as_args.py
         function_as_args2.py

      1 # function_as_args.py
      2 
      3 
      4 def f1():
      5     print("f1被调用")
      6 
      7 def f2():
      8     print("f2被调用!")
      9 
     10 def fx(fn):
     11     print(fn)
     12     fn()  # ???
     13 
     14 fx(f1)
     15 fx(f2)
     16 
     17 
     18 
     19 
     20 
     21 
     22 
     23 
    1
      1 # function_as_args2.py
      2 
      3 def goodbye(L):
      4     for x in L:
      5         print("再见:", x)
      6 
      7 def operator(fn, L):
      8     fn(L)
      9 
     10 operator(goodbye, ['Tom', 'Jerry', 'Spike'])
    2

    练习:
       看懂下列代码:
         def myinput(fn):
             L = [1, 3, 5, 7, 9]
             return fn(L)

        print(myinput(max))  # 9
         print(myinput(min))  # 1
         print(myinput(sum))  # 25


    函数可以作为另一个函数的返回值
       示例见:
         function_as_return_value.py

      1 # function_as_return_value.py
      2 
      3 def get_function():
      4     s = input("请输入您要做的操作: ")
      5     if s == '求最大':
      6         return max
      7     elif s == '求最小':
      8         return min
      9     elif s == '求和':
     10         return sum
     11 
     12 L = [2, 4, 6, 8, 10]
     13 f = get_function()   # ??? f绑定什么?
     14 print("f绑定:", f)
     15 print(f(L))
     16 
     17 
     18 
     19 
     20 
     21 
     22 
     23 
     24 
     25 
    funcyion_as_retrun_value

    练习:
       写一个计算公式的解释执行器
         已知有如下一些函数:
             def myadd(x, y):
                 return x + y
             def mysum(x, y):
                 return x - y
             def mymul(x, y):
                 return x * y
           ...
         定一个带有一个参数的函数 get_func(s):
             def get_func(s):
                 ...  # 此处自己实现
         此函数的在传入字符串"加"或"+" 返回myadd函数;
         此函数的在传入字符串"乘"或"*" 返回mysum函数, ...
         在主函数中程序如下:
             def main():
                 while True:
                     s = input("请输入计算公式: ")  # 10 加 20
                     L = s.split()  # L = ['10', '加', '20']
                     a = int(L[0])
                     b = int(L[2])
                     fn = get_func(L[1])
                     print("结果是:", fn(a, b))  # 结果是: 30

      1 # 练习:
      2 #   写一个计算公式的解释执行器
      3 #     已知有如下一些函数:
      4 #         def myadd(x, y):
      5 #             return x + y
      6 #         def mysum(x, y):
      7 #             return x - y
      8 #         def mymul(x, y):
      9 #             return x * y
     10 #       ...
     11 #     定一个带有一个参数的函数 get_func(s):
     12 #         def get_func(s):
     13 #             ...  # 此处自己实现
     14 #     此函数的在传入字符串""或"+" 返回myadd函数;
     15 #     此函数的在传入字符串""或"*" 返回mysum函数, ...
     16 #     在主函数中程序如下:
     17 #         def main():
     18 #             while True:
     19 #                 s = input("请输入计算公式: ")  # 10 加 20
     20 #                 L = s.split()  # L = ['10', '加', '20']
     21 #                 a = int(L[0])
     22 #                 b = int(L[2])
     23 #                 fn = get_func(L[1])
     24 #                 print("结果是:", fn(a, b))  # 结果是: 30
     25 
     26 
     27 
     28 
     29 
     30 def myadd(x, y):
     31     return x + y
     32 def mysub(x, y):
     33     return x - y
     34 def mymul(x, y):
     35     return x * y
     36 
     37 def get_func(s):
     38     if s == '加' or s == '+':
     39         return myadd
     40     elif s == '减' or s == '-':
     41         return mysub
     42     elif s in ('乘', '*'):
     43         return mymul
     44 
     45 def main():
     46     while True:
     47         s = input("请输入计算公式: ")  # 10 加 20
     48         L = s.split()  # L = ['10', '加', '20']
     49         a = int(L[0])
     50         b = int(L[2])
     51         fn = get_func(L[1])
     52         print("结果是:", fn(a, b))  # 结果是: 30
     53 
     54 main()
    1

      1 # 练习:
      2 #   写一个计算公式的解释执行器
      3 #     已知有如下一些函数:
      4 #         def myadd(x, y):
      5 #             return x + y
      6 #         def mysum(x, y):
      7 #             return x - y
      8 #         def mymul(x, y):
      9 #             return x * y
     10 #       ...
     11 #     定一个带有一个参数的函数 get_func(s):
     12 #         def get_func(s):
     13 #             ...  # 此处自己实现
     14 #     此函数的在传入字符串""或"+" 返回myadd函数;
     15 #     此函数的在传入字符串""或"*" 返回mysum函数, ...
     16 #     在主函数中程序如下:
     17 #         def main():
     18 #             while True:
     19 #                 s = input("请输入计算公式: ")  # 10 加 20
     20 #                 L = s.split()  # L = ['10', '加', '20']
     21 #                 a = int(L[0])
     22 #                 b = int(L[2])
     23 #                 fn = get_func(L[1])
     24 #                 print("结果是:", fn(a, b))  # 结果是: 30
     25 
     26 
     27 
     28 
     29 
     30 
     31 def get_func(s):
     32     def myadd(x, y):
     33         return x + y
     34 
     35     def mysub(x, y):
     36         return x - y
     37 
     38     def mymul(x, y):
     39         return x * y
     40 
     41     if s == '加' or s == '+':
     42         return myadd
     43     elif s == '减' or s == '-':
     44         return mysub
     45     elif s in ('乘', '*'):
     46         return mymul
     47 
     48 def main():
     49     while True:
     50         s = input("请输入计算公式: ")  # 10 加 20
     51         L = s.split()  # L = ['10', '加', '20']
     52         a = int(L[0])
     53         b = int(L[2])
     54         fn = get_func(L[1])
     55         print("结果是:", fn(a, b))  # 结果是: 30
     56 
     57 main()
    2

    函数的嵌套定义
       函数嵌套定义是指一个函数里用def语句来创建其它函数的情况

      示例见:
         function_embed_def.py

        

      1 # function_embed_def.py
      2 
      3 
      4 # 此示例示意函数的嵌套定义
      5 def fn_outer():
      6     print("fn_outer被调用")
      7     # 此处能否创建新的函数并且调用呢?
      8     def fn_inner():
      9         print("fn_inner被调用!")
     10     fn_inner()  # 调用函数内部的fn_inner
     11     fn_inner()
     12     print("fn_outer调用结束")
     13 
     14 fn_outer()
     15 
     16 
    funcyion_embed_def

    python 作用域
       作用域也叫名字空间,是访问变量时查找变量名的范围空间

      示例:
         a = 100
         def fx():
             a = 10000  # a=10000和a=100是两个不同作用域内的变量
             print(a)

        fx()
         print(a)


    python的四个作用域 LEGB
         作用域               英文解释                英文简写
    局部作用域(函数内)       Local(function)             L
    外部嵌套函数作用域        Enclosing function local   E
    函数定义所在模块的作用域   Global(module)             G
    python 内置模块的作用域   Builtin(Python)            B

    示例见:
       namespace.py

      1 # namespace.py
      2 
      3 
      4 # 此示例示意python的作用域
      5 v = 100
      6 def fun1():
      7     v = 200
      8     print('fun1.v=', v)  # 200
      9     def fun2():
     10         v = 300
     11         print('fun2.v=', v)  # 300
     12     fun2()
     13 
     14 fun1()
     15 print("全局的v=", v)  # 100
     16 
     17 
     18 
    namespace.py
      1 # namespace2.py
      2 
      3 
      4 # 此示例示意python的作用域
      5 v = 100
      6 def fun1():
      7     # v = 200
      8     print('fun1.v=', v)  # ???
      9     def fun2():
     10         # v = 300
     11         print('fun2.v=', v)  # ???
     12     fun2()
     13 
     14 fun1()
     15 print("全局的v=", v)  # 100
     16 
     17 
     18 
    2

    变量名的查找规则:
       在访问变量时,先查找本地变量,然后是包裹此函数外部的子数内部的
       变量,之后是全局变量,最后是内置变量,即:
           L --> E --> G --> B
       在默认的情况下,变量名赋值会创建或者改变本地作用域的变量

    练习:
       执行以下程序,看执行结果是什么?为什么?
       L = [1, 2, 3]
       v = 100
       def f1():
           L.append(4)
           v = 200
       f1()
       print(L)  # ???
       print(v)  # ???

      def f2():
           L += [5]
           v += 1
       f2()  # 此处会怎么样?为什么?
      

      1 # 练习:
      2 #   执行以下程序,看执行结果是什么?为什么?
      3 #   L = [1, 2, 3]
      4 #   v = 100
      5 #   def f1():
      6 #       L.append(4)
      7 #       v = 200
      8 #   f1()
      9 #   print(L)  # ???
     10 #   print(v)  # ???
     11 
     12 #   def f2():
     13 #       L += [5]
     14 #       v += 1
     15 #   f2()  # 此处会怎么样?为什么?
     16 
     17 
     18 
     19 
     20 L = [1, 2, 3]
     21 v = 100
     22 def f1():
     23     L.append(4)
     24     v = 200
     25 f1()
     26 print(L)  # ???
     27 print(v)  # ???
     28 
     29 def f2():
     30     L.extend([5])
     31     # L += [5]  # 出错
     32     v += 1  # 出错
     33 f2()  # 此处会怎么样?为什么?
     34 
     35 print(L)
     36 print(v)
     37 
     38 



    global语句:
       作用:
         告诉解释执行器, global语句声明的一个或多个变量,这些变量的
         作用域为模块级的作用域,也称作全局变量
         全局声明(global) 将赋值变量映射到模块文件内部的作用域
       语法:
         global 变量1, 变量2, ...
       示例:
         global ga, gb
         global gc

       示例见:
         global.py

      1 v = 100
      2 def f1():
      3     global v  # 全局声明语句
      4     v = 200  # 要想让此语句来修改全局变量v怎么办?
      5 
      6 f1()
      7 print(v)  # 200
    global.py
      1 # 3. 不能先声明局部变量,再用global声明为全局变量,此做法不
      2 #    附合规则
      3 
      4 
      5 v = 100
      6 def fx():
      7     v = 200
      8     global v
      9     v += 300
     10     print("v=", v)  # ??
     11 fx()
     12 print(v)  # ????
    2
      1 # global变量列表里的变量名不能出现在函数的形参列表里
      2 
      3 
      4 v = 100
      5 def fx(v):
      6     print(v)
      7     global v  # 出错
      8     v = 300
      9 
     10 fx(200)
     11 print(v)
    3

       说明:
         1. 全局变量如果要在函数内部被赋值,则必须经过全局声明(否则
            会被认为是局部变量)
         2. 全局变量在函数内部不经过声明就可以直接访问(变量已经存在
            并关联一个对象)
         3. 不能先声明局部变量,再用global声明为全局变量,此做法不
            附合规则
         4. global变量列表里的变量名不能出现在函数的形参列表里

    练习:
       用全局变量记录一个函数fx调用的次数,部分代码如下:
       count = 0
       def fx(name):
           print("你好", name)
           .... # 此处自己实现
       fx('小张')
       fx('小李')
       print("fx函数共被调用", count, '次')  # 2

      1 # 练习:
      2 #   用全局变量记录一个函数fx调用的次数,部分代码如下:
      3 #   count = 0
      4 #   def fx(name):
      5 #       print("你好", name)
      6 #       .... # 此处自己实现
      7 #   fx('小张')
      8 #   fx('小李')
      9 #   print("fx函数共被调用", count, '次')  # 2
     10 
     11 
     12 count = 0
     13 def fx(name):
     14     print("你好", name)
     15     global count
     16     count += 1
     17 fx('小张')
     18 fx('小李')
     19 print("fx函数共被调用", count, '次')  # 2
     20 

    nonlocal 语句
       作用:
         告诉解释器 nonlocal 声明的变量不是局部变量,也不是全局变量
         而是外部嵌套函数内的变量
       语法:
         nonlocal 变量名1, 变量名2, ...
       示例见:
         nonlocal.py

      1 # nonlocal.py
      2 
      3 
      4 v = 100
      5 
      6 def f1():
      7     v = 200
      8     print("f1.v=", v)
      9     # 此外嵌入另一个函数
     10     def f2():
     11         nonlocal v  # 声明v为外部嵌套函数作用域的变量
     12         v = 300
     13         print("f2.v=", v)
     14     f2()
     15     print("f1执行后f1.v=", v)
     16 
     17 f1()
     18 
     19 
    nonlocal.py
      1 # nonlocal.py
      2 
      3 
      4 # 3. 当有两层或两层以上函数嵌套时,访问nonlocal变量只对最近
      5 #    一层变量进行操作
      6 
      7 v = 100
      8 
      9 def f1():
     10     v = 200
     11     print("f1.v=", v)
     12     # 此外嵌入另一个函数
     13     def f2():
     14         v = 300
     15         # 再嵌入另一个函数
     16         def f3():
     17             nonlocal v
     18             v = 400
     19         f3()
     20         print("f2.v=", v)  # 400
     21     f2()
     22     print("f1执行后f1.v=", v)
     23 
     24 f1()
     25 
     26 
    2

       说明:
         1. nonlocal语句只能在被嵌套函数内部进行使用
         2. 对nonlocal变量进行赋值将对外部嵌套函数作用域内的变量
            进行操作
         3. 当有两层或两层以上函数嵌套时,访问nonlocal变量只对最近
            一层变量进行操作
         4. nonlocal语句的变量列表里的变量名,不能出现在此函数形参
            列表中


    问题:
       def 语句的作用是创建函数, 同时用变量名绑定这个函数

    lambda 表达式(又称匿名函数)
       作用:
         创建一个匿名函数对象
         同def类似,但不提供函数名
       语法:
         lambda [函数形式列表]: 表达式
       示例见:
         lambda.py

      1 # lambda.py
      2 
      3 
      4 # def myadd(x, y):
      5 #     return x + y
      6 
      7 myadd = lambda x, y: x + y
      8 
      9 print("20 + 30 =", myadd(20, 30))  # 50
     10 print("1 + 2 =", myadd(1, 2))  # 3
     11 
     12 
     13 
    lambda.py

       说明:
         lambda 表达式创建的函数只能包含一条表达式
         lambda 比函数简单且可以随时创建和销毁,有利于减少程序的偶合度

    练习:
       1. 写一个lambda 表达式
         fx = lambda n: ...
       此表达式创建的函数判断n这个数的2次方+1 能否被5整除,如果能被整
       除返回True,否则返回False
       如:
         print(fx(3))  # True
         print(fx(4))  # False

      1 # 练习:
      2 #   1. 写一个lambda 表达式
      3 #     fx = lambda n: ...
      4 #   此表达式创建的函数判断n这个数的2次方+1 能否被5整除,如果能被整
      5 #   除返回True,否则返回False
      6 #   如:
      7 #     print(fx(3))  # True
      8 #     print(fx(4))  # False
      9 
     10 
     11 
     12 fx = lambda n: (n ** 2 + 1) % 5 == 0
     13 
     14 print(fx(3))  # True
     15 print(fx(4))  # False
     16 
     17 
    1

      2. 写一个lambda 表达式来创建函数,此函数返回两个形参变量的最
       大值
         def mymax(x, y):
             ...
         mymax = lambda ......
         print(mymax(100, 200))  # 200
         print(mymax("100", "20"))  # 20  <-- 注意这是字符串

      看懂下面的程序在做什么?
         def fx(f, x, y):
             print(f(x, y))
         fx((lambda a, b: a + b), 100, 200)
         fx((lambda a, b: a * b), 3, 4)

      1 #   2. 写一个lambda 表达式来创建函数,此函数返回两个形参变量的最
      2 #     大值
      3 #     def mymax(x, y):
      4 #         ...
      5 #     mymax = lambda ......
      6 #     print(mymax(100, 200))  # 200
      7 #     print(mymax("100", "20"))  # 20  <-- 注意这是字符串
      8 
      9 
     10 
     11 # def mymax(x, y):
     12 #     if x > y:
     13 #         return x
     14 #     return y
     15 
     16 # def mymax(x, y):
     17 #     return x if x > y else y
     18 
     19 mymax = lambda x, y: x if x > y else y
     20 print(mymax(100, 200))  # 200
     21 print(mymax("100", "20"))  # 20  <-- 注意这是字符串
     22 
     23 
    2

    eval() 和 exec() 函数
       eval(source, globals=None, locals=None) 把一个字符串
             source 当成一个表达式来执行,返回表达式执行后的结果
       exec(source, globals=None, locals=None) 把一个字符串
             source 当成一个"程序"来执行

    eval 函数示例见:
       eval.py

      1 # eval.py
      2 
      3 x = 100
      4 y = 200
      5 
      6 s = 'x + y + 1'
      7 r = eval(s)
      8 print('r=', r)  # 301
      9 
     10 # 先创建一个局部作用域的字典
     11 local_scope = {'x': 1, 'y': 2}
     12 a = eval(s, None, local_scope)
     13 print('a=', a)
     14 
     15 # 创建一个全局作用域的字典
     16 global_scope = {'x': 10, 'y': 20}
     17 b = eval(s, global_scope)
     18 print('b=', b)  # 31
     19 
     20 c = eval(s, {'x': 10, 'y': 20}, {'x': 1})
     21 print('c=', c)  # 22
     22 
     23 
     24 
     25 
     26 
     27 
     28 
     29 
     30 
     31 
     32 
     33 
    eval.py

    exec 函数示例见:
      

      1 # exec.py
      2 
      3 s = '''
      4 myadd = lambda x, y: x + y
      5 
      6 print("20 + 30 =", myadd(20, 30))  # 50
      7 print("1 + 2 =", myadd(1, 2))  # 3
      8 '''
      9 
     10 exec(s)
    exec.py

      1 
      2 
      3 def fx():
      4     def fy():
      5         print("hello")
      6     return fy
      7 
      8 fn = fx()
      9 fn()  # ???
     10 
     11 def fa():
     12     L = [1, 2, 3, 4]
     13     return L
     14 L2 = fa()
     15 print(L2)
     16 
     17 
    0

    练习:
       1. 写一个函数mysum(n) ,此函数用来计算
          1 + 2 + 3 + 4 + ... + n 的和
          (要求: 不允许调用sum)
         如:
           print(mysum(100))  # 5050
           print(mysum(4))  # 10

      1 #   1. 写一个函数mysum(n) ,此函数用来计算
      2 #      1 + 2 + 3 + 4 + ... + n 的和
      3 #      (要求: 不允许调用sum)
      4 #     如:
      5 #       print(mysum(100))  # 5050
      6 #       print(mysum(4))  # 10
      7 
      8 
      9 #   1. 写一个函数mysum(n) ,此函数用来计算
     10 #      1 + 2 + 3 + 4 + ... + n 的和
     11 #      (要求: 不允许调用sum)
     12 #     如:
     13 
     14 def mysum(n):
     15     s = 0
     16     for x in range(1, n + 1):
     17         s += x
     18     return s
     19 
     20 print(mysum(100))  # 5050
     21 print(mysum(4))  # 10
     22 
    mysum1
      1 #   1. 写一个函数mysum(n) ,此函数用来计算
      2 #      1 + 2 + 3 + 4 + ... + n 的和
      3 #      (要求: 不允许调用sum)
      4 #     如:
      5 #       print(mysum(100))  # 5050
      6 #       print(mysum(4))  # 10
      7 
      8 
      9 # def mysum(n):
     10 #     s = 0
     11 #     for x in range(1, n + 1):
     12 #         s += x
     13 #     return s
     14 
     15 def mysum(n):
     16     return sum(range(1, n + 1))
     17 
     18 print(mysum(100))  # 5050
     19 print(sum(range(1, 101)))
     20 print(mysum(4))  # 10
     21 
    mysum2

    2. 写一个函数myfac(n) 来计算n!(n的阶乘)
         n! = 1*2*3*4*....*n
         如:
           print(myfac(5))  # 120

      1 #   2. 写一个函数myfac(n) 来计算n!(n的阶乘)
      2 #     n! = 1*2*3*4*....*n
      3 #     如:
      4 #       print(myfac(5))  # 120
      5 
      6 def myfac(n):
      7     s = 1
      8     for x in range(1, n + 1):
      9         s *= x
     10     return s
     11 
     12 print(myfac(5))  # 120
     13 print(myfac(3))  # 6
     14 
     15 
    myfac


       3. 写一个函数计算:
         1 + 2**2 + 3**3 + ... + n ** n的和
         (n给个小点的数来进行测试)

      1 #   3. 写一个函数计算:
      2 #     1 + 2**2 + 3**3 + ... + n ** n的和
      3 #     (n给个小点的数来进行测试)
      4 
      5 # 方法1
      6 # def mysum(n):
      7 #     s = 0
      8 #     for x in range(1, n + 1):
      9 #         s += x ** x
     10 #     return s
     11 
     12 # 方法2
     13 # def mysum(n):
     14 #     s = sum([x ** x for x in range(1, n + 1)])
     15 #     return s
     16 
     17 # 方法3
     18 def mysum(n):
     19     return sum(map(lambda x: x**x, range(1, n+1)))
     20 
     21 print(mysum(3))  # 32
     22 
     23 
    3

       4. 实现带界面的学生信息管理系统
         操作界面如下:
           +--------------------------+
           | 1) 添加学生信息            |
           | 2) 显示学生信息            |
           | 3) 删除学生信息            |
           | 4) 修改学生成绩            |
           | q) 退出                   |
           +--------------------------+
         学生信息包括: 姓名,年龄,成绩(与之前相同), 每个功能写一个
         函数与之相对应

      1 
      2 #   3. 改写之前的学生信息管理程序:
      3 #     用两个函数来封装功能的代码块
      4 #        函数1:  input_student()   # 返回学生信息字典的列表
      5 #        函数2:  output_student(L)  # 打印学生信息的表格
      6 
      7 def input_student():
      8     L = []  # 创建一个列表,准备存放学生数据的字典
      9     while True:
     10         n = input("请输入姓名: ")
     11         if not n:  # 如果用户输入空字符串就结束输入
     12             break
     13         a = int(input("请输入年龄: "))
     14         s = int(input("请输入成绩: "))
     15         d = {}  # 一定要每次都创建一个新的字典
     16         d['name'] = n
     17         d['age'] = a
     18         d['score'] = s
     19         L.append(d)   # 把d加入列表中L
     20     return L
     21 
     22 def output_student(L):
     23     print("+---------------+----------+----------+")
     24     print("|     姓名      |   年龄   |   成绩   |")
     25     print("+---------------+----------+----------+")
     26     for d in L:
     27         name = d['name']
     28         age = str(d['age'])  # 转为字符串
     29         score = str(d['score'])  # 转为字符串
     30         print("|%s|%s|%s|" % (name.center(15),
     31                             age.center(10),
     32                             score.center(10)))
     33     print("+---------------+----------+----------+")
     34 
     35 def delete_student(L):
     36     name = input("请输入要删除学生的姓名: ")
     37     i = 0  # i 代表列表的索引
     38     while i < len(L):
     39         d = L[i]  # d绑定字典
     40         if d['name'] == name:
     41             del L[i]
     42             print("删除", name, "成功!")
     43             break
     44     else:
     45         print("删除失败!")
     46 
     47 def modify_student_score(L):
     48     pass
     49 
     50 def show_menu():
     51     '''显示菜单'''
     52     print("+--------------------------+")
     53     print("| 1) 添加学生信息          |")
     54     print("| 2) 显示学生信息          |")
     55     print("| 3) 删除学生信息          |")
     56     print("| 4) 修改学生成绩          |")
     57     print("| q) 退出                  |")
     58     print("+--------------------------+")
     59 
     60 def main():
     61     infos = []  # 此列表用于保存学生数据
     62     while True:
     63         show_menu()
     64         s = input("请选择: ")
     65         if s == '1':
     66             infos += input_student()
     67         elif s == '2':
     68             output_student(infos)
     69         elif s == '3':
     70             delete_student(infos)
     71         elif s == '4':
     72             modify_student_score(infos)
     73         elif s == 'q':
     74             break
     75 
     76 main()
     77 
    4
  • 相关阅读:
    安利博客
    python 的高阶算法之堆排序
    functools模块用途
    类型注解
    高阶函数和装饰器
    生成器

    递归函数
    匿名函数
    函数 的 返回值作用域
  • 原文地址:https://www.cnblogs.com/shengjia/p/10321302.html
Copyright © 2011-2022 走看看