python自定义异常类

1. python如何自定义异常

8.5. 用户自定义异常
在程序中可以通过创建新的异常类型来命名自己的异常（Python 类的内容请参见 类 ）。异常类通常应该直接或间接的从 Exception 类派生，例如:
>>> class MyError(Exception):
... def __init__(self, value):
... self.value = value
... def __str__(self):
... return repr(self.value)
...
>>> try:
... raise MyError(2*2)
... except MyError as e:
... print('My exception occurred, value:', e.value)
...
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
File "
", line 1, in ?
__main__.MyError: 'oops!'
在这个例子中，Exception 默认的 __init__() 被覆盖。新的方式简单的创建 value 属性。这就替换了原来创建 args 属性的方式。
异常类中可以定义任何其它类中可以定义的东西，但是通常为了保持简单，只在其中加入几个属性信息，以供异常处理句柄提取。如果一个新创建的模块中需要抛出几种不同的错误时，一个通常的作法是为该模块定义一个异常基类，然后针对不同的错误类型派生出对应的异常子类:
class Error(Exception):
"""Base class for exceptions in this mole."""
pass
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression = expression
self.message = message
class TransitionError(Error):
"""Raised when an operation attempts a state transition that's not
allowed.
Attributes:
previous -- state at beginning of transition
next -- attempted new state
message -- explanation of why the specific transition is not allowed
"""
def __init__(self, previous, next, message):
self.previous = previous
self.next = next
self.message = message
与标准异常相似，大多数异常的命名都以 “Error” 结尾。
很多标准模块中都定义了自己的异常，用以报告在他们所定义的函数中可能发生的错误。

2. python except中的e是什么意思

这个e是异常类的一个实例，如果我们完整地解释这个问题，我觉得还是从Python的自定义异常类说起比较好。

假如，我们现在自定义一个简单的异常类：
class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)

我们抛这个异常的时候可以这么写：
try:
raise MyError(2*2)
except MyError as e:
print 'My exception occurred, value:', e.value

我们在捕获这个异常之后假如需要访问TA的一些属性怎么办，这个时候就可以使用as关键字
所以，这里的e是前面MyError类的一个instance，我们可以直接访问他的value，也就是你看到的e.value

3. python初学者Traceback (most recent call last):

1、打开Python开发工具IDLE，新建‘myexcept．py’文件，并写代码如下：

classmyException（Exception）：

def＿＿init＿＿（self，error）：

self．error＝error

def＿＿str＿＿（self，＊args，＊＊kwargs）：

returnself．error

这就是自定义定义的异常类，继承自Exception父类，有error字段，＿＿str＿＿函数的作用是打印对象时候，显示的字符串。

4. python中用来抛出异常的关键字是

python中用来抛出异常的关键字是1.抛出异常和自定义异常 Python用异常对象(exception object)表
raise 语句 Python中的raise 关键字用于引发一个异常,基本上和C#和
自定义异常类型 Python中也可以自定义自己的特殊类型的异常,只需要要从Excepti
2.捕捉异常 和C#中的try/catch类似,Python中使用try/excep

5. 怎么写如果输出有误则输出“输入异常”的代码

题目信息：命令行参数解析计算正方形周长、面积

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--length', default = 10, type = float, help = '正方形边长')
args = parser.parse_args()
area = args.length * args.length
girth = 4 * args.length
print('面积 = ',area, '周长 = ', girth)
测试结果：
PS D:\CodeProject\PyCharm\work1\lab6> python 6-1.py --length 3.2
面积 = 10.240000000000002 周长 = 12.8

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：命令行参数确认文件，读取并输出

import sys
filename = sys.argv[1]
f = open(filename, 'r', encoding = 'utf-8')
line_no = 0
while True:
line_no += 1
line = f.readline()
if line:
print(line_no, ":", line)
else:
break
f.close()
测试结果：
PS D:\CodeProject\PyCharm\work1\lab6> python 6-1.py C:\\Users\\JohnRothan\\Desktop\\test.txt
1 : Hello,World!

2 : Today is Friday.

3 : Let's do amazing things!

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：命令行参数确认文件，with语句读取并输出

import sys
filename = sys.argv[1]
line_no = 0
with open(filename, 'r', encoding = 'utf-8') as f:
for line in f:
line_no += 1
print(line_no, ":", line)
f.close()
测试结果：
PS D:\CodeProject\PyCharm\work1\lab6> python 6-1.py C:\\Users\\JohnRothan\\Desktop\\test.txt
1 : Hello,World!

2 : Today is Friday.

3 : Let's do amazing things!

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：利用with语句读取并输出文本文件，由命令行确认文件名

import sys

n = int(sys.argv[1])
power = 1
i = 0

f = open('D:\\CodeProject\\flex\\log.txt', 'w')
sys.stdout = f
while i <= n:
double = i * 2
print(str(i), '', str(double), '', str(power))
power = 2 * power
i = i + 1
sys.stdout = sys.__stdout__
print('done!')
测试结果：
0 0 1
1 2 2
2 4 4
3 6 8
4 8 16
5 10 32

#7.7 上机实践-错误和异常

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：语法错误

print("Good Luck!"
print("幸运数：",random.choice(range(10)))
测试结果：
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 6
print("幸运数：",random.choice(range(10)))
^
SyntaxError: invalid syntax

错误处理：
print("Good Luck!"）

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：运行时错误

print("Good Luck!")
print("幸运数：",random.choice(range(10)))
测试结果：
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 6, in <mole>
print("幸运数：",random.choice(range(10)))
NameError: name 'random' is not defined

错误处理：
import random

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：零除错误

a = 1
b = 0
c = a / b
测试结果：
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 7, in <mole>
c = a / b
ZeroDivisionError: division by zero

错误处理：
除数不能为0

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：逻辑错误

import math
a = 1; b = 2; c = 1
x1 = -b + math.sqrt(b*b - 4*a*c) / 2 * a
x2 = -b - math.sqrt(b*b - 4*a*c) / 2 * a
print(x1,x2)
测试结果：
-2.0 -2.0

错误处理：
一元二次方程计算公式错误，应修改为：
x1 = (-b + math.sqrt(b*b - 4*a*c)) / (2 * a)
x2 = (-b - math.sqrt(b*b - 4*a*c)) / (2 * a)

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：常见异常

noname
测试结果：变量未声明
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 5, in <mole>
noname
NameError: name 'noname' is not defined

int a

测试结果：语法错误
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 5
int a
^
SyntaxError: invalid syntax

a = 1
a.show()

测试结果：show()函数未定义
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 6, in <mole>
a.show()
AttributeError: 'int' object has no attribute 'show'

11 + 'abc'

测试结果：类型错误
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 5, in <mole>
11 + 'abc'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

int('abc')

测试结果：数值错误
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 5, in <mole>
int('abc')
ValueError: invalid literal for int() with base 10: 'abc'

1 / 0

测试结果：零除错误
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 5, in <mole>
1 / 0
ZeroDivisionError: division by zero

a = [10,11,12]
a[3]
测试结果：索引越界
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 6, in <mole>
a[3]
IndexError: list index out of range

m = {'1' : 'yes', '2' : 'no'}
m['3']
测试结果：字典关键字不存在
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 6, in <mole>
m['3']
KeyError: '3'

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：引发异常

a = input()
if a < 0: raise ValueError("不能为负！")
测试结果：
-2
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 5, in <mole>
if a < 0: raise ValueError("不能为负！")
TypeError: '<' not supported between instances of 'str' and 'int'

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：try-except-else-finally处理捕获异常

try:
f = open("test.txt", 'w')
f.write("测试文件")
f1 = open('test1.txt', 'r')
except IOError:
print("没有找到文件")
else:
print("写入成功")
finally:
f.close()
测试结果：
没有找到文件

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：处理异常

try:
f = open('mytxt.txt', 'w')
while True:
s = input("请输入字符串（Q键结束）：")
if s.upper() == 'Q' : break
f.write(s + '\n')
except KeyboardInterrupt:
print('程序中断！（Ctrl-C)')
finally:
f.close()
测试结果：
请输入字符串（Q键结束）：cava
请输入字符串（Q键结束）：dcav
请输入字符串（Q键结束）：fe
请输入字符串（Q键结束）：4
请输入字符串（Q键结束）：Q

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：自定义异常类

class NumberError(Exception): #自定义异常类，继承于Exception
def __init__(self,data):
Exception.__init__(self, data)
self.data = data
def __str__(self): #重载__str__方法
return self.data + ': 非法数值(< 0)'
def total(data):
total = 0
for i in data:
if i < 0: raise NumberError(str(i))
total += i
return total

#测试代码
data1 = (44, 78, 90, 80, 55)
print('总计=', total(data1))
data2 = (44, 78, 90, -80, 55)
print('总计=', total(data2))

测试结果：
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 21, in <mole>
print('总计=', total(data2))
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 14, in total
if i < 0: raise NumberError(str(i))
__main__.NumberError: -80: 非法数值(< 0)
总计= 347

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：断言

a = int(input("请输入整数a："))
b = int(input("请输入整数b："))
assert b != 0, '除数不能为0'
c = a / b
print(a, '/', b, '=', c)
测试结果：
请输入整数a：1
请输入整数b：0
Traceback (most recent call last):
File "D:\CodeProject\PyCharm\work1\lab6\6-1.py", line 7, in <mole>
assert b != 0, '除数不能为0'
AssertionError: 除数不能为0

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：输出信息跟踪逻辑错误调试：命令行参数分解为素数之积

import sys
n = int(sys.argv[1])
result=[]
factor = 2
while factor*factor <= n:
while (n % factor) == 0:
n //= factor
result.append(factor)
print(n, factor)
factor += 1
if n > 1:
result.append(n)
print(result)
测试结果：
PS D:\CodeProject\PyCharm\work1\lab6> python 6-1.py 1364
682 2
341 2
31 11
[2, 2, 11, 31]

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：默认配置直接输出

import logging
logging.debug("调试信息") #不会输出
logging.info("一般信息")
logging.warning("警告信息")
logging.error("错误信息")
logging.critical("严重错误")
测试结果：
WARNING:root:警告信息
ERROR:root:错误信息
CRITICAL:root:严重错误

# 作者：JohnRothan
# 时间：2022-4-22
# 题目信息：basicConfig配置输出日志到控制台

import logging
#配置logging
logging.basicConfig(level = logging.INFO
,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#输出日志信息
logging.debug("调试信息") #不会输出
logging.info("一般信息")
logging.warning("警告信息")
logging.error("错误信息")
logging.critical("严重错误")
测试结果：
2022-04-22 10:16:14,345 - root - INFO - 一般信息
2022-04-22 10:16:14,345 - root - WARNING - 警告信息
2022-04-22 10:16:14,345 - root - ERROR - 错误信息
2022-04-22 10:16:14,345 - root - CRITICAL - 严重错误

# 作者：JohnRothan
# 时间：2022-4-21
# 题目信息：basicConfig配置输出日志到文件和控制台

import logging
#配置logging
logger = logging.getLogger(__name__)
logger.setLevel(level=logging.DEBUG)
handler = logging.FileHandler("logging_console_file.txt")
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
console = logging.StreamHandler()
console.setLevel(logging.ERROR)
logger.addHandler(handler)
logger.addHandler(console)

#输出日志信息
logger.debug("调试信息")
logger.info("一般信息")
logger.warning("警告信息")
logger.error("错误信息")
logger.critical("严重错误")

测试结果：

控制台：
错误信息
严重错误

文件：
2022-04-22 10:18:41,783 - __main__ - DEBUG - 调试信息
2022-04-22 10:18:41,783 - __main__ - INFO - 一般信息
2022-04-22 10:18:41,783 - __main__ - WARNING - 警告信息
2022-04-22 10:18:41,783 - __main__ - ERROR - 错误信息
2022-04-22 10:18:41,783 - __main__ - CRITICAL - 严重错误

6. python中关于“ _,”的用法请教

python中的异常

异常是指程序中的例外，违例情况。异常机制是指程序出现错误后，程序的处理方法。当出现错误后，程序的执行流程发生改变，程序的控制权转移到异常处理。
Exception类是常用的异常类，该类包括StandardError，StopIteration, GeneratorExit, Warning等异常类。
StandardError类是python中的错误异常，如果程序上出现逻辑错误， 将引发该异常。StandardError类是所有内敛异常的基类，放置在默认的命名空间中，因此使用IOEroor,
EOFError, ImportError等类，不需要导入exception模块。
StopIteration类判断循环是否执行到尾部，如果循环到尾部，则抛出该异常。
GeneratorExit类是由Generator函数引发的异常，当调用close（）时引发该异常。
Warning类表示程序中的代码引起的警告。
python中的异常使用继承结构创建，可以在异常处理程序中捕获基类异常，也可以捕获各种子类异常，python中使用try...except语句捕获异常，异常子句定义在try子句后面。

try...except的使用方法

try...except用于处理问题语句，捕获可能出现的异常。try子句中的代码块放置可能出现异常的语句，except子句中的代码块处理异常。
演示try...except语句捕获IOError异常
try：
file("hello.txt", "r") #如果文件不存在，引发异常
print "读文件"
except IOError: #捕获IO异常
print "文件不存在"
except： #其它异常
print "程序异常"

python与java的异常处理模式相似，异常处理语句也可以嵌套，演示如下:
try:
s = "hello"
try:
print s[0] + s[1]
print s[0] - s[1]
except TypeError:
print "字符串不支持减法运算"
except:
print "异常"
如果外层try子句中的代码引发异常，程序将直接跳转到外层try对应的except子句，而内部的try子句将不会被执行。

try...finally的使用方法
try...except后还可以添加一个finally子句。无论异常是否发生，finally子句都会被执行。所有的finally子句通常用于关闭因异常而不能释放的系统资源。
try:
f = open("hello.txt", "r")
try:
print f.read(5)
except:
print "读文件异常"
finally:
print "释放资源"
f.close()
except IOError:
print "文件不存在"

使用raise抛出异常
当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。
演示raise用法
try:
s = None
if s is None:
print "s 是空对象"
raise NameError #如果引发NameError异常，后面的代码将不能执行
print len(s)
except TypeError:
print "空对象没有长度"

自定义异常
python允许程序员自定义异常，用于描述python中没有涉及的异常情况，自定义异常必须继承Exception类，自定义异常按照命名规范以"Error"结尾，显示地告诉程序员这是异常。自定义异常使用raise语句引发，而且只能通过人工方式触发。
from __future__ import division

class DivisionException(Exception):
def __init__(self, x, y):
Exception.__init__ (self, x, y) #调用基类的__init__进行初始化
self.x = x
self.y = y

if __name__ == "__main__":
try:
x = 3
y = 2
if x % y > 0: #如果大于0， 则不能被初始化，抛出异常
print x/y
raise DivisionException(x, y)
except DivisionException,div: #div 表示DivisionException的实例对象
print "DivisionExcetion: x/y = %.2f" % (div.x/div.y)

assert语句的使用
assert语句用于检测某个条件表达式是否为真。assert语句又称为断言语句，即assert认为检测的表达式永远为真，if语句中的条件判断都可以使用assert语句检测。

7. python:定义一个Circle类，其中有求面积的方法，当半径小于0时，抛出一个用户自定义异常

//圆心坐标在此题中无用，是否是需求有问题。public class Circle { double x; double y; double r; double area; double length; public static void main(String[] args) { Circle c = new Circle(); c.setR(2); c.getArea(); c.getLength(); c.setXY(0, 0); } void setXY(double x, double y) { this.x = x; this.y = y; } void setR(double r) { this.r = r; } void getArea() { area = java.lang.Math.PI * r * r; } void getLength() { length = 2 * java.lang.Math.PI * r; }}

8. Python 异常处理总结

什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。

异常处理： 本站Python教程会具体介绍。
断言(Assertions)：本站Python教程会具体介绍。

异常处理

捕捉异常可以使用try/except语句。try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：

以下为简单的try….except…else的语法：

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

· 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

· 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。

· 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

实例

下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，且并未发生异常：

以上程序输出结果：

实例

下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，但文件没有写入权限，发生了异常：

以上程序输出结果：

使用except而不带任何异常类型

你可以不带任何异常类型使用except，如下实例：

以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。

使用except而带多种异常类型

你也可以使用相同的except语句来处理多个异常信息，如下所示：

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

实例

如果打开的文件没有可写权限，输出如下所示：

同样的例子也可以写成如下方式：

当在try块中抛出一个异常，立即执行finally块代码。finally块中的所有语句执行后，异常被再次提出，并执行except块代码。参数的内容不同于异常。

异常的参数

一个异常可以带上参数，可作为输出的异常信息参数。你可以通过except语句来捕获异常的参数，如下所示：

变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。

元组通常包含错误字符串，错误数字，错误位置。

实例

以下为单个异常的实例：

以上程序执行结果如下：

触发异常

我们可以使用raise语句自己触发异常

raise语法格式如下：

语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是”None”。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

实例

一个异常可以是一个字符串，类或对象。 Python的内核提供的异常，大多数都是实例化的类，这是一个类的实例的参数。

定义一个异常非常简单，如下所示：

注意：为了能够捕获异常，”except”语句必须有用相同的异常来抛出类对象或者字符串。

例如我们捕获以上异常，”except”语句如下所示：

用户自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。

以下为与RuntimeError相关的实例，实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。

在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

在你定义以上类后，你可以触发该异常，如下所示：

来源 | 脚本之家 原文链接：http://www.jb51.net/article/47996.htm

9. python中的异常类的认识理解

9.8. 异常也是类
用户自定义异常也可以是类。利用这个机制可以创建可扩展的异常体系。
以下是两种新的，有效的（语义上的）异常抛出形式，使用 raise 语句:
raise Class
raise Instance
第一种形式中，Class 必须是 type 或其派生类的一个实例。第二种形式是以下形式的简写:
raise Class()
发生的异常其类型如果是 except 子句中列出的类，或者是其派生类，那么它们就是相符的（反过来说－－发生的异常其类型如果是异常子句中列出的类的基类，它们就不相符）。例如，以下代码会按顺序打印 B，C，D:
class B(Exception):
pass
class C(B):
pass
class D(C):
pass
for cls in [B, C, D]:
try:
raise cls()
except D:
print("D")
except C:
print("C")
except B:
print("B")
要注意的是如果异常子句的顺序颠倒过来（ execpt B 在最前），它就会打印 B，B，B－－第一个匹配的异常被触发。
打印一个异常类的错误信息时，先打印类名，然后是一个空格、一个冒号，然后使用内置函数 str() 将类转换得到的完整字符串。

10. Python中程序异常都能被处理吗

“异常”是Python对象，表示一个错误。

如果不想出现异常后程序自动停止运行，编程的人，就要主动捕捉异常，并自己作出相应处理。

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

下面是try/except的示例，说明了怎样处理各种异常：

try:

<语句> #运行别的代码

except <名字>：

<语句> #如果在try部份引发了'name'异常

except <名字>，<数据>:

<语句> #如果引发了'name'异常，获得附加的数据

else:

<语句> #如果没有异常发生

Python的各种标准异常是预先定义好的。基本上包括了常见的异常情况，主要有以下内容。

异常名称 描述

BaseException 所有异常的基类

SystemExit 解释器请求退出

KeyboardInterrupt 用户中断执行(通常是输入^C)

Exception 常规错误的基类

StopIteration 迭代器没有更多的值

GeneratorExit 生成器(generator)发生异常来通知退出

StandardError 所有的内建标准异常的基类

ArithmeticError 所有数值计算错误的基类

FloatingPointError 浮点计算错误

OverflowError 数值运算超出最大限制

ZeroDivisionError 除(或取模)零 (所有数据类型)

AssertionError 断言语句失败

AttributeError 对象没有这个属性

EOFError 没有内建输入,到达EOF 标记

EnvironmentError 操作系统错误的基类

IOError 输入/输出操作失败

OSError 操作系统错误

WindowsError 系统调用失败

ImportError 导入模块/对象失败

LookupError 无效数据查询的基类

IndexError 序列中没有此索引(index)

KeyError 映射中没有这个键

MemoryError 内存溢出错误(对于Python 解释器不是致命的)

NameError 未声明/初始化对象 (没有属性)

UnboundLocalError 访问未初始化的本地变量

ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象

RuntimeError 一般的运行时错误

NotImplementedError 尚未实现的方法

SyntaxError Python 语法错误

IndentationError 缩进错误

TabError Tab 和空格混用

SystemError 一般的解释器系统错误

TypeError 对类型无效的操作

ValueError 传入无效的参数

UnicodeError Unicode 相关的错误

UnicodeDecodeError Unicode 解码时的错误

UnicodeEncodeError Unicode 编码时错误

UnicodeTranslateError Unicode 转换时错误

Warning 警告的基类

DeprecationWarning 关于被弃用的特征的警告

FutureWarning 关于构造将来语义会有改变的警告

OverflowWarning 旧的关于自动提升为长整型(long)的警告

PendingDeprecationWarning 关于特性将会被废弃的警告

RuntimeWarning 可疑的运行时行为(runtime behavior)的警告

SyntaxWarning 可疑的语法的警告

UserWarning 用户代码生成的警告

Python系统处理异常就是提示一下，停止运行。不想停止，只有自己处理。

可以不带类型，所有异常执行同一组语句：

try:
正常的操作
except:
发生异常，执行这块代码
else:
如果没有异常执行这块代码

也可以多个异常共用一段代码：

ry:
正常的操作
except(Exception1[, Exception2[,...ExceptionN]]]):
发生以上多个异常中的一个，执行这块代码
else:
如果没有异常执行这块代码

还有一种格式，可以有finally部分：

try:
fh = open("testfile", "w")
try:
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print "关闭文件"
fh.close()except IOError:
print "Error: 没有找到文件或读取文件失败"

当在try块中抛出一个异常，立即执行finally块代码。

finally块中的所有语句执行后，异常被再次触发，并执行except块代码。

参数的内容不同于异常。

除了标准异常，我们也可以自己定义异常，并进行处理,这时用到raise语句：

raise [Exception [, args [, traceback]]]

语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

相应的异常处理程序示例如下：

try:
正常语句，内含raise语句

except Exception,err:
触发自定义异常

else:
其余代码