Python学习笔记九（异常、模块）

Python学习笔记九（异常、模块）

异常

什么是异常

程序发生错误，既程序非正常终止，则为异常。异常会让程序终止，这样的程序很不友好，我们希望程序异常结束时能给出提示。

1/0# 结果为：
# Traceback (most recent call last):
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 1, in <module>
#     1/0
# ZeroDivisionError: division by zero

捕获异常

try … except … 用于捕获异常，处理异常，程序在一次运行中只会产生一个异常。

格式

try:pass
except:pass

一个try 可以配合多个except 使用，每一个except 认为是一个分支。

try:1 / 0
except:print("发生异常程序，即将退出")# 结果为：
# 发生异常程序，即将退出

捕获异常，作出提示，程序的友好性有所提升。

捕获异常的方式

• 单分支捕获指定异常
• 单分支捕获指定多个异常
• 多分支捕获异常
• 单分支捕获常见异常

捕获指定异常

捕获指定异常（一个分支捕获一个异常）

try:1 / 0
except ZeroDivisionError:print("被除数不能为 0")# 结果为：
# 被除数不能为 0

如果需要获得异常的一些信息怎么办？使用 as 为异常对象起一个别名

try:1 / 0
except ZeroDivisionError as exc:print("被除数不能为 0 ,""异常信息：%s ,""异常代码所在的行数：%d" % (exc, exc.__traceback__.tb_lineno))# 结果为：
# 被除数不能为 0 ,异常信息：division by zero ,异常代码所在的行数：2

单分支指定捕获多个异常

当多个异常处理逻辑相同时，可以放在一个分支中进行处理。

try:# max()  # TypeError# max([])  # ValueErrorpass
except (TypeError, ValueError) as exc:print("异常信息：%s ,""异常代码的行数：%d" % (exc, exc.__traceback__.tb_lineno))

通过元组的形式可以在一个分支指定捕获多个异常，但是每次只有一个异常被捕获处理，为啥？因为一次只会产生一个异常。

多分支捕获异常

try:max()  # TypeError# max([])  # ValueErrorexcept ValueError as exc:print("异常信息：%s ,""异常代码的行数：%d" % (exc, exc.__traceback__.tb_lineno))
except TypeError as exc:print("异常信息：%s ,""异常代码的行数：%d" % (exc, exc.__traceback__.tb_lineno))

单分支捕获常见异常

try:max()  # TypeError# max([])  # ValueErrorexcept Exception as exc:  # 单分支捕获常见异常print("异常信息：%s ,""异常代码的行数：%d" % (exc, exc.__traceback__.tb_lineno))# Exception 的直接子类
# ArithmeticError(Exception)
# AssertionError(Exception)
# AttributeError(Exception)
# WindowsError(Exception)
# BufferError(Exception)
# Warning(Exception)
# EOFError(Exception)
# ImportError(Exception)
# SyntaxError(Exception)
# LookupError(Exception)
# MemoryError(Exception)
# NameError(Exception)
# RuntimeError(Exception)
# ReferenceError(Exception)
# StopAsyncIteration(Exception)
# StopIteration(Exception)
# SystemError(Exception)
# TypeError(Exception)
# ValueError(Exception)
# 19 个

异常的传递

def func1():1 / 0def func2():func1()def func3():func2()func3()# 结果为：
# Traceback (most recent call last):
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 10, in <module>
#     func3()
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 8, in func3
#     func2()
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 5, in func2
#     func1()
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 2, in func1
#     1 / 0
# ZeroDivisionError: division by zero

通过错误日志可以看出来在第十行调用了func3 ,func3 调用了 func2 ，func2 调用了func1 ，在行2 也就是func1 里面出错，没有处理错误，错误向上传递到func2 ，再传给func3 ，直到func3 的调用处都没有处理异常，程序异常终止。

自定义异常

class UserDefinedException(Exception):  # 继承Exception类'''自定义的异常类'''def __init__(self):passraise UserDefinedException()  # 使用raise 抛出一个UserDefinedException 异常

---

模块

什么是模块

一个 .py 文件就是一个模块，作用：分工，一个人负责某几个模块。

模块的导入

什么是模块名

前面已经说了一个 .py 文件就是一个模块，所以模块名就是 .py 文件的文件名。文件名将会用于标识符，所以文件名必须满足标识符的命名规则，否则不能导入。

导入

• import 模块名
• form 模块名 import 功能

模块 piece.py 的内容

def func():print("------ piece func -----------")

使用import 导入

import piece  # impotent 模块名，直接找人帮忙piece.func()  # 模块名.功能名 使用,功能包括模块中的方法、变量、类等都可以使用。# 结果为：
# ------ piece func -----------# as 定义别名,结合import 使用 
import piece as p  # 使用as 给模块名 定义别名p.func()  # 别名.功能名# 结果为：
# ------ piece func -----------

import 导入可以理解为交了一个朋友（导入模块），比如说你的朋友会做做菜（模块中的功能），如果你需要做菜（想使用模块中的功能），你得先找到你的朋友（通过模块名），然后让他帮你做菜（调用功能）

form 模块名 import 功能

from piece import func  # form 模块名 import 功能，只能导入指定的功能func()  # 直接使用# 结果为：
# ------ piece func -----------# as 结合 form import 使用# form 模块名 import 功能 as 别名，功能包括模块中的方法、变量、类等都可以使用。
from piece import func as f f()  # 直接使用# 结果为：
# ------ piece func -----------

form import 的形式：还是用做菜来说吧，你有一个朋友会做菜（模块名），一顿烧烤，你从他那里学会了几道菜（功能），你学会了之后，想做菜了，还需要找朋友来帮忙吗？！你要是觉得别人帮你理所应当我也没法！！！继续，你都会了，当然是自己下厨了（使用功能）。

from 模块名 import *

导入模块中的所有公开部分

from piece import *  # from 模块名import 星号 func()  # 直接使用

看上面的代码和导入指定的功能没什么区别，那为什么说 星号 是导入所有公开部分和import 模块有什么区别呢？
首先，说一下from 模块名 import * 怎么理解，可以理解为你的朋友会做菜，会修车等等，你一顿烧烤学会做菜（公共的功能），但是他没教你修车（公共功能，但是我不想教你），所以你只会做菜（只能使用做菜，不能使用修车）。
通过上面的叙述应该可以明白 星号 是导入所有公开部分和import 模块的区别。区别在于找朋友帮忙，只要朋友会他就能帮你做（import）。但是你从朋友那里学 （from import *），他不教，你就不会。

那么有一个问题，星号是怎么知道你的朋友有哪些是想教给你，哪些不想的呢？__all__ 变量

__all__ 变量

通过前面可以知道__all__ 变量 的作用是控制 星号 可以导入的功能，也只对 星号 起作用。

piece.py

__all__ = ["func","func3"]  # __all__ 变量，赋值列表，列表中的每个元素都是功能名称的字符串def func():print("------ piece func -----------")def func2():print("------ piece func -----------")def func3():print("------ piece func -----------")

使用 星号 导入

from piece import *func()
func3()
func2()# 结果为：
# ------ piece func -----------
# Traceback (most recent call last):
# ------ piece func3 -----------
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 7, in <module>
#     func2()
# NameError: name 'func2' is not defined# 结果分析：
# 通过结果可以看出，__all__ 变量中的功能都正常运行，不在__all__ 中的功能不能使用

模块与路径

导入模块，会了，那么导入模块是根据什么导入的呢？比如说系统有个random 模块，我的工程目录下有一个random 模块，是导入我工程目录下的random ，还是 系统中的random ？往下看

import piece
import sys
import osprint(piece.__file__)  # 模块有一个__file__属性，可以查看当前导入的模块的存放路径
wd())  # 获取当前工作路径
print(sys.path)  # 获取系统搜索导入模块会查看的路径# 结果为：
# E:workspacepycharmpycharmpiece.py
# E:workspacepycharmpycharm
# ['E:\workspace\pycharm\pycharm', 
# 'E:\workspace\pycharm\pycharm', 'D:\software\Python36\python36.zip', 
# 'D:\software\Python36\DLLs', 'D:\software\Python36\lib', 
# 'D:\software\Python36', 'D:\software\Python36\lib\site-packages']# 结果分析：
# sys.path 搜索路径是一个列表，列表可以增删改查，列表的第一个元素是当前的工作路径，
# 所以当工作路径下有一个和系统模块重名的模块时，会导入工作路径下的模块。
# 问重名会不会有影响？首先不建议重名，那我怎么知道有没有重名？你不需要知道！为什么不需要知道？
# 首先你知道系统有random 模块，你才会用系统的，如果说系统没有这个模块或者你不知道有这个模块,
# 你还会用吗？ 不会用吧？！那么在工作目录下创建一个random 模块来使用，有影响吗？

自定义模块与测试

自定义模块

通俗点说就是自己写一个 .py 的文件，文件中包含一些功能。

测试

在自己的模块中写测试代码，测试模块功能。

piece.py

def func():print("------ piece func -----------")print(" piece 的测试")# 结果：
#  piece 的测试  # 假设当前模块测试通过

piece.py 被当做模块导入

Demo.py 中导入piece 模块，直接运行Demo.py 文件

import piece# 直接运行
# 结果为：
#  piece 的测试

Demo.py文件中只有一句import ，为什么会有输出？输出的结果是不是有点眼熟？这不是模块中的测试代码吗？
怎么解决这个问题？__name__变量

修改模块piece

def func():print("------ piece func -----------")if __name__ == "__main__":print(" piece 的测试")# 运行结果为：
# __main__
# piece 的测试

修改Demo.py

# import piece
# import piece as p# 分别以 import形式 以及 别名形式导入
# 运行结果：
# piece
# piece
# 分析在piece 中直接运行的结果与piece 被当做模块导入Demo 文件中运行的结果可以发现
# 在piece 直接piece 本身时，__name__的值为__main__,
# 当piece 被当做模块导入Demo 文件中，运行Demo 文件时,piece 的__name__值为模块名，且不受别名的影响。

import 没有继承

piece1.py

def func():print("------ piece1 func -----------")

piece.py

import piece1def func():print("------ piece func -----------")if __name__ == '__main__':piece1.func()

Demo.py

import pieceif __name__ == '__main__':piece.func()piece1.func()# 执行结果：
# ------ piece func -----------
# Traceback (most recent call last):
#   File "E:/workspace/pycharm/pycharm/Demo.py", line 5, in <module>
#     piece1.func()
# NameError: name 'piece1' is not defined

怎么理解呢？朋友（piece）的朋友（piece1）并不是你（Demo）的朋友

包

什么是包

包就是文件夹或者目录，作用：归类，将功能相类似或者相关联的模块放在同一包下，方便管理

在工程目录下新建文件夹，如果使用集成开发工具pytcharm 新建python package会自带__init__.py 文件，
这个文件有什么作用呢？

__init__.py文件

__init__.py 是包的一个初始化文件，可以提供一个__all__变量（和模块中的__all__变量类似），初始化模块所需环境，python2中必须有这个文件。

包名的格式

com.XXX1.XXX2.XXX3
. 的作用是分隔目录，如上有三个. 分隔了四层目录，com 下有XXX1，XXX1 下有XXX2 ，XXX2 下有XXX3

导入包中的模块

• import 包名.模块名
• from 包名.模块名 import 功能名

com.dragon_fang.demo 包下的模块 piece.py 的内容

def func():print("------ piece func -----------")

使用import 导入

com.dragon_fang 包下的Demo.py

import demo.piece  # impotent 包名.模块名，去找你的中国（包名）朋友（模块名）帮忙，导入指定的模块demo.piece.func()  # 包名.模块名.功能名 使用,功能包括模块中的方法、变量、类等都可以使用。# 结果为：
# ------ piece func -----------# as 定义别名,结合import 使用 
import demo.piece as p  # 使用as 定义别名，当包的层级比较深时，很好用p.func()  # 别名.功能名# 结果为：
# ------ piece func -----------

form 模块名 import 功能

from demo import piece   # form 包名 import 模块名 ，导入指定的模块piece.func()  # 直接使用# 结果为：
# ------ piece func -----------# as 结合 form import 使用# from demo import piece as 别名，为指定的模块起一个别名
from demo import piece as p p.func()  # 别名.功能# 结果为：
# ------ piece func -----------

from包名 import *

导入包中的所有公开部分

from demo import *  # from 包名 import 星号 piece.func()  # 模块.功能

导入包中的模块的 import 和 from import 与 导入模块的 import 和 from import 类似，不做赘述。

说一下 *(星号) 前面说过，包下有一个__init__.py 文件，文件中有一个__all__ 变量控制 *(星号) 可以导入包中的哪些模块，
所有在__all__ 变量列表中以字符串存储的功能名才能被 *(星号) 导入。

---

到此结   DragonFang   2018.4.16