从零开始学习人工智能Day5-Python3 模块

​​​二、Python3基础语法学习

三、Python3 基本数据类型

四、Python3 数据类型转换

五、Python3 运算符

六、python基本数据类型(续)

七、Python3 控制语句

八、Python推导式

九、Python3 函数

十、Python3 数据结构

十一、Python3 模块

Python 中的模块（Module）是一个包含 Python 定义和语句的文件，文件名就是模块名加上 .py 后缀。

模块可以包含函数、类、变量以及可执行的代码。通过模块，我们可以将代码组织成可重用的单元，便于管理和维护。

模块的作用

• 代码复用：将常用的功能封装到模块中，可以在多个程序中重复使用。

• 命名空间管理：模块可以避免命名冲突，不同模块中的同名函数或变量不会互相干扰。

• 代码组织：将代码按功能划分到不同的模块中，使程序结构更清晰。

使用 python 标准库中模块的例子

import sys
for i in sys.argv:print(i)
#输出： D:\桌面\pythonProject\Day5_模块.pyprint('\n')
for i in sys.path:print(i)
#输出：
# D:\桌面\pythonProject
# D:\桌面\pythonProject
# C:\Users\Drink\AppData\Local\Programs\Python\Python310\python310.zip
# C:\Users\Drink\AppData\Local\Programs\Python\Python310\DLLs
# C:\Users\Drink\AppData\Local\Programs\Python\Python310\lib
# C:\Users\Drink\AppData\Local\Programs\Python\Python310
# C:\Users\Drink\AppData\Local\Programs\Python\Python310\lib\site-packages

• 1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
• 2、sys.argv 是一个包含命令行参数的列表。
• 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

1.import 语句​​​​​​​

语法如下：

import module1[, module2[,... moduleN]

当解释器遇到 import 语句，如

果模块在当前的搜索路径就会被导入。

搜索路径时一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：

 Day_模块support.py

def hello():print("Hello Module Support")

Day_模块.py

import Day5_模块support as supportsupport.hello()

1.1 模块的搜索路径

当导入一个模块时，Python 会按照以下顺序查找模块：

1. 当前目录。

2. 环境变量 PYTHONPATH 指定的目录。

3. Python 标准库目录。

4. .pth 文件中指定的目录。

搜索路径是在 Python 编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在 sys 模块中的 path 变量

import sys
print(sys.path)
#输出：
# ['D:\\桌面\\pythonProject', 
# 'D:\\桌面\\pythonProject', 
# 'C:\\Users\\Drink\\AppData\\Local\\Programs\\Python\\Python310\\python310.zip', 
# 'C:\\Users\\Drink\\AppData\\Local\\Programs\\Python\\Python310\\DLLs', 
# 'C:\\Users\\Drink\\AppData\\Local\\Programs\\Python\\Python310\\lib', 
# 'C:\\Users\\Drink\\AppData\\Local\\Programs\\Python\\Python310', 
# 'C:\\Users\\Drink\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages']
#导入模块时，Python会在搜索路径中依次查找模块文件，如果找到了，就加载模块并执行；如果没有找到，就会报错。

2.from … import 语句

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

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

 给模块起别名:

使用 as 关键字为模块或函数起别名：

import numpy as np # 将 numpy 模块别名设置为 np 
from math import sqrt as square_root # 将 sqrt 函数别名设置为 square_root

#from import语句
from math import sqrt   #导入math模块中的sqrt函数
print(sqrt(9))    #输出：3.0#导入模块时，可以用as给模块指定别名，方便使用。
import math as m
print(m.sqrt(9))   #输出：3.0#导入模块时，可以用from ... import ... as ... 给模块中的函数指定别名，方便使用。
from math import sqrt as square_root
print(square_root(9))   #输出：3.0

3.from … import * 语句

语法：

from modname import *

不推荐，容易引起命名冲突。

4.深入模块

模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。

每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。

所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞混。

从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。

模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。

还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。比如:

from math import sqrt
math=100    
print(sqrt(math))   #输出：10.0

这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，math 这个名称是没有定义的）

5.__name__ 属性

一个模块被另一个程序第一次引入时，其主程序将运行。

如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 __name__ 属性来使该程序块仅在该模块自身运行时执行。

#File Name:Day5_模块support.py
if __name__ == "__main__":print("在自身执行")#输出： 在自身执行
else:print("在其他地方导入")

#File Name: Day5_模块.py
#__name__变量
#当模块被直接运行时，__name__变量的值为__main__；当模块被导入时，__name__变量的值为模块名。import Day5_模块support as support    #输出:在其他地方导入(仅第一次导入时会输出)print(support.__name__)   #输出：Day5_模块support

说明：每个模块都有一个 __name__ 属性。

• 如果模块是被直接运行，__name__ 的值为 __main__。

• 如果模块是被导入的，__name__ 的值为模块名。

• __name__ 是一个内置变量，表示当前模块的名称。

• 使用 if __name__ == "__main__": 可以控制模块在被导入时不会执行某些代码，而只有在作为独立脚本运行时才会执行这些代码。

6.dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

#dir函数
import sys
#五个为一行输出
attributes = dir(sys)
for i in range(0, len(attributes), 5):print(" ".join(attributes[i:i+5]))#输出    
# __breakpointhook__ __displayhook__ __doc__ __excepthook__ __interactivehook__
# __loader__ __name__ __package__ __spec__ __stderr__
# __stdin__ __stdout__ __unraisablehook__ _base_executable _clear_type_cache
# _current_exceptions _current_frames _deactivate_opcache _debugmallocstats _enablelegacywindowsfsencoding
# _framework _getframe _git _home _xoptions
# addaudithook api_version argv audit base_exec_prefix
# base_prefix breakpointhook builtin_module_names byteorder call_tracing
# copyright displayhook dllhandle dont_write_bytecode exc_info
# excepthook exec_prefix executable exit flags
# float_info float_repr_style get_asyncgen_hooks get_coroutine_origin_tracking_depth getallocatedblocks
# getdefaultencoding getfilesystemencodeerrors getfilesystemencoding getprofile getrecursionlimit
# getrefcount getsizeof getswitchinterval gettrace getwindowsversion
# hash_info hexversion implementation int_info intern
# is_finalizing maxsize maxunicode meta_path modules
# orig_argv path path_hooks path_importer_cache platform
# platlibdir prefix pycache_prefix set_asyncgen_hooks set_coroutine_origin_tracking_depth
# setprofile setrecursionlimit setswitchinterval settrace stderr
# stdin stdlib_module_names stdout thread_info unraisablehook
# version version_info warnoptions winver

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称：

#dir()函数，无参数时，输出当前模块的所有属性和方法
allDir=dir()
for i in range(0,len(dir()),5):print(" ".join(allDir[i:i+5]))#输出   
# __annotations__ __builtins__ __cached__ __doc__ __file__
# __loader__ __name__ __package__ __spec__ attributes
# i m math sqrt square_root
# support sys

7.标准模块

模块名	功能描述
math	数学运算（如平方根、三角函数等）
os	操作系统相关功能（如文件、目录操作）
sys	系统相关的参数和函数
random	生成随机数
datetime	处理日期和时间
json	处理 JSON 数据
re	正则表达式操作
collections	提供额外的数据结构（如 defaultdict、deque）
itertools	提供迭代器工具
functools	高阶函数工具（如 reduce、lru_cache）

8.包​​​​​​​ 

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。

不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。

现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。

并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所以你还需要一组怎么也写不完的模块来处理这些操作。

这里给出了一种可能的包结构（在分层的文件系统中）:

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。 

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包

用户可以每次只导入一个包里面的特定模块，比如:

import sound.effects.echo

这将会导入子模块:sound.effects.echo。 他必须使用全名去访问: 

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是:

from sound.effects import echo

 这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:

echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量:

from sound.effects.echo import echofilter

同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:

echofilter(input, output, delay=0.7, atten=4)

9.从一个包中导入* 

Python 会进入文件系统，找到这个包里面所有的子模块，然后一个一个的把它们都导入进来。

但这个方法在 Windows 平台上工作的就不是非常好，因为 Windows 是一个不区分大小写的系统。

在 Windows 平台上，我们无法确定一个叫做 ECHO.py 的文件导入为模块是 echo 还是 Echo，或者是 ECHO。

为了解决这个问题，我们只需要提供一个精确包的索引。

导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。

以下实例在 file:sounds/effects/__init__.py 中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

如果 __all__ 真的没有定义，那么使用from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来（可能运行__init__.py里定义的初始化代码）。

这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

import sound.effects.echo 
import sound.effects.surround 
from sound.effects import *

这个例子中，在执行 from...import 前，包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。（当然如果定义了 __all__ 就更没问题了）

通常我们并不主张使用 * 这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。

记住，使用 from Package import specific_submodule 这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。

如果在结构中包是一个子包（比如这个例子中对于包sound来说），而你又想导入兄弟包（同级别的包）你就得使用导入绝对的路径来导入。比如，如果模块sound.filters.vocoder 要使用包 sound.effects 中的模块 echo，你就要写成 from sound.effects import echo。

from . import echo 
from .. import formats 
from ..filters import equalizer

无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"__main__"，一个Python应用程序的主模块，应当总是使用绝对路径引用。

包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。

这个功能并不常用，一般用来扩展包里面的模块。