Python系列 39 模块相关

2021/7/3 14:21:50

编程Tag： 模块 import M2 导入 python py m1 39

本文主要是介绍Python系列 39 模块相关，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Python模块

Python中的模块是一系列功能的集合体，总计可分为3大类：

  • 内置模块：Python自带的一些内置库，开箱即用
  • 第三方模块：通过pip命令下载到的模块，无需自己定义，Python拥有海量的第三方模块
  • 自定义模块：一个.py文件就是一个模块，所以自己编写的.py文件也可以当做模块使用，例如文件名为m.py的文件就是一个名为m的自定义模块

自定义模块

自定义模块即自己写的模块，好处如下：

  • 将相同功能的代码进行分类
  • 降低代码耦合度，减少代码冗余
  • 使整个程序组织结构更清晰，便于后期维护

结构分类

由于一个.py文件即为一个模块，故我们可以创建2个.py文件，一个当做程序入口文件，一个当做功能模块文件，以下是结构图：

.
├── m1.py    # 功能模块文件
└── run.py   # 程序入口文件

首先在m1.py中写一个基本的函数：

# m1.py

print("this is module m1")
def add(x, y):
    return x + y

其次是在run.py中写上一个打印语句：

# run.py

print("run ..")

import简单使用

如果run.py中想要使用到m1.py中的add()函数，该怎么做？

只需要在run.py中导入m1.py里定义的add()函数即可，注意在使用时也必须按m1开头才行：

# run.py

import m1 # ❶

print("run ..")
result = m1.add(1, 2) # ❷
print(result)

# this is module m1
# run ..
# 3

❶：当解释器发现import m1时，会查找m1.py文件，并且会执行m1.py中的所有代码，所以下面会打印出 this is module m1的字样

❷：使用了m1中的add()函数

针对❶，提出一个问题，如果导入多次这个m1文件，是否也会执行多次其中的代码呢？

结果是否，也就是说只有第一次导入模块时，才会执行模块中的代码，多次导入只执行一次，其根本原因参照Python模块查找一节。

# run.py

import m1
import m1
import m1

print("run ..")
result = m1.add(1, 2)
print(result)

# this is module m1 ❶
# run ..
# 3

模块命名空间

现在我们有2个模块文件：

.
├── m1.py
├── m2.py
└── run.py

且2个模块文件中的代码都大部分相似：

# m1.py

print("this is module m1")
def add(x, y):
    return x + y

# m2.py

print("this is module m2")
def add(x, y):
    return x + y

在run中导入2个模块，且分别使用其下的add()函数时，内部发生了什么事情？

# run.py

import m1
import m2

print("run ..")
resultM1 = m1.add(1, 2)
resultM2 = m2.add(1, 2)

print(resultM1)
print(resultM2)

# this is module m1
# this is module m2
# run ..
# 3
# 3
  1. run.py执行时，会按照import的顺序执行m1.py和m2.py文件中的代码
  2. 当m1，m2执行完成之后，会产生一个模块的命名空间
  3. run.py的全局命名空间中将产生2个标识符，分别指向了m1.py和m2.py的模块命名空间

模块命名空间如下所示：

image-20210522141941653

当要使用m1.add()时，则run.py通过全局命名空间中的标识符m1，去m1模块的命名空间中查找函数标识符add。

当要使用m2.add()时，则run.py通过全局命名空间中的标识符m2，去m2模块的命名空间中查找函数标识符add。

__name__与__main__

当一个模块编写完成后，将要对其进行测试工作，确保代码无误才能投入使用。

如下，m1的测试代码写上：

# m1.py

print("this is module m1")
def add(x, y):
    return x + y

# test
print(add(1, 2))

测试没问题后，run.py中对其进行功能引用：

# run.py

import m1
import m2

print("run ..")
resultM1 = m1.add(1, 2)
resultM2 = m2.add(1, 2)
print(resultM1)
print(resultM2)

# this is module m1
# 3  ❶
# this is module m2
# run ..
# 3

当运行run.py后，会发现1处多打印了个3，这是因为在执行m1模块时，也将测试代码给执行了。

如何避免这种问题？我们可以在m1.py中加上一个判断语句：

# m1.py

print("this is module m1")
def add(x, y):
    return x + y

# test
if __name__ == "__main__":  # ❶
    print(add(1, 2))

❶：__name__：如果该.py文件当做脚本被执行，则该变量为__main__，如果该.py文件当做模块导入被执行，则该变量为.py文件的名字，如m1.py就是m1

所以说，加入这条测试语句的目的在于，.py文件在不同的方式使用时可以执行不同的代码：

  • 当做脚本被执行时，会运行测试代码
  • 当做模块被导入时，不会运行测试代码

模块导入

import …

import语句的使用方式：

  • import 模块名
  • 导入的最小单元是模块

使用import导入模块的优缺点：

  • 优点：不会和当前的全局命名空间标识符产生冲突
  • 缺点：在使用模块功能时必须加上import右边的标识符前缀

如下所示，2个不同模块的相同标识符函数并不会产生冲突：

import time
import datetime

print(time.time())
print(datetime.time())

# 1621665686.779634
# 00:00:00

也可以一行导入多个模块，使用逗号进行分割：

import time, datetime

from … import …

from语句的使用方式：

  • from 模块名 import 标识符
  • 导入的最小单元是具体功能

使用from语句导入模块的优缺点：

  • 优点：在使用模块功能时必须加上import右边的标识符前缀，如果直接导入了一个具体功能，则不用加前缀
  • 缺点：容易和当前的全局命名空间标识符产生冲突

如下示例，由于datetime模块后导入，所以它的time函数标识符替代了time模块的time函数标识符：

from time import time
from datetime import time

print(time())
print(time())

# 00:00:00
# 00:00:00

也可以在一行导入同一模块下的多个功能，以逗号进行分割：

from time import time, sleep, ctime

别名的使用

使用as语句来为冲突的标识符取一个别名：

from time import time as ttime
from datetime import time as dtime

print(ttime())
print(dtime())

# 1621665953.605452
# 00:00:00

*与__all__

使用from 模块名 import *的方式，可以导入该模块下的所有标识符。

如果你是该模块的开发者，则可以通过__all__属性规定这种导入方式允许哪些标识符被导入。

  • 在__all__中的标识符，可以被from 模块名 import *的方式进行导入
  • 未在__all__中的标识符，不会被from 模块名 import *的方式进行导入
  • 如果未定义__all__属性，则所有的标识符都会from 模块名 import *的方式进行导入

如下，在m1.py模块文件中，定义了1个getMax()的接口暴露函数，此外还有1个内部处理函数computeMax()以及模块说明变量desc：

# m1.py

def getMax(iterable):
    currentMax = None
    for index, item in enumerate(iterable):
        if index == 0:
            currentMax = computeMax(item, iterable[index + 1])
        elif currentMax != item:
            currentMax = computeMax(currentMax, item)
    return currentMax


def computeMax(x, y):
    return x if x > y else y


desc = "this is module m1"

__all__ = ("getMax", "desc")  # ❶

❶：__all__的格式必须是Tuple(str, str)

现在run.py中如果使用from m1 import *，则会将__all__中的所有标识符进行导入，下面示例中由于使用了未在__all__中定义的标识符，则抛出NameError的异常：

# run.py

from m1 import *

print(getMax)
print(desc)

print(computeMax)

# <function getMax at 0x102bff6a8>
# this is module m1
# NameError: name 'computeMax' is not defined

循环导入问题

模块a中导入模块b，模块b中又导入了模块a，且导入语句都在首行，此时将引发循环导入的问题。

示例如下：

# run.py

import m1

print(m1.desc)

# m1.py

import m2

desc = "this is module m1"

print(m2.desc)

# m2.py

import m1

desc = "this is module m2"

print(m1.desc)

运行run.py，结果如下：

AttributeError: module 'm2' has no attribute 'desc'

异常原因在于：

run.py首行导入了m1，m1首行导入了m2，m2首行又导入了m1，导致m1.desc未能成功进行对象声明，故抛出异常。

执行步骤：

  1. run.py：import m1 (将m1加载至内存中)
  2. m1.py：import m2 (将m2加载至内存中)
  3. m2.py：import m1 (m1已经执行了，不重复执行了)
  4. m2.py：desc = "this is module m2”
  5. m2.py：print(m1.desc)）(m1.desc没有进行对象声明，抛出异常)

解决办法：

  • 将m1导入m2的语句放在行尾
  • 将m1导入m2的语句放入函数中，并在行尾执行函数

办法1：

# m1.py

desc = "this is module m1"

import m2

print(m2.desc)

办法2：

desc = "this is module m1"

def importFunction():
    import m2
    print(m2.desc)

importFunction()

模块查找

查找优先级

无论是from … import …语句还是import语句，在导入模块时都会涉及到模块位置查找的问题。

模块查找优先级如下：

  • 先查找内存
  • 后查找硬盘

当一个模块被导入过一次后，就会加载至内存中，重复导入便可直接从内存中拿到该模块，而存在于内存中的模块代码是不会被执行的。

sys.modules

sys.modules用于查看存在于内存中的模块，如果要导入的模块存在于这里面，就直接进行导入，而不执行其中的代码：

>>> import sys
>>> sys.modules
...

当一个存在于硬盘之上的模块被导入时，则会将该模块加载至内存中，只要是存在于内存中的模块，重复导入时就不会执行其中的代码了。

如下示例，第一次导入存在于硬盘之上的m1模块后，它被加载至了内存中：

>>> tuple(sys.modules.items())[-1]
('rlcompleter', <module 'rlcompleter' from '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/rlcompleter.py'>)

>>> import m1
>>> tuple(sys.modules.items())[-1]
(('m1', <module 'm1' from '/Users/yunya/PycharmProjects/Python基础/m1.py'>))

Ps：其实当Python解释器启动时，会自动的运行一遍所有的内置模块并加载至内存中，因为这些内置模块也是存放在磁盘下的，你可以在Python解释器安装根目录的lib目录下找到它们。

sys.path

当内存中没有模块路径时，将按照sys.path的路径顺序依次在磁盘中查找。

如果在PyCharm下打印sys.path，它会做一些优化处理，比原生的REPL环境多出一些查找路径，下面使用#号进行标注：

[
# '/Users/yunya/PycharmProjects/Project',  
# '/Users/yunya/PycharmProjects/Project', 
# '/Applications/PyCharm.app/Contents/plugins/python/helpers/pycharm_display', 

'/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Users/yunya/Library/Python/3.6/lib/python/site-packages', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages',   

# '/Applications/PyCharm.app/Contents/plugins/python/helpers/pycharm_matplotlib_backend'
]

原生的REPL环境打印：

>>> import sys
>>> sys.path
[
'', 
'/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Users/yunya/Library/Python/3.6/lib/python/site-packages', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages'
]
>>>

模块导入规范

导入模块时要遵循的一些规范：

  • 导入顺序：内置模块在最上面，第三方模块在中间，自定义模块在下面

  • 自定义模块名风格：蛇形式命名

    Ps：Python2中有些模块是驼峰式命名，但是在Python3中都更改为蛇形式命名了，如PyMySQL，更名为pymysql

此外，模块也是一等公民，运行被赋值、传参等等。

模块编写规范

如果要编写自定义模块，也需要遵循一些规范：

  • 首行添加模块文档描述，让别人知道你的模块是干嘛的
  • 减少全局变量的使用，这样在第一次导入模块时会加快导入速度
  • 模块中的类、函数等都需要写好注释
  • 使用 if __name__ == “__main__”:的语句写好测试案例


这篇关于Python系列 39 模块相关的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程