python基础day14笔记

2018.7.19

day13回顾

自定义模块

  模块名.py

  模块名必须是标识符

三条导入语句

  import 语句

  from import 语句

  from import * 语句

__all__列表和以'__' 隐藏属性会对from import语句或from import * 语句产生影响

搜索路径顺序

  1，当前路径

  2，sys.path列表提供的路径

  3，索引系统内建模块

模块的预制属性

  __doc__

  __file__

  __name__

标准库模块

  随机模块 random

包 package

  __init__.py 每个包必须要有

包的导入

  import 语句

    import xxx .yyy .zzz

  from import 语句

    from xxx .yyy .zzz import aaa

  from import * 语句

    from xxx .yyy .zzz import *

day14

异常（基础）except

什么是错误

  错误是指由于逻辑或语法等导致一个程序已无法正常执行的问题

什么是异常

  异常时程序出错时标识的一种状态

  当异常发生时，程序不会再向下执行，而转去调用此函数的地方待处理此错误并恢复为正常状态

异常作用：

  用作信号，通知上层调用者有错误产生需要处理

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:

    异常处理语句（其它）

else：

    未发生异常语句

finally：

    最终语句

作用：

  尝试捕获异常,将程序转为正常状态并继续执行

try-except 语句说明：

1. except 子句可以有一个或多个，但至少要有一个 
2. else子句最多只能有一个,也可以省略 
3. finally子句最多只能有一个，也可以省略
4. as子句是用于绑定错误对象的变量，可以省略
5. else子句的语句将在此try语句没有发生异常时执行
6. fimally子句的语句在任何情况下都会执行

示例1：

# 此示例示意用try-except语句来捕获异常

def div_apple(n):
    """此示例用分苹果来示意捕获异常"""
    print("%d个苹果你想要分给几个人?" % n)
    s = input("请输入人数: ")
    cnt = int(s)  # <-此处可能会引起ValueError类型的错误
    result = n / cnt
    print("每个人分了", result, "个苹果")
try:
    print('开始分苹果')
    div_apple(10)
except ValueError:
    print("发生了值错误，已转为正常状态")
except ZeroDivisionError:
    print("发生了被零除的错误，苹果收回办公室")
print("程序正常退出")

  示例2：

# except 子句可以有一个或多个，但至少要有一个 
# 此示例示意用try-except语句来捕获异常

def div_apple(n):
    """此示例用分苹果来示意捕获异常"""
    print("%d个苹果你想要分给几个人?" % n)
    s = input("请输入人数: ")
    cnt = int(s)  # <-此处可能会引起ValueError类型的错误
    result = n / cnt
    print("每个人分了", result, "个苹果")
try:
    div_apple(10)
except (ValueError, ZeroDivisionError):
    # 以上两个类型的错误都会用相同的方法来处理
    print("发生了错误，苹果被收回")
print("程序正常退出")

示例3：

#except 异常处理语句（其它）
# 此示例示意用try-except语句来捕获异常

def div_apple(n):
    """此示例用分苹果来示意捕获异常"""
    print("%d个苹果你想要分给几个人?" % n)
    s = input("请输入人数: ")
    cnt = int(s)  # <-此处可能会引起ValueError类型的错误
    result = n / cnt
    print("每个人分了", result, "个苹果")
try:
    div_apple(10)
except ValueError:
    print("发生了值错误，苹果被收回")
except:
    print("发生了除了值错误以外的错误，在此处处理")
print("程序正常退出")

示例4：

# else子句的语句将在此try语句没有发生异常时执行
# 此示例示意用try-except语句来捕获异常
def div_apple(n):
    """此示例用分苹果来示意捕获异常"""
    print("%d个苹果你想要分给几个人?" % n)
    s = input("请输入人数: ")
    cnt = int(s)  # <-此处可能会引起ValueError类型的错误
    result = n / cnt
    print("每个人分了", result, "个苹果")
try:
    div_apple(10)
except ValueError:
    print("发生了值错误，苹果被收回")
else:
    # 此处语句只在没有发生异常时才会执行
    print("没有发生错误，苹果分完了")
print("程序正常退出")

示例5：

# as子句是用于绑定错误对象的变量，可以省略
# 此示例示意用try-except语句来捕获异常

def div_apple(n):
    """此示例用分苹果来示意捕获异常"""
    print("%d个苹果你想要分给几个人?" % n)
    s = input("请输入人数: ")
    cnt = int(s)  # <-此处可能会引起ValueError类型的错误
    result = n / cnt
    print("每个人分了", result, "个苹果")
try:
    div_apple(10)
except ValueError as err:
    print("发生了值错误，苹果被收回")
    print("错误的值是:", err)

print("程序正常退出")

示例6：

#fimally子句的语句在任何情况下都会执行 
#此示例示意用try-except语句来捕获异常
def div_apple(n):
    """此示例用分苹果来示意捕获异常"""
    print("%d个苹果你想要分给几个人?" % n)
    s = input("请输入人数: ")
    cnt = int(s)  # <-此处可能会引起ValueError类型的错误
    result = n / cnt
    print("每个人分了", result, "个苹果")
try:
    div_apple(10)
except ValueError:
    print("发生了值错误，苹果被收回")
else:
    # 此处语句只在没有发生异常时才会执行
    print("没有发生错误，苹果分完了")
finally:
    # 此子句内的语句无论是否发生异常都一定会执行
    print("我一定会执行的!!!!")
print("程序正常退出")

练习：

  写一个函数get_score() 来获取学生成绩，

  要求用户输入1-100的整数，如果输入出现异常，返此函数返回0，否则返回用户输入的成绩

  方法一：

def get_score():
    s = int(input("请输入成绩(0~100): "))
    if not (0 <= s <= 100):
        return 0
    return s


try:
    score = get_score()
except:
    score = 0
print("学生的成绩是:", score)

方法二：

def get_score():
    try:
        s = int(input("请输入成绩(0~100): "))
    except:
        return 0
    if not (0 <= s <= 100):
        return 0
    return s


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

python中全部的错误类型：

参见文档：点击

try-finally 语句

语法：

try:

    可能触发的语句

finally:

    最终语句

说明:

1. finally子句不可以省略
2. 一定不存在except子句

作用:

  通常用try-finally语句来做触发异常时必须要处理的事情

  无论异常是否发生，finally子句都会被执行

注意:

  try-finally 语句不会改变程序的（正常/异常）状态

示例1：

def fry_egg():
    print("打开天然气点燃．．．")
    try:    
        count=int(input('请输入鸡蛋个数: '))
        print('完成煎鸡蛋，并煎了%d个鸡蛋' % count)
    finally:
        print('关闭天然气')
try:
    fry_egg()
    print('煎鸡蛋成功！')
except ValueError:
    print('煎鸡蛋出现错误，已经转为正常')

示例2：

#try的嵌套,末尾煎鸡蛋成功，成不成都会执行
def fry_egg():
    try:
        print("打开天然气点燃．．．")
        try:    
            count=int(input('请输入鸡蛋个数: '))
            print('完成煎鸡蛋，并煎了%d个鸡蛋' % count)
        finally:
            print('关闭天然气')
    except ValueError:
        print('煎鸡蛋失败，并已经处理')

# try:
fry_egg()
# print('煎鸡蛋成功！')
# except ValueError:
#     print('煎鸡蛋出现错误，已经转为正常')

raise 语句

作用：

  触发一个错误，让程序进入异常状态

语法：

  raise 异常类型

  或

  raise异常对象

示例1：

  1，没有使用raise示例：

def make_exception():
    print('函数开始')
    print('函数结束')


make_exception()
print('make_exception调用结束')

  2，使用raise示例：

def make_exception():
    print('函数开始')
    #发出一个ValueError错误通知
    raise ValueError('这是错误的通知')
    print('函数结束')

try:
    make_exception()
    print('make_exception调用结束')

except ValueError as e:
    print('接收到ValueError类型的异常通知')
    print('错误的对象是', e)

示例2：

  1，没有使用raise示例：

# 此示例示意raise语句的用法


# 以下示意其它语言中不用异常机制，用返回值方式返回错误问题

def make_except(n):
   # 假设n必须是 0~100之间的数
   print("begin...")
   if n > 100:  # 传过的来参数无效，怎么告诉调用者呢？
       return -1
   if n < 0:
       return -2
   print("end")
   return 0


value = int(input("请输入一个整数:"))
r = make_except(value)
if r < 0:
   print("发生错误")
else:
   print("程序正常完成")

  2，使用raise示例：

# 此示例示意raise语句的用法

def make_except(n):
    # 假设n必须是 0~100之间的数
    print("begin...")
    if n > 100:  # 传过的来参数无效，怎么告诉调用者呢？
        raise ValueError
    if n < 0:
        raise ValueError("参数小于零错误:%d" % n)
    print("end")


value = int(input("请输入一个整数:"))
try:
    make_except(value)
except ValueError as e:
    # print("make_except 抛出了错误，此异常状态已处理")
    # print("错误的值是:", e)
    print("发生错误")

print("程序正常完成")

练习：

  写一个函数pet_age()用来获取一个人的年龄信息

  此函数规定用户只能输入1-140之间的整数，如果用户输入其它的数，则直接触发ValueError类型的错误通知

  如果用户输入的年龄大于140，则触发ValueError（‘年龄超出了正常值’）

  如果用户输入的年龄小于1，则触发ValueError（‘年龄太小...’）

答案：

def get_age():
    a=int(input('输入年龄(1-140): '))
    if a > 140:
        raise ValueError('年龄超出了正常值')
    if a < 1:
        raise ValueError('年龄太小...')
    return a


try:
    age=get_age()
    print('用户输入的年龄是：',age)
except ValueError as err:
    print('用户输入的不是1-140的整数，获取年龄失败')
    print('原因是:',err)

assert 语句（断言语句）

语法：

  assert 真值表达式，错误数据（通常是字符串）

作用：

  当真值表达式为False时，用错误数据创建一个AssertionError

  类型的错误，并进入异常状态

等同于：

if 真值表达式==False

raise AssertionError(错误数据)

示例：

def get_score():
    s = int(input("请输入学生成绩: "))
    assert 0 <= s <= 100, '成绩超出范围'
    # if not (0 <= s <= 100):
    #     raise AssertionError('成绩超出范围')
    return s


try:
    score = get_score()
except AssertionError as err:
    print("错误数据是:", err)
    print('获取成绩失败')
    score = 0

print("学生的成绩为:", score)

小结：

异常处理语句（四条）：

try-except 语句：

    用于接收异常通知，捕获异常

try-finally 语句：

    执行必须要执行的内容

raise 语句：

    发送异常通知，并进入异常状态

assert 语句：

    根据条件选择性的发送AssertionError类型的异常通知

为什么要异常处理机制：

  在程序调用层数较深时，向主调函数传递错误信息需要层层return返回比较麻烦，

  用异常处理机制可以较简单的传送错误信息

示意：

  不使用异常处理语句时：

def f1():
    print("开始盖房子打地基")
    err = ValueError("挖出文物停工")
    return err
    print("地基完成")

def f2():
    print("开始盖房子地上部分")
    print("房子盖完了")

def f3():
    '第二承包商'
    r = f1()
    if r is not None:
        return r
    f2()

def build_house():
    '第一承包商'
    r = f3()
    return r


r = build_house()
print(r)

#直接运行得：
#开始盖房子打地基
#挖出文物停工

  使用异常处理语句时：

def f1():
    print("开始盖房子打地基")
    err = ValueError("挖出文物停工")
    raise err
    print("地基完成")

def f2():
    print("开始盖房子地上部分")
    raise ValueError("要建高压线停工")
    print("房子盖完了")

def f3():
    '第二承包商'
    f1()
    f2()

def build_house():
    '第一承包商'
    f3()


try:
    build_house()
except ValueError as e:
    print(e)

#直接运行
#开始盖房子打地基
#挖出文物停工

练习：

1，一个球从100米高度落下，每次落地后反弹高度为原高度的一半，再落下， 
  1) 写程序算出皮球从第10次落地后反弹高度是多少？ 
  2) 球共经过多少米路径?

解析：

def fantan(height, times):
    '''height 原始高度
    times 次数'''
    for _ in range(times):
        height /= 2
    return height


def lucheng(height, times):
    s = 0
    for _ in range(times):
        s += height + height / 2
        height /= 2
    return s

print('从100米反弹十次后高度是:', fantan(100, 10))
print('从100米反弹十次后经历的路程是:', lucheng(100, 10))

2，分解质因数: 输入一个正整数，分解质因数:

   如输入: 90 则打印: 90 = 2*3*3*5 
  (质因数是指最小能被原数整除的素数(不包含1))

递归方式实现：

def is_primes(x):
    if x <= 2:
        return False
    for i in range(2, x):
        if x % i == 0:
            return False
    return True
    

def get_zhiyishu(n):
    '''递归方式实现'''
    L = []
    # 如果n已经为素数，终止递归，把L 返回回去
    if is_primes(n):
        L.append(n)
        return L
    for i in range(2, n):
        if n % i == 0:
            L.append(i)  # i是质数数
            n = int(n / i)  # 转为整数
            L += get_zhiyishu(n)
            break  # 此处一定要加break 来终止循环
    return L


n = int(input("请输入一个数: "))
print(n, "的质因数是:", get_zhiyishu(n))

循环来实现：

def is_primes(x):
    if x <= 2:
        return False
    for i in range(2, x):
        if x % i == 0:
            return False
    return True


def get_zhiyishu(n):
    L = []
# 如果n不是素数就循环取出一个质因数
    while not is_primes(n):
        for i in range(2, n):
            if n % i == 0:
                L.append(i)  # i是质数数
                n = int(n / i)  # 转为整数
                break
    else:  # n一定为最后一个质因数
        L.append(n)
    return L



n = int(input("请输入一个数: "))
print(n, "的质因数是:", get_zhiyishu(n))

3，修改学生信息管理程序，加入异常处理语句，让程序在任何情况下都能够按逻辑正常执行

  例如：

  输入成绩和年龄时，如果用户输入非法字符串也不会导致程序崩溃