- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

Python基础：异常与模块

AI浩发表于 2022/01/18 06:36:36 2022/01/18

【摘要】 13 异常当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。 13.1 捕获异常 13.1.1 捕获异常 try…except…看如下示例:try: print('-----test--1---') open('123.txt','r') print('-----test--2---')except IOError: ...

13 异常

当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。

13.1 捕获异常

13.1.1 捕获异常 try…except…

看如下示例:

try:
    print('-----test--1---')
    open('123.txt','r')
    print('-----test--2---')
except IOError:
    pass

运行结果:

-----test--1---

说明:

此程序看不到任何错误，因为用except 捕获到了IOError异常，并添加了处理的方法
pass 表示实现了相应的实现，但什么也不做；如果把pass改为print语句，那么就会输出其他信息

小总结:

把可能出现问题的代码，放在try中
把处理异常的代码，放在except中

13.1.2 except捕获多个异常

看如下示例:

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

运行结果如下:

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 2, in <module>
    print(num)
NameError: name 'num' is not defined

想一想:

上例程序，已经使用except来捕获异常了，为什么还会看到错误的信息提示？

答:

except捕获的错误类型是IOError，而此时程序产生的异常为 NameError ，所以except没有生效

修改后的代码为:

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

运行结果如下:

产生错误了

实际开发中，捕获多个异常的方式，如下：

#coding=utf-8
try:
    print('-----test--1---')
    open('123.txt','r') # 如果123.txt文件不存在，那么会产生 IOError 异常
    print('-----test--2---')
    print(num)# 如果num变量没有定义，那么会产生 NameError 异常

except (IOError,NameError):
    #如果想通过一次except捕获到多个异常可以用一个元组的方式
    # errorMsg里会保存捕获到的错误信息
    print(errorMsg)

运行结果：

-----test--1---
Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 4, in <module>
    open('123.txt','r') # 如果123.txt文件不存在，那么会产生 IOError 异常
FileNotFoundError: [Errno 2] No such file or directory: '123.txt'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 12, in <module>
    print(errorMsg)
NameError: name 'errorMsg' is not defined

注意：

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

13.1.3 获取异常的信息描述

13.1.4捕获所有异常

13.1.5 else

咱们应该对else并不陌生，在if中，它的作用是当条件不满足时执行的实行；同样在try…except…中也是如此，即如果没有捕获到异常，那么就执行else中的事情

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

运行结果如下:

100
没有捕获到异常，真高兴

13.1.6 try…finally…

try…finally…语句用来表达这样的情况：

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

demo:

import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    except:
        #如果在读取文件的过程中，产生了异常，那么就会捕获到
        #比如 按下了 ctrl+c
        pass
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

说明:

test.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl+c中断（取消）程序。

我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。

13.2 异常的传递

13.2.1. try嵌套中

import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

运行结果:

没有这个文件

13.2.2 函数嵌套调用中

def test1():
    print("----test1-1----")
    print(num)
    print("----test1-2----")


def test2():
    print("----test2-1----")
    test1()
    print("----test2-2----")


def test3():
    try:
        print("----test3-1----")
        test1()
        print("----test3-2----")
    except Exception as result:
        print("捕获到了异常，信息是:%s" % result)

    print("----test3-2----")


test3()
print("------华丽的分割线-----")
test2()

运行结果:

----test3-1----
----test1-1----
捕获到了异常，信息是:name 'num' is not defined
----test3-2----
------华丽的分割线-----
----test2-1----
----test1-1----
Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 26, in <module>
    test2()
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 9, in test2
    test1()
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 3, in test1
    print(num)
NameError: name 'num' is not defined

总结：

如果try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递。。。
如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C,而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样
注意观察上图中，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行

13.3 抛出自定义的异常

你可以用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类

下面是一个引发异常的例子:

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

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

main()

运行结果如下:

请输入 --> 11
ShortInputException: 输入的长度是 2,长度至少应是 3

注意

以上程序中，关于代码#super().init()的说明

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

13.4 异常处理中抛出异常

class Test(object):
    def __init__(self, switch):
        self.switch = switch #开关
    def calc(self, a, b):
        try:
            return a/b
        except Exception as result:
            if self.switch:
                print("捕获开启，已经捕获到了异常，信息如下:")
                print(result)
            else:
                #重新抛出这个异常，此时就不会被这个异常处理给捕获到，从而触发默认的异常处理
                raise


a = Test(True)
a.calc(11,0)

print("----------------------华丽的分割线----------------")

a.switch = False
a.calc(11,0)

运行结果：

捕获开启，已经捕获到了异常，信息如下:
division by zero
----------------------华丽的分割线----------------
Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 21, in <module>
    a.calc(11,0)
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 6, in calc
    return a/b
ZeroDivisionError: division by zero

14 模块

14.1 模块介绍

14.1.1 Python中的模块

有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt函数，必须用语句#include <math.h>引入math.h这个头文件，否则是无法正常进行调用的。

那么在Python中，如果要引用一些其他的函数，该怎么处理呢？

在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块，下面就来了解一下Python中的模块。

说的通俗点：模块就好比是工具包，要想使用这个工具包中的工具(就好比函数)，就需要导入这个模块

14.1.2 import

在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。

形如:

    import module1,mudule2...

当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。

在调用math模块中的函数时，必须这样引用：

　　模块名.函数名

想一想:

为什么必须加上模块名调用呢？
答:

因为可能存在这样一种情况：在多个模块中含有相同名称的函数，此时如果只是通过函数名来调用，解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候，调用函数必须加上模块名

    import math

    #这样会报错
    print sqrt(2)

    #这样才能正确输出结果
    print math.sqrt(2)

有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：

    from 模块名 import 函数名1,函数名2....

不仅可以引入函数，还可以引入一些全局变量、类等

注意:
- 通过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，但是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( )，在模块B中也有函数function( )，如果引入A中的function在先、B中的function在后，那么当调用function函数的时候，是去执行模块B中的function函数。
- 如果想一次性引入math中所有的东西，还可以通过from math import *来实现

14.1.3 from…import

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中

语法如下：

    from modname import name1[, name2[, ... nameN]]

例如，要导入模块fib的fibonacci函数，使用如下语句：

    from fib import fibonacci

注意

不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入

14.1.4 from … import *

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

    from modname import *

注意

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

14.1.5 as

    In [1]: import time as tt

    In [2]: time.sleep(1)
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-2-07a34f5b1e42> in <module>()
    ----> 1 time.sleep(1)

    NameError: name 'time' is not defined

    In [3]: 

    In [3]: 

    In [3]: tt.sleep(1)

    In [4]: 

    In [4]: 

    In [4]: from time import sleep as sp

    In [5]: sleep(1)
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-5-82e5c2913b44> in <module>()
    ----> 1 sleep(1)

    NameError: name 'sleep' is not defined

    In [6]: 

    In [6]: 

    In [6]: sp(1)

    In [7]:

14.1.6 定位模块

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

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

14.2 制作模块

14.2.1 定义自己的模块

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。

比如有这样一个文件test.py，在test.py中定义了函数add

test.py

    def add(a,b):
        return a+b

14.2.2 调用自己定义的模块

那么在其他文件中就可以先import test，然后通过test.add(a,b)来调用了，当然也可以通过from test import add来引入

main.py

    import test

    result = test.add(11,22)
    print(result)

14.2.3 测试模块

在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：

test.py
    def add(a,b):
        return a+b

    # 用来进行测试
    ret = add(12,22)
    print('int test.py file,,,,12+22=%d'%ret)

如果此时，在其他py文件中引入了此文件的话，想想看，测试的那段代码是否也会执行呢！

main.py
    import test

    result = test.add(11,22)
    print(result)

运行现象：

int test.py file,,,,12+22=34
33

至此，可发现test.py中的测试代码，应该是单独执行test.py文件时才应该执行的，不应该是其他的文件中引用而执行

为了解决这个问题，python在执行一个文件时有个变量__name__

直接运行此文件

def add(a, b):
    return a + b
# # 用来进行测试
# ret = add(12,22)
# print('int test.py file,,,,12+22=%d'%ret)
print("in test.py file,__name__ is %s "%__name__)

运行结果：

in test.py file,__name__ is __main__

在其他文件中import此文件

in test.py file,__name__ is test 
33

总结：

可以根据__name__变量的结果能够判断出，是直接执行的python脚本还是被引入执行的，从而能够有选择性的执行测试代码

执行test.py:

def add(a, b):
    return a + b


if __name__ == "__main__":
    # 用来进行测试
    ret = add(12, 22)
    print('int test.py file,,,,12+22=%d' % ret)
    print("in test.py file,__name__ is %s " % __name__)

运行结果:

D:\ProgramData\Anaconda3\python.exe C:/Users/WH/Desktop/Python基础/test.py
int test.py file,,,,12+22=34
in test.py file,__name__ is __main__

执行main.py ：

import test

result = test.add(11, 22)
print(result)

运行结果：

14.3 模块中的`all`

14.3.1 没有`all`

test.py

class Test(object):
    def test(self):
        print("Test类中的test函数")
def test1():
    print("test1函数")
def test2():
    print("test2函数")

main.py调用

from test import *

a=Test()
print(a.test())
print(test1())
print(test2())

运行结果：

Test类中的test函数
None
test1函数
None
test2函数
None

14.3.2. 模块中有`all`

__all__=["Test","test1"]
class Test(object):
    def test(self):
        print("Test类中的test函数")
def test1():
    print("test1函数")
def test2():
    print("test2函数")

执行main.py

from test import *

a=Test()
print(a.test())
print(test1())
print(test2())

运行结果：

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 6, in <module>
    print(test2())
NameError: name 'test2' is not defined
Test类中的test函数
None
test1函数
None

总结

如果一个文件中有__all__变量，那么也就意味着这不在变量中的元素，不会被from xxx import *时导入

14.4 python中的包

14.4.1. 引入包

有2个模块功能有些联系

所以将其放到同一个文件夹下

使用import 文件.模块的方式导入

使用from 文件夹 import 模块的方式导入

在msg文件夹下创建__init__.py文件

在__init__.py文件中写入

重新使用from 文件夹 import 模块的方式导入

总结：

包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py 文件，那么这个文件夹就称之为包
有效避免模块名称冲突问题，让应用组织结构更加清晰

14.4.2 `init.py`文件作用

__init__.py 控制着包的导入行为

__init__.py为空，仅仅是把这个包导入，不会导入包中的模块

__all__在__init__.py文件中，定义一个__all__变量，它控制着 from 包名 import *时导入的模块

14.5 模块发布

1.mymodule目录结构体如下：

.
├── setup.py
├── suba
│   ├── aa.py
│   ├── bb.py
│   └── __init__.py
└── subb
    ├── cc.py
    ├── dd.py
    └── __init__.py

2.编辑setup.py文件

py_modules需指明所需包含的py文件

from distutils.core import setup

setup(name="AIhao", version="1.0", description="AIhao's module", author="AIhao", py_modules=['suba.aa', 'suba.bb', 'subb.cc', 'subb.dd'])

3.构建模块

python setup.py build

构建后目录结构

.
├── build
│   └── lib.linux-i686-2.7
│       ├── suba
│       │   ├── aa.py
│       │   ├── bb.py
│       │   └── __init__.py
│       └── subb
│           ├── cc.py
│           ├── dd.py
│           └── __init__.py
├── setup.py
├── suba
│   ├── aa.py
│   ├── bb.py
│   └── __init__.py
└── subb
    ├── cc.py
    ├── dd.py
    └── __init__.py

4.生成发布压缩包

python setup.py sdist

打包后,生成最终发布压缩包AIhao-1.0.tar.gz , 目录结构

.
├── build
│   └── lib.linux-i686-2.7
│       ├── suba
│       │   ├── aa.py
│       │   ├── bb.py
│       │   └── __init__.py
│       └── subb
│           ├── cc.py
│           ├── dd.py
│           └── __init__.py
├── dist
│   └── AIhao-1.0.tar.gz
├── MANIFEST
├── setup.py
├── suba
│   ├── aa.py
│   ├── bb.py
│   └── __init__.py
└── subb
    ├── cc.py
    ├── dd.py
    └── __init__.py

14.6 模块安装、使用

14.6.1 安装的方式

找到模块的压缩包
解压
进入文件夹
执行命令python setup.py install

注意：

如果在install的时候，执行目录安装，可以使用python setup.py install --prefix=安装路径

14.6.2 模块的引入

在程序中，使用from import 即可完成对安装的模块使用

from 模块名 import 模块名或者*

PDF版本：https://download.csdn.net/download/hhhhhhhhhhwwwwwwwwww/21839010?spm=1001.2014.3001.5501

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

Python基础：异常与模块

13 异常

13.1 捕获异常

13.1.1 捕获异常 try…except…

13.1.2 except捕获多个异常

13.1.3 获取异常的信息描述

13.1.4捕获所有异常

13.1.5 else

13.1.6 try…finally…

13.2 异常的传递

13.2.1. try嵌套中

13.2.2 函数嵌套调用中

13.3 抛出自定义的异常

13.4 异常处理中抛出异常

14 模块

14.1 模块介绍

14.1.1 Python中的模块

14.1.2 import

14.1.3 from…import

14.1.4 from … import *

14.1.5 as

14.1.6 定位模块

14.2 制作模块

14.2.1 定义自己的模块

14.2.2 调用自己定义的模块

14.2.3 测试模块

14.3 模块中的__all__

14.3.1 没有__all__

14.3.2. 模块中有__all__

14.4 python中的包

14.4.1. 引入包

14.4.2 __init__.py文件作用

14.5 模块发布

14.6 模块安装、使用

14.6.1 安装的方式

14.6.2 模块的引入

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品

14.3 模块中的`all`

14.3.1 没有`all`

14.3.2. 模块中有`all`

14.4.2 `init.py`文件作用