'''

在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码，这样，就可以知道是否有错，以及出错的原因。在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数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:\Users\Administrator\Desktop>python err.py
> c:\users\administrator\desktop\err.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

#################################################################