'''
在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码，这样，就可以知道是否有错，以及出错的原因。在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数open()，成功时返回文件描述符（就是一个整数），出错时返回-1。
用错误码来表示是否出错十分不便，因为函数本身应该返回的正常结果和错误码混在一起，造成调用者必须用大量的代码来判断是否出错
'''
# Exception
# 高级语言通常都内置了一套try...except...finally...的错误处理机制，Python也不例外。
# 当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，
# 执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。
try:
print('try...')
r = 10 / 0
print('result: ', r)
except ZeroDivisionError as e:
print('except:', e)
finally:
print('finally...')
print("END")
# 如果把除数0改成2，
# 由于没有错误发生，所以except语句块不会被执行，但是finally如果有，则一定会被执行（可以没有finally语句）。
try:
print('try...')
r = 10 / 2
print('result: ', r)
except ZeroDivisionError as e:
print('except:', e)
finally:
print('finally...')
print("END")
# 错误应该有很多种类，如果发生了不同类型的错误，应该由不同的except语句块处理。
try:
print('try...')
r = 10 / int('a')
print('result:', r)
except ValueError as e:
print('ValueError:', e)
except ZeroDivisionError as e:
print('ZeroDivisionError:', e)
finally:
print('finally...')
print('END')
# Python 的异常都是 class，文档：https://docs.python.org/3/library/exceptions.html#exception-hierarchy
# 注意：捕获异常的语句会将其子类的异常也一同捕获
# 使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用
# 比如函数main()调用foo()，foo()调用bar()，结果foo()出现了除以零错误，这时，只要main()捕获到了，就可以处理：
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
print('Error:', e)
finally:
print('finally...')
main()
# 也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。
# 调用栈
# 如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出。
'''
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
bar('0')
main()
执行，结果如下：
Traceback (most recent call last): # 提示我们以下是错误跟踪信息
File "python learning Error, Debug and Test.py", line 101, in <module>
main() # 调用main出错了，位置是第 111 行，而原因是
File "python learning Error, Debug and Test.py", line 99, in main
bar('0') # 调用 bar('0') 出错，位置是第 99 行，而原因是
File "python learning Error, Debug and Test.py", line 96, in bar
return foo(s) * 2 # return foo(s) * 2这个语句出错了，但这还不是最终原因，继续往下看：
File "python learning Error, Debug and Test.py", line 93, in foo
return 10 / int(s) # return 10 / int(s)这个语句出错了，这是错误产生的源头
ZeroDivisionError: division by zero # 我们判断，int(s)本身并没有出错，但是int(s)返回0，在计算10 / 0时出错，至此，找到错误源头。
'''
# 记录错误
# 如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。
# 既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。
import logging
logging.basicConfig(level=logging.INFO)
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
logging.exception(e)
main()
print('END')
'''
ERROR:root:division by zero
Traceback (most recent call last):
File "python learning Error, Debug and Test.py", line 137, in main
bar('0')
File "python learning Error, Debug and Test.py", line 133, in bar
return foo(s) * 2
File "python learning Error, Debug and Test.py", line 130, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
END # 继续打印了 END 表明程序打印完错误信息之后会继续执行并正常退出
'''
# 抛出错误
# 错误是class，捕获一个错误就是捕获到该class的一个实例。
# 错误并不是凭空产生的，而是有意创建并抛出的。
# Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。
# 如果要抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：
class FooError(ValueError):
pass
def foo(s):
n = int(s)
if n == 0:
raise FooError('invalid value: %s' % s)
return 10 / n
try:
foo('0')
except Exception as e:
logging.exception(e)
print('END')
'''
Traceback (most recent call last):
File "python learning Error, Debug and Test.py", line 176, in <module>
foo('0')
File "python learning Error, Debug and Test.py", line 173, in foo
raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0
'''
# 只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。
# 练习：
# 运行下面的代码，根据异常信息进行分析，定位出错误源头，并修复：
from functools import reduce
def str2num(s):
return int(s)
def calc(exp):
ss = exp.split('+')
ns = map(str2num, ss)
return reduce(lambda acc, x: acc + x, ns)
def main():
r = calc('100 + 200 + 345')
print('100 + 200 + 345 =', r)
r = calc('99 + 88 + 7.6')
print('99 + 88 + 7.6 =', r)
try:
main()
except Exception as e:
logging.exception(e)
print('END')
'''
控制台输出信息如下：
100 + 200 + 345 = 645
Traceback (most recent call last):
File "python learning Error, Debug and Test.py", line 212, in <module>
main()
File "python learning Error, Debug and Test.py", line 209, in main
r = calc('99 + 88 + 7.6')
File "python learning Error, Debug and Test.py", line 204, in calc
return reduce(lambda acc, x: acc + x, ns)
File "python learning Error, Debug and Test.py", line 199, in str2num
return int(s)
ValueError: invalid literal for int() with base 10: ' 7.6'
'''
# 分析得知：错误在于 str2num 这个函数无法把 7.6 转换成浮点数
from functools import reduce
def str2num(s):
if '.' in s:
return float(s)
else:
return int(s)
def calc(exp):
ss = exp.split('+')
ns = map(str2num, ss)
return reduce(lambda acc, x: acc + x, ns)
def main():
r = calc('100 + 200 + 345')
print('100 + 200 + 345 =', r)
r = calc('99 + 88 + 7.6')
print('99 + 88 + 7.6 =', r)
main()
#################################################################
# Debugging
# 断言
# 凡需要用到 print 来打印某个变量来查看是否正确的地方，都可以用 assert 来替代
def foo(s):
n = int(s)
assert n != 0, 'n is zero!'
return 10 / n
def main():
foo('0')
# assert的意思是，assert 后面跟着的表达式应该是True，否则，根据程序运行的逻辑，后面的代码肯定会出错。
# 如果断言失败，assert语句本身就会抛出AssertionError
# main()
'''
控制台输出如下：
Traceback (most recent call last):
File "python learning Error, Debug and Test.py", line 279, in <module>
main()
File "python learning Error, Debug and Test.py", line 272, in main
foo('0')
File "python learning Error, Debug and Test.py", line 268, in foo
assert n != 0, 'n is zero!'
AssertionError: n is zero!
'''
'''
程序中如果到处充斥着assert，和print()相比也好不到哪去。不过，启动Python解释器时可以用-O参数来关闭assert：
$ python -O err.py
Traceback (most recent call last):
...
ZeroDivisionError: division by zero
关闭后，你可以把所有的assert语句当成pass来看。
'''
# logging
# Python内置的logging模块可以非常容易地记录错误信息：
# 还可以把print()替换为logging。
# 和assert比，logging不会抛出错误，而且可以输出到文件：
# 语句如下：
'''
import logging
logging.basicConfig(level=logging.INFO)
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)
'''
'''
INFO:root:n = 0
Traceback (most recent call last):
File "python learning Error, Debug and Test.py", line 315, in <module>
print(10 / n)
ZeroDivisionError: division by zero
logging的好处，它允许你指定记录信息的级别，有debug，info，warning，error等几个级别，当我们指定level=INFO时，logging.debug就不起作用了。同理，指定level=WARNING后，debug和info就不起作用了。这样一来，你可以放心地输出不同级别的信息，也不用删除，最后统一控制输出哪个级别的信息。
logging的另一个好处是通过简单的配置，一条语句可以同时输出到不同的地方，比如console和文件。
'''
# pdb 单步调试
import pdb
s = '0'
n = int(s)
pdb.set_trace() # 设置断点
print(10/n)
# pdb 指令：
# 启动调试器：python -m pdb err.py
# 输入命令n可以单步执行代码：
# 任何时候都可以输入命令 p 变量名来查看变量：
# 设置断点之后，直接 python err.py 就会停在断点处
# 命令 c 继续运行
'''
C:UsersAdministratorDesktop>python err.py
> c:usersadministratordesktoperr.py(10)<module>()
-> print(10/n)
(Pdb) p n
0
(Pdb) c
Traceback (most recent call last):
File "err.py", line 10, in <module>
print(10/n)
ZeroDivisionError: division by zero
'''
# 比较好用的 IDE：VSCode、PyCharm
# 虽然用IDE调试起来比较方便，但是最后你会发现，logging才是终极武器。
#################################################################
# Unit Test
# to be completed
#################################################################