python学习第25天

时间：2022-06-12 12:19:06

异常处理

什么是异常？什么是错误？

1，程序中难免出现错误。

错误主要分为两种：

　　1，语法错误

　　　　语法错误是根本上的错误，无法通过PYTHON解释器。完全无法执行，是在程序中不应该出现的错误。无法进行异常处理。

　　2，逻辑错误

　　　　是对编程的逻辑存在一定的认知不足，需要重新构思逻辑。这一类大多是python做不到的事。可以进行异常处理。

 AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x

 IOError 输入/输出异常；基本上是无法打开文件

 ImportError 无法引入模块或包；基本上是路径问题或名称错误

 IndentationError 语法错误（的子类） ；代码没有正确对齐

 IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]

 KeyError 试图访问字典里不存在的键

 KeyboardInterrupt Ctrl+C被按下

 NameError 使用一个还未被赋予对象的变量

 SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）

 TypeError 传入对象类型与要求的不符合

 UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，

 导致你以为正在访问它

 ValueError 传入一个调用者不期望的值，即使值的类型是正确的

常用语法异常

 ArithmeticError

 AssertionError

 AttributeError

 BaseException

 BufferError

 BytesWarning

 DeprecationWarning

 EnvironmentError

 EOFError

 Exception

 FloatingPointError

 FutureWarning

 GeneratorExit

 ImportError

 ImportWarning

 IndentationError

 IndexError

 IOError

 KeyboardInterrupt

 KeyError

 LookupError

 MemoryError

 NameError

 NotImplementedError

 OSError

 OverflowError

 PendingDeprecationWarning

 ReferenceError

 RuntimeError

 RuntimeWarning

 StandardError

 StopIteration

 SyntaxError

 SyntaxWarning

 SystemError

 SystemExit

 TabError

 TypeError

 UnboundLocalError

 UnicodeDecodeError

 UnicodeEncodeError

 UnicodeError

 UnicodeTranslateError

 UnicodeWarning

 UserWarning

 ValueError

 Warning

 ZeroDivisionError

所有异常类型

代码异常后会发生什么？

代码停止执行，进行报错提示。除了finally语句中的代码，全都不执行。

什么是异常处理？

python解释器检测到错误，触发异常（也允许程序员自己触发异常）

程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）

如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理

为什么要进行异常处理？

python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。

所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性

如何进行异常处理？

首先须知，异常是由程序的错误引起的，语法上的错误跟异常处理无关，必须在程序运行前就修正

1，我们常见的if语句判断输入的数据的组成就是一种异常处理。

（欠一段代码）

2，python为每一种异常定制了一个类型，然后提供了一种特定的语法结构用来进行异常处理

　　1,基本语法

　　　　try：

　　　　    被检测的代码块

　　　　except 异常类型：

　　　　    try中一旦检测到异常，就执行这个位置的逻辑。

　　2，异常类只能用来处理指定的异常情况，如果是非指定异常则无法处理。

　　　　当报错的类型是异常处理中没有指定的异常。则不拦截错误，直接报错。

　　3，多分支

 s1 = 'hello'

 try:

     int(s1)

 except IndexError as e:

     print(e)

 except KeyError as e:

     print(e)

 except ValueError as e:

     print(e)

多分支的创建方式。

　　4，万能异常

 s1 = 'hello'

 try:

     int(s1)

 except Exception as e: #万能异常Exception,可以捕获所有的异常。

     print(e)

 关于万能异常:

     由于万能异常可以捕获所有的错误，所以有以下特点。

         1，在异常处理分支中，Exception下面的异常分支无法运行。

         2，如果不将错误信息赋值，便无法查看错误信息。在调试程序时非常的

            不便于调试。

异常的其他组成

finally语句

 s1 = 'hello'

 try:

     int(s1)

 except IndexError as e:

     print(e)

 except KeyError as e:

     print(e)

 except ValueError as e:

     print(e)

 #except Exception as e:

 #    print(e)

 e是except收集的错误信息，可以通过调用查看作物信息，常在Exception中使用。

 else:

     print('try内代码块没有异常则执行我')

 finally:

     print('无论异常与否,都会执行该模块,通常是进行清理工作')

finally语句

主动触发异常

 try:

     raise TypeError('类型错误')

 except Exception as e:

     print(e)

主动触发异常

自定义异常

 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)

自定义异常

断言

 # assert 条件

 assert 1 == 1

 assert 1 == 2

try..except这种异常处理机制就是取代if那种方式，让你的程序在不牺牲可读性的前提下增强健壮性和容错性

异常处理中为每一个异常定制了异常类型（python中统一了类与类型，类型即类），对于同一种异常，一个except就可以捕捉到，可以同时处理多段代码的异常（无需‘写多个if判断式’）减少了代码，增强了可读性

使用try..except的方式

1：把错误处理和真正的工作分开来
2：代码更易组织，更清晰，复杂的工作任务更容易实现；
3：毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；

什么时候使用异常处理？

try...except应该尽量少用，因为它本身就是你附加给你的程序的一种异常处理的逻辑，与你的主要的工作是没有关系的
这种东西加的多了，会导致你的代码可读性变差，只有在有些异常无法预知的情况下，才应该加上try...except，其他的逻辑错误应该尽量修正

异常的继承关系

    

 BaseException

  +-- SystemExit

  +-- KeyboardInterrupt

  +-- GeneratorExit

  +-- Exception

       +-- StopIteration

       +-- StandardError

       |    +-- BufferError

       |    +-- ArithmeticError

       |    |    +-- FloatingPointError

       |    |    +-- OverflowError

       |    |    +-- ZeroDivisionError

       |    +-- AssertionError

       |    +-- AttributeError

       |    +-- EnvironmentError

       |    |    +-- IOError

       |    |    +-- OSError

       |    |         +-- WindowsError (Windows)

       |    |         +-- VMSError (VMS)

       |    +-- EOFError

       |    +-- ImportError

       |    +-- LookupError

       |    |    +-- IndexError

       |    |    +-- KeyError

       |    +-- MemoryError

       |    +-- NameError

       |    |    +-- UnboundLocalError

       |    +-- ReferenceError

       |    +-- RuntimeError

       |    |    +-- NotImplementedError

       |    +-- SyntaxError

       |    |    +-- IndentationError

       |    |         +-- TabError

       |    +-- SystemError

       |    +-- TypeError

       |    +-- ValueError

       |         +-- UnicodeError

       |              +-- UnicodeDecodeError

       |              +-- UnicodeEncodeError

       |              +-- UnicodeTranslateError

       +-- Warning

            +-- DeprecationWarning

            +-- PendingDeprecationWarning

            +-- RuntimeWarning

            +-- SyntaxWarning

            +-- UserWarning

            +-- FutureWarning

        +-- ImportWarning

        +-- UnicodeWarning

        +-- BytesWarning

异常的继承关系

logging模块

函数式简单配置

 import logging

 logging.debug('debug message')

 logging.info('info message')

 logging.warning('warning message')

 logging.error('error message')

 logging.critical('critical message')

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

灵活配置日志级别，日志格式，输出位置：

 import logging

 logging.basicConfig(level=logging.DEBUG,

                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',

                     datefmt='%a, %d %b %Y %H:%M:%S',

                     filename='/tmp/test.log',

                     filemode='w')  

 logging.debug('debug message')

 logging.info('info message')

 logging.warning('warning message')

 logging.error('error message')

 logging.critical('critical message')

配置参数：

 logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

 filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。

 filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。

 format：指定handler使用的日志显示格式。

 datefmt：指定日期时间格式。

 level：设置rootlogger（后边会讲解具体概念）的日志级别

 stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

 format参数中可能用到的格式化串：

 %(name)s Logger的名字

 %(levelno)s 数字形式的日志级别

 %(levelname)s 文本形式的日志级别

 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有

 %(filename)s 调用日志输出函数的模块的文件名

 %(module)s 调用日志输出函数的模块名

 %(funcName)s 调用日志输出函数的函数名

 %(lineno)d 调用日志输出函数的语句所在的代码行

 %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示

 %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数

 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

 %(thread)d 线程ID。可能没有

 %(threadName)s 线程名。可能没有

 %(process)d 进程ID。可能没有

 %(message)s用户输出的消息

配置参数

logger对象配置

 import logging

 logger = logging.getLogger()

 # 创建一个handler，用于写入日志文件

 fh = logging.FileHandler('test.log',encoding='utf-8') 

 # 再创建一个handler，用于输出到控制台

 ch = logging.StreamHandler()

 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

 fh.setLevel(logging.DEBUG)

 fh.setFormatter(formatter)

 ch.setFormatter(formatter)

 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象

 logger.addHandler(ch) 

 logger.debug('logger debug message')

 logger.info('logger info message')

 logger.warning('logger warning message')

 logger.error('logger error message')

 logger.critical('logger critical message')

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过

fh.setLevel(logging.Debug)单对文件流设置某个级别。

相关文章