python的导入系统import module模块

模块内部封装了很多实用的功能，有时在模块外部调用就需要将其导入，导入模块简单划分，
实际上就只有两种：
import ……

from …… import

参考：https://docs.python.org/zh-cn/3/reference/import.html

1，导入模块的的几种方式

模块是什么？
模块实际上就是 以.py为结尾的文件
注意点：自定义的模块尽量不要和系统模块重名

模块内部封装了很多实用的功能，有时在模块外部调用就需要将其导入，导入模块简单划分，实际上就只有两种：

import ……
from …… import

详细一点划分有五种：

1，improt 模块名
调用：模块名.功能名
2，import 模块名 as 别名
调用：别名.功能名
3，from 模块名 import 功能名
调用：直接功能名
4，from 模块名 import 功能名 as 别名
调用： 直接拿别名来用
5，from 模块名 import * （用 * 号 一次性导入所有功能）
调用：直接功能名
注意点：* 号没法用别名

2，模块的搜索路径

sys.path 返回导入模块时的搜索路径集，是一个list列表。

从上面列出的目录里依次查找要导入的模块文件
’ ’ 表示当前路径
列表中的路径的先后顺序代表了python解释器在搜索模块时的先后顺序

可以添加新的模块：

sys.path.append(‘/home/python/xxx’)
sys.path.insert(0, ‘/home/python/xxx’) # 可以确保先搜索这个路径
注意点：sys.path.append(path)和sys.path.insert(path)添加的相关路径，在退出交互式环境或者IDE后会自动消失。

In [37]: sys.path.insert(0,”/home/python/xxxx”)
In [38]: sys.path
Out[38]:
[‘/home/python/xxxx’,
”,
‘/usr/bin’,
‘/usr/lib/python35.zip’,
‘/usr/lib/python3.5’,
‘/usr/lib/python3.5/plat-x86_64-linux-gnu’,
‘/usr/lib/python3.5/lib-dynload’,
‘/usr/local/lib/python3.5/dist-packages’,
‘/usr/lib/python3/dist-packages’,
‘/usr/lib/python3/dist-packages/IPython/extensions’,
‘/home/python/.ipython’]1234567891011121314

3，重新导入模块

模块被导入后，import module不能重新导入模块，重新导入需用reload

创建一个reload_test.py文件，里面写一个test方法

打开 ipython 终端导入 reload_test 模块

修改reload_test.py 文件中的test方法

再一次import reload_test 模块 然后调用test方法会发现值没变

原因：import 导入模块只会导入一次，因此即使模块被修改了，import也不会重新导入
解决方案

关闭终端，重新打开，然后再import 导入一次
用 reload 可以在不关闭终端的情况下重新导入

4，多模块开发时，要注意修改导入模块的值时，from……import 与 import 导入模块的区别

main.py

from send import *
from show import *

主流程

def main():
# 发女朋友
send()
# 秀恩爱
show()

if name == ‘main‘:
main()12345678910111213

send.py

import girl

from girl import *

发女朋友

def send():
print(“发女朋友了,翠花是你的了”)
#girl.have_girl = True
have_girl = True12345678

show.py

import girl

from girl import *

秀恩爱

def show():
if have_girl == True:
#if girl.have_girl == True:
print(“我有女朋友了,好开心”)
else:
print(“单身贵族”)12345678910

girl.py

共同变量模块

have_girl = False #False代表没有女朋友 True代表有女朋友123

运行结果：

发女朋友了,翠花是你的了
单身贵族
12

是不是有点惊讶？结果难道，不应该是这样的吗：

发女朋友了,翠花是你的了
我有女朋友了,好开心
12

会产生这种情况的原因：
import girl 可以理解为地址的复制，也就是 引用 用来修改值

from girl import * 可以理解成内容的复制，也就是深拷贝，那么深拷贝有什么特点，深拷贝最大的特点就是数据独立。

循环导入的最好的解决方法是从架构上优化，即调整模块和模块成员变量的设计。一个好的原则是：可导出的成员变量，都不应该依赖于导入进来的成员变量。
但是在业务开发的过程中，总会遇到通过架构层面解决不了的导入问题，这时候就只能通过语言层面来解决了。

目录结构（下面的案例的目录结构都是这样的）：

root.py
/pack1
    __init__.py
    module_a.py
/pack2
    __init__.py
    module_b.py
module_c.py
module_d.py

循环导入例子

首先看一下什么是循环导入和循环导入的原因。
root.py

from pack1.module_a import class_a

module_a.py

print "start init module a"
from pack2.module_b import class_b
class class_a():
    def f(self):
        class_b
print "init module a"

module_b.py

print "start init module b"
from pack1.module_a import class_a
class class_b():
    def f(self):
        class_a
print "init module b"

会报错：

start init module a
start init module b
Traceback (most recent call last):
  File "E:/my_demo/demo2016/bѭ������/s2/root.py", line 2, in <module>
    from pack1.module_a import class_a
  File "E:\my_demo\demo2016\bѭ������\s2\pack1\module_a.py", line 2, in <module>
    from pack2.module_b import class_b
  File "E:\my_demo\demo2016\bѭ������\s2\pack2\module_b.py", line 2, in <module>
    from pack1.module_a import class_a
ImportError: cannot import name class_a

代码执行的流程：

  1. 执行root.py的from pack1.module_a import class_a，发现需要导入模块module_a
  2. 一个空的字典会被创建，对应module_a的globals
  3. module_a的代码会被执行，当执行到from pack2.module_b import class_b时，发现需要导入模块module_b
  4. 一个空的字典会被创建，对应module_b的globals
  5. module_b的代码会被执行，当执行到from pack1.module_a import class_a时，发现需要导入模块module_a，但是此时已经有module_a的globals了，所以直接访问字典里的class_a，但是由于module_a的globals还是空的，即里面没有class_a，所以抛出异常

参考文档
所以根本原因是：在导入的时候，module_b需要访问module_a的变量class_a，但是class_a没有初始化完成
所以解决方法有两个：

  1. 在导入的时候，让module_b不要访问module_a的变量，也就是方案一
  2. class_a初始化完成后，才让module_b访问module_a的变量，也就是方案二和三

方案一、使用import ...代替 from...import...

root.py

import pack1.module_a

module_a.py

print "start init module a"
import pack2.module_b 
class class_a():
    def f(self):
        m_b.class_b
print "init module a"
if __name__ == '__main__':
    pass

module_b.py

print "start init module b"
import pack1.module_a 
class class_b():
    def f(self):
        pack1.module_a.class_a
print "init module b"

module_a和module_b都会被编译，终端会输出：

start init module a
start init module b
init module b
init module a

即首先编译a，编译过程中发现需要编译b，编译b完成后，编译a剩下的部分、

这个案例不使用from....import....，而使用import,这样是可以成功循环导入的，不过一个缺点是，每次访问module的时候，都需要写全路径，例如pack1.module_a.class_a，非常繁琐。
一个优化的方案是导入的时候，使用import....as... 例如：import pack1.module_a as m_a。但是很奇怪的是，在module_a中可以这样用，但是在module_b中不可以，否则就会导致报错。还有如果把roo.py改为import pack2.module_b,就会反过来，即module_b中可以这样用，但是在module_a中不可以。所以准确点应该是在root.py导入的模块中可以使用，但是在其他模块不能使用。所以import....as...这个方案并不好。
注意，import...只能import到模块，不能import模块里面的成员变量，例如import pack1.module_a.class_a 是不可以的

这个方案的缺点就是访问模块里面的成员变量太繁琐

方案二、把导入放在后面

root.py

from pack1.module_a import class_a

module_a.py

print "start init module a"
#from pack2.module_b import class_b #放在这里会报错
class class_a():
    def f(self):
        # m_b.class_b
        pass

from pack2.module_b import class_b #放在这里不会
class class_c():
    def f(self):
        class_b
print "init module a"

module_b.py

print "start init module b"
from pack1.module_a import class_a
class class_b():
    def f(self):
        class_a
print "init module b"

当存在类似的依赖关系：class_c依赖class_b依赖class_a，然后class_a和class_c在同一个模块时，可以使用这种方案。
把from pack2.module_b import class_b这句放在class_a后面，这样在module_b中访问module_a.class_a是成功的，因为class_a的定义代码已经执行完成，并被添加到module_a的globals中。

方案三、把导入语句放在语句块中

root.py

from pack1.module_a import func_a

print 'root start run func a'
func_a()
print 'root end run func a'

module_a.py

print "start init module a"

def func_a():
    from pack2.module_b import func_b
    func_b()
    print 'run func a'
print "init module a"

module_b.py

print "start init module b"

def func_b():
    from pack1.module_a import func_a
    print 'run func b'

print "init module b"

输出：

start init module a
init module a
root start run func a
start init module b
init module b
run func b
run func a
root end run func a

在需要使用func_b的时候，才进行导入操作，这样在执行module_b的时候，module_a已经初始化完成，module_a的globals已经有func_a了，所以导入不会报错。

查看已经导入的module情况

import sys
from pack1.module_a import func_a
print sys.modules  
# {'pack1': <module 'pack1' from 'E:\my_demo\demo2016\bѭ������\s4\pack1\__init__.pyc'>,}
print sys.modules['pack1.module_a'].__dict__
# {'func_a': <function func_a at 0x0254FB30>, '__doc__': None}
sys.modules['pack1.module_a'].func_a_tmp=sys.modules['pack1.module_a'].func_a

通过sys.modules可以访问所有当前已导入的模块。
modules是一个字典，key是模块的路径，例如pack1.module_a,value是一个模块对象
模块对象中，属性名是模块中全局变量的名字，即sys.modules['pack1.module_a'].__dict__等于module_a里面的globals()

所以，当在module_b中执行from pack1.module_a import class_a时，相当于执行代码：

import sys
if 'pack1.module_a' in sys.modules:
    if hasattr(sys.modules['pack1.module_a'],"class_a"):
        sys.modules['pack2.module_b'].class_a=sys.modules['pack1.module_a'].class_a
    else:
        raise Exception(u"循环导入异常")
else:
    #执行导入pack1.module_a的操作，也就是初始化一个module对象，然后令sys.modules['pack1.module_a']=这个对象

所以解决循环导入的问题，就相当于使上面的代码不会执行到raise Exception(u"循环导入异常")这一句，方案一和方案二都是通过这种方法解决的。

作者：

喜欢围棋和编程。

 
作者 发布于 分类 编程标签

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注