day 20 异常
# 什么是异常 # IndexError [][1] # KeyError {}['key'] # pickle.load() EOFError # FileNotFoundError open('aa') # ModuleNotFoundError import aaaaaaaaaaa # ValueError int('sdjkhf') # 语法错误 应该在写代码的时候就规避掉 # SyntaxError # NameError name
# 什么时候最容易出异常 # 当你要处理的内容不确定的时候 # 有用户参与 # 有外界数据接入 : 从文件中读 从网络上获取
# 当有多行报错的时候是为什么? # def func1(): # name # # def func2(): # func1() # # def main(): # func2() # # main() # 在嵌套调用的过程中,内部的代码出了问题,外部所有的调用的地方都成为报错追溯信息的一部分 # 怎么解决 # 从下往上找 首先找到你写的代码 出错的那一行 # 看看能不能看出问题 # 就把报错的最后一行 错误类型和详细提示贴到百度里,结合报错的那一行解决问题 # 单分支 # l = ['login','register'] # for num,i in enumerate(l,1): # print(num,i) # # try: # num = int(input('num >>>')) # print(l[num - 1]) # except ValueError : # except处理的异常必须和实际报错的异常是相同的 # print('请输入一个数字') # print(l[num - 1]) # 多分支 # l = ['login','register'] # for num,i in enumerate(l,1): # print(num,i) # # try: # num = int(input('num >>>')) # print(l[num - 1]) # except ValueError : # # 从上向下报错的代码只要找到一个和报错类型相符的分支就执行这个分支中的代码,然后直接退出分支 # print('请输入一个数字') # except IndexError : # # 如果找不到能处理和报错类型相同的分支,会一直往下走,最后还是没有找到就会报错 # print('只能输入1或2')
# 多分支合并 # l = ['login','register'] # for num,i in enumerate(l,1): # print(num,i) # # try: # num = int(input('num >>>')) # print(l[num - 1]) # except (ValueError,IndexError) : # print('您输入的内容不合法') # 万能异常 # def buy(): # print('buy') # name # # def back(): # print('back') # [][1] # # def show(): # print('show') # 1/0 # # def main(): # l = [('购物',buy),('退货',back),('查看订单',show)] # while True: # for num,i in enumerate(l,1): # print(num,i[0]) # num = int(input('num >>>')) # print(l[num - 1]) # try: # func = l[num - 1][1] # func() # except Exception: # print('用户在选择了%s操作之后发生了不可知的异常' % l[num - 1][0]) # # main()
# as语法 能够将具体错误信息打印出来 # def buy(): # print('buy') # name # # def back(): # print('back') # [][1] # # def show(): # print('show') # 1/0 # # def main(): # l = [('购物',buy),('退货',back),('查看订单',show)] # while True: # for num,i in enumerate(l,1): # print(num,i[0]) # num = int(input('num >>>')) # print(l[num - 1]) # try: # func = l[num - 1][1] # func() # except Exception as e: # print(e) # #print(e.args,e.__traceback__.tb_lineno,e.__traceback__.tb_frame) # print('用户在选择了%s操作之后发生了不可知的异常' % l[num - 1][0]) # # main() # 万能异常,相当于except Exception # try: # name # [][1] # int('aaa') # except: # print(123) # 多分支 + 万能异常 : 万能异常应该永远放在异常处理的最下面 # def buy(): # print('buy') # name # # def back(): # print('back') # [][1] # # def show(): # print('show') # 1/0 # # def main(): # l = [('购物',buy),('退货',back),('查看订单',show)] # while True: # for num,i in enumerate(l,1): # print(num,i[0]) # try: # num = int(input('num >>>')) # print(l[num - 1]) # func = l[num - 1][1] # func() # except (ValueError,IndexError) : # print('您输入的内容不合法') # except Exception as e: # print(e) # #print(e.args,e.__traceback__.tb_lineno,e.__traceback__.tb_frame) # print('用户在选择了%s操作之后发生了不可知的异常' % l[num - 1][0]) # main() # try: # pass # except (ValueError,IndexError): # print('针对性的处理') # except Exception as e: # print(e) # print('通用性的处理')
# else分支 # try: # print('aaa') # 给某某某发邮件 # # name # # [][1] # # 1/0 # except NameError: # 网络不稳定,邮箱地址错误 # print('name error') # except IndexError: # print('index error') # except Exception as e: # print('Exception') # else: # 当try中的代码不发生异常的时候 走else分支 如果发送成功了 进行一些处理 # print('else')
# finally分支 # try: # print('aaa') # 给某某某发邮件 # name # # [][1] # # 1/0 # except NameError: # 网络不稳定,邮箱地址错误 # print('name error') # except IndexError: # print('index error') # except Exception as e: # print('Exception') # else: # 当try中的代码不发生异常的时候 走else分支 如果发送成功了 进行一些处理 # print('else') # finally: # 无论如何都会被执行 # print('finally') # def func(): # f = open('file') # try: # while True: # for line in f: # if line.startswith('a'): # return line # except: # print('异常处理') # finally: # 即使return也会先执行fianlly中的代码 # f.close() # try: # f = open('www','w') # f.read() # finally: # 即使遇到报错,程序结束,也会先执行finally中的代码,然后再结束程序 # f.close() # print('文件已经关闭了')
finally用来回收一些操作系统的资源 : 数据库连接 打开的文件句柄 网络连接
异常处理的几种情况
try ... except
try ... except ... else
try ... finally
try ... except ... finally
try ... except ... else ... finally
主动抛出异常 : 是给其他开发者用的
raise ValueError
raise ValueError('你写的不对')
django是别人写的程序 框架 --> 程序员用
断言 - 语法
assert 1==2 # 只能接受一个布尔值 False
assert 1==1 # 只能接受一个布尔值 False
print(123456)
# if 1 == int(input()): # pass # else: # raise AssertionError
自定义异常 :面向对象之后
异常处理的忠告,在最外层的异常处理应该在所有的开发结束之后才放
main()
sdhjlkghl
# try: # main() # except Exception as e: # 把e报错写到文件里
计算器例题
import re def atom_cal(exp): if '*' in exp: a,b = exp.split('*') return str(float(a) * float(b)) elif '/' in exp: a, b = exp.split('/') return str(float(a) / float(b)) def format_exp(exp): exp = exp.replace('--','+') exp = exp.replace('+-','-') exp = exp.replace('-+','-') exp = exp.replace('++','+') return exp def mul_div(exp): while True: ret = re.search('\d+(\.\d+)?[*/]-?\d+(\.\d+)?',exp) if ret: atom_exp = ret.group() res = atom_cal(atom_exp) exp = exp.replace(atom_exp,res) else:return exp def add_sub(exp): ret = re.findall('[+-]?\d+(?:\.\d+)?', exp) exp_sum = 0 for i in ret: exp_sum += float(i) return exp_sum def cal(exp): exp = mul_div(exp) exp = format_exp(exp) exp_sum = add_sub(exp) return exp_sum # float def main(exp): exp = exp.replace(' ','') while True: ret = re.search('\([^()]+\)',exp) if ret : inner_bracket = ret.group() res = str(cal(inner_bracket)) exp = exp.replace(inner_bracket,res) exp = format_exp(exp) else:break return cal(exp) s = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )' ret = main(s) print(ret,type(ret))
Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例
>>>while True print('Hello world') File "<stdin>", line 1, in ? while True print('Hello world') ^ SyntaxError: invalid syntax
这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号（:）。
语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。
异常
即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:
>>>10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: division by zero >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'spam' is not defined >>> '2' + 2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: Can't convert 'int' object to str implicitly
异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。
错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息
异常处理
以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。
>>>while True: try: x = int(input("Please enter a number: ")) break except ValueError: print("Oops! That was no valid number. Try again ")
try语句按照如下方式工作；
- 首先，执行try子句（在关键字try和关键字except之间的语句）
- 如果没有异常发生，忽略except子句，try子句执行后结束。
- 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
- 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。
一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:
except (RuntimeError, TypeError, NameError): pass
最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。
import sys try: f = open('myfile.txt') s = f.readline() i = int(s.strip()) except OSError as err: print("OS error: {0}".format(err)) except ValueError: print("Could not convert data to an integer.") except: print("Unexpected error:", sys.exc_info()[0]) raise
try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:
for arg in sys.argv[1:]: try: f = open(arg, 'r') except IOError: print('cannot open', arg) else: print(arg, 'has', len(f.readlines()), 'lines') f.close()
使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。
异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:
>>>def this_fails(): x = 1/0 >>> try: this_fails() except ZeroDivisionError as err: print('Handling run-time error:', err) Handling run-time error: int division or modulo by zero
抛出异常
Python 使用 raise 语句抛出一个指定的异常。例如:
>>>raise NameError('HiThere') Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: HiThere
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
>>>try: raise NameError('HiThere') except NameError: print('An exception flew by!') raise An exception flew by! Traceback (most recent call last): File "<stdin>", line 2, in ? NameError: HiThere
用户自定义异常
你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:
>>>class MyError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) >>> try: raise MyError(2*2) except MyError as e: print('My exception occurred, value:', e.value) My exception occurred, value: 4 >>> raise MyError('oops!') Traceback (most recent call last): File "<stdin>", line 1, in ? __main__.MyError: 'oops!'
在这个例子中，类 Exception 默认的 __init__() 被覆盖。
<p异常的类可以像其他的类一样做任何事情，但是通常都会比较简单，只提供一些错误相关的属性，并且允许处理异常的代码方便的获取这些信息。< p="">
当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:
class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message
大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
定义清理行为
try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:
>>>try: ... raise KeyboardInterrupt ... finally: ... print('Goodbye, world!') ... Goodbye, world! Traceback (most recent call last): File "<stdin>", line 2, in <module> KeyboardInterrupt
以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。
如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。
下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:
>>>def divide(x, y): try: result = x / y except ZeroDivisionError: print("division by zero!") else: print("result is", result) finally: print("executing finally clause") >>> divide(2, 1) result is 2.0 executing finally clause >>> divide(2, 0) division by zero! executing finally clause >>> divide("2", "1") executing finally clause Traceback (most recent call last): File "<stdin>", line 1, in ? File "<stdin>", line 3, in divide TypeError: unsupported operand type(s) for /: 'str' and 'str'
预定义的清理行为
一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。
这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:
for line in open("myfile.txt"): print(line, end="")
以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。
关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法
with open("myfile.txt") as f: for line in f: print(line, end="")
以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。
在 python3 中，处理带有参数的异常的方法如下： # 定义函数 def temp_convert(var): try: return int(var) except (ValueError) as Argument: print ("参数没有包含数字\n", Argument) # 调用函数 temp_convert("xyz");
