模块的导入和使用

概述一.模块 1.什么是模块？ 　　常见的场景：一个模块就是一个包含了python定义和声明的文件文件名就是模块名字加上.py的后缀 但是其实import加载的模块分为四个通用类别： 　　1使用python编写的代码（.py文件） 　　2.已被编译为共享库 　　3.包好一组模块的包 　　4.使用c编写并链接到python解释器的内置模块 2.为何要使用模块 　　1.用别人写好的模块（内置的，第三方的）

一.模块

1.什么是模块？

　　常见的场景：一个模块就是一个包含了python定义和声明的文件文件名就是模块名字加上.py的后缀

但是其实import加载的模块分为四个通用类别：

　　1使用python编写的代码（.py文件）

　　2.已被编译为共享库

　　3.包好一组模块的包

　　4.使用c编写并链接到python解释器的内置模块

2.为何要使用模块

　　1.用别人写好的模块（内置的，第三方的）：典型的拿来主义，极大的提高了开发效率

　　2.使用自己写的模块（自定义的）：当程序比较庞大的时候，你的项目不可能只在一个py中

　　随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。

3.如何使用模块？

　　3.1.import

示例文件：自定义模块my_module.py，文件名my_module.py，模块名my_module

#my_module.pyprint(‘from the my_module.py‘)money = 1000def read1():    print(‘my_module-->read1-->money‘,money)def read2():    print(‘my_module-->read2 calling read1‘)    read1()def change():    global money    money = 0

　　3.1.1

模块可以包含可执行的语句和函数的定义，这些语句的目睹是初始化模块，它们只在模块名第一次遇到导入import语句是才执行（import语句是可以在程序中的任意位置使用的，且针对同一个模块import多次，为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下

#demo.pyimport my_module   #只在第一次导入时才执行my_module.py内代码，此处的显示效果是只打印一次‘from the my_module.py’，当然其他的顶级代码也都被执行了，只不过没有显示效果。import my_moduleimport my_moduleimport my_module‘‘‘执行结果：from the my_module.py‘‘‘

　　3.1.2

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当作全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

#测试一：money与my_module.money不冲突#demo.pyimport my_modulemoney = 10print(my_module.money)‘‘‘执行结果：from the my_module.py1000

#测试二：read1与my_module.read不冲突#demo.pyimport my_moduledef read1():    print(‘======‘)my_module.read1()‘‘‘执行结果：from the my_module.pymy_module-->read1-->money 1000‘‘‘

#测试三：执行my_module.change（） *** 作的全局变量money仍然是my_module中的#demo.pyimport my_modulemoney = 1my_module.change()print(money)‘‘‘执行结果：from the my_module.py1‘‘‘

　　3.1.3

总结：首次导入模块my_module时会做三件事：

　　1.为源文件（my_module模块）创建新的名称空间，在my_module中定义的函数和方法若是用到了global是访问的就是这个名称空间

　　2.在新创建的命名空间中执行模块中包含的代码，见初始导入import my_module

　　3.创建名字my_module来引用该名称空间

　　3.1.4

为模块名起别名。相当于m1 = 1；m2 = m1

import my_module as smprint(sm.money)

　　3.1.5

在一行导入多个模块

import sys，os，re

3.2

form...import...

3.2.1

对比import my_module，会将源文件的名称空间‘my_module’带到当前名称空间中，使用时必须是my_module.名字的方式

而from语句相当于import，也会创建新的名称空间，但是将my_module中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了。

from my_module import read1,read2

这样在当前位置直接使用read1和read2就好了，执行时，仍然以my_module.py文件全局名称空间

#测试一：导入的函数read1，执行时仍然回到my_module.py中寻找全局变量money#demo.pyfrom my_module import read1money=1000read1()‘‘‘执行结果:from the my_module.pyspam->read1->money 1000‘‘‘#测试二:导入的函数read2，执行时需要调用read1(),仍然回到my_module.py中找read1()#demo.pyfrom my_module import read2def read1():    print(‘==========‘)read2()‘‘‘执行结果:from the my_module.pymy_module->read2 calling read1my_module->read1->money 1000‘‘‘

如果当前有重名read1或者read2，那么会有覆盖效果。

#测试三:导入的函数read1，被当前位置定义的read1覆盖掉了#demo.pyfrom my_module import read1def read1():    print(‘==========‘)read1()‘‘‘执行结果:from the my_module.py==========‘‘‘

需要特别强调的一点是：python中的变量赋值不是一种存储 *** 作，而只是一种绑定关系，如下：

from my_module import money,read1money=100 #将当前位置的名字money绑定到了100print(money) #打印当前的名字read1() #读取my_module.py中的名字money,仍然为1000‘‘‘from the my_module.py100my_module->read1->money 1000‘‘‘

3.2.2

from my_module import*把my_module中所有的不是以下划线（_）开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性及其差，在交互环境中导入时没有问题。

from my_module import * #将模块my_module中所有的名字都导入到当前名称空间print(money)print(read1)print(read2)print(change)‘‘‘执行结果:from the my_module.py1000<function read1 at 0x1012e8158><function read2 at 0x1012e81e0><function change at 0x1012e8268>‘‘‘

在my_module.py中新增一行

__all__=[‘money‘,‘read1‘]#这样在另外一个文件中用from my_module import*就只能导入列表中规定的两个名字

3.3把模块当作脚本执行

我们可以通过模块的全局变量__name__来查看模块名：

当做脚本运行：

__name__等于‘__main__‘

当做模块导入：

__name__=模块名

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑

if __name__ == ‘__main__‘:

def fib(n):       a,b = 0,1    while b < n:        print(b,end=‘ ‘)        a,b = b,a+b    print()if __name__ == "__main__":    print(__name__)    num = input(‘num :‘)    fib(int(num))

3.4模块搜索路径

python解释器在启动时会加载一些模块，可以使用sys.modules查看

在第一次导入某个模块时（比如my_module），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用，如果没有，解释器则会查找同名的内建模块，如果还没有找到就从sys.path给出的目录列表中依次寻找my_module.py文件。

模块的查找顺序是：内存中已经加载的模块-->内置模块-->sys.path路径中包含的模块

需要注意的是：我们自定义的模块名不应该与系统内置模块重名。

4.绝对导入与相对导入总结

绝对导入与相对导入# 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入#        优点: 执行文件与被导入的模块中都可以使用#        缺点: 所有导入都是以sys.path为起始点,导入麻烦# 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入#        符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹#        优点: 导入更加简单#        缺点: 只能在导入包中的模块时才能使用　　　　  #注意:　　　　　　　　1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内　　　　　　　　2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包

 

4.软件开发规范

总结

以上是内存溢出为你收集整理的模块的导入和使用全部内容，希望文章能够帮你解决模块的导入和使用所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。