了解异常

什么是异常

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

异常演示

例如：以’r’方式打开一个不存在的文件

1
f = open('linux.txt','r')

执行结果：FileNotFoundError

总结

  1. 什么是异常：异常就是程序运行的过程中出现了错误
  2. bug是什么意思：bug就是指异常的意思，历史上因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错误。

Demo

1
2
3
4
5
"""
主动写一段错误代码，演示异常的出现
"""
# 通过open，读取一个不存在的文件
f = open("D:/abc.txt", "r", encoding = "UTF-8")

运行结果

1
2
3
4
5
Traceback (most recent call last):
  File "D:\python\pythonProject\demo.py", line 5, in <module>
    f = open("D:/abc.txt", "r", encoding = "UTF-8")
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: 'D:/abc.txt'

异常的捕获

捕获异常

在力所能及的范围内，对可能出现的bug，进行提前准备、提前处理

当我们的程序遇到了bug，那么接下来又两种情况：

  1. 整个程序因为一个bug停止运行
  2. 对bug进行提醒，整个程序继续运行

显然在之前的学习中，我们所有的程序遇到bug就会出现1的这种情况，也就是整个程序直接崩溃

但是在真实工作中，我们肯定不能因为一个小的bug就让整个程序全部崩溃，也就是我们希望的是达到2的这种情况，那这里我们就需要使用到捕获异常

捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段

捕获常规异常

基本语法：

1
2
3
4
try:
	可能发生错误的代码
except:
	如果出现异常执行的代码

快速入门

需求：尝试以’r’模式打开文件，如果文件不存在，则以‘w’方式打开

1
2
3
4
try:
	f = open('linux.txt', 'r')
except:
	f = open('linux.txt', 'w')

捕获多个异常

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

1
2
3
4
try:
	print(1/0)
except (NameError, ZeroDivisionError):
	print('ZeroDivision错误...')

执行结果：

1
ZeroDivision错误...

异常else

else表示的是如果没有异常要执行的代码。

1
2
3
4
5
6
try:
	print(1)
except Exception as e:
	print(e)
else:
	print('我是else，是没有异常的时候执行的代码')

执行结果：

1
2
1
我是else，是没有异常的时候执行的代码

异常的finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件

1
2
3
4
5
6
7
8
try:
	f = open('test.txt', 'r')
except Exception as e:
	f = open('test.txt', 'w')
else:
	print('没有异常')
finally:
	f.close()

总结

  1. 为什么要捕获异常

    在可能发生异常的地方，进行捕获。当异常出现的时候，提供解决方式，而不是任由其导致程序无法运行

  2. 捕获异常的语法？

    1
    2
    3
    4
    5
    6
    7
    8
    try:
    	可能要发生异常
    except[异常 as 别名:]
    	出现异常的准备手段
    [else:]
    	未出现异常时应做的事情
    [finally:]
    	不管出不出现异常都会做的事情

  3. 如何捕获所有异常？

    异常的种类多种多样，如果想要不管什么类型的异常都能捕获到，那么使用：

    • except
    • except Exception:
    • 两种方式捕获全部的异常

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
"""
演示捕获异常
"""
# 基本捕获语法
# try:
#     f = open("D:/abc.txt", "r", encoding = "UTF-8")
# except:
#     print("出现异常了，因为文件不存在，我将open的模式，改为w模式去打开")
#     f = open("D:/abc.txt", "w", encoding = "UTF-8")
# 捕获多个异常
# try:
#     print(name)
#     # 1 / 0
# except NameError as e:
#     print("出现了变量未定义的异常")
#     print(e)
# 捕获多个异常
# try:
#     1 / 0
#     print(name)
# except (NameError, ZeroDivisionError) as e:
#     print("出现了变量未定义 或者 除以0的异常错误")
# 未正确设置捕获异常类型，将无法捕获异常
# 捕获所有异常
try:
    f = open("D:/123.txt", "r", encoding = "UTF-8")
except Exception as e:
    print("出现异常了")
    f = open("D:/123.txt", "w", encoding = "UTF-8")
else:
    print("没有异常")
finally:
    print("我是finally，有没有异常我都要执行")
    f.close()

异常的传递性

异常的传递

异常是具有传递性

当函数func01中发现异常，并且没有捕获处理这个异常的时候，异常会传递到函数func02，当func02也没有捕获处理这个异常的时候main函数会捕获这个异常，这就是异常的传递性

提示：当所有函数都没有捕获异常的时候，程序就会报错

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
"""
演示异常的传递性
"""
# 定义一个出现异常的方法
def func1():
    print("func1 开始执行")
    num = 1 / 0     # 肯定有异常，除以0的异常
    print("func1 结束执行")
# 定义一个无异常的方法，调用上面的方法
def func2():
    print("func2 开始执行")
    func1()
    print("func2 结束执行")
# 定义一个方法，调用上面的方法
def main():
    try:
        func2()
    except Exception as e:
        print(f"出现异常了，异常的信息是：{e}")
main()

运行结果

1
2
3
func2 开始执行
func1 开始执行
出现异常了，异常的信息是：division by zero

模块的概念和导入

什么是模块

Python模块（Module），是一个Python文件，以.py结尾。模块能定义函数，类和变量，模块里也能包含可执行的代码

模块的作用：Python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块。我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能

（模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用（导入模块去使用）

模块的导入方式

模块在使用前需要先导入，导入的语法如下：

1
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

常用的组合形式如：

  • import 模块名
  • from 模块名 import 类、变量、方法等
  • from 模块名 import *
  • import 模块名 as 别名
  • from 模块名 import 功能名 as 别名

import模块名

基本语法：

1
2
3
import 模块名
import 模块名1，模块名2
模块名.功能名()

案例：导入time模块

1
2
3
4
5
6
# 导入时间模块
import time
print("开始")
# 让程序睡眠1秒（阻塞）
time.sleep(1)
print("结束")

as定义别名

基本语法：

1
2
3
4
# 模块定义别名
import 模块名 as 别名
# 功能定义别名
from 模块名 import 功能 as 别名

案例：

1
2
3
4
# 模块别名
import time as tt
tt.sleep(2)
print('hello')
1
2
3
4
# 功能别名
from time import sleep as sl
sl(2)
print('hello')

总结

  1. 什么是模块

    模块就是一个Python代码文件，内含类、函数、变量等，我们可以导入进行使用

  2. 如何导入模块

    1
    [from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

  3. 注意事项

    • from可以省略，直接import即可
    • as别名可以省略
    • 通过”.”来确定层级关系
    • 模块的导入一般写在代码文件的开头位置

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
"""
演示Python的模块导入
"""
# # 使用import导入time模块使用sleep功能（函数）
# import time       # 导入Python内置的time模块（time.py这个代码文件）
# print("你好")
# time.sleep(5)     # 通过，就可以使用模块内部的全部功能（类、函数、变量）
# print("我好")
# 使用from导入time的sleep功能（函数）
# from time import sleep
# print("你好")
# sleep(5)
# print("我好")
# 使用 * 导入time模块的全部功能
# from time import *      # *表示全部的意思
# print("你好")
# sleep(5)
# print("我好")
# 使用as给特定功能加上别名
# import time as t
# print("你好")
# t.sleep(5)
# print("我好")
from time import sleep as sl
print("你好")
sl(5)
print("我好")

自定义模块并导入

制作自定义模块

Python中已经帮我们实现了很多的模块，不过有时候我们需要一些个性化的模块，这里就可以通过自定义模块实现，也就是自己制作一个模块

注意：每个Python文件都可以作为一个模块，模块的名字都是文件的名字，也就是说自定义模块名必须要符合标识符命名规则

注意事项

1
2
3
4
5
6
7
8
9
10
11
# 模块1代码
def my_test(a, b):
	print(a + b)
# 模块2代码
def my_test(a, b):
	print(a - b)
# 导入模块和调用功能代码
from my_module1 import my_test
from my_module2 import my_test
# my_test函数是模块2中的函数
my_test(1, 1)

注意事项：当导入多个模块的时候，且模块内有同名功能，当调用这个同名功能的时候，调用到的是后面导入的模块的功能

测试模块

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

1
2
3
def test(a, b):
	print(a + b)
test(1, 1)

问题：此时，无论是当前文件，还是其他已经导入了该模块的文件，在运行的时候都会自动执行'test'的调用

解决方案：

1
2
3
4
5
def test(a, b):
	print(a + b)
# 只在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行test函数调用
if__name__='__main__':
	test(1, 1)

__all__

如果一个模块文件中有’__all__‘变量，当使用’from xxx import *’导入时，只能导入这个列表中的元素

总结

  1. 如果自定义模块并导入

    在Python代码文件中正常写代码即可，通过import、from关键字和导入Python内置模块一样导入即可使用

  2. __main__变量的功能是？

    if__main__ == “__main__“表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入

  3. 注意事项

    • 不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
    • __all__变量可以控制import *的时候哪些功能可以被导入

Demo

demo.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"""
演示自定义模块
"""
# 导入自定义模块使用
# import my_module1
# from my_module1 import test
# test(1, 2)
# 导入不同模块的同名功能
# from my_module1 import test
# from my_module2 import test
# test(1, 2)
# __main__变量
# from my_module1 import test
# __all__变量
from my_module1 import *
test_a(1, 2)
# test_b(2, 1)

my_module1.py

1
2
3
4
5
6
7
8
9
# def test(a, b):
#     print(a + b)
# if __name__ == '__main__':
#     test(1, 2)
__all__ = ['test_a']
def test_a(a, b):
    print(a + b)
def test_b(a, b):
    print(a - b)

my_module2.py

1
2
def test(a, b):
    print(a - b)

运行结果

1
3

自定义Python包

什么是Python包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init___.py文件，该文件夹可用于包含多个模块文件

从逻辑上看，包的本质依然是模块

包的作用：当我们的模块文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块

导入包

方式一：

1
2
import 包名.模块名
包名.模块名.目标

方式二：

注意：必须在’__init__.py’文件中添加’__all__ = []‘，控制允许导入的模块列表

1
2
from 包名 import *
模块名.目标

总结

  1. 什么是Python的包？

    包就是一个文件夹，里面可以存放许多Python的模块（代码文件），通过包，在逻辑上将一批模块归为一类，方便使用·

  2. __init__.py文件的作用？

    创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹

  3. __all__变量的作用？

    同模块中学习到的是一个作用，控制import *能够导入的内容

Demo

Demo.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
"""
演示Python的包
"""
# 创建一个包
# 导入自定义的包中的模块，并使用
# import my_package.my_module1
# import my_package.my_module2
# my_package.my_module1.info_print1()
# my_package.my_module2.info_print2()
# from my_package import my_module1
# from my_package import my_module2
# my_module1.info_print1()
# my_module2.info_print2()
# from my_package.my_module1 import info_print1
# from my_package.my_module2 import info_print2
# info_print1()
# info_print2()
# 通过__all__变量，控制import *
from my_package import *
my_module1.info_print1()
# my_module2.info_print2()

__init__.py

1
__all__ = ['my_module1']

my_module1.py

1
2
3
4
5
"""
演示自定义模块1
"""
def info_print1():
    print("我是模块1的功能函数代码")

my_module2.py

1
2
3
4
5
"""
自定义模块2
"""
def info_print2():
    print("我是模块2的功能函数代码")

运行结果

1
我是模块1的功能函数代码

安装第三方包

什么是第三方包

我们知道，包可以包含一堆的Python模块，而每个模块有内含许多的功能

所以，我们可以认为：一个包，就是一堆同类型功能的集合体

在Python程序的生态中，有许多非常多的第三方包（非Python官方），可以极大的帮助我们提高开发效率，如：

  • 科学计算中常用的：numpy包
  • 数据分析中常用的：pandas包
  • 大数据计算中常用的：pyspark、apache-flink包
  • 图形可视化常用的：matplotlib、pyecharts
  • 人工只能常用的：tensortflow等

这些第三方的包，极大的丰富了Python的生态，提高了开发效率

但是由于是第三方，所以Python没有内置，所以我们需要安装它们才可以导入使用

安装第三方包-pip

第三方包的安装非常简单，我们只需要使用Python内置的pip程序即可

打开命令提示符程序，在里面输入：

1
pip install 包名称

即可通过网络快速安装第三方包

pip的网络优化

由于pip是连接的国外的网络进行包的下载，所以有的时候会速度很慢

我们可以通过如下命令，让其连接国内的网站进行包的安装

1
pip install -i https//pypi.tuna.tsinghua.edu.cn/simple 包名称

https//pypi.tuna.tsinghua.edu.cn/simple是清华大学提供的一个网站，可供pip程序下载第三方包

安装第三方包-PyCharm

PyCharm也提供了安装第三方包的功能

打开PyCharm，点击右下角的Python型号，选择解释器设置，即可查看python中已经安装的第三方包，点击+后即可搜索别的第三方包进行安装

总结

  1. 第三方包就是非Python官方内置的包，可以安装它们扩展功能，提高开发效率

  2. 如何安装？

    • 在命令提示符内：

      1
      2
      pip install 包名称
      pip install -i https//pypi.tuna.tsinghua.edu.cn/simple 包名称

    • 在PyCharm中安装

异常-模块-包-综合案例讲解

str_util.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
"""
字符串相关的工具模块
"""
def str_reverse(s):
    """
    功能是将字符串完成反转
    :param s: 将被反转的字符串
    :return: 反转后的字符串
    """
    return s[::-1]
def substr(s, x, y):
    """
    功能是按照给定的下标完成给定字符串的切片
    :param s: 即将被切片的字符串
    :param x: 切片的开始下标
    :param y: 切片的结束下标
    :return: 切片完成后的字符串
    """
    return s[x:y]
if __name__ == '__main__':
    print(str_reverse("Python"))
    print(substr("Python", 1, 3))

file_util.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
"""
文件处理相关的工具模块
"""
from importlib.resources import contents


def print_file_info(file_name):
    """
    功能是：将给定路径的文件内容输出到控制台中
    :param file_name: 即将读取的文件路径
    :return: None
    """
    f = None
    try:
        f = open(file_name, "r", encoding = "UTF-8")
        content = f.read()
        print("文件的全部内容如下：")
        print(content)
    except Exception as e:
        print(f"程序出现异常了，原因是：{e}")
    finally:
        if f:       # 如果变量是None，表示False，如果有任何内容，就是True
            f.close()
def append_to_file(file_name, data):
    """
    功能：将指定的数据追加到指定的文件中
    :param file_name: 指定的文件的路径
    :param data: 指定的数据
    :return: None
    """
    f = open(file_name, "a", encoding = "UTF-8")
    f.write(data)
    f.write("\n")
    f.close()
if __name__ == '__main__':
    print_file_info("D:/test.txt")
    append_to_file("D:/test.txt", "Python")

demo.py

1
2
3
4
5
6
7
8
9
10
11
"""
演示异常、模块、包的综合案例练习
"""
# 创建my_utils包，在包内创建：str_util.py和file_util.py 2个模块，并提供相应的函数
import my_utils.str_util
from my_utils import file_util
print(my_utils.str_util.str_reverse("Python"))
print(my_utils.str_util.substr("Python", 0, 4))
file_util.print_file_info("D:/test.txt")
file_util.append_to_file("D:/test.txt", "Python")
file_util.print_file_info("D:/test.txt")

运行结果

1
2
3
4
5
6
nohtyP
Pyth
文件的全部内容如下：
hello world
文件的全部内容如下：
hello worldPython