刀刀的知识积累

异常、模块与包

更新时间: 2024-03-20 21:24:39

# 什么是异常

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

# 异常的捕获方法

# 捕获常规异常

基本语法：

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

快速入门
需求：尝试以r模式打开文件，如果文件不存在，则以w方式打开。

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

# 捕获指定异常

基本语法：

try:
  print(name)
except NameError as e:
  print('name变量名称未定义错误')
1
2
3
4

注意

  • 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
  • 一般try下方只放一行尝试执行的代码

# 捕获多个异常

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

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

# 捕获所有异常

try:
  1 / 0
except Exception as e:
  print("出现异常了")
1
2
3
4

# 异常else

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

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

# 异常的finally

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

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

# 异常的传递

异常具有传递性的

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

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

def func01():
  print('这是func01开始')
  num = 1 / 0
  print('这是func01结束')

def func02():
  print("这是func02开始")
  func01()
  print("这是func02结束")

def main():
  try:
    func02()
  except Exception as e:
    print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Python模块

# 什么是模块

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

# 模块的作用

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

# 模块的导入方式

模块在使用前需要先导入，导入的语法如下：
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]
常用的组合形式如：

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

# import模块名

基本语法：

import 模块名
import 模块名1, 模块名2

模块名.功能名()
1
2
3
4

案例：导入time模块

# 导入时间模块
import time

print("开始")
# 让程序睡眠1秒
time.sleep(1)
print("结果")
1
2
3
4
5
6
7

# from 模块名 import 功能名

基本语法：

from 模块名 import 功能名
功能名()
1
2

案例：导入time模块中的sleep方法

# 导入时间模块中的sleep方法
from time import sleep

print("开始")
sleep(1)
print("结束")
1
2
3
4
5
6

# from 模块名 import *

基本语法

from 模块名 import *
功能名()
1
2

案例：导入time模块中所有的方法

from time import *
print("开始")
sleep(1)
print("结束")
1
2
3
4

# as 定义别名

基本语法

# 模块定义别名
import 模块名 as 别名

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

案例

# 模块别名
import time as tt

tt.sleet(2)
print("hello")
1
2
3
4
5
# 功能别名
from time import sleep as sl
sl(2)
print("hello")
1
2
3
4

# 自定义模块

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

案例：新建一个Python文件，命名为my_module.py，并定义test函数

# my_module1.py
def test(a, b):
  print(a + b)
1
2
3
# test_my_module.py
import my_module1

my_module1.test(10, 20)
1
2
3
4

注意

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

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

# 测试模块

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

def test(a, b):
  print(a + b)

test(1, 1)
1
2
3
4

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

解决方案

def test(a, b):
  print(a + b)

# 只在当前文件中调用该函数，其他导入的文件内不会调用
if __name__=='__main__':
  test(1, 1)
1
2
3
4
5
6

# all

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

# my_module1.py
__all__ = ['test_A']

def test_A():
  print('testA')

def test_B():
  print('testB')
1
2
3
4
5
6
7
8
from my_module1 import *

# 这里只能使用test_A()函数
test_A()
1
2
3
4

# Python包

# 什么是Python包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py文件，该文件可用于包含多个模块文件。
从逻辑上看，包的本质依然是模块。

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

# 快速入门

  1. 新建包my_package
  2. 新建包内模块：my_module1和my_module2
import my_package.my_module1
import my_package.my_module2

my_package.my_module1.info_print1()
my_package.my_module2.info_print2()
1
2
3
4
5
from my_package import my_module1
from my_package import  my_module2
my_module1.info_print1()
my_module2.info_print2()
1
2
3
4
from my_package.my_module1 import info_print1
from my_package.my_module2 import info_print2
info_print1()
info_print2()
1
2
3
4

# 导入包

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

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

# 安装第三方包

我们知道，包可以包含一堆的Python模块，而每个模块又内含许多的功能。
所以，我们可以认为：一个包，就是一堆同类型功能的集合体

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

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

这些第三方的包，极大的丰富了Python的生态，提高我们的效率
但由于是第三方，所以Python没有内置，所以我们需要安装他们才可以导入使用哦。

# 安装第三方包 - pip

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

打开我们许久未见的：命令提示符程序，在里面输入： pip install 包名称
即可通过网络快速安装第三方包

网不好可以去连接https://pypi.tuna.tsinghua.edu.cn/simple

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

← 面向对象 →

MIT Licensed | Copyright © 2021-present 刀刀