Python之路，第十五篇：Python入门与基础15

python3   异常

异常（基础）

什么是错误？

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

什么是异常？

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

try / except / else/ finally 语句

语法：

try:
　　可能触发异常的语句
except 　错误类型1 [as 变量1]：
　　异常处理语句1
except    错误类型2 [as 变量2]：
　　异常处理语句2
except    (错误类型3, 错误类型4, ...) [as 变量3]：
　　异常处理语句3
...
except:
　　异常处理语句other
else:
　　未发生异常语句
finally:
　　最终语句

语法说明:
　　except    子句可以有一个或多个,但至少要有一个
　　as     子句是用于绑定错误对象的变量,可以省略
　　else   子句最多只能有一个,也可以省略
　　finally   子句最多只能有一个,也可以省略不写

处理说明:
1.    except子句用来捕获和处理当某种类型的错误发生时,处理异常
2.    except 子句会根据错误的类型进行匹配,如匹配成功则调用异常处理语句进行处理,然后程序转为正常状态
3.    如果except子句没有匹配到任何类型的异常则转到except:子句
4.   如果没有任何except子句进行处理,则程序的异常状态会继续下去,并向上层传递
5.    如果没有异常,则执行else 子句中的语句
6.    最后执行finally子句中的语句

练习:
写一个程序,输入学生成绩(0~100之间的整数),如果输入出现异常,则设置此成绩变量的值为0

Python中的错误类型 ：
ZeroDivisionError 　　 除(或取模)零
StopIteration 　　　　 迭代器没有更多的值
OverflowError 　　　  数值运算超出最大限制
IOError 　　　　　　 输入/输出操作失败
ImportError 　　　　 导入模块错误
GeneratorExit 　　     生成器发生异常来通知退出
IndexError 　　　 　 序列中没有此索引
FloatingPointError 　 浮点计算错误
IndentationError 　　 缩进错误
TypeError 　　　　 对类型无效的操作
ValueError 　　　　 传入无效的参数
AssertonError　　　 断言语句失败
NameError 　　　    未声明/初始化对象
AttributeError 　　    对象没有这个属性
KeyboardInterrupt 　 用户中断执行(通常是输入Ctrl+c)
更多见: >>> help(__builtins__)

 def div_apple(n):
     print("现在有", n, "个苹果,请问分给几个人")
     d = int(input("请输入人数:"))
     print("每个人分", n / d, "个苹果")

 try:
     div_apple(10)
 except ValueError as err:
     print("出现在值错误异常")
     print(err)
 except ZeroDivisionError:
     print("出现在被除数为零的错误,已转为正常状态")
 except:
     print("程序出现错误,已纠正!")
 else:
     print("这是else 子句,被执行了")
 finally:
     print("这是finnaly子句,我一定会被执行")

 print("程序结束!")

 def div_apple(n):
     print("现在有", n, "个苹果,请问分给几个人")
     try:
         d = int(input("请输入人数:"))
         print("每个人分", n / d, "个苹果")
     except ZeroDivisionError:
         print("div_apple中已处理被零除错误")

 try:
     div_apple(10)
 except:
     print("程序出现错误,已纠正!")
 else:
     print("程序没有异常")
 print("程序结束!")

try / finally 语句
语法:
try:
　　可能触发异常的语句
finally:
　　最终语句
说明:
　　1.    finally子句不可以省略
　　2.    一定不存在except 子句

作用:
　　通常用try / finally语句来做触发异常时必须要处理的事情,无论异常是否发生,finally子句都会被执行

注:
try / finally语句不会改变程序的(正常/异常)状态
示例见:try_finally.py

 def frag_egg():
     print("打个鸡蛋")
     print("打开天燃气...")
     print("找油")
     try:
         old = int(input("请输入油的位置:"))
         print("煎鸡蛋")
     finally:
         print("关闭天燃气")
     # 此处出现异常
     # 3/0

 # frag_egg()

 try:
     frag_egg()
 except:
     print("处理完相应的事儿...")

 print("工作完成,可以就餐了....")

try嵌套 :
示例:
try:
　　try:
　　　　d = int(input("输入一个数:"))
　　　　a = 3 / d
　　finally:
　　　　print("内部finally已执行")
except:
　　print("有异常发生")
finally:
　　print("外部finally已执行")

raise语句
作用：生成一个错误，让程序进入异常状态；
语法：
raise 异常状态
或
raise 异常对象

 def make_except():
     print("开始")
     raise ValueError("值错误")
     print("结束") #不执行

 try:
     make_except()
     print("ABCD") #不执行
 except ValueError as e:
     print("发生错误，值为：",str(e))
 except:
     print("发现错误且已处理")
 print("程序错误")

 #开始
 #发生错误，值为： 值错误
 #程序错误

 def f(x,y):
     if y == 0:
         raise ZeroDivisionError("y的值为0")
     return x / y

 try:
     f(100,0)
 except:
     print("发生被零除的错误")

 #发生被零除的错误

assert 语句（断言语句）
语法：
assert 真值表达式， 错误数据（通常字符串）
作用：
当真值表达式为False时， 用错误数据创建一个 AssertionError类型的错误，抛出后进入异常状态；
等同于：
if 真值表达式 == False：
raise AssertionError（错误数据）

 def get_score():
     p = int(input("学生的成绩为："))
     if p > 100:
         raise AssertionError("错误，成绩不能大于100！")
     return p

 try:
     score = get_score()
     print("学生的成绩是：",score)
 except AssertionError as err:
     print(err)

 ##########
 def get_score():
     p = int(input("学生的成绩为："))
     assert p <= 100, "错误，成绩不能大于100！"
     #if p > 100:
     #    raise AssertionError("错误，成绩不能大于100！")
     return p

 try:
     score = get_score()
     print("学生的成绩是：",score)
 except AssertionError as err:
     print(err)

迭代器Interator 和生成器 gennerator
什么是迭代器;
迭代器是指能用next（it）函数取值的对象（实例）
说明：
用iter函数可返回一个可迭代对象的迭代器
迭代器是访问可迭代对象的一种方式；
迭代器只能往前，不会后退；
函数
iter(x)
从一个对象x中返回迭代器，x必须能够提供一个迭代器的对象next（it）， 从迭代器it中获取下一个记录，如果无法获取下一条记录，则触发StopIteration异常；
#例子：

 L = [1,1,2,3,5]
 it = iter(L)
 print(next(it)) #
 print(next(it))  #
 print(next(it))  #
 print(next(it))  #
 print(next(it))  #
 print(next(it))  #StopIteration异常
 #例子2
 it = iter(range(1,10,3))
 print(next(it))
 print(next(it))
 print(next(it))
 try:
     print(next(it))
 except StopIteration:
     print("iteration取值结束")
 #执行结果
 #
 #
 #
 #iteration取值结束
 #

 #打印1-10的奇数
 it = iter(range(1,10,2))
 try:
     while True:
         print(next(it))
 except StopIteration:
     print("程序结束")
     #pass

 ##
 #
 #
 #
 #
 #
 #程序结束

生成器generator
生成器是能够提供迭代器的对象（实例）；
生成器函数
含有yield语句的函数是生成器函数；
注：yield（生成或生产）
yield语句
语法：
yield 表达式
说明：yield用于def函数中，目的是将此函数作为生成器函数使用；
yield用来生成数据，供迭代器next（it）函数使用；
#例子：

 def my_yield():
     print("yield2  之前")
     yield 2
     print("yield3  之前")
     yield 3
     print("yield5  之前")
     yield 5
     print("yield7  之前")
     yield 7
     print("生成器函数调用结束")

 it = iter(my_yield())
 print(next(it)) #
 print(next(it)) #
 print(next(it)) #
 print(next(it)) #
 print(next(it)) #"生成器函数调用结束" ，触发StopIteration异常

说明：
生成器函数的调用将返回一个生成器对象，生成器对象是可迭代对象；
在生成器函数内调用return，会产生一个StopIteration异常；

 def my_yield():
     yield 2
     yield 3
     return "我是生成器函数里的return语句"
     #raise StopIteration（"我是生成器函数里的return语句"）

 it = iter(my_yield())
 print(next(it))
 print(next(it))
 print(next(it))
 #StopIteration: 我是生成器函数里的return语句
 #
 #

练习1

 #写一个生成器函数 my_yield(x)，传入一个终止值，可生成一个生成1,3,5...x奇数的生成器；
 #
 #
 def my_yield(n):
     L = []
     x = 1
     while  x <= n:
         L.append(x)
         x += 2
     return L

 for y in my_yield(10):
     print(y, end=' ')
 #1 3 5 7 9
 def my_yield2(n):
     x = 1
     while x <= n:
         yield x
         x += 2

 for y in my_yield2(10):
     print(y, end=' ')

 #1 3 5 7 9

练习2

 #写一个生成器函数 myrange（stop）来生成一系列整数，
 #要求：myrange与range功能完全一样，不允许调用range函数
 #def myrange(stop):
 #    return range(stop)
 #
 #print([x for x in myrange(10)])
 ##print([x for x in myrange(5,10)])
 ##print([x for x in myrange(5,10,2)])
 #for x in range(10)
 #    print(x)
 #def myrange(s, *args):
 #    return range(s, *args)
 #
 #print([x for x in myrange(10)])
 #print([x for x in myrange(5,10)])
 #print([x for x in myrange(5,10,2)])
 #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 #[5, 6, 7, 8, 9]
 #[5, 7, 9]
 #def myrange(s, e=0, step=1):
 #    return range(s,e,step)
 #
 ##print([x for x in myrange(10)])
 #print([x for x in myrange(5,10)])
 #print([x for x in myrange(5,10,2)])
 ##
 def myrange(s, *args):
     if len(args) == 1:
         start = s
         stop = args[0]
         step = 1
     elif len(args) == 2:
         start = s
         stop,step = args
     else:#只有一个参数传入时
         start = 0
         stop = s
         step = 1
     while start < stop:
         yield start
         start += 1

 print([x for x in myrange(10)])
 print([x for x in myrange(5, 10)])
 print([x for x in myrange(5, 10, 2)])

生成器表达式
语法：
(表达式 for 变量 in 可迭代对象 [ if 真值表达式])
注： if 子句可以省略
作用：用推导式形式生成一个新的生成器（可迭代对象）

 a = [ x for x in range(10) if x % 2 ==1]
 print(a) #[1, 3, 5, 7, 9]
 b = ( x for x in range(10) if x % 2 ==1)
 print(b) #<generator object <genexpr> at 0x00000000021E2A20>
 print(next(b))#
 print(next(b))#
 print(next(b))#
 print(next(b))#
 print(next(b))#
 print(next(b))#StopIteration异常

迭代工具函数
作用;生成一个个性化的可迭代对象；
语法：
zip(iter1[, iter2[...]])
返回一个zip对象，此对象用于生成一个元组，此元组的个数由最小的可迭代对象决定；

enumerate(iterable [, start])
生成带索引的迭代器，返回的迭代类型为索引-值对（index - value）对，默认索引从0开始，也可以用start指定；

 numbers = [ 10086, 10000, 10010, 95588]
 names = ["中国移动","中国电信","中国联通"]
 zip_m = zip(numbers, names)
 for nu, name in zip_m:
     print(name,"的客服电话是：", nu)

 #中国移动 的客服电话是： 10086
 #中国电信 的客服电话是： 10000
 #中国联通 的客服电话是： 10010

 #zip 应用： 字典
 d = dict(zip(numbers, names))
 print(d)
 #{10000: '中国电信', 10010: '中国联通', 10086: '中国移动'}

 names = ["刘备","关羽", "张飞"]
 for nu, n in enumerate(names,1):
     print("第",nu,"个是：",n)

 #第 1 个是： 刘备
 #第 2 个是： 关羽
 #第 3 个是： 张飞

文件
什么是文件
        文件是存储数据的单位，通常用于长期存储数据；
文件分为普通文件和设备文件；
       普通文件是文件名和文件中的数据两部分组成；
文件的打开和关闭
       文件是需要在使用时先打开才能读写；
       在不使用文件时要关闭，应该及时关闭文件以释放系统资源；
       任何操作系统，打开的文件数有最大限制；

打开的文件函数：
      open(file , mode='r')

#用于打开一个文件，返回此文件的操作对象，如果打开文件失败则触发错误，抛出异常；

文件关闭方法：
     F.close()      #关闭文件

文本文件的常用方法：
F.readline() 读取一行数据，如果到达文件尾则返回空行；（字符串包含行尾/n）
F.readlines(n) 返回每行字符串的列表，n代表最大字符数（字节数）
F.writelines(lines) 写入字符串中的列表

f.write(x)  将数据（字符/字节）写入到文件中
F.flush() 把写入文件对象的缓存内容写入的磁盘；

练习1

 #第一种
 f = open('test_data1.txt ', mode='r')
 while True:
     s = f.readline()
     if len(s) == 0: break
     s = s.rstrip() #去掉‘\n’
     l = s.split(' ')
     print("姓名：",l[0],"电话：",l[1])
 f.close()
 #第二种
 f = open('test_data1.txt ', mode='r')
 L = f.readlines()
 #print(L)
 for s in L:
     s = s.rstrip()
     l = s.split(' ')
     print("姓名：",l[0],"电话：",l[1])
 f.close()
 #
 try:
     f = open('test_data1.txt ', mode='r')
     L = f.readlines()
     #print(L)
     for s in L:
         s = s.rstrip()
         l = s.split(' ')
         print("姓名：",l[0],"电话：",l[1])
     f.close()
 except IOError:
     print("打开文件失败")
 except:
     f.close()
     print("文件已关闭")

 print("程序结束")

模式文件字符串的含义：
‘r’ 指以只读的方式打开文件（默认）
‘w’ 指以写的方式打开文件，删除原文件内容（如果文件不存在，则创建该文件并以只写的方式打开文件）
‘x’ 创建一个新文件，并以写的模式打开，如果文件存在则会产生FileExistError错误；
‘a’ 以追加写方式打开一个文件，如果有原文件则追加到原文件末尾；
‘b’ 用二进制模式打开
‘t’ 用文本文件模式打开（默认）
‘+’ 为更新内容打开一个磁盘文件（可读可写）
注：缺省模式是‘rt’ 帮助help（open）

 #f = open('newfile.txt','w')
 #f.writelines(['aaa','bbb','ccc'])   #创建文件写入内容aaabbbccc
 #
 #f.close()
 #
 #f = open('newfile.txt','w')
 #f.writelines(['aaa\n','bbb\n','ccc\n'])
 #f.writelines(['ddd\n'])
 #f.close()
 #返回结果
 #aaa
 #bbb
 #ccc
 #ddd
 #
 f = open('newfile.txt','w')
 f.writelines(['aaa\n','bbb\n','ccc\n'])
 f.writelines(['ddd\n'])
 f.write('eeee\n')
 f.close()
 #aaa
 #bbb
 #ccc
 #ddd
 #eeee

二进制文件

bytes 类型和 bytearray类型
汉字编码
bytes 类型
以字节为单位存储数据，每个字节的值为0-255 [2**8 -1]

字符串可能是Unicode字符，字节是0-255之间的数
bytes 常量的表示方式：
b'' 空字节串
b'ABCD' 有四个字节的字节串
b'\x41\x42' 有两个字节的字节串
bytes运算(不能包含中文字节串)
+ 、 += 、 * 、 *=
< 、<= > >= == !=
in / not in
bytes 相关的函数：
len（x） 求字节的个数
max（x）
min（x）
sum（x）
any(x)
all(x)

 b''
 b''
 b''
 b''
 b' '
 b' '
 b'ABCD'
 b'ABCD'
 b=b'ABCD'
 type(b)
 <class 'bytes'>
 a=b'EF'
 a+b
 b'EFABCD'
 a += b
 a
 b'EFABCD'
 a
 b'EFABCD'
 b
 b'ABCD'
 b * 3
 b'ABCDABCDABCD'
 b *= 3
 b
 b'ABCDABCDABCD'
 b'AB' > b'AB'
 False
 b'ac' > b'ab'
 True
 b'ab' != b'AB'
 True
 b'\xff' < b'\xee'
 False
 b
 b'ABCDABCDABCD'
 b'A' in b
 True
 b'E' not in b
 True

创建字节串（bytes）的函数
bytes（）创建空的字节串
bytes (整数)
bytes（整型可迭代对象）
bytes（字符串，encoding='utf-8'）

字节串可以看做序列，
字节串是不可变的，
>>>help（bytes） 查看帮助

一个汉字（字符）占三个字节串

bytes和str转换
str --> bytes

str.encode(encoding='utf-8') 方法来转换

例：b = "英文abc".encode('utf-8')

bytes ---> str

B.decode(encoding='utf-8')
例：
b'\xe8\x8b\xb1\xe6\x96\x87abc'.decode('utf-8')

 >>> bytes()
 b''
 >>> bytes(10) #生成10个空字节串
 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 >>> bytes([0x41, 0x62, 99, 100])
 b'Abcd'
 >>> bytes([0x41, 0x62, 99, 257])
 Traceback (most recent call last):
   File "<pyshell#3>", line 1, in <module>
     bytes([0x41, 0x62, 99, 257])
 ValueError: bytes must be in range(0, 256)
 >>> bytes(range(65, 65+26))
 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 >>> bytes("ABCD", 'utf-8')
 b'ABCD'

 >>> bytes("ABCD中文",'utf-8')
 b'ABCD\xe4\xb8\xad\xe6\x96\x87'
 >>> bytes("ABCD中",'utf-8')
 b'ABCD\xe4\xb8\xad'
 >>> b1 = bytes("ABCD中",'utf-8')
 >>> for x in b1:
     print(x, end=' ')

 65 66 67 68 228 184 173
 >>> "英文abc".encode('utf-8')
 b'\xe8\x8b\xb1\xe6\x96\x87abc'
 >>> b = "英文abc".encode('utf-8')
 >>> b
 b'\xe8\x8b\xb1\xe6\x96\x87abc'
 >>> b'\xe8\x8b\xb1\xe6\x96\x87abc'.decode('utf-8')
 '英文abc'
 >>> b.decode('utf-8')
 '英文abc'
 >>>