try：
<代码块> 
except <异常名字>
print(‘语句’)
实例如下：
def func():
try:
a = x/y
print('a=',a)
return a
eccept Exception:
print('程序出现异常，异常信息：被除数为0')

class EvaException(BaseException):
def __init__(self,msg):
self.msg=msg
def __str__(self):
return self.msg

try:
raise EvaException('类型错误')
except EvaException as e:
print(e)

try:
<语句>
except <异常名字>：
print（‘异常说明’）
except <异常名字>：
print（‘异常说明’）
try语句的工作方式如下：
　　首次执行try中语句块，如果没有发生异常，则忽略except中的字句，try语句中的代码块执行后结束。如果try语句中的代码块出现异常，try中的剩余语句则会被忽略，
如果异常和eccept中的异常名字一直，相应的except语句就会被执行。如果一个异常也没有匹配，这个异常就会传递给上层的try语句中，一个语句可能包含第一个except语句，
分别处理不同的异常，但是最多只有一个分支会执行。
try:
#a
#1/0
dic = {1:2}
dic[3]
except NameError:
print('名字没有定义，报错了')
except ZeroDivisionError:
print('0不能当做除数，报错了')
except KeyError:
print('没有这个key')

try:
<语句>
except <异常名字> ：
<语句>
except <异常名字>：
<语句>
else：
<语句> #(try语句中没有异常后执行此段代码)
如果在try语句中执行没有发生异常，就会执行else语句，使用else语句比把所有语句都放在try字句里面更好，这样可以避免一些意想不到的而except有没有捕获到的异常：
def func(x,y):
try:
a = x/y
except :
print('Error,happened')
else:
print('It went as execpt')
func(2,1)

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 "<stdin>", line 1, in ?
main__.MyError: 'oops!'
在这个例子中，类 Exception 默认的 __init__() 被覆盖。

当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):
"""Base class for exceptions in this module."""
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"结尾，就跟标准的异常命名一样。

>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
... 
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

>>> def divide(x, y):
try:
result = x / y
except ZeroDivisionError:
print("division by zero!")
else:
print("result is", result)
finally:
print("executing finally clause")

>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
预定义的清理行为
一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"):
print(line, end="")
以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:
for line in f:
print(line, end="")
以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。