异常

<1>捕获异常

捕获一个异常

print num
 except NameError:
print('产生错误了')

捕获多个异常
当捕获多个异常时， 可以把要捕获的异常的名字， 放到except 后， 并使用元组的方式仅进行存储

try:
	print('-----test--1---')
	open('123.txt','r') 
	print('-----test--2---')
	print(num)#如果num变量没有定义， 那么会产生 NameError 异常
except (IOError,NameError):
	print("well done")

获取异常的信息描述

try:
	print(num)
# except NameError :
# 	print('产生错误了')
except Exception as e:
	print('产生错误了,',e)

可以把except理解为：if

try:
	num = 100
	print num
except NameError as errorMsg:
	print('产生错误了:%s'%errorMsg)
else:
	print('没有捕获到异常， 真高兴')

<6> try…finally…

在程序中， 如果一个段代码必须要执行， 即无论异常是否产生都要执行， 那么此时就需要使
用finally。 比如文件关闭， 释放锁

import time
try:
	f = open("nihao.txt")
	try:
		while True:
			content = f.readline()
			if len(content) == 0:
				break
			time.sleep(2)
			print(content)
	except:
		pass
	finally:
		f.close()
except Exception as errorMsg:
	print('产生错误了:%s' % errorMsg)
else:
	print('没有捕获到异常， 真高兴')

try嵌套中

import time
try:
	f = open("nihao.txt")
	try:
		while True:
			content = f.readline()
			if len(content) == 0:
				a = int(content)
			time.sleep(2)
			# print(content)
	# except Exception as e: #如果这里已经处理过错误，那么外层的except就不会再次处理错误
	# 	print('An error occurred',e)
	finally:
		f.close()
		print("关闭文件")
except Exception as F: #如果内层没有处理过错误，那么外层的except就会处理错误
	print("F",F)
else:
	print("错误已经被弹出去了")
finally:
	print('没有捕获到异常， 真高兴')

总结

如果try嵌套， 那么如果里面的try没有捕获到这个异常， 那么外面的try会接收到这个异常， 然
后进行处理， 如果外边的try依然没有捕获到， 那么再进行传递。 。 。
如果一个异常是在一个函数中产生的， 例如函数A---->函数B---->函数C,而异常是在函数C中产
生的， 那么如果函数C中没有对这个异常进行处理， 那么这个异常会传递到函数B中， 如果函
数B有异常处理那么就会按照函数B的处理方式进行执行； 如果函数B也没有异常处理， 那么这
个异常会继续传递， 以此类推。 。 。 如果所有的函数都没有处理， 那么此时就会进行异常的默
认处理， 即通常见到的那样

raise

class ShortInputException(Exception):
	'''自定义的异常类'''
	def __init__(self, length, atleast):
		# super().__init__()
		self.length = length
		self.atleast = atleast

def main(n):
	try:
		s = input('请输入 --> ')
		if len(s) < n:
			# raise引发一个你定义的异常
			raise ShortInputException(len(s), n) #可以理解为返回一个实例对象
	except ShortInputException as result:  # x这个变量被绑定到了错误的实例
		print('ShortInputException: 输入的长度是 %d,长度至少应是 %d' % (result.length, result.atleast))
	else:
		print('没有异常发生.')

关于代码 #super().init() 的说明 这一行代码， 可以调用也可以不调用， 建议调用， 因为 init
方法往往是用来对创 建完的对象进行初始化工作， 如果在子类中重写了父类的 init 方法， 即意味着父 类中的很多初始化工作没有做， 这样就不保证程序的稳定了， 所以在以后的开发中， 如 果重写了父类的 init 方法， 最好是先调用父类的这个方法， 然后再添加自己的功能

异常处理中抛出异常

class ShortInputException(Exception):
	'''自定义的异常类'''
	def __init__(self, length, atleast,switch):
		# super().__init__()
		self.length = length
		self.atleast = atleast
		self.switch = switch

	def main(self,a,b):
		try:
			print(a / b)

		except Exception as result:  # x这个变量被绑定到了错误的实例
			if self.switch:
				print("异常已经处理")
			else:
				raise Exception

ShortInputException(10,10,1).main(10,0)

模块

当你导入一个模块， Python解析器对模块位置的搜索顺序是：

  1. 当前目录
  2. 如果不在当前目录， Python则搜索在shell变量PYTHONPATH下的每个目录。
  3. 如果都找不到， Python会察看默认路径。 UNIX下， 默认路径一般为/usr/local/lib/python/
  4. 模块搜索路径存储在system模块的sys.path变量中。 变量里包含当前目录， PYTHONPATH和 由安装过程决定的默认目录。

定义自己的模块

在Python中， 每个Python文件都可以作为一个模块， 模块的名字就是文件的名字。比如有这样一个文件test.py， 在test.py中定义了函数add test.py

name = main

__name__是一个变量。前后加了双下划线是因为是因为这是系统定义的名字
name__就是标识模块的名字的一个系统变量。这里分两种情况：假如当前模块是主模块（也就是调用其他模块的模块），那么此模块名字就是__main，通过if判断这样就可以执行“mian:”后面的主函数内容；假如此模块是被import的，则此模块名字为文件名字（不加后面的.py），通过if判断这样就会跳过“mian:”后面的内容。

模块中的 all,是模块中的

all 变量，就是*的意思

当其他文件仅以

*from 模块名 import *

形式导入该模块时，表示只能使用该列表中指定的成员

init.py

1.包将有联系的模块组织在一起， 即放到同一个文件夹下， 并且在这个文件夹创建一个名字为 init.py 文件， 那么这个文件夹就称之为 包
2.init.py 控制着包的导入行为
3.all__在 init.py 文件中， 定义一个 all 变量， 它控制着 from 包名 import *时导入的模块
4.在__init.py 中编辑__all__=['模块1，模块2]
5.在将__init__.py 和其他模块一起放入要导入的文件夹a，编辑init.py 在其中写上from . import model