特别管理,详细解释在Python中管理非常的教程

目录:

详解在Python中处理异常的教程,详解python教程

什么是异常?

异常是一个事件,其中一个程序,破坏程序的指令的正常流的执行过程中而发生的。一般情况下,当一个Python脚本遇到一些情况不能处理,就抛出一个异常。异常是一个Python对象,它表示一个错误。

当Python脚本抛出一个异常,它必须处理异常,否则将立即终止。
处理异常:

如果有可能会引发异常的一些可疑的代码,就可以通过将可疑的代码在一个try块:保卫你的程序。在try块,包括以下情况except:语句,其次是代码,作为优雅的处理问题,尽可能块。
语法

这里是try....except...else 块的简单语法:

try:
  You do your operations here;
  ......................
except ExceptionI:
  If there is ExceptionI, then execute this block.
except ExceptionII:
  If there is ExceptionII, then execute this block.
  ......................
else:
  If there is no exception then execute this block. 

这里有一些关于上述语法要点:

  •     单个try语句可以有多个不同的语句。当try块中包含可能会引发不同类型的异常语句,这是很有用的。
  •     也可以提供一个通用的except子句,它用来处理任何异常。
  •     except子句后,可以包括其他子句。块没有引发异常:在别的块中的代码,如果在try中的代码执行。
  •     在else块是不需要try:块的代码的保护。

例子

这里是简单的例子,这将打开一个文件并写入内容的文件中并移出正常:

#!/usr/bin/python

try:
  fh = open("testfile", "w")
  fh.write("This is my test file for exception handling!!")
except IOError:
  print "Error: can't find file or read data"
else:
  print "Written content in the file successfully"
  fh.close()

这将产生以下结果:

Written content in the file successfully

示例:

这里有一个更简单的例子,它试图打开没有权限并在文件中写入内容,所以它会引发一个异常:

#!/usr/bin/python

try:
  fh = open("testfile", "r")
  fh.write("This is my test file for exception handling!!")
except IOError:
  print "Error: can't find file or read data"
else:
  print "Written content in the file successfully"

这将产生以下结果:

Error: can't find file or read data

在except子句无异常:

还可以使用不同的定义如下无异常的声明:

try:
  You do your operations here;
  ......................
except:
  If there is any exception, then execute this block.
  ......................
else:
  If there is no exception then execute this block. 

try-except 语句捕获所有出现的异常。使用这种try-except 声明不被认为是一个良好的编程习惯,但因为它捕获所有异常,但不会使程序员找出可能出现的问题的根本原因。
在except子句的多个异常:

也可以使用相同的除语句来处理多个异常,如下所示:

try:
  You do your operations here;
  ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
  If there is any exception from the given exception list, 
  then execute this block.
  ......................
else:
  If there is no exception then execute this block. 

try-finally 语句:

可以使用finally:块连同try:块。在try块是否引发异常或没有任何代码 finally块是一个必须执行的块。try-finally语句的语法是这样的:

try:
  You do your operations here;
  ......................
  Due to any exception, this may be skipped.
finally:
  This would always be executed.
  ......................

请注意,可以提供except子句或finally子句,但不能同时使用。不能同时使用else子句与finally子句。
例子:

#!/usr/bin/python

try:
  fh = open("testfile", "w")
  fh.write("This is my test file for exception handling!!")
finally:
  print "Error: can't find file or read data"

如果没有权限,以写入方式打开文件,那么这将产生以下结果:

Error: can't find file or read data

同样的例子可以写入更简洁,如下所示:

#!/usr/bin/python

try:
  fh = open("testfile", "w")
  try:
   fh.write("This is my test file for exception handling!!")
  finally:
   print "Going to close the file"
   fh.close()
except IOError:
  print "Error: can't find file or read data"

当一个异常被抛出在try块中,执行立即传递到finally块。finally块中的所有语句都执行,该异常被再次抛出,并在被处理 except 语句如果出现在一个更高的层在try-except语句。
Exception参数:

异常可以有一个参数,参数是一个值,它给出了关于这个问题的其他信息。参数按异常内容改变。可以通过不同的子句提供一个变量,如下所示捕获异常的参数:

try:
  You do your operations here;
  ......................
except ExceptionType, Argument:
  You can print value of Argument here...

如果正在编写代码来处理一个异常,可以有一个变量按照异常的名称在不同的声明。如果捕捉多个异常,可以有一个变量按照异常的元组。

这个变量将接收主要包含异常原因的异常值。该变量可以在一个元组的形式接收一个或多个值。该元组通常包含错误串,错误码和一个错误的位置。
示例:

下面是一个异常的例子:

#!/usr/bin/python

# Define a function here.
def temp_convert(var):
  try:
   return int(var)
  except ValueError, Argument:
   print "The argument does not contain numbersn", Argument

# Call above function here.
temp_convert("xyz");

这将产生以下结果:

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

抛出异常:

可以通过使用raise语句抛出几个方面的异常。一般raise语句的语法。
语法

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

这里,Exception是异常的类型(例如,NameError)和参数是用于异常的参数值。该参数是可选的;如果未提供,则异常的参数是None。

最后一个参数traceback,也是可选的(并且在实践中很少使用),并且如果存在的话,那么用于异常回溯对象。
例子:

异常可以是一个字符串,一个类或一个对象。大多数Python核心抛出是类,有参数认为是类的实例的异常。定义新的异常是很容易的,可以参考如下:

def functionName( level ):
  if level < 1:
   raise "Invalid level!", level
   # The code below to this would not be executed
   # if we raise the exception

注:为了捕获一个异常,“except”语句必须引用抛出类对象或简单的字符串相同的异常。例如,捕捉到上面的异常,必须写except子句,如下所示:

try:
  Business Logic here...
except "Invalid level!":
  Exception handling here...
else:
  Rest of the code here...

用户定义的异常:

Python中,还可以通过内置的异常标准的派生类来创建自己的异常。

下面是有关RuntimeError一个例子。这里是从RuntimeError子类的类被创建。当需要显示更多的具体信息时,一个异常被捕获,这是很有用的。

在try块中,用户定义的异常引发,并夹在except块。变量e被用来创建类Networkerror的一个实例。

class Networkerror(RuntimeError):
  def __init__(self, arg):
   self.args = arg

所以一旦在上面定义的类,可以按如下方法抛出异常:

try:
  raise Networkerror("Bad hostname")
except Networkerror,e:
  print e.args

什么是异常? 异常是一个事件,其中一个程序,破坏程序的指令的正常流的执行过程中而发...

什么是异常?

异常即是一个事件,该事件会在程序执行过程中发生,影响了程序的正常执行。

一般情况下,在Python无法正常处理程序时就会发生一个异常。

异常是Python对象,表示一个错误。

当Python脚本发生异常时我们需要捕获处理它,否则程序会终止执行。

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

  一、try-except语句

抛出异常和自定义异常

raise 语句

Python中的raise 关键字用于引发一个异常,基本上和C#和Java中的throw关键字相同

#coding:UTF8

def ThorwErr():
  raise Exception("抛出一个异常")

# Exception: 抛出一个异常
ThorwErr()

raise关键字后面是抛出是一个通用的异常类型(Exception),一般来说抛出的异常越详细越好,Python在exceptions模块内建了很多的异常类型,通过使用dir函数来查看exceptions中的异常类型,如下:

#coding:UTF8

import exceptions

# ['ArithmeticError', 'AssertionError'.....]
print dir(exceptions)

传递异常

捕捉到了异常,但是又想重新引发它(传递异常),可以使用不带参数的raise语句即可:

#coding:UTF8

class MuffledCalculator:
  muffled = False
  def calc(self,expr):
    try:
      return eval(expr)
    except ZeroDivisionError:
      if self.muffled:
        print 'Division by zero is illegal'
      else:
        raise

自定义异常类型

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

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

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

 

class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg

#在你定义以上类后,你可以触发该异常,如下所示:

try:
    raise Networkerror("Bad hostname")
except Networkerror,e:
    print e.args

运行结果:
('B', 'a', 'd', ' ', 'h', 'o', 's', 't', 'n', 'a', 'm', 'e')

 

 

我们可打开idle-->F1进行查看文档,里面很多异常类型,如图:

  二、try-finally语句

异常处理

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

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

如果你不想在异常发生时结束你的程序,只需在try里捕获它。

语法:

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

try:
<语句>        #运行别的代码
except <名字>:
<语句>        #如果在try部份引发了'name'异常
except <名字>,<数据>:
<语句>        #如果引发了'name'异常,获得附加的数据
else:
<语句>        #如果没有异常发生

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

  • 如果当try后的语句执行时发生异常,python就跳回到try并执行第一个匹配该异常的except子句,异常处理完毕,控制流就通过整个try语句(除非在处理异常时又引发新的异常)。
  • 如果在try后的语句里发生了异常,却没有匹配的except子句,异常将被递交到上层的try,或者到程序的最上层(这样将结束程序,并打印缺省的出错信息)。
  • 如果在try子句执行时没有发生异常,python将执行else语句后的语句(如果有else的话),然后控制流通过整个try语句。

 

图片 1

  三、raise语句

实例

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

 

 

 1 #coding:UTF8
 2 
 3 try:
 4     fh = open("testfile", "w")
 5     fh.write("这是一个测试文件,用于测试异常!!")
 6 except IOError:
 7     print "Error: 没有找到文件或读取文件失败"
 8 else:
 9     print "内容写入文件成功"
10     fh.close()

运行结果:
内容写入文件成功

 

  四、课时33课后习题及答案

实例

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

 

 1 #coding:UTF8
 2 
 3 
 4 try:
 5     fh = open("testfile", "r")
 6     fh.write("这是一个测试文件,用于测试异常!!")
 7 except IOError:
 8     print "Error: 没有找到文件或读取文件失败"
 9 else:
10     print "内容写入文件成功"
11     fh.close()

运行结果:
Error: 没有找到文件或读取文件失败

 

 

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

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

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

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

 

什么是异常?

异常即是一个事件,该事件会在程序执行过程中发生,影响了程序的正常执行。

一般情况下,在Python无法正常处理程序时就会发生一个异常。

异常是Python对象,表示一个错误。

当Python脚本发生异常时我们需要捕获处理它,否则程序会终止执行。

**********************

使用except而带多种异常类型

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

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

异常处理

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

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

如果你不想在异常发生时结束你的程序,只需在try里捕获它。

语法:

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

try``:

<语句>        ``#运行别的代码

except <名字>:

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

except <名字>,<数据>:

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

else``:

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

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

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

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

#如果在try子句执行时没有发生异常,python将执行else语句后的语句(如果有else的话),然后控制流通过整个try语句。

 

一、try-except语句

try-finally 语句

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

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

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

#coding:UTF8


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

运行结果:
关闭文件
Error: 没有找到文件或读取文件失败

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

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

 

总结性:

 1 #coding:UTF8
 2 def div(a, b):
 3     try:
 4         print(a / b)
 5     except ZeroDivisionError:
 6         print("Error: b should not be 0 !!")
 7     except Exception as e:
 8         print("Unexpected Error: {}".format(e))
 9     else:
10         print('Run into else only when everything goes well')
11     finally:
12         print('Always run into finally block.')
13 
14 # 验证
15 div(2, 0)
16 div(2, 'bad type')
17 div(1, 2)

 

参数的内容不同于异常。

实例

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

#!/usr/bin/python

 

try``:

``fh ``= open``(``"testfile"``, ``"w"``)

``fh.write(``"This is my test file for exception handling!!"``)

except IOError:

``print "Error: can't find file or read data"

else``:

``print "Written content in the file successfully"

``fh.close()

以上程序输出结果:

``Written content ``in the ``file successfully

 

**********************

python标准异常

图片 2

 

实例

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

#!/usr/bin/python

 

try``:

``fh ``= open``(``"testfile"``, ``"r"``)

``fh.write(``"This is my test file for exception handling!!"``)

except IOError:

``print "Error: can't find file or read data"

else``:

``print "Written content in the file successfully"

 

以上程序输出结果:

Error: can't find ``file or read data

 

try-except语句格式如下:

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

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

try``:

``You do your operations here;

``......................

except``:

``If there ``is any exception, then execute this block.

``......................

else``:

``If there ``is no exception then execute this block.

try:
    检测范围
except Exception[as reason]:
    出现异常(Exception)后的处理代码

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

 try-except语句用于检测和处理异常,举个例子来说明这一切是如何操作的:

使用except而带多种异常类型

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

try``:

``You do your operations here;

``......................

except``(Exception1[, Exception2[,...ExceptionN]]]):

``If there ``is any exception ``from the given exception ``list``,

``then execute this block.

``......................

else``:

``If there ``is no exception then execute this block.

 

f = open("我为什么是一个文档.txt")
print(f.read())
f.close()

try-finally 语句

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

try``:

<语句>

finally``:

<语句>    ``#退出try时总会执行

raise

 

注意:你可以使用except语句或者finally语句,但是两者不能同时使用。else语句也不能与finally语句同时使用

#!/usr/bin/python

 

try``:

``fh ``= open``(``"testfile"``, ``"w"``)

``fh.write(``"This is my test file for exception handling!!"``)

finally``:

``print "Error: can't find file or read data"

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

Error: can't find ``file or read data

 

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

#!/usr/bin/python

 

try``:

``fh ``= open``(``"testfile"``, ``"w"``)

``try``:

``fh.write(``"This is my test file for exception handling!!"``)

``finally``:

``print "Going to close the file"

``fh.close()

except IOError:

``print "Error: can't find file or read data"

 

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

finally块中的所有语句执行后,异常被再次提出,并执行except块代码。

参数的内容不同于异常。

以上代码在“我为什么是一个文档.txt”这个文档不存在的时候,Python就会报错说文件不存在:

异常的参数

一个异常可以带上参数,可作为输出的异常信息参数。

你可以通过except语句来捕获异常的参数,如下所示:

try``:

``You do your operations here;

``......................

except ExceptionType, Argument:

``You can ``print value of Argument here...

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

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

Traceback (most recent call last):
  File "C:Users14158Desktoplalallalalal.py", line 1, in <module>
    f = open("我为什么是一个文档.txt")
FileNotFoundError: [Errno 2] No such file or directory: '我为什么是一个文档.txt'

实例

以下为单个异常的实例:

#!/usr/bin/python

 

# Define a function here.

def temp_convert(var):

``try``:

``return int``(var)

``except ValueError, Argument:

``print "The argument does not contain numbersn"``, Argument

 

# Call above function here.

temp_convert(``"xyz"``);

 

以上程序执行结果如下:

The argument does ``not contain numbers

invalid literal ``for int``() with base ``10``: ``'xyz'

 

显然这样的用户体验很糟糕,因此可以这样修改:

触发异常

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

raise语法格式如下:

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

 

语句中Exception是异常的类型(例如,NameError)参数是一个异常参数值。该参数是可选的,如果不提供,异常的参数是"None"。

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

try:
      f = open("我为什么是一个文档.txt")
      print(f.read())
      f.close()
except OSError:
      print("文件打开的过程出错啦")

实例

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

定义一个异常非常简单,如下所示:

def functionName( level ):

``if level < ``1``:

``raise "Invalid level!"``, level

``# The code below to this would not be executed

``# if we raise the exception

 

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

例如我们捕获以上异常,"except"语句如下所示:

try``:

``Business Logic here...

except "Invalid level!"``:

``Exception handling here...

else``:

``Rest of the code here...

 

上面的例子由于使用了大家习惯的语言来表达错误的信息,用户体验当然会好很多:

用户自定义异常

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

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

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

 

class Networkerror(RuntimeError):

``def __init__(``self``, arg):

``self``.args ``= arg

 

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

try``:

``raise Networkerror(``"Bad hostname"``)

except Networkerror,e:

``print e.args

 

 

 

 

 

 

 

 

 

文件打开的过程出错啦

但是从程序员的角度来看,导致OSError异常的原因有很多(例如FileExistsError、FileNotFoundError等等),所以可能会更在意错误的具体内容,这里可以使用as把具体的错误信息给打印出来:

try:
      f = open("我为什么是一个文档.txt")
      print(f.read())
      f.close()
except OSError as reason:
      print("文件打开的过程出错啦,错误的原因是:"   str(reason))



文件打开的过程出错啦,错误的原因是:[Errno 2] No such file or directory: '我为什么是一个文档.txt'

 

1、针对不同异常设置多个except

一个try语句还可以和多个except语句搭配,分别对感兴趣的异常进行检测处理:

try:
      sum = 1   '1'
      f = open("我是一个不存在的文档.txt")
      print(f.read())
      f.close()
except OSError as reason:
      print("文件打开的过程出错啦,错误的原因是:"   str(reason))
except TypeError as reason:
      print("文件打开的过程出错啦,错误的原因是:"   str(reason))



文件打开的过程出错啦,错误的原因是:unsupported operand type(s) for  : 'int' and 'str'

 

2、对多个异常统一处理

except后边还可以跟多个异常,然后对这些异常进行统一的处理:

try:
      int("abc")
      sum = 1   "1"
      f = open("我是一个不存在的文档.txt")
      print(f.read())
      f.close()
except (OSError,TypeError):
      print("文件打开的过程出错啦,错误的原因是:"   str(reason))



Traceback (most recent call last):
  File "C:Users14158Desktoplalallalalal.py", line 2, in <module>
    int("abc")
ValueError: invalid literal for int() with base 10: 'abc'

 

3、捕获所有的异常

如果你无法确定要对哪一类异常进行处理,只是希望在try语句块里一旦出现异常,可以给用户一个“看得懂”的提醒,那么可以这么做。

............

except:

  print("出错了~")

............

不过通常不建议这么做,因为它会隐藏所有程序员未想到并且未做好处理准备的错误,例如当用户输入ctrl C试图终止程序,却被解释为KeyboardInterrupt异常。另外要注意的是,try语句检测范围内一旦出现异常,剩下的语句将不会执行。

 

*********************

二、try-finally语句

*********************

 如果“我是一个不存在的文档”确实存在,open()函数正常返回文件对象,但异常却发生在成功打开文件后的sum = 1 “1”语句上。此时python将直接跳转到except语句,也就是说,文件被打开了,但并没有执行关闭的命令:

try:
      f = open("我是一个不存在的文档.txt")
      print(f.read())
      sum = 1   "1"
      f.close()
except:
      print("出错啦")       

为了实现像这种“就算出现异常,但不得不执行的收尾工作(比如在程序崩溃前保存用户文档)”,引入了finally来扩展try:

try:
      f = open("我是一个不存在的文档.txt")
      print(f.read())
      sum = 1   "1"
except:
      print("出错啦")
finally:
      f.close()

如果try语句块中没有出现任何运行时出现的错误,会跳过except语句执行finally语句块的内容。如果出现异常,则会先执行except语句块的内容再执行finally语句块的内容。总之,finally语句块中的内容就是确保无论如何都将被执行的内容。

 

****************

三、raise语句

****************

 也许会问,我的代码能不能自己抛出一个异常呢?答案是可以的,可以使用raise语句抛出一个异常:

>>> raise ZeroDivisionError
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    raise ZeroDivisionError
ZeroDivisionError

抛出的异常还可以带参数,表示异常的解释:

>>> raise ZeroDivisionError("除数不能为零!")
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    raise ZeroDivisionError("除数不能为零!")
ZeroDivisionError: 除数不能为零!

 

*******************************

四、课时33课后习题及答案

*******************************

图片 3图片 4图片 5图片 6图片 7图片 8图片 9图片 10图片 11图片 12图片 13图片 14图片 15

本文由星彩网app下载发布于计算机编程,转载请注明出处:特别管理,详细解释在Python中管理非常的教程

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。