三、模块、包和异常

mChenys

已于 2023-09-28 16:44:51 修改

阅读量864

点赞数 1

分类专栏： python 文章标签： python 爬虫 numpy

于 2023-03-06 12:06:25 首次发布

本文链接：https://blog.csdn.net/mchenys/article/details/129358197

版权

python 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

1.模块的导入方式

模块是 Python 程序架构的一个核心概念

每一个以扩展名 py 结尾的 Python 源代码文件都是一个模块
模块名同样也是一个标识符，需要符合标识符的命名规则
在模块中定义的全局变量、函数、类都是提供给外界直接使用的工具
模块就好比是工具包，要想使用这个工具包中的工具，就需要先导入这个模块

import xxx 导入

import 模块名 是一次性把模块中所有工具全部导入，并且通过 模块名/别名 访问

import 模块名1
import 模块名2

注意：在导入模块时，每个导入应该独占一行

导入之后通过 模块名. 使用模块提供的工具 —— 全局变量、函数、类。
如果模块名字太长还可以使用as 指定模块的别名, 例如:

import 模块名1 as 模块别名

from xxx import xxx 导入

如果希望从某一个模块中，导入部分工具，就可以使用 from … import 的方式

# 从 模块 导入 某一个工具
from 模块名1 import 工具名

导入之后

不需要通过模块名.调用
可以直接使用模块提供的工具 —— 全局变量、函数、类

注意:
如果两个模块，存在同名的函数，那么后导入模块的函数，会覆盖掉先导入的函数;
开发时 import 代码应该统一写在代码的顶部，更容易及时发现冲突,一旦发现冲突，可以使用 as 关键字给其中一个工具起一个别名;
不建议使用from…import *的方式导入某个模块的所有内容,因为函数重名并没有任何的提示，出现问题不好排查。

import xxx as XXX 导入

这种导入方式可以对导入的模块起别名

使用示例:
假设现在有2个模块, 分别是:
lz_01_测试模块1.py

# 全局变量
title = "模块1"

# 函数
def say_hello():
    print("我是 %s" % title)

# 类
class Dog(object):
    pass

lz_02_测试模块2.py

# 全局变量
title = "模块2"

# 函数
def say_hello():
    print("我是 %s" % title)

# 类
class Cat(object):
    pass

(1) import导包的使用方式如下:

import lz_01_测试模块1
import lz_02_测试模块2

lz_01_测试模块1.say_hello()
lz_02_测试模块2.say_hello()

dog = lz_01_测试模块1.Dog()
print(dog)

cat = lz_02_测试模块2.Cat()
print(cat)

(2) from…import导包的使用方式如下:

from lz_01_测试模块1 import Dog
from lz_02_测试模块2 import say_hello

# 直接使用导入后的方法
say_hello()

# 直接使用导入后的类
wangcai = Dog()
print(wangcai)

(3) import as导包的使用方式如下:

import lz_01_测试模块1 as DogModule
import lz_02_测试模块2 as CatModule

DogModule.say_hello()
CatModule.say_hello()

dog = DogModule.Dog()
print(dog)

cat = CatModule.Cat()
print(cat)

2. 模块的搜索顺序

Python 的解释器在导入模块时，会：

首先搜索当前目录指定模块名的文件，如果有就直接导入
如果没有，再搜索系统目录

在开发时，给文件起名，不要和系统的模块文件重名;
Python 中每一个模块都有一个内置属性 file 可以查看模块的完整路径, 例如:
print(DogModule.file), 输出结果:
/Users/chenyousheng/workspace/python/Learn/day01/lz_01_测试模块1.py

如下是一个导入系统random模块的用法

import random

# 生成一个 0～10 的数字
rand = random.randint(0, 10)

print(rand)

假设当前目录下，存在一个 random.py 的文件，程序就无法正常执行了！
因为, Python 的解释器会优先加载当前目录下的 random.py 而不会加载系统的 random 模块

3. 模块的重新导入

在开发调试过程中，如果修改了已经导入的模块，可以使用 reload 函数来动态加载最新的代码，否则程序可能仍然运行的是旧的代码。 Python 3.4 或更高版本，reload 函数被移到了 importlib 模块之外，并且不再是内置函数，需要使用 importlib.reload() 函数来重新加载模块。
使用如下:

import module
from importlib import reload

# 重新导入module模块
reload(module)

下面在ipython不退出窗口的情况下, 修改module.py的输出为"Hello Python!" , 但是访问的时候还是"Hello Java!", 说明之前import的内容存在内存中的数据是旧的, 使用重新导入后, 输出的内容才是正确的.
在这里插入图片描述

4.多模块导入共享模块的注意事项

在开发中我们通常会定义一些全局的数据维护在一个公共模块中, 方便其他模块共享, 这时候最好使用import xxx的方式导入, 避免使用from xxx import yyy的方式, 因为这种方式导入会在当前模块创建一个yyy变量, 它指向的是xxx模块中yyy变量的值, 和xxx模块中的yyy不是同一个对象, 如果在后续使用中对yyy进行了赋值修改, 那么它不会修改原模块的值, 达不到共享数据的作用.

例如, common模块有一个全局变量a

a = 100

然后sub模块的printA方法会访问common模块的这个值

from common import a


def printA():
    print(a)

在main模块尝试修改common模块的a变量

from common import a  # 从common模块导入a变量的值, 赋值给当前模块的a变量
import sub


def updateA():
    global a  # 标记为修改的全局变量 ,注意它修改只是当前模块的a变量, 并没有修改common模块的变量a
    a = 200


updateA() # 尝试修改common模块的a变量
print(a)  # 200
sub.printA() # 100

结果main模块无法修改common模块的全局变量a, 它只能修改自己模块的a变量的值, 也就是说from common import a这种方式会在当前模块创建一个新的变量a, 这个变量的初始值和common模块的a变量的初始值是一样. 所以main模块如何修改a变量, 都不会影响到common模块的a变量。

而import common这种方式就可以实现数据共享, 因为这种方式会在当前模块创建一个变量common, 它指向的是common.py整个模块

5. name属性的使用

首先明确下模块的导入原则:

一个独立的 Python 文件就是一个模块
在导入文件时，文件中所有没有任何缩进的代码都会被执行一遍！

假设某个模块内定义了一些测试代码, 不想让别人导入的时候被执行了,只允许在当前文件中直接执行,那么就可以用到__name__属性了.

__name__ 是 Python 的一个内置属性，记录着一个字符串:

如果是被其他文件导入的，__name__ 就是 模块名
如果是当前执行的程序 __name__ 是 main

例如: lz_xiaoming_模块.py定义如下:

# 输出当前执行模块的名字
# 如果直接执行模块，__main__
print("当前模块名字:%s" % __name__)


def say_hello():
    print("这里是测试逻辑...")


if __name__ == "__main__":
    # 文件被导入时，能够直接执行的代码不需要被执行！
    print("小明写的测试代码")
    say_hello()

直接运行该模块,输出结果如下:

当前模块名字:__main__
小明写的测试代码
这里是测试逻辑...

然后在 test.py中导入模块使用

import lz_xiaoming_模块

print("-" * 50)

输出结果如下:

当前模块名字:lz_xiaoming_模块
--------------------------------------------------

可以看到, 导入后运行,输出的结果和直接执行的结果是不一样的.

6. 包

包是一个包含多个模块的特殊目录,目录下有一个特殊的文件 init.py,包名的命名方式和变量名一致，小写字母 + _,使用 import 包名可以一次性导入包中所有的模块

包的使用步骤

新建一个 lz_message 的包
在目录下，新建两个文件 send_message.py 和 receive_message.py
在 send_message 文件中定义一个 send 函数
在 receive_message 文件中定义一个 receive 函数
创建__init__.py声明对外导出的模块列表
在外部直接导入 lz_message 的包使用

目录结构如下:
在这里插入图片描述
send_message.py和receive_message.py定义如下:

# send_message.py
def send(text):
    print("正在发送 %s..." % text)
    
# receive_message.py 
 def receive():
    return "这是来自 100xx 的短信"

__init__.py定义如下:

from . import send_message
from . import receive_message

使用方式如下:

# 导入包
import lz_message

# 使用 包名.模块名.调用模块的方法
lz_message.send_message.send("hello")
txt = lz_message.receive_message.receive()
print(txt)

输出结果:

正在发送 hello...
这是来自 100xx 的短信

7. 发布模块

如果希望自己开发的模块，分享给其他人，可以按照以下步骤操作
以发布上面创建的lz_message包为例

(1) 创建 setup.py
首先需要在模块外创建setup.py文件,内容如下:

from distutils.core import setup

setup(name="lz_message",  # 包名
      version="1.0",  # 版本
      description="lz's 发送和接收消息模块",  # 描述信息
      long_description="完整的发送和接收消息模块",  # 完整描述信息
      author="mchenys",  # 作者
      author_email="mchenys@gmail.com",  # 作者邮箱
      url="lz.com",  # 主页
      py_modules=["lz_message.send_message",
                  "lz_message.receive_message"])

有关字典参数的详细信息，可以参阅官方网站：

(2) 构建模块
在控制台中切换到setup文件同级目录,我这里是pycharm项目的根目录,控制台输入如下命令:

python3 setup.py build

执行结果如下:
在这里插入图片描述
成功后会在当前目录下生成build目录

(3) 生成发布压缩包

控制台执行如下命令:

python3 setup.py sdist

执行结果如下:

在这里插入图片描述

此时根目录下会生成一个dist目录,里面有一个lz_message-1.0.tar.gz的压缩包
在这里插入图片描述

8. 安装模块

当你从别人那里得到一个已发布的模块压缩包后,我们就可以安装到python的内置目录内, 以上面发布的lz_message-1.0.tar.gz为例, 安装步骤如下:
假设我已经把lz_message-1.0.tar.gz复制到了桌面,那么需要在控制台上切换到~/Desktop目录

 tar -zxvf lz_message-1.0.tar.gz
 cd lz_message-1.0 
 sudo python3 setup.py install

执行结果如下:
在这里插入图片描述
可以看到安装的模块被导入到/opt/homebrew/lib/python3.9/site-packages目录内, 进入该目录也可以查看到新安装的模块

模块安装完后, 就可以直接在import来使用了.

9. 卸载模块

直接从安装目录下，把安装模块的目录删除就可以

cd /opt/homebrew/lib/python3.9/site-packages
sudo rm -r lz_message*

10 pip 安装第三方模块

pip 是一个通用的 Python 包管理工具，提供了对 Python 包的查找、下载、安装、卸载等功能
例如针对pygame 模块的安装和卸载命令如下：

# 将模块安装到 Python 2.x 环境
$ sudo pip install pygame
$ sudo pip uninstall pygame

# 将模块安装到 Python 3.x 环境
$ sudo pip3 install pygame
$ sudo pip3 uninstall pygame

安装效果:
在这里插入图片描述

如果在mac上提示sudo: pip: command not found, 按如下步骤进行安装:

curl https://bootstrap.pypa.io/pip/2.7/get-pip.py -o get-pip.py
sudo python get-pip.py
sudo easy_install pip

如何为特定版本的Python安装pip可以这样操作,假设你希望给Python 3.11.4安装一个独立的pip版本:

首先通过运行以下命令来检查当前使用的Python版本：python --version 或者 python3 --version(多个版本的情况下如果想修改python关联的是python3可以通过在.bash_profile中设置别名)
如果输出显示为Python 3.11.4，则继续在终端中运行以下命令来下载并安装get-pip.py文件：
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
运行以下命令来使用Python 3.11.4安装pip：
python3.11 get-pip.py
安装成功后, 输入pip3 --V可以查看当前pip3关联的Python版本和安装路径, 例如:
pip 23.2.1 from /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pip (python 3.11)
如果你想让pip也关联到python3.11.4, 可以输入下面命令进行重新安装或修复:
sudo /Library/Frameworks/Python.framework/Versions/3.11/bin/python3.11 -m ensurepip
修复后重新打开终端输入pip -V应该就可能看到关联了

11. 异常处理

程序在运行时，如果 Python 解释器遇到到一个错误，会停止程序的执行，并且提示一些错误信息，这就是异常。
程序停止执行并且提示错误信息这个动作，我们通常称之为：抛出(raise)异常。

异常捕获

(1) 基本语法
如果对某些代码的执行不能确定是否正确，可以增加 try(尝试) 来捕获异常, 语法格式如下:

try:
    尝试执行的代码
except:
    出现错误的处理

用法示例:

try:
    # 提示用户输入一个数字
    num = int(input("请输入数字："))
except:
    print("请输入正确的数字")

(2) 错误类型捕获
在程序执行时，可能会遇到不同类型的异常，并且需要针对不同类型的异常，做出不同的响应，这个时候，就需要捕获错误类型了,语法如下：

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1，对应的代码处理
    pass
except (错误类型2, 错误类型3):
    # 针对错误类型2 和 3，对应的代码处理
    pass
except Exception as result:
    print("未知错误 %s" % result)

用法示例:

try:
    num = int(input("请输入整数："))
    result = 8 / num
    print(result)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除 0 错误")

(3) 捕获未知错误
在开发时，要预判到所有可能出现的错误，还是有一定难度的,如果希望程序无论出现任何错误，都不会因为 Python 解释器抛出异常而被终止，可以再增加一个 except, 例如:

except Exception as result:
    print("未知错误 %s" % result)

(4) 异常捕获完整语法
在实际开发中，为了能够处理复杂的异常情况，完整的异常语法如下：

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1，对应的代码处理
    pass
except 错误类型2:
    # 针对错误类型2，对应的代码处理
    pass
except (错误类型3, 错误类型4):
    # 针对错误类型3 和 4，对应的代码处理
    pass
except Exception as result:
    # 打印错误信息
    print(result)
else:
    # 没有异常才会执行的代码
    pass
finally:
    # 无论是否有异常，都会执行的代码
    print("无论是否有异常，都会执行的代码")

else 只有在没有异常时才会执行的代码
finally 无论是否有异常，都会执行的代码

用法示例:

try:
    num = int(input("请输入整数："))
    result = 8 / num
    print(result)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除 0 错误")
except Exception as result:
    print("未知错误 %s" % result)
else:
    print("正常执行")
finally:
    print("执行完成，但是不保证正确")

异常的传递

异常的传递 —— 当函数/方法执行出现异常，会将异常传递给函数/方法的调用一方
如果传递到主程序，仍然没有异常处理，程序才会被终止

def demo1():
    return int(input("请输入一个整数："))


def demo2():
    return demo1()

try:
    print(demo2())
except ValueError:
    print("请输入正确的整数")
except Exception as result:
    print("未知错误 %s" % result)

输出结果:

请输入一个整数：aaa
请输入正确的整数

抛出 raise 异常

在开发中，除了代码执行出错 Python 解释器会抛出异常之外,还可以根据应用程序特有的业务需求主动抛出异常。
Python 中提供了一个 Exception 异常类，在开发时，如果满足特定业务需求时，希望抛出异常，可以这样处理：

创建一个 Exception 的对象
使用 raise 关键字抛出异常对象
用法示例:

def input_password():
    # 1. 提示用户输入密码
    pwd = input("请输入密码：")

    # 2. 判断密码长度，如果长度 >= 8，返回用户输入的密码
    if len(pwd) >= 8:
        return pwd

    # 3. 密码长度不够，需要抛出异常
    # 使用异常的错误信息字符串作为参数
    raise Exception("密码长度不够")


try:
    user_pwd = input_password()
    print(user_pwd)
except Exception as result:
    print("发现错误：%s" % result)

输出结果:

请输入密码：aaa
发现错误：密码长度不够

可以看到捕获的异常结果就是抛出异常的字符串内容。

自定义异常

只需要继承Exception基类,在构造方法__init__中赋值message即可,例如:

class MyException(Exception):
    def __init__(self, message):
        self.message = message


def test(number):
    if number == 100:
        raise MyException("数字不能是100")
    else:
        return number


def main(number):
    try:
        return test(number)
    except MyException as e:
        return e


if __name__ == '__main__':
    print(main(50))
    print(main(100))

输出结果:

50
数字不能是100

断言

断言的关键字是assert, 作用是判断表达式是否相等, 不相等则抛出异常
用法: assert expression,[message]
参数:
expression是表达式, 一般是判断相等或者判断是某种数据类型的bool判断
message是具体的错误信息,可选 ,加上会根据直观的看到错误

if __name__ == '__main__':
    assert 1 == 1
    assert 1 > 2, "1不可能大于2"

输出结果:

Traceback (most recent call last):
  File "/Users/chenyousheng/workspace/python/Learn/day01/main.py", line 281, in <module>
    assert 1 > 2, "1不可能大于2"
AssertionError: 1不可能大于2

mChenys

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
三、模块、包和异常

可以看到安装的模块被导入到/opt/homebrew/lib/python3.9/site-packages目录内, 进入该目录也可以查看到新安装的模块。.py,包名的命名方式和变量名一致，小写字母 + _,使用 import 包名可以一次性导入包中所有的模块。import *的方式导入某个模块的所有内容,因为函数重名并没有任何的提示，出现问题不好排查。程序在运行时，如果 Python 解释器遇到到一个错误，会停止程序的执行，并且提示一些错误信息，这就是异常。import 的方式。
复制链接

扫一扫