10.29Python_包和模块

最新推荐文章于 2025-03-22 22:13:14 发布

孤单网愈云

最新推荐文章于 2025-03-22 22:13:14 发布

阅读量959

点赞数 12

分类专栏： Python基础文章标签： python 开发语言

本文链接：https://blog.youkuaiyun.com/gs1we1/article/details/143333907

版权

Python基础专栏收录该内容

41 篇文章

订阅专栏

Python包和模块

当使用Python编程时，包（Packages）和模块（Modules）是两个关键的概念，它们有助于组织、管理和复用代码。

1. 模块（Modules）

1.1 什么是模块

一个.py 文件就是一个模块

模块是含有一系列数据，函数，类等的程序

作用

把相关功能的函数等放在一起有利于管理，有利于多人合作开发
模块的分类
1. 内置模块（在python3 程序内部，可以直接使用）
2. 标准库模块(在python3 安装完后就可以使用的 )
3. 第三方模块（需要下载安装后才能使用）
4. 自定义模块(用户自己编写)
模块名如果要给别的程序导入，则模块名必须是标识符
实例

## file: mymod.py
'''
小张写了一个模块，内部有两个函数，两个字符串
... 此处省略 200字
'''
name1 = 'audi'
name2 = 'tesla'

def mysum(n):
    '''
    此函数用来求和
    by weimingze
    '''
    print("正在计算， 1 + 2 + 3 + .... + n的和 ")

def get_name():
    return "tarena"

调用模块

## file: test_mod.py
## 小李写的程序，小李想调用 小张写的 mymod.py 里的两个函数和两个字符串

## 用import 语句导入模块
import mymod

print(mymod.name1)  # Audi
print(mymod.name2)    # tesla

mymod.mysum(100)  # 调用 mymod 模块里的 mysum 函数
print(mymod.get_name())   # 'tarena'

1.2 导入模块

语法

import 模块名  [as 模块新名字1]

导入一个模块到当前程序

from 模块名 import 模块属性名 [as 属性新名]

导入一个模块内部的部分属性到当前程序

```
from 模块名 import *
```
导入一个模块内部的全部属性到当前程序

示例

import mymod
mymod.mysum(10)   # 要加模块名

from mymod import get_name
print(get_name())   # 调用get_name 时不需要加 "模块名."

from mymod import *   
print(get_name())
print(name2)

模块的内部属性

__file__  绑定模块的路径
__name__  绑定模块的名称
       如果是主模块（首先启动的模块）则绑定 '__main__'
       如果不是主模块则 绑定 xxx.py 中的 xxx 这个模块名

示例
```
见： test_mymod.py  和 mymod.py
```
模块的 __name__ 属性

每个.py 模块文件都会有 __name__ 属性
1. 当一个模块是最先运行的模块，则这个模块是主模块, 主模块的__name__ 属性绑定'__main__' 字符串
2. 如果一个模块是用三种 import 语句中的一个导入的模块，则此模块不是主模块。
  
  不是主模块的模块的 __name__ 绑定的模块名
主模块 (__name__ == '__main__')：当一个模块是直接运行的，即不是通过 import 语句导入的，那么它的 __name__ 属性会被赋值为 '__main__'。例如：

# main_module.py
if __name__ == "__main__":
    print("This is the main module.")

如果运行 python main_module.py，输出将是：

This is the main module.

被导入的模块 (__name__ == 模块名)：当一个模块被导入到另一个模块中时，它的 __name__ 属性会被赋值为它的模块名。例如：

# imported_module.py
print(f"This module's name is {__name__}") # 被其他模块导入时会自动运行

# main_module.py
import imported_module

if __name__ == "__main__":
    print("This is the main module.")

如果运行 python main_module.py，输出将是：

This module's name is imported_module
This is the main module.

这里 imported_module.py 被导入到 main_module.py 中，所以它的 __name__ 是 'imported_module'，而 main_module.py 是直接运行的，所以它的 __name__ 是 '__main__'。

python 的第三方模块

https://pypi.org/

使用导入的模块中的函数、变量等，可以通过模块名或从语句中导入的名称来访问。

1.3 Python 常用的内建模块

1.3.1 random 模块

先引入random库基础库:

import random

函数	描述
random.choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random.randrange (start, stop,step)	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random.random()	随机生成下一个实数，它在[0,1)范围内。
random.shuffle(list)	将序列的所有元素随机排序,修改原list
uniform(x, y)	随机生成实数，它在[x,y]范围内.

生成随机数

文档位置: https://docs.python.org/zh-cn/3/library/random.html

>>> import random
>>> random.randint(1, 6)  # random.randint(a,b) 生产 a~b的随机整数
3
>>> random.randint(1, 6)
4
>>> random.random()   # random.random  生成包含0 但不包含1 的浮点数
0.5884109388439075
>>> random.choice("ABCD")    # 从一个序列中，随机返回一个元素
'C'
>>> random.choice("ABCD")
'B'
>>> L = [1, 2, 3, 6, 9]
>>> random.choice(L)
6
>>> random.shuffle(L)   # random.shuffer(x)  # 把列表X 打乱
>>> L
[1, 6, 2, 9, 3]

课后练习

写一个程序， 生产6位由数字组成的随机密码

参考答案

import random

## 生成 n 位的数字密码
def get_random_password(n):
    r_str = ''
    for _ in range(n):
        r_str += str(random.randint(0, 9))
    return r_str

## 生成 n 位的数字和字母组成的密码
charactors = '0123456789abcdefghijklmnopqrstwuxyz'
def get_random_password2(n):
    r_str = ''
    for _ in range(n):
        r_str += random.choice(charactors)
    return r_str


print(get_random_password(6))
print(get_random_password(6))
import time
time.sleep(10)
print(get_random_password2(10))

1.3.2 time 模块

https://docs.python.org/zh-cn/3/library/time.html

时间戳:从 1970年1月1日 0:0:0 UTC 时间开始计时到现在的秒数

UTC 时间 : 世界协调时间

struct_time 用含有9个元素的元组来表示时间

>>> import time
>>> time.time()   # 返回当前时间的时间戳
1617117219.0382686
>>> time.ctime()    #返回当前的UTC 时间的字符串
'Tue Mar 30 23:14:48 2021'
>>> t1 = time.localtime()   # 返回当前的本地时间元组
>>> t1
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=30, tm_hour=23, tm_min=18, tm_sec=22, tm_wday=1, tm_yday=89, tm_isdst=0)
>>> t1.tm_year
2021
>>> t1.tm_yday
89
>>> time.sleep(3)  # time.sleep(n)  # 让程序睡眠 n 秒
>>> time.strftime("%Y-%m-%d", t1)   # 格式化时间
'2021-03-30'
>>> time.strftime("%y-%m-%d", t1)
'21-03-30'
>>> time.strftime('%Y-%m-%d %H:%M:%S', t1)
'2021-07-21 17:37:41'
    # 用时间元组来创建一个自定义的时间
>>> t2 = time.struct_time ( (2021,1, 1, 10, 11, 20, 0, 0, 0) )

1.3.3 datetime 模块

https://docs.python.org/zh-cn/3/library/datetime.html

>>> import datetime
>>> d1 = datetime.datetime.now()  # 返回当前的时间
>>> d1
datetime.datetime(2021, 3, 30, 23, 32, 7, 342559)
>>> d1.year
2021
>>> d1.year, d1.month, d1.day, d1.hour, d1.minute, d1.second, d1.microsecond  # 用 datetime 的各个属性可以得到 具体的信息
(2021, 3, 30, 23, 32, 44, 757673)
>>> d1.strftime("%Y-%m-%d")
'2021-03-30'

## 计算时间差
>>> delta_time = datetime.timedelta(days=2, hours=1)  # 生成 2天1小时后的时间差
>>> delta_time
datetime.timedelta(2, 3600)
>>> t1 = datetime.datetime.now()  # 得到当前时间
>>> t1
datetime.datetime(2021, 3, 30, 23, 39, 26, 863109)
>>> t1 + delta_time  # 计算 未来时间
datetime.datetime(2021, 4, 2, 0, 39, 26, 863109)

课后练习：

猜数字游戏: guess_number.py
随机生成一个0~100之间的一个整数，用变量x绑定
让用户输入一个数y,输出猜数字的结果，
    如果y等于生成的数x，则提示"恭喜你猜对了",并退出程序
    如果y大于x,则提示"您猜的数字大了"
    如果y小于x,则提示"您猜的数字小了"
直到猜对为止,显示用户猜数字的次数后退出程序.

import random

def guess_number():
    x = random.randint(0, 100)
    guess_count = 0
    
    while True:
        y = input("请输入一个0到100之间的数字: ")
        
        # 检查输入是否为数字
        if not y.isdigit():
            print("请输入一个有效的数字")
            continue
        
        y = int(y)
        guess_count += 1
        
        if y == x:
            print(f"恭喜你猜对了！你一共猜了 {guess_count} 次.")
            break
        elif y > x:
            print("您猜的数字大了")
        else:
            print("您猜的数字小了")

if __name__ == "__main__":
    guess_number()

课后练习 2

随机生成一个6位数字组成的验证码!

1.3.4 os 模块

os 模块

os模块是Python标准库中的一部分，提供了一种与操作系统进行交互的方法。主要功能包括文件和目录的操作、路径处理、进程管理等。在使用os模块之前，我们需要先导入它：

import os

在这里插入图片描述

举例

#1. os.getcwd(): 获取当前工作目录
import os
current_directory = os.getcwd()
print("当前工作目录:", current_directory)

#2. os.chdir(path): 改变当前工作目录
import os
new_directory = "/path/to/new/directory"
os.chdir(new_directory)
print("工作目录已更改为:", os.getcwd())

#3. os.listdir(path='.'): 返回指定目录下的所有文件和目录列表
import os
directory_path = "."
files_and_dirs = os.listdir(directory_path)
print("指定目录下的文件和目录列表:", files_and_dirs)

#4. os.mkdir(path): 创建目录
import os
new_directory = "new_folder"
os.mkdir(new_directory)
print(f"目录 '{new_directory}' 已创建")

#5. os.rmdir(path): 删除目录
import os
directory_to_remove = "new_folder"
os.rmdir(directory_to_remove)
print(f"目录 '{directory_to_remove}' 已删除")

#6. os.remove(path): 删除文件
import os
file_to_remove = "example.txt"
os.remove(file_to_remove)
print(f"文件 '{file_to_remove}' 已删除")

os.path 模块

os.path 模块是 Python 标准库的一部分，专门用于处理文件和目录路径的操作。它提供了一系列函数，用于操作和处理文件路径，使得路径操作更加方便和跨平台。

#1.os.path.basename(path): 返回路径中最后的文件名或目录名
import os
path = "/path/to/some/file.txt"
print(os.path.basename(path))  # 输出: file.txt

#2.os.path.dirname(path): 返回路径中的目录部分
import os
path = "/path/to/some/file.txt"
print(os.path.dirname(path))  # 输出: /path/to/some

#3.os.path.join(*paths): 将多个路径合并成一个路径
import os
path1 = "/path/to"
path2 = "some/file.txt"
full_path = os.path.join(path1, path2)
print(full_path)  # 输出: /path/to/some/file.txt

#4.os.path.split(path): 将路径分割成目录和文件名
import os
path = "/path/to/some/file.txt"
print(os.path.split(path))  # 输出: ('/path/to/some', 'file.txt')

#5.os.path.splitext(path): 将路径分割成文件名和扩展名
import os
path = "/path/to/some/file.txt"
print(os.path.splitext(path))  # 输出: ('/path/to/some/file', '.txt')

#6.os.path.exists(path): 检查路径是否存在
import os
path = "/path/to/some/file.txt"
print(os.path.exists(path))  # 输出: True 或 False

#7.os.path.isfile(path): 检查路径是否是文件
import os
path = "/path/to/some/file.txt"
print(os.path.isfile(path))  # 输出: True 或 False

#8.os.path.isdir(path): 检查路径是否是目录
import os
path = "/path/to/some/directory"
print(os.path.isdir(path))  # 输出: True 或 False

2. 包（Packages）

2.1 包的定义和作用

定义

包是将模块以文件夹的组织形式进行分组管理的方法，以便更好地组织和管理相关模块。
包是一个包含一个特殊的__init__.py文件的目录，这个文件可以为空，但必须存在，以标识目录为Python包。
包可以包含子包（子目录）和模块，可以使用点表示法来导入。

作用

将一系列模块进行分类管理,有利于防止命名冲突
可以在需要时加载一个或部分模块而不是全部模块

包示例:

    mypack/
        __init__.py
        menu.py            # 菜单管理模块
        games/
            __init__.py
            contra.py      # 魂斗罗
            supermario.py  # 超级玛丽 mario
            tanks.py       # 坦克大作战
        office/
            __init__.py
            excel.py
            word.py
            powerpoint.py

2.2 导入包和子包

使用import关键字可以导入包和子包，以访问其中的模块和内容。

    # 同模块的导入规则
    import 包名 [as 包别名]
    import  包名.模块名 [as 模块新名]
    import  包名.子包名.模块名 [as 模块新名]
    
    from 包名 import 模块名 [as 模块新名]
    from 包名.子包名 import 模块名 [as 模块新名]
    from 包名.子包名.模块名 import 属性名 [as 属性新名]
    
    # 导入包内的所有子包和模块
    from 包名 import *
    from 包名.模块名 import *

参考案例：

# 导入包中的模块
import matplotlib.pyplot as plt

# 导入子包中的模块
from sklearn.linear_model import LinearRegression

2.3 使用包和子包

使用导入的包和模块的内容，可以通过包名和点表示法来访问。

参考案例：

# 使用包中的模块
import pandas as pd
data_frame = pd.DataFrame()

# 使用子包中的模块
from tensorflow.keras.layers import Dense

2.4 `init.py`文件

__init__.py 文件的主要作用是用于初始化Python包（package）或模块（module），它可以实现以下功能：

标识包目录： 告诉Python解释器所在的目录应被视为一个包或包含模块的包。没有这个文件，目录可能不会被正确识别为包，导致无法导入包内的模块。
执行初始化代码： 可以包含任何Python代码，通常用于执行包的初始化操作，如变量初始化、导入模块、设定包的属性等。这些代码在包被导入时会被执行。
控制包的导入行为： 通过定义 __all__ 变量，可以明确指定哪些模块可以被从包中导入，从而限制包的公开接口，防止不需要的模块被导入。
提供包级别的命名空间： __init__.py 中定义的变量和函数可以在包的其他模块中共享，提供了一个包级别的命名空间，允许模块之间共享数据和功能。
批量导入模块： 可以在 __init__.py 文件中批量导入系统模块或其他模块，以便在包被导入时，这些模块可以更方便地使用。

以下是一个简单的 __init__.py 文件的代码示例，演示了上述功能的使用：

# __init__.py 文件示例

# 1. 批量导入系统模块
import os
import sys
import datetime

# 2. 定义包级别的变量
package_variable = "This is a package variable"

# 3. 控制包的导入行为
__all__ = ['module1', 'module2']

# 4. 执行初始化代码
print("Initializing mypackage")

# 注意：这个代码会在包被导入时执行

# 5. 导入包内的模块
from . import module1
from . import module2

在这个示例中，__init__.py 文件用于批量导入系统模块、定义包级别的变量、控制包的导入行为、执行初始化代码，以及导入包内的模块。这有助于包的组织、初始化和导入管理。

3. 第三方包

Python第三方包是由Python社区开发的，可用于扩展Python功能和解决各种问题的软件包。这些包提供了各种各样的功能，包括数据分析、机器学习、网络编程、Web开发、图形处理、自然语言处理等。

3.1 安装和使用

使用pip：pip是Python的包管理工具，用于安装、升级和管理第三方包。确保你的Python安装中包含了pip。
安装第三方包：
- 使用pip安装包：在命令行中运行以下命令来安装包，将"package-name"替换为要安装的包的名称。
```
pip install package-name
```
- 安装特定版本的包：如果你需要安装特定版本的包，可以使用以下命令：
```
pip install package-name==version
```
- 通过镜像安装，可以使用以下命令：
```
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package1 package2 package3 ...
```
- 从requirements文件安装：你可以将要安装的包及其版本记录在一个文本文件中，通常命名为requirements.txt，然后运行以下命令安装其中列出的所有包：
```
pip install -r requirements.txt
 
```
导入包：在Python脚本或交互式环境中，使用import语句导入已安装的包，以便在代码中使用它们。
```
import package_name
```
使用包：每个第三方包都有不同的用法和功能，通常伴随着官方文档和示例代码。你可以查阅官方文档，或者使用help()函数来了解包的功能和方法。示例：
```
import package_name
help(package_name)
```
更新和卸载包：
- 更新包：使用以下命令来更新已安装的包：
```
pip install --upgrade package-name
```
- 卸载包：如果你想卸载包，可以使用以下命令：
```
pip uninstall package-name
```

3.2 依赖清单

可以使用pipreqs来维护requirements.txt文件，以便轻松地重建环境。

pipreqs是一个用于管理Python项目依赖清单的工具，它会自动分析项目代码，并生成requirements.txt文件，列出项目所需的所有依赖包及其版本。以下是使用pipreqs管理依赖清单的步骤：

安装pipreqs：

如果你还没有安装pipreqs，可以使用pip安装它(比较慢,可能会丢包)：

pip install pipreqs

在项目目录中运行pipreqs：

进入你的项目目录，然后运行以下命令：

pipreqs .

这会分析项目代码，并在当前目录下生成一个名为requirements.txt的文件，其中包含了项目所需的所有依赖包及其版本。

如果遇到编码错误UnicodeDecodeError，则将指定编码为utf8：

pipreqs ./ --encoding=utf8
pipreqs ./ --encoding=gbk
pipreqs ./ --encoding='iso-8859-1'

查看生成的requirements.txt文件：

打开requirements.txt文件，你将看到列出的依赖包及其版本，类似于以下内容：

package1==1.0.0
package2==2.1.3
...

选择是否要修改requirements.txt文件：

pipreqs生成的requirements.txt文件可能包含一些不必要的依赖，或者可能需要手动指定特定版本。

你可以编辑requirements.txt文件，根据项目的需要添加、删除或修改依赖项。

安装依赖：

一旦你准备好了requirements.txt文件，你可以使用pip来安装项目的依赖：
```
pip install -r requirements.txt
```
定期更新依赖：

定期使用pipreqs重新生成requirements.txt文件，以确保依赖清单保持最新。你可以使用以下命令：
```
pipreqs .
```

pipreqs是一个方便的工具，它可以帮助你自动创建和维护项目的依赖清单。不过，需要记住，生成的依赖清单可能包含一些不必要的依赖，因此你应该仔细检查和编辑requirements.txt文件以确保它反映了项目的真实需求。

Python的包和模块是组织、管理和重用代码的重要工具。它们有助于将代码划分为可管理的单元，提高了代码的可读性和可维护性。通过模块和包，你可以更有效地组织项目，减少命名冲突，以及在不同项目之间重用代码，从而更轻松地进行Python编程。通过上述参考案例，你可以更好地理解如何在实际项目中应用这些概念。