wk_10.md

Python检测和处理异常

try-except语句

try-except语句定义了进行异常监控的一段代码，并且提供了异常处理的机制，下面是使用的语法：

try:
    # 可能抛出异常的语句，会一直执行，直到抛出异常。
except:
    # 异常处理额语句，当try快任意语句抛出异常时执行。

当try中执行的语句没有抛出异常则except中的语句是不会执行的：

try:
    print(float(23232))
    print('********')
except:
    print('except')
输出：
23232.0
********

当try中语句有多个时一旦执行到错误或异常的语句之后就是执行except中的语句并退出程序，而try中没有执行的语句则不会在被执行：

try:
    print(float(23232))
    print('********')
    print(float('dota'))
    print('-------')
except:
    print('except')
输出：
23232.0
********
except 

在try中定义的变量是可以在except中使用的：

try:
    a='DOTA'
    print(a)
    print(float(a))
except:
    print('except',a)
输出：
DOTA
except DOTA

通过制定类型对不同的异常做不同的处理：

try:
    float('aaaa')
except ValueError as e:
    print('aaaa value error. {}'.format(e))
except NameError as e:
    print('aaaa name error. {}'.format(e))
except Exception:
    print('error')
except:
    print('......')
输出：
aaaa value error. could not convert string to float: 'aaaa'

• 异常语句从上往下执行，匹配到哪一条执行该条语句并停止匹配。
• 如果Exception放在最上面则下面的具体性异常ValueError或者NameError是不会执行的。
• 通常会把具体的异常放到上面，一般性的异常放到下面。
• 当不带任何模式的时候，相当于default分支，会捕获所有未捕获的异常。

finally 子句

• finally 语句总是会被执行，无论有没有抛出异常。所有的清理工作通常放到finally语句块里执行。
• finally 在return 语句之后，函数返回之前执行。通常使用中不会再finally 里return。

def fn():
    try:
        1 / 0
        print('try')
        return 1
    except:
        print('except')
        return 2
    finally:
        print('finally')
        return 3
    print('fn')
    return 4

print(fn())
输出：
except
finally
3

自定义异常

• 自定义异常需要我们自己抛出，使用raise语句抛出。
• raise 语句后面只能跟一个异常的实例。

class UserException(Exception):
    pass

class SystemException(Exception):
    pass

def div(x,y):
    try:
        return x/y
    except ZeroDivisionError:
        raise UserException('y must no be zero')

try:
    div(5,0)
except UserException as e:
    print(e)
except SystemException as e:
    pass 
输出：
y must no be zero

在实际的编码中，我们应该在哪一层处理异常：

• 通常在endpoint （指的一个边界）处处理异常。
• 有替代方案时立即处理异常。使用替代方案。
• 异常做为业务逻辑，不推荐使用。
• 异常可以忽略。
• 异常需要延后处理，需要立即处理，并暂存异常，以便延后处理。

导入模块

import 语句

import 语句用于导入模块，当模块导入后，就可以以模块名为命名空间，使用模块的变量，函数和类了。

In [1]: import os

In [3]: os.getcwd()
Out[3]: '/root'

from import 语句

可以把模块中指定的成员导入如到当前作用域，这就是部分导入，这种导入的命名空间也是部分的。

In [5]: from os import path

In [8]: path.basename('/tmp')
Out[8]: 'tmp'

In [9]: os.cpu_count()
Out[9]: 1

In [10]: from os import cpu_count

In [11]: cpu_count()
Out[11]: 1

扩展的 import 语句（as）

当我们导入模块的名称重复或者名称过长的时候就可以使用as 来进行重命名。

In [15]: from posix import stat_result as posix_stat_result

In [16]: from os import stat_result as os_stat_result

模块搜索路径

如果不做特殊修改，在用import导入模块是路径的先后顺序如下：当前目录-->标准库-->第三方库。

In [17]: import sys

In [18]: for path in sys.path:
   ....:     print(path)
   ....:     

/root/.pyenv/versions/3.5.2/envs/pengfei/bin
/root/.pyenv/versions/3.5.2/lib/python35.zip
/root/.pyenv/versions/3.5.2/lib/python3.5
/root/.pyenv/versions/3.5.2/lib/python3.5/plat-linux
/root/.pyenv/versions/3.5.2/lib/python3.5/lib-dynload
/root/.pyenv/versions/3.5.2/envs/pengfei/lib/python3.5/site-packages
/root/.pyenv/versions/3.5.2/envs/pengfei/lib/python3.5/site-packages/IPython/extensions
/root/.ipython

由于python默认第一是从当前目录进行导入模块，所以一旦当前路径的模块名和系统模块名重名则不会导入系统模块。

包

包是一个有层次的文件目录结构，它定义了一个由模块和子包组成的Python应用程序执行环境。

1. 一个目录下有__init__.py的时候，这个目录是一个模块（包），模块的内容写在__init__.py。
2. 这个目录下的其他文件，是这个模块的子模块。
3. 导入子模块的时候会先导入父模块。
4. 导入父模块不会自动导入子模块。
5. 子模块可以使用from parent import child这样的形式导入，也可以使用import parent,child。
6. import parent.child这种导入方式，child必须是子模块。
7. 同一模块下的子模块，可以使用相对导入，也可以使用绝对导入。