PYTOHN1.day14

day13回顾
自定义模块
   文件名: 标识符.py
        hello.py
   自定义模块内的全局变量将成为此模块的属性
     函数, 数据, 类
   模块的搜索顺序:
     1. 内建模块
     2. 当前工作目录
     3. sys.path提供的路径

   编译过程
     .py   ----> .pyc ----> python3

模块的属性:
     __doc__ 属性
        绑定文档字符串
     __file__ 属性
        绑定当前模块文件所在的路径
     __name__ 属性
        绑定模块名(主模块此属性绑定'__main__')

__all__ 列表
__all__ = ['name1', 'name2', ...]
限制from import * 语句只导入此列内的属性

隐藏属性:
以下划线(_) 开头的全局变量是隐藏属性
限制from import * 语句的导入

包
以文件夹形式进行管理模块的方式

导入:
    import 语句
    from import 语句
    from import * 语句

如：
      import mypack.games.contra as contra
      from mypack.games.contra import play
      from mypack.games.contra import *

搜索顺序
1. 当前工作目录
2. sys.path提供的路径

__init__.py
编写包的内容

__init__.py 里 __all__ 列表
记录当用from import * 导入时，导入哪儿些子包或模块

包的相对导入:
   from ..menu import show_menu
   from ..office.word import save
   from .games import *

随机模块 random 模块

day14 笔记

异常(基础) exception
   什么是错误
     错误是指由于逻辑或语法待导致一个程序无法正常执行的问题
   错误的特点:
      无法预知

什么是异常
     异常是程序出错时标识的一种状态
     当异常发生时，程序不会再向下执行，而转去调用此函数的地方待
       处理此错误并恢复为正常状态
   作用:
     用作信号，通知上层调用者有错误产生需要处理

try 语句的两种语法:
try-except 语句
try-finally 语句

try-except 语句
   语法:
     try:
         可能触发异常的语句
     except 错误类型1 [as 变量1]:
         异常处理语句1
     except 错误类型2 [as 变量2]:
         异常处理语句2
     except (错误类型3, 错误类型4) [as 变量3]:
         异常处理语句3
     ...
     except:
         异常处理语句other
     else:
         未发生异常语句
     finally:
         最终语句
   作用:
     偿试捕获异常错误，得到异常通知，将程序由异常流程转为正常流程
     并继续执行
   说明:
     as 子句是用于绑定错误对象的变量，可以省略
     except 子句可以有一个或多个，但至少要有一个
     else 子句最多只能有一个，也可以省略不写
     finally 子句最多只能有一个，也可以省略不写
   示例见:
     try_except.py

  1
  2
  3 # 此示例示意try-except语句的语法和用法
  4
  5 def div_apple(n):
  6     print(n, '个苹果你想分给几个人?')
  7     s = input('请输入人数: ')
  8     cnt = int(s)      # <-- 可能触发ValueError错误
  9     result = n / cnt  # <--可能触发ZeroDivisionError错误
 10     print("每个人分了", result, '个苹果')
 11
 12 try:
 13     div_apple(10)
 14     print("分苹果成功!")
 15 except ValueError:
 16     print("分苹果失败!,苹果被收回!")
 17 except ZeroDivisionError:
 18     print("没有人来，苹果自己吃了！")
 19
 20 print("程序正常退出")
 21
 22
 23

try_except.py

  1
  2
  3 # 此示例示意try-except语句的语法和用法
  4
  5 def div_apple(n):
  6     print(n, '个苹果你想分给几个人?')
  7     s = input('请输入人数: ')
  8     cnt = int(s)      # <-- 可能触发ValueError错误
  9     result = n / cnt  # <--可能触发ZeroDivisionError错误
 10     print("每个人分了", result, '个苹果')
 11
 12 try:
 13     div_apple(10)
 14     print("分苹果成功!")
 15 except ValueError as err:
 16     print("分苹果失败!,苹果被收回!")
 17     print("err=", err)
 18 except ZeroDivisionError:
 19     print("没有人来，苹果自己吃了！")
 20
 21 print("程序正常退出")
 22
 23
 24

  1
  2
  3 # 此示例示意try-except语句的语法和用法
  4
  5 def div_apple(n):
  6     print(n, '个苹果你想分给几个人?')
  7     s = input('请输入人数: ')
  8     cnt = int(s)      # <-- 可能触发ValueError错误
  9     result = n / cnt  # <--可能触发ZeroDivisionError错误
 10     print("每个人分了", result, '个苹果')
 11
 12 try:
 13     div_apple(10)
 14     print("分苹果成功!")
 15 except (ValueError, ZeroDivisionError) as err:
 16     print("分苹果失败!苹果被收回!")
 17
 18 # except ValueError:
 19 #     print("分苹果失败!苹果被收回!")
 20 # except ZeroDivisionError:
 21 #     print("分苹果失败!苹果被收回!")
 22
 23 print("程序正常退出")
 24
 25
 26

  1
  2
  3 # 此示例示意try-except语句的语法和用法
  4
  5 def div_apple(n):
  6     print(n, '个苹果你想分给几个人?')
  7     s = input('请输入人数: ')
  8     cnt = int(s)      # <-- 可能触发ValueError错误
  9     result = n / cnt  # <--可能触发ZeroDivisionError错误
 10     print("每个人分了", result, '个苹果')
 11
 12
 13 try:
 14     div_apple(10)
 15     print("分苹果成功!")
 16 except ValueError:
 17     print("分苹果失败!苹果被收回!")
 18 else:  # 此子句里的语句只有在此try内没有发生异常时才执行
 19     print("此try语句中没有发生错误，此else子句会执行!")
 20
 21
 22
 23 print("程序正常退出")
 24
 25
 26

  1
  2
  3 # 此示例示意try-except语句的语法和用法
  4
  5 def div_apple(n):
  6     print(n, '个苹果你想分给几个人?')
  7     s = input('请输入人数: ')
  8     cnt = int(s)      # <-- 可能触发ValueError错误
  9     result = n / cnt  # <--可能触发ZeroDivisionError错误
 10     print("每个人分了", result, '个苹果')
 11
 12
 13 try:
 14     div_apple(10)
 15     print("分苹果成功!")
 16 except ValueError:
 17     print("分苹果失败!苹果被收回!")
 18 finally:  # 此子句中的语句在结束try语句执行前一定会被执行
 19     print("这是try中的finally 语句，我一定会被执行")
 20
 21
 22
 23
 24 print("程序正常退出")
 25
 26
 27
 28
 29
 30
 31

练习:
   写一个函数 get_score() 来获取学生输入的成绩(0~100的整数),
   如果输入出现异常，则此函数返回0,否则返回用户输入的成绩
     如:
         def get_score():
             ... # 此处自己实现

score = get_score()
print("学生的成绩是", score)

  1 # 练习:
  2 #   写一个函数 get_score() 来获取学生输入的成绩(0~100的整数),
  3 #   如果输入出现异常，则此函数返回0,否则返回用户输入的成绩
  4 #     如:
  5 #         def get_score():
  6 #             ...  # 此处自己实现
  7
  8 #         score = get_score()
  9 #         print("学生的成绩是", score)
 10
 11
 12
 13 def get_score():
 14     s = input("请输入学生成绩(0~100): ")
 15     scr = int(s)  # 字符串转为整数
 16     if scr < 0 or scr > 100:
 17         return 0
 18     return scr
 19
 20 try:
 21     score = get_score()
 22 except ValueError:
 23     score = 0
 24
 25 print("学生的成绩是", score)
 26

get_score.py

  1 # 练习:
  2 #   写一个函数 get_score() 来获取学生输入的成绩(0~100的整数),
  3 #   如果输入出现异常，则此函数返回0,否则返回用户输入的成绩
  4 #     如:
  5 #         def get_score():
  6 #             ...  # 此处自己实现
  7
  8 #         score = get_score()
  9 #         print("学生的成绩是", score)
 10
 11
 12
 13 def get_score():
 14     s = input("请输入学生成绩(0~100): ")
 15     try:
 16         scr = int(s)  # 字符串转为整数
 17     except ValueError:
 18         return 0
 19     if scr < 0 or scr > 100:
 20         return 0
 21     return scr
 22
 23
 24 score = get_score()
 25
 26 # try:
 27 #     score = get_score()
 28 # except ValueError:
 29 #     score = 0
 30
 31 print("学生的成绩是", score)
 32

get_score2.py

python3 全部的错误类型
参见文档:
python_base_docs_html/python全部的异常类型.html

  1 Python全部的异常类型
  2 错误类型    说明
  3 ZeroDivisionError   除(或取模)零 (所有数据类型)
  4 ValueError  传入无效的参数
  5 AssertionError  断言语句失败
  6 StopIteration   迭代器没有更多的值
  7 IndexError  序列中没有此索引(index)
  8 IndentationError    缩进错误
  9 OSError 输入/输出操作失败
 10 ImportError 导入模块/对象失败
 11 NameError   未声明/初始化对象 (没有属性)
 12 AttributeError  对象没有这个属性
 13 BaseException   所有异常的基类
 14 SystemExit  解释器请求退出
 15 KeyboardInterrupt   用户中断执行(通常是输入^C)
 16 Exception   常规错误的基类
 17 GeneratorExit   生成器(generator)发生异常来通知退出
 18 StandardError   所有的内建标准异常的基类
 19 ArithmeticError 所有数值计算错误的基类
 20 FloatingPointError  浮点计算错误
 21 OverflowError   数值运算超出最大限制
 22 EOFError    没有内建输入,到达EOF 标记
 23 EnvironmentError    操作系统错误的基类
 24 OSError 操作系统错误
 25 WindowsError    系统调用失败
 26 LookupError 无效数据查询的基类
 27 KeyError    映射中没有这个键
 28 MemoryError 内存溢出错误(对于Python 解释器不是致命的)
 29 UnboundLocalError   访问未初始化的本地变量
 30 ReferenceError  弱引用(Weak reference)试图访问已经垃圾回收了的对象
 31 RuntimeError    一般的运行时错误
 32 NotImplementedError 尚未实现的方法
 33 SyntaxError Python  语法错误
 34 TabError    Tab 和空格混用
 35 SystemError 一般的解释器系统错误
 36 TypeError   对类型无效的操作
 37 UnicodeError    Unicode 相关的错误
 38 UnicodeDecodeError  Unicode 解码时的错误
 39 UnicodeEncodeError  Unicode 编码时错误
 40 UnicodeTranslateError   Unicode 转换时错误
 41 以下为警告类型
 42 Warning 警告的基类
 43 DeprecationWarning  关于被弃用的特征的警告
 44 FutureWarning   关于构造将来语义会有改变的警告
 45 OverflowWarning 旧的关于自动提升为长整型(long)的警告
 46 PendingDeprecationWarning   关于特性将会被废弃的警告
 47 RuntimeWarning  可疑的运行时行为(runtime behavior)的警告
 48 SyntaxWarning   可疑的语法的警告
 49 UserWarning 用户代码生成的警告

异常

查看全部的类型，详见:
>>> help(__builtins__)

try-finally语句
   语法:
     try:
         可能触发异常的语句
     finally:
         最终语句
   说明:
     finally 子句不可以省略
     一定不存在except子句
   作用:
     1. 通常用try-finally 语句来做触发异常时必须要处理的事
        情,无论异常是否发生，finally 子句都会被执行
   注:
     try-finally 语句不会改变程序的(正常/异常) 状态
   示例见:
     try_finally.py

  1 # try_finally.py
  2
  3 # 此示例示意try_finally语句的作用
  4
  5 def fry_egg():
  6     print("打开天燃气...")
  7     try:
  8         count = int(input("请输入鸡蛋个数: "))
  9         print("完成煎鸡蛋，共煎了%d个鸡蛋" % count)
 10     finally:
 11         print("关闭天燃气!")
 12
 13 try:
 14     fry_egg()
 15 except ValueError:
 16     print("煎蛋过程中出错！！！！")
 17

  1 # try_finally.py
  2
  3 # 此示例示意try_finally语句的作用
  4
  5 def fry_egg():
  6     try:
  7         print("打开天燃气...")
  8         try:
  9             count = int(input("请输入鸡蛋个数: "))
 10             print("完成煎鸡蛋，共煎了%d个鸡蛋" % count)
 11         finally:
 12             print("关闭天燃气!")
 13     except ValueError:
 14         print("煎蛋过程中出错！！！！")
 15
 16
 17 fry_egg()
 18

raise 语句
   作用:
     触发一个错误，让程序进入异常状态
     发送错误通知给调用者
   语法:
     raise 异常类型
     或
     raise 异常对象
     或
     raise # 重新触发上一次异常
   示例见:
     raise.py
     raise2.py
     raise3.py
     raise4.py

  1 # raise.py
  2
  3
  4 def make_except():
  5     print("函数开始...")
  6
  7     # int("AAAAA")  # int 函数内抛出异常
  8     # raise ValueError   # 触发ValueError类型的异常
  9     raise ZeroDivisionError
 10
 11     print("函数结束")
 12
 13
 14 try:
 15     make_except()
 16     print("make_except 调用完毕!")
 17 except ValueError:
 18     print("make_except 函数调用发生异常")
 19
 20 print("程序正常退出!")
 21
 22

  1 # raise.py
  2
  3
  4 def make_except():
  5     print("函数开始...")
  6
  7     # raise ZeroDivisionError
  8     error = ValueError("这是故意制造的错误！！！")
  9     raise error  # 发错误通知
 10
 11     print("函数结束")
 12
 13
 14 try:
 15     make_except()
 16     print("make_except 调用完毕!")
 17 except ZeroDivisionError:
 18     print("make_except 函数调用发生异常")
 19 except ValueError as err:
 20     print("发生了值错误!!!")
 21     print("发生错误的数据是:", err)
 22
 23 print("程序正常退出!")
 24
 25

  1 # raise3.py
  2
  3
  4 # 此示例示意用raise 无参调用来传递异常信息
  5
  6 def f1():
  7     print("f1开始...")
  8     raise ValueError("f1内部发生错误!")
  9     print("f1结束!!!")
 10
 11 def f2():
 12     try:
 13         f1()
 14     except ValueError as e:
 15         print("f2中已收到f1中发生的错误:", e)
 16         raise   # raise e  重新触发当前已捕获的错误！！！
 17
 18 try:
 19     f2()
 20 except ValueError as err:
 21     print("主程序中已收到f2中发生的错误:", err)
 22
 23

  1 # raise4.py
  2
  3 # 此示例示意用raise 语句来传递消息给调用者
  4 # 当用户输入的数字不是0~100之间的数时，用异常方式通知调用者
  5
  6 def get_score():
  7     '''此函数强制用户输入0~100之间的数，如果输入的是
  8     其它的数则直接触发异常来通知调用者'''
  9     score = int(input("请输入成绩: "))
 10     if score < 0:
 11         raise ValueError
 12     if score > 100:
 13         raise ValueError("成绩超出了最大值")
 14     return score
 15
 16
 17 try:
 18     score = 0
 19     score = get_score()
 20 except ValueError as err:
 21     print("用户输入有错，err=", err)
 22
 23 print("学生的成绩是:", score)

练习:
   写一个函数 get_age 用来获取一个人的年龄信息
     此函数规定用户只能输入1~140之间的整数，如果用户输入其它
     的数则直接触发ValueError类型的错误！
   如:
     def get_age():
         ... # 此处的逻辑自己实现
     try:
        age = get_age()
        print("用户输入的年龄是:", age)
     except ValueError:
         print("用户输入的不是1~140的整数，获取年龄失败")

  1 # 练习:
  2 #   写一个函数 get_age 用来获取一个人的年龄信息
  3 #     此函数规定用户只能输入1~140之间的整数，如果用户输入其它
  4 #     的数则直接触发ValueError类型的错误！
  5 #   如:
  6 #     def get_age():
  7 #         ...  # 此处的逻辑自己实现
  8 #     try:
  9 #        age = get_age()
 10 #        print("用户输入的年龄是:", age)
 11 #     except ValueError:
 12 #         print("用户输入的不是1~140的整数，获取年龄失败")
 13
 14
 15 def get_age():
 16     age = int(input("请输入年龄(1~140): "))
 17     if age < 1 or age > 140:
 18         raise ValueError("年龄不在有效的范围内!")
 19     return age
 20
 21 try:
 22     age = get_age()
 23     print("用户输入的年龄是:", age)
 24 except ValueError:
 25     print("用户输入的不是1~140的整数，获取年龄失败")
 26
 27

get_age

assert 语句(断言语句)
   语法:
     assert 真值表达式, 错误数据(通常是字符串)
   作用:
     当真值表达式为False时，用错误数据创建一个AssertionError
     类型的错误，并进入异常状态
   等同于:
     if bool(真值表达式) == False:
         raise AssertionError(错误数据)
示例见:
     assert.py

  1 # assert.py
  2
  3
  4 # 获取学生成绩:
  5 def get_score():
  6     s = int(input("请输入学生成绩: "))
  7     assert 0 <= s <= 100, '成绩超出范围!'
  8     # if bool(0 <= s <= 100) == False:
  9     #     raise AssertionError('成绩超出范围!')
 10     return s
 11
 12 try:
 13     score = get_score()
 14     print("学生成绩为:", score)
 15 except AssertionError:
 16     print("断言失败！")
 17
 18 print('程序正常退出!')
 19
 20

assert.py

为什么要用异常处理机制
在程序调用层数较深时，向主调函数传递错误信息需要层层return
返回比较麻烦，所以需要异常处理机制

示例见:
exception.py

  1 # exception.py
  2
  3
  4 def f1():
  5     err = ValueError("一个错误")
  6     raise err
  7
  8
  9 def f2():
 10     f1()
 11
 12 def f3():
 13     f2()
 14
 15 def f4():
 16     f3()
 17
 18 try:
 19     f4()
 20 except ValueError as err:
 21     print(err)

exception.py

异常小结:
   四条语句:
     try-except      捕获异常，把程序由异常状态转回正常状态
     try-finally     执行必须要执行的语名
     raise           发送错误通知
     assert          根据条件发送AssertionError类型的错误通知

迭代器 Iterator
   什么是迭代器
     迭代器是访问可迭代对象的工具
     迭代器是指用iter(obj) 函数返回的对象(实例)
     迭代器可以用next(it) 函数获取可迭代对象的数据
   函数
     iter(iterable) 从可迭代对象中返回一个迭代器，iterable
              必须是一个能够提供一个迭代器的对象
    next(iterator)   从迭代器iterator中获取下一个记录，如果
              无法获取下一条记录，则触发StopIteraton异常

说明:
迭代器只能往前取值，不会后退
用iter函数可以返回一个可迭代对象的迭代器

示例:
     L = [2, 3, 5, 7]
     it = iter(L) # it 绑定一个能访问L列表的迭代器
     print(next(it)) # 2 通过it 从可迭代对象中提取一个数据
     print(next(it)) # 3
     print(next(it)) # 5
     print(next(it)) # 7
     print(next(it)) # StopIteration

     # 访问range
     it = iter(range(1, 10, 3))
     print(next(it)) # 1
     print(next(it)) # 4
     print(next(it)) # 7
     print(next(it)) # StopIteration

迭代器的用途
迭代器对象能用next函数获取下一个元素，可以用迭代器对
任何的可迭代对象进行访问和遍历

示例见:
iterator.py

  1 # iterator.py
  2
  3
  4 L = [2, 3, 5, 7]
  5 # 如何遍历L中数据
  6 # 方法1
  7 # i = 0
  8 # while i < len(L):
  9 #     x = L[i]
 10 #     print(x)
 11 #     i += 1
 12
 13 # 方法2
 14 # for x in L:
 15 #     print(x)
 16
 17 # 方法3 用迭代器来遍历
 18 it = iter(L)
 19 while True:
 20     try:
 21         x = next(it)
 22         print(x)
 23     except StopIteration:
 24         break
 25
 26

iterator.py

练习:
   有一个集合:
     s = {'唐僧', '悟空', '八戒', '沙僧'}
   用for语句来遍历所有元素如下:
     for x in s:
         print(x)
     else:
         print("遍历结束")
   请将上面的for语句改写为while和语句迭代器实现

练习:
   1. 一个球从100米高空落下，每次落地后反弹高度为原高度的一半，再
     落下,写程序算出:
        1) 皮球在第10次落地后反弹的高度
        2) 皮球在第10次落地反弹后共经历多少米路程

  1 #   1. 一个球从100米高空落下，每次落地后反弹高度为原高度的一半，再
  2 #     落下,写程序算出:
  3 #        1) 皮球在第10次落地后反弹的高度
  4 #        2) 皮球在第10次落地反弹后共经历多少米路程
  5
  6 def get_last_height(height, times):
  7     '''height 原来的高度
  8        times 为反弹次数'''
  9     for _ in range(times):
 10         height /= 2  # 每次反弹高度为原高度的一半
 11     return height
 12
 13 print("皮球从100米高度落下反弹十次后高度为:",
 14       get_last_height(100, 10))
 15
 16
 17 def get_distance(height, times):
 18     meter = 0  # 用来记录总路程
 19     for _ in range(times):
 20         # 累加下落过程的路程
 21         meter += height
 22         height /= 2 # 计算返回后的高度
 23         # 累加反弹之后的路程
 24         meter += height
 25     return meter
 26
 27 print("皮球从100米高度落下反弹十次后的总路程为:",
 28     get_distance(100, 10))

ball.py

2. 分解质因数.输入一个正整数，分解质因数
     如:
       输入: 90
     打印：
     90 = 2*3*3*5
     (质因数是指最小能被原数整数的素数(不包括1))

  1 #   2. 分解质因数.输入一个正整数，分解质因数
  2 #     如:
  3 #       输入: 90
  4 #     打印：
  5 #     　　90 = 2*3*3*5
  6 #     (质因数是指最小能被原数整数的素数(不包括1))
  7
  8 def get_zhiyin_list(x):
  9     '''此函数返回x的质因数的列表
 10     如 x = 90
 11     返回[2, 3, 3, 5]
 12     '''
 13     L = []  # 准备存储质因数
 14     while x > 1:
 15         # 每次求取一个质因数，然后放在L中
 16         for i in range(2, x + 1):
 17             if x % i == 0:  # i一定是质因数
 18                 L.append(i)
 19                 x = int(x/i)
 20                 break  # 进入下一次while
 21
 22     return L
 23
 24 x = int(input("请输入正整数: "))
 25 L = get_zhiyin_list(x)
 26 L2 = (str(x) for x in L)
 27 print(x, '=', '*'.join(L2))
 28
 29
 30

3. 修改原学生信息管理程序，加入异常处理语句，让程序在任何情
况下都能按逻辑正常执行(不至于崩溃退出)
如: 输入年龄和成绩时输入字母会崩溃

  1 # file : menu.py
  2
  3
  4 def show_menu():
  5     '''显示菜单'''
  6     print("+--------------------------------+")
  7     print("| 1) 添加学生信息                |")
  8     print("| 2) 显示学生信息                |")
  9     print("| 3) 删除学生信息                |")
 10     print("| 4) 修改学生成绩                |")
 11     print("| 5) 按学生成绩高-低显示学生信息 |")
 12     print("| 6) 按学生成绩低-高显示学生信息 |")
 13     print("| 7) 按学生年龄高-低显示学生信息 |")
 14     print("| 8) 按学生年龄低-高显示学生信息 |")
 15     print("| q) 退出                        |")
 16     print("+--------------------------------+")
 17
 18

menu.py

  1 # file : main.py
  2
  3 from menu import show_menu
  4 from student_info import *
  5
  6 def main():
  7     infos = []  # 此列表用于保存学生数据
  8     while True:
  9         show_menu()
 10         s = input("请选择: ")
 11         if s == '1':
 12             infos += input_student()
 13         elif s == '2':
 14             output_student(infos)
 15         elif s == '3':
 16             delete_student(infos)
 17         elif s == '4':
 18             modify_student_score(infos)
 19         elif s == '5':
 20             output_by_score_desc(infos)
 21         elif s == '6':
 22             output_by_score_asc(infos)
 23         elif s == '7':
 24             output_by_age_desc(infos)
 25         elif s == '8':
 26             output_by_age_asc(infos)
 27         elif s == 'q':
 28             break
 29
 30 main()
 31

main.py

  1 # file: student.py
  2
  3 def input_student():
  4     L = []  # 创建一个列表,准备存放学生数据的字典
  5     while True:
  6         n = input("请输入姓名: ")
  7         if not n:  # 如果用户输入空字符串就结束输入
  8             break
  9         try:
 10             a = int(input("请输入年龄: "))
 11             s = int(input("请输入成绩: "))
 12         except ValueError:
 13             print("您的输入有错，请重新输入!!!")
 14             continue
 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
 51 def output_by_score_desc(L):
 52     def get_score(d):
 53         return d['score']
 54     L2 = sorted(L, key=get_score, reverse=True)
 55     output_student(L2)
 56
 57 def output_by_score_asc(L):
 58     L2 = sorted(L, key=lambda d:d['score'])
 59     output_student(L2)
 60
 61 def output_by_age_desc(L):
 62     L2 = sorted(L, key=lambda d:d['age'], reverse=True)
 63     output_student(L2)
 64
 65 def output_by_age_asc(L):
 66     L2 = sorted(L, key=lambda d:d['age'])
 67     output_student(L2)
 68
 69
 70
 71
 72

studnt.py

　4. 打印杨辉三角，只打印6层
        1
       1 1
      1 2 1
     1 3 3 1
    1 4 6 4 1
1 5 10 10 5 1

  1 # 　4. 打印杨辉三角，只打印6层
  2 #        1
  3 #       1 1
  4 #      1 2 1
  5 #     1 3 3 1
  6 #    1 4 6 4 1
  7 #  1 5 10 10 5 1
  8
  9 def get_next_line(L):
 10     '''此函数根据上一层L, 返回下一层数字列表
 11     如: L = [1, 2, 1]
 12     返回:  [1, 3, 3, 1]'''
 13     L2 = [1]  # 最左边的1
 14     # 计算中间的数字
 15     for i in range(len(L)-1):
 16         L2.append(L[i] + L[i+1])
 17
 18     # 添加最后一个1
 19     L2.append(1)
 20     return L2
 21
 22
 23 def get_yangui_list(n):
 24     '''此函数返回n层的杨辉三解的列表
 25     如 n 等于4 则返回
 26     [
 27         [1],
 28         [1, 1],
 29         [1, 2, 1],
 30         [1, 3, 3, 1]
 31     ]
 32     '''
 33     L = []  # 用来存放每一层的列表
 34     layer = [1]
 35     while len(L) < n:
 36         # 每次循环放入一层
 37         L.append(layer)
 38         layer = get_next_line(layer)  # 算出下一层
 39     return L
 40
 41
 42 def get_yangui_string_list(L):
 43     '''此函数 传入一个由数字列表组成的列表，返回字符串列表
 44     如: L = [[1], [1, 1], [1, 2, 1]]
 45     返回 ['1', '1 1', '1 2 1']'''
 46
 47     L2 = []  # 准备存放字符串
 48     for layer in L:
 49         s = ' '.join((str(x) for x in layer))
 50         L2.append(s)
 51     return L2
 52
 53 def print_yanghui_triangle(L):
 54     max_len = len(L[-1])
 55     for s in L:
 56         print(s.center(max_len))
 57
 58 L = get_yangui_list(10)  # 得到六层数据
 59 string_L = get_yangui_string_list(L)
 60 print_yanghui_triangle(string_L)
 61
 62
 63
 64
 65
 66
 67
 68

转载于:https://www.cnblogs.com/shengjia/p/10323035.html

PYTOHN1.day14相关推荐

黑马day14 过滤器概述amp;生命周期amp;运行过程
过滤器:当訪问一个web资源的时候,过滤器就在你訪问这个web资源的前进行拦截...在放行过后...filter过滤器也能够做一些其它的事情. 编写过滤器的步骤: 1.写一个过滤器类实现filter接 ...
Java基础day14
Java基础day14 Java基础day14-集合 1.Collection集合 1.1集合体系结构 1.2Collection集合概述和基本使用 1.3Collection集合的常用方法 1.4C ...
Day14作业三、编程题写一个Student类，属性：名字，年龄，分数，班级 (注意分包)
三.编程题写一个Student类,属性:名字,年龄,分数,班级 (注意分包) 写一个测试类:创建一个集合,里面装6个学生(有三个班级class01,class02,class03) 例如:list. ...
Day14作业二、有两个List集合怎么取两个无重复的并集
二.有两个List集合怎么取两个无重复的并集例如:list1 里面有 a,f,c,b,d list2 里面有c,a,s,h,k 最后的结果:a,f,c,b,d,s,h,k package Day ...
Day14作业一、完成下面的要求? 先创建一个工人类，属性：姓名，年龄，工资
Day14作业一.完成下面的要求? 先创建一个工人类,属性:姓名,年龄,工资 1)创建一个List,在List中增加三个工人,基本信息如下: 姓名.年龄.工资 zhang3.18.3000 li4. ...
【JAVA零基础入门系列】Day14 Java对象的克隆
[JAVA零基础入门系列](已完结)导航目录 Day1 开发环境搭建 Day2 Java集成开发环境IDEA Day3 Java基本数据类型 Day4 变量与常量 Day5 Java中的运算符 Day ...
[ASP.NET 控件实作 Day14] 继承 CompositeControl 实作 Toolbar 控件
之前我们简单介绍过继承 CompositeControl 来实作复合控件,在本文我们将以 Toolbar 控件为例,以复合控件的作法(继承 CompositeControl )来实作 Toolbar ...
LeetCode算法入门- Compare Version Numbers -day14
LeetCode算法入门- Compare Version Numbers -day14 题目描述: Compare two version numbers version1 and version2 ...
day14(xml 编写及解析)
编写 xml的组成: 1.文档的声明 <?xml version='1.0' encoding='UTF-8' standalone='yes'>xml 表示标签的名字encoding 编 ...

PYTOHN1.day14

PYTOHN1.day14相关推荐

最新文章

热门文章