Python-Error&Debug&Test基础知识

1.当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续
代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，
如果有finally语句块，则执行finally语句块，至此，执行完毕。

try:
	print('try...')
	r = 10 /0		#发生错误，下面的代码不再执行，直接到except
	print('Resault', r)
except ZeroDivisionError as e:
	print('except...')
finally:
	print('finally...')
print('END')	

try:
    print('try...')
    r = 10 / 2		#修改0为2 
    print('Resault', r)
except ZeroDivisionError as e:	#no error, not be executed
    print('except...')
finally:
    print('finally...')
print('END')
修改上述代码0为2，由于不再发生错误，所以正常执行，except代码块不被执行。

如果发生了多类错误，就应由不同的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')

int()函数可能会抛出ValueError，所以我们用一个except捕获ValueError，
用另一个except捕获ZeroDivisionError。
此外，如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，
会自动执行else语句：
try:
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

python的错误本质上也是class，所有的错误类型都继承自BaseException, 所以在使用
except时需要注意，它不但捕获该类型的错误，而且捕获其子类的错误。
try:
	foo()
except ValueError as e:
	print('ValueError')
except UnicodeError as e:	
	print('UnicodeError')
第二个except永远捕捉不到，因为UnicodeError是ValueError的子类。

使用try...except捕获的另外一个好处是可以跨越多层调用。
#main()调用foo()，foo()调用bar()，如果bar()出错，只要main()捕获到就可以处理
def bar(s):
	return 10 / int(s)

def foo(s):
	return bar(s) * 2

def main():
	try:
		foo('0')
	except Exception as e:
		print('Error', e)
	finally:
		print('Finally...')

main()
Output:
Error division by zero
Finally...

这个特性说明不需要在出错的地方去捕获错误，只要在合适的层次去捕获就可以了。		



2.调用栈:出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置。
# err.py:
def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    bar('0')

main()
Output：
Traceback (most recent call last):		#错误的跟踪信息
  File "err.py", line 11, in <module>	
    main()								#调用main()出错，原因是第9行
  File "err.py", line 9, in main
    bar('0')
  File "err.py", line 6, in bar			#bar('0')出错，原因在第6行
    return foo(s) * 2		
  File "err.py", line 3, in foo			#return foo(s) * 2出错，原因是第3行
    return 10 / int(s)					#return 10 / int(s)出错，这是源头
ZeroDivisionError: division by zero 	#错误类型

3.记录错误：Python内置的logging模块

# err_logging.py
import logging
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')

Output:#程序打印完错误信息后继续执行，并正常退出
ERROR:root:division by zero
Traceback (most recent call last):
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 10, in main
    bar('0')
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 6, in bar
    return foo(s) * 2
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 3, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero
END

通过配置，logging还可以把错误记录到日志文件中，方便以后排查。


4.抛出错误
因为错误是class，捕获一个错误就是捕获到该class的一个实例。因此，错误并不是凭空
产生的，而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误，我们自己编写
的函数也可以抛出错误。如果要抛出错误，首先根据需要，可以定义一个错误的class，
选择好继承关系，然后，用raise语句抛出一个错误的实例：
# err_raise.py
class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

foo('0')

Output：
Traceback (most recent call last):
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 11, in <module>
    foo('0')
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 8, in foo
    raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0

只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型
（比如ValueError，TypeError），尽量使用Python内置的错误类型。

#另一种错误处理方式
def foo(s):
	n = int(s)
	if n == 0:
		raise ValueError('Invalid value: %s' % s)
	return 10 / n

def bar(s):
	#先捕获错误再raise抛出。
	#捕获只是为了记录错误，抛出错误便于程序运行
	try:
		foo('0')			
	except ValueError as e:
		print('ValueError')
		raise  	#raise语句如果不带参数，就会把当前错误原样抛出。

bar()
Output：
ValueError
Traceback (most recent call last):
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 15, in <module>
    bar()        
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 9, in bar
    foo('0')
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 4, in foo
    raise ValueError('Invalid value: %s' % s)
ValueError: Invalid value: 0



在except中raise一个Error，还可以把一种类型的错误转化成另一种类型：
(决不应该把一个IOError转换成毫不相干的ValueError!!!!)
try:
    10 / 0
except ZeroDivisionError:
    raise ValueError('input error!')


1.调试
(1). 断言：用print来辅助查看结果的地方，使用断言assert代替
def foo(s):
	n = int(s)
	assert n != 0, 'n is zero!' 
	return  10 / n 
def bar(s):
	return foo('0')

assert的意思是，表达式n != 0应该是True，否则，根据程序运行的逻辑，后面的代码肯定
会出错。如果断言失败，assert语句本身就会抛出AssertionError：
$ python err.py
Traceback (most recent call last):
  ...
AssertionError: n is zero!

程序中如果到处充斥着assert，和 print()相比也好不到哪去。不过，启动Python解释器时
可以用-O参数来关闭assert：

$ python -O err.py
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
关闭后，你可以把所有的assert语句当成pass来看。
(2).logging:把 print()替换为logging,和assert比，logging不会抛出错误，而且可以输出
到文件：
import logging

s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)
logging.info()就可以输出一段文本。运行，发现除了ZeroDivisionError，没有任何信息。
怎么回事？别急，在import logging之后添加一行配置再试试：
import logging
logging.basicConfig(level=logging.INFO)
看到输出了：

$ python err.py
INFO:root:n = 0
Traceback (most recent call last):
  File "err.py", line 8, in <module>
    print(10 / n)
ZeroDivisionError: division by zero
这就是logging的好处，它允许你指定记录信息的级别，有debug，info，warning，error等
几个级别，当我们指定level=INFO时，logging.debug就不起作用了。同理，
指定level=WARNING后，debug和info就不起作用了。这样一来，你可以放心地输出不同级别
的信息，也不用删除，最后统一控制输出哪个级别的信息。
logging的另一个好处是通过简单的配置，一条语句可以同时输出到不同的地方，
比如console和文件。

2.单元测试
单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。
“测试驱动开发”（TDD：Test-Driven Development）

#mydict.py
#编写一个Dict类，这个类的行为和dict一致，但是可以通过属性来访问

#>>> d = Dict(a=1, b=2)
# >>> d['a']
# 1
# >>> d.a
# 1

class Dict(dict):

	def __init__(self, **kw):
		super().__init__(**kw)

	def __getattr__(self, key):
		try:
			return self[key]
		except KeyError :
			raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

	def __setattr__(self, key, value):
		self[key] = value

#mydict_test.py
import unittest

from mydict import Dict

class TestDict(unittest.TestCase):

	def test_init(self):
		d = Dict(a = 1, b = 'test')
		self.assertEqual(d.a, 1)
		self.assertEqual(d.b, 'test')
		self.assertEqual(isinstance(d, dict))

	def test_key(self):
	d = Dict()
	d['key'] = 'value'
	self.assertEqual(d.key, 'value')

	def test_attr(self):
	d = Dict()
	d.key = 'value'
	self.assertTrue('key' in d)
	self.assertEqual(d['key'], value)

	def test_keyerror(self):
		d = Dict()
		with self.assertRaises(KeyError):
			value = d['empty']

	def test_attrerror(self):
		d = Dict()
		with self.assertRaises(AttributeError):
			value = d.empty		

编写单元测试时，我们需要编写一个测试类，从unittest.TestCase继承。
以test开头的方法就是测试方法，不以test开头的方法不被认为是测试方法，测试的时候不
会被执行。
对每一类测试都需要编写一个 test_xxx()方法。由于unittest.TestCase提供了很多内置的
条件判断，我们只需要调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是
assertEqual()：
self.assertEqual(abs(-1), 1) # 断言函数返回的结果与1相等
另一种重要的断言就是期待抛出指定类型的Error，比如通过d['empty']访问不存在的key时，
断言会抛出KeyError：
with self.assertRaises(KeyError):
    value = d['empty']
而通过d.empty访问不存在的key时，我们期待抛出AttributeError：
with self.assertRaises(AttributeError):
    value = d.empty

运行单元测试
一旦编写好单元测试，我们就可以运行单元测试。最简单的运行方式是在mydict_test.py的
最后加上两行代码：
if __name__ == '__main__':
    unittest.main()
这样就可以把mydict_test.py当做正常的python脚本运行：
$ python mydict_test.py
另一种方法是在命令行通过参数-m unittest直接运行单元测试：
$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s
OK
这是推荐的做法，因为这样可以一次批量运行很多单元测试，并且，有很多工具可以自动来
运行这些单元测试。