python 在不同层级目录 import 模块的方法
在不同层级目录import模块的方法
使用python进行程序编写时，经常会调用不同目录下的模块及函数。本篇博客针对常见的模块调用讲解导入模块的方法。
1. 同级目录下的调用
目录结构如下：
|– mod1.py
|– test1.py
若在程序test1.py中导入模块mod1, 则直接使用
import mod1*或from mod1 import *;
2. 调用子目录下的模块
目录结构如下：
|– mod1.py
| |– mod2.py
|– test1.py
这时，如果想在程序test1.py中导入模块mod2.py ，可以在lib件夹中建立空文件__init__.py文件
新的目录结构如下：
|– mod1.py
| |–__init__.py
| |– mod2.py
|– test1.py
然后使用：
from lib.mod2 import *或import lib.mod2.
3. 调用上级目录下的文件
目录结构如下：
|– mod1.py
| |– mod2.py
| |– test2.py
这里想要实现test2.py调用mod1.py和mod2.py ，做法是我们先跳到src目录下面，直接可以调用mod1，然后在lib上当下建一个空文件__init__.py ，就可以像第二步调用子目录下的模块一样，通过import lib.mod2进行调用了。具体代码如下：
import sys
sys.path.append('C:\\test\\A\\C')
import mod1
import lib.mod2
需要注意的一点是：sys.path添加目录时注意是在windows还是在下，windows下需要‘\\’否则会出错。
补充__init__.py
在python模块的每一个包中，都有一个__init__.py文件（这个文件定义了包的属性和方法）然后是一些模块文件和子目录，假如子目录中也有__init__.py 那么它就是这个包的子包了。当你将一个包作为模块导入（比如从 xml 导入 dom ）的时候，实际上导入了它的__init__.py 文件。
一个包是一个带有特殊文件 __init__.py 的目录。__init__.py 文件定义了包的属性和方法。其实它可以什么也不定义；可以只是一个空文件，但是必须存在。如果 __init__.py 不存在，这个目录就仅仅是一个目录，而不是一个包，它就不能被导入或者包含其它的模块和嵌套包。
__init__.py 中还有一个重要的变量，叫做__all__。
如果此时目录如下
|– mod1.py
| |– mod2.py
| |– mod3.py
| |– | |– mod3.py
我们有时会使出一招“全部导入”，也就是这样：
from lib import *
这时 import 就会把注册在包__init__.py 文件中 __all__ 列表中的子模块和子包导入到当前作用域中来。比如：
#文件__init__.py
__all__ = ["mod2", "mod3", "sub"][Python]Python中的import和from&import
&一、Python路径介绍
在python用import或者from...import来导入相应的模块。
模块其实就是一些函数和类的集合文件，它能实现一些相应的功能，当我们需要使用这些功能的时候，直接把相应的模块导入到我们的程序中，我们就可以使用了。
这类似于C语言中的include头文件，Python中我们用import导入我们需要的模块。
二、搜索路径
Python会在以下路径中搜索它想要寻找的模块：
1. 程序所在的文件夹
2. 标准库的安装路径
3. 操作系统环境变量PYTHONPATH所包含的路径
Python代码&&
import&sys&&
print('================Python&import&mode==========================');&&
print&('The&command&line&arguments&are:')&&
for&i&in&sys.argv:&&
&&&&print&(i)&&
print&('\n&The&python&path',sys.path)&&
from&sys&import&argv,path&&#&&导入特定的成员&&
print('================python&from&import===================================')&&
print('path:',path)&#&因为已经导入path成员，所以此处引用时不需要加sys.path&&
如果你要使用所有sys模块使用的名字，你可以这样：&&
from&sys&import&*&&
print('path:',path)&&
三、Python项目结构
所以在Python项目里面的区分，按照如下规定进行：
1.严格区分包和文件夹。包的定义就是包含__init__.py的文件夹。
如果没有__init__.py,那么就是普通的文件夹。
2.导入package。&
在python 安装目录的site-package文件夹中新建xxx.pth，内容是需要导入的package所在的文件夹路径。
3.导入模块。
就是一般的模块导入写法，注意只要包路径，不要文件夹路径。
<img STYLE="BorDer-Top: 0 BorDer-riGHT: 0 BorDer-BoTToM: 0 BorDer-LeFT: 0px" ALT="" src="/blog7style/images/common/sg_trans.gif" real_src ="/upload/attachment//a900ada7-c352-32b2-a592-c3d.png" WIDTH="251" HEIGHT="476"
TITLE="[Python]Python中的import和from&import" />
以上面工程为例，
总共有4个包，分别是：package，package1， package2，
folder2.（注意，folder1不是package，因为它没有__init__.py）。
这些包所在的文件夹共有两个，test以及test/folder1。&
注意，package2所在的文件夹是test，虽然它是包含在folder2里面，但是folder2是一个包，不是一个文件夹。
因此在site-package中新建一个XXX.pth, 里面添加上test以及test/folder1的绝对路径即可。
模块导入比较简单，只要依次填包名就可以了，但注意只要包名
如果需要导入module2，则import folder2.package2.module2
如果需要导入module1，则import
package1.module1&&
注意，路径中没有folder1，因为folder1是文件夹，不是包。
———*———*————*————*———*———*分割线————*————*———*———*————*——
1&如何使用import
对于大型的软件项目,模块化的管理非常有必要.
于是在现如今的面向对象语言中,都有相应的机制来应对这一问题.
如C++中的namespace, Java中的package,C#中的namespace和using.
import就是Python中用于程序模块化管理的关键字.
通过import语句,将模块中声明或定义的变量或者函数等名字在当前程序运行的时刻可见.
这样我们就可以直接通过名字的方式,如变量名或者函数名复用原有代码.
通过import语句,我们就能将python代码模块化,方便管理和维护
2&import语句针对单个模块文件的工作方式
先看一组示例:
Traceback (most recent call last):
File "", line 1, in
NameError: name 'path' is not defined
&&& sys.path
Traceback (most recent call last):
File "", line 1, in
NameError: name 'sys' is not defined
&&& import sys
Traceback (most recent call last):
File "", line 1, in
NameError: name 'path' is not defined
&&& sys.path
['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk',
'/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload',
'/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10',
'/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7']
&&& from sys import path
['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk',
'/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload',
'/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10',
'/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7']
这段代码中,我们尝试使用sys包中的path变量得到python默认查找模块的路径信息,只有在import
sys之后,python解释器才能正确的找到该变量.
我们通过一个python内部函数dir()来看看python解释器如何找到名字的.
dir()函数是python内建函数,用于查看指定作用域下可用的名字.
若没有传参数,则打印当前作用域下的可用名字.
&&& help(dir)
Help on built-in function dir in module __builtin__:
dir([object]) -& list of strings
If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, otherwise
the default dir() logic is used and returns:
for a module object: the module's attributes. for a class object: its attributes, and recursively the attributes of its bases. for any other object: its attributes, its class's attributes, and
recursively the attributes of its class's base classes. &&& dir() ['__builtins__', '__doc__', '__name__', '__package__'] &&& import sys &&& dir() ['__builtins__', '__doc__', '__name__', '__package__', 'sys'] &&& dir(sys) [ ..., 'modules', 'path', ... , 'version', 'version_info', 'warnoptions'] &&& from sys import path &&& dir() ['__builtins__', '__doc__', '__name__', '__package__', 'path', 'sys']
执行import语句后,python解释器会将sys模块的名字添加到当前作用域中,这样就能直接通过sys.path得到python的搜索路径了.
注意到,我们还用了from sys import
path语句.通过这条语句path就被直接提升到当前作用域中,这样path这个名字就能被直接使用了.
之所以有from,是为了更加精确的让某个模块中的某个名字在当前作用域可见.通过这种机制,程序员可以精确控制当前作用域的名字,防止作用域被不必要的名字污染.
另外,这种机制也避免了使用”.”来进行子成员的引用,减小程序员的输入.
这里需要提一句,虽然python提供了from XXX import
*支持,能将XXX模块中的所有名字都提升到当前作用域中,但是要小心使用,因为程序员不能精确的知道到底import了哪些名字.
再看一组示例:
['__builtins__', '__doc__', '__name__', '__package__']
&&& import sys
['__builtins__', '__doc__', '__name__', '__package__', 'sys']
&&& import sys as SYS
['SYS', '__builtins__', '__doc__', '__name__', '__package__', 'sys']
&&& SYS.path
['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk',
'/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload',
'/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10',
'/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7']
&&& sys.path
['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk',
'/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload',
'/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10',
'/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7']
&&& del(sys)
&&& SYS.path
['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk',
'/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload',
'/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages',
'/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10',
'/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7']
&&& sys.path
Traceback (most recent call last):
File "", line 1, in
NameError: name 'sys' is not defined
上面的例子展示了两个功能:
import XXX as YYY:
这个可以对模块实施重命名操作.
用于删除当前空间中不再使用的名字.当空间中出现很多不再需要的名字时,可以利用该函数进行清理.
3&import语句针对模块包的工作方式
有时我们可能需要编写一个完整的模块库,比如python对XML的处理就需要一堆的函数.这时候可能划分成多个文件,更加方便管理.
逻辑上也更加清晰.
因此python引入了对多文件模块包的支持.说白了,就是import的不是一个文件的内容,而是一个文件夹的内容.
看下面的示例:
['__builtins__', '__doc__', '__name__', '__package__']
&&& import xml
['__builtins__', '__doc__', '__name__', '__package__', 'xml']
&&& import xml.sax.xmlreader
['__builtins__', '__doc__', '__name__', '__package__', 'xml']
&&& dir(xml)
['_MINIMUM_XMLPLUS_VERSION', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', 'sax']
&&& dir(xml.sax)
['ContentHandler', 'ErrorHandler', 'InputSource', 'SAXException', 'SAXNotRecognizedException', 'SAXNotSupportedException',
'SAXParseException', 'SAXReaderNotAvailable', '__builtins__', '__doc__', '__file__', '__name__',
'__package__', '__path__', '_create_parser', '_exceptions', '_false', '_key', 'default_parser_list', 'handler',
'make_parser', 'parse', 'parseString', 'xmlreader']
&&& from xml import *
&&& dir(xml)
['_MINIMUM_XMLPLUS_VERSION', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', 'dom', 'etree', 'parsers', 'sax']
表面上看起来,和内容在单个文件内的import机制差不多.
我们可以到xml对应的目录下看看:
erlv@erlv-debian:/usr/lib/python2.7/xml$ ls *
__init__.py
__init__.pyc
__init__.pyo
expatbuilder.py
__init__.py
minicompat.py
minidom.py
NodeFilter.py
pulldom.py
xmlbuilder.py
cElementTree.py
ElementInclude.py
ElementPath.py
ElementTree.py
__init__.py
__init__.py
_exceptions.py
expatreader.py
handler.py
__init__.py
saxutils.py
xmlreader.py
我们import的xmlreader,它的路径是xml/sax/xmlreader.py,和import
xml.sax.xmlreader相同.
这实际上也正是python解释器实际的动作.
注意到,每个文件夹下都有一个_init__.py文件.这个是模块包中的必须文件,它帮助python解释器将该目录识别成包.
没有此文件的文件夹,python解释器不会把它当模块包文件夹的.
_init__.py中一般会指定包中所有的模块,以及import此包时,需要预先import哪些包等初始化信息.当然,你可以往里面添加其他代码.
该脚本会在import 包时执行. 默认可以为空.
另外,还注意到有.py,.pyc和.pyo三个文件.
.py文件:Python源程序文件,文本文件
.pyc文件:编译成字节码的python文件,可以使用python解释器,或者调用pycompile模块生成该文件.
.pyo文件:进行一定编译优化的后的字节码文件.
另外,还可以控制python解释器,去掉”docstrings”,即代码中的无关文档字符串.
4&总结及深入阅读
从上面的观察中可以看到,其实python的import机制完成的是名字作用域的相关操作.包括作用域的分层,提升和删除等等.
Python中的作用域是一个树状的结构,通过”.”操作,程序员可以进入作用域分支中找到想要的名字.
同时,可以通过from XXX import YYY机制实现将某个树枝上的名字提升到当前作用域中.
所以,python解释器在实现这种作用域机制的时候,需要引入作用域层级的概念.
另外,为了实现这套机制的动态支持,包括提升新名字,名字重命名和名字删除操作.
Python解释器采取了全局模块池的方式.所有的模块在加载后都添加到这个池中.
在通过链表的形式维护树状的逻辑结构.
python中灵活的作用域管理,一方面可以让程序员更加方便的对代码进行模块化管理,另外一方面也增加了灵活性,最大可能的减小当前作用域的名字污染问题.
参考2中的中,详细介绍了python解释器中如何支持import动作的.
这部分的实现主要在cpython解释器的import.c文件中.import动作的入口函数是bltinmodule.c的builtin__import__函数.
python源码剖析:深度探索动态语言核心技术 陈儒 电子工业出版社
可爱的Python 哲思社区著 电子工业出版社 2009.9
———*———*————*————*———*———*分割线————*————*———*———*————*——
在eclipse中用pydev开发python脚本时，我遇到了一个这样的现象，当我新建一个pydev
package时，总会自动地生成一个空的__init__.py文件，因为是python新手，所以很不了解这个空文件的作用是什么，因为没有什么东西可写在这里，所以我直接把这个文件给删掉了，结果我的包图标自动变为文件夹图标了，这是怎么回事呢！
&<img STYLE="BorDer-Top-sTYLe: BorDer-BoTToM-sTYLe: BorDer-riGHT-sTYLe: BorDer-LeFT-sTYLe: none" ALT="" src="/blog7style/images/common/sg_trans.gif" real_src ="http://p.blog.csdn.net/images/p_blog_csdn_net/yxmmxy7913/EntryImages/.JPG" WIDTH="734" HEIGHT="427"
TITLE="[Python]Python中的import和from&import" />
原来在python模块的每一个包中，都有一个__init__.py文件（这个文件定义了包的属性和方法）然后是一些模块文件和子目录，假如子目录中也有
__init__.py
那么它就是这个包的子包了。当你将一个包作为模块导入（比如从xml&导入&dom&）的时候，实际上导入了它的&__init__.py&文件。
一个包是一个带有特殊文件&__init__.py&的目录。__init__.py&文件定义了包的属性和方法。其实它可以什么也不定义；可以只是一个空文件，但是必须存在。如果&__init__.py&不存在，这个目录就仅仅是一个目录，而不是一个包，它就不能被导入或者包含其它的模块和嵌套包。
_init__.py
__init__.py 控制着包的导入行为。假如 __init__.py
为空，那么仅仅导入包是什么都做不了的。
&&& import Package1 &&& Package1.Module1 Traceback (most recent call last):
& File "D:/Work Space/Python practice/MyPractice/src/test.py", line 8, in
&&& aa=Package1.Module1
AttributeError: 'module' object has no attribute 'Module1'
我们需要在 __init__.py
里把 Module1 预先导入：
#文件 __init__.py import Module1
&&& import Package1 &&& aa=Package1.Module1 &&& print aa
<img STYLE="BorDer-Top-sTYLe: BorDer-BoTToM-sTYLe: BorDer-riGHT-sTYLe: BorDer-LeFT-sTYLe: none" ALT="" src="/blog7style/images/common/sg_trans.gif" real_src ="http://p.blog.csdn.net/images/p_blog_csdn_net/yxmmxy7913/EntryImages/.JPG" WIDTH="886" HEIGHT="490"
TITLE="[Python]Python中的import和from&import" />
__init__.py
中还有一个重要的变量，叫做 __all__。我们有时会使出一招“全部导入”，也就是这样：
from PackageName import *
这时 import 就会把注册在包
__init__.py 文件中 __all__ 列表中的子模块和子包导入到当前作用域中来。比如：
#文件 __init__.py __all__ = ["Module1", "Module2", "subPackage1", "subPackage2"]
&&& from Package1 import *
test222222
__init__.py
文件会在导入时被执行。
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。python 在不同层级目录import 模块的方法
我的图书馆
python 在不同层级目录import 模块的方法
python包含子目录中的模块方法比较简单，关键是能够在sys.path里面找到通向模块文件的路径。
下面将具体介绍几种常用情况:
1. 主程序与模块程序在同一目录下:
如下面程序结构:
&&& |-- mod1.py
& & |--&test1.py
若在程序test1.py中导入模块mod1, 则直接使用
import&mod1 &&
from mod1 import *;
2. 主程序所在目录是模块所在目录的父(或祖辈)目录
如下面程序结构:
&&& |-- mod1.py
&&& |-- mod2
&&& | & & |-- mod2.py
& & |-- test1.py
若在程序test1.py中导入模块mod2, 需要在mod2文件夹中建立空文件__init__.py文件(也可以在该文件中自定义输出模块接口);
from mod2.mod2 import *
import mod2.mod2.
3. 主程序导入上层目录中模块或其他目录(平级)下的模块
如下面程序结构:
&&& |-- mod1.py
&&& |-- mod2
&&& | & & |-- mod2.py
&&& |-- sub
&&& | & & |-- test2.py
& & |-- test1.py
若在程序test2.py中导入模块mod1和mod2。
首先需要在mod2下建立__init__.py文件(同(2))，src下不必建立该文件。
下面程序执行方式均在程序文件所在目录下执行，如test2.py是在
# 之后执行
#&python test2.py
而test1.py是在
#&之后执行
#&python test1. 不保证在src目录下执行python sub/test2.py成功。
test2.py 中导入模块mod1和mod2的调用方式如下:
import sys
sys.path.append("..")
import mod1
import mod2.mod2
4.&从(3)可以看出，导入模块关键是能够根据sys.path环境变量的值，找到具体模块的路径。
这里仅介绍上面三种简单情况。
TA的最新馆藏import作用：导入/引入一个python标准模块，其中包括.py文件、带有__init__.py文件的目录。e.g：
import module_name[,module1,...]
from module import *|child[,child1,...]
说明：多次重复使用import语句时，不会重新加载被指定的模块，只是把对该模块的内存地址给引用到本地变量环境。测试：
#!/usr/bin/env python
#encoding: utf-8
print 'in a',id(os)
#!/usr/bin/env python
#encoding: utf-8
#第一次会打印a里面的语句
#再次导入os后，其内存地址和a里面的是一样的，因此这里只是对os的本地引用
print 'in c',id(os)
#第二次不会打印a里面的语句，因为没有重新加载
reload作用：对已经加载的模块进行重新加载，一般用于原模块有变化等特殊情况，reload前该模块必须已经import过。e.g：import osreload(os)说明：reload会重新加载已加载的模块，但原来已经使用的实例还是会使用旧的模块，而新生产的实例会使用新的模块；reload后还是用原来的内存地址；不能支持from。。import。。格式的模块进行重新加载。测试：
#!/usr/bin/env python
#encoding: utf-8
print 'in a',id(os)
#!/usr/bin/env python
#encoding: utf-8
#第一次import会打印a里面的语句
print id(a) #原来a的内存地址
#第二次reload还会打印a里面的语句，因为有重新加载
print id(a) #reload后a的内存地址，和原来一样
扩展：上面说了，在特殊情况的下才会使用reload函数；除了原来模块文件有修改外，还有哪些情况需要使用reload函数呢，这里举个例子。
#!/usr/bin/env python
#encoding: utf-8
import sys
#引用sys模块进来，并不是进行sys的第一次加载
reload(sys)
#重新加载sys
sys.setdefaultencoding('utf8')
##调用setdefaultencoding函数
上面的代码是正确的，再测试下面的代码
#!/usr/bin/env python
#encoding: utf-8
import sys
sys.setdefaultencoding('utf8')
上面的测试会失败，那么为什么要在调用setdefaultencoding时必须要先reload一次sys模块呢？因为这里的import语句其实并不是sys的第一次导入语句，也就是说这里其实可能是第二、三次进行sys模块的import，这里只是一个对sys的引用，只能reload才能进行重新加载；那么为什么要重新加载，而直接引用过来则不能调用该函数呢？因为setdefaultencoding函数在被系统调用后被删除了，所以通过import引用进来时其实已经没有了，所以必须reload一次sys模块，这样setdefaultencoding才会为可用，才能在代码里修改解释器当前的字符编码。试试下面的代码，同样会报错：
#!/usr/bin/env python
#encoding: utf-8
import sys
reload(sys)
sys.setdefaultencoding('utf8')
del sys.setdefaultencoding
##删除原来的setdefaultencoding函数
sys.setdefaultencoding('gb2312')
那么到底是谁在之前就导入sys并且调用了setdefaultencoding函数呢？答案就在python安装目录的Lib文件夹下，有一个叫site.py的文件【python2.6】，在里面可以找到main() --& setencoding()--&sys.setdefaultencoding(encoding),因为这个site.py每次启动python解释器时会自动加载，所以main函数每次都会被执行，setdefaultencoding函数一出来就已经被删除了。__import__作用：同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数，所以它的作用就可想而知了。其实import语句就是调用这个函数进行导入工作的，import sys &==&sys = __import__('sys')e.g：
__import__(module_name[, globals[, locals[, fromlist]]]) #可选参数默认为globals(),locals(),[]__import__('os') & &__import__('os',globals(),locals(),['path','pip']) &#等价于from os import path, pip
通常在动态加载时可以使用到这个函数，比如你希望加载某个文件夹下的所用模块，但是其下的模块名称又会经常变化时，就可以使用这个函数动态加载所有模块了，最常见的场景就是插件功能的支持。
扩展：既然可以通过字符串来动态导入模块，那么是否可以通过字符串动态重新加载模块吗？试试reload('os')直接报错，是不是没有其他方式呢?虽然不能直接reload但是可以先unimport一个模块，然后再__import__来重新加载模块。现在看看unimport操作如何实现，在python解释里可以通过globals(),locals(),vars(),dir()等函数查看到当前环境下加载的模块及其位置，但是这些都只能看不能删除，所以无法unimport；不过除此之外还有一个地方是专门存放模块的，这就是sys.modules，通过sys.modules可以查看所有的已加载并且成功的模块，而且比globals要多，说明默认会加载一些额外的模块，接下来就是unimport了。
#!/usr/bin/env python
#encoding: utf-8
import sys
__import__('a')
#第一次导入会打印消息
del sys.modules['a']
__import__('a')
#再次导入还是会打印消息，因为已经unimport一次了
__import__('a')
#这次就不会打印消息了
import就是调用的__import__
如果你事先不知道要导入的module名称，而需要把module name存放在string变量里，那么就只能用__import__
def getfuncbymodule(module_name, func_name):
&&&&module =&__import__(module_name)
&&&&return getattr(module, func_name)
&&except ImportError as e:
print getfuncbymodule("string", "split")("a b c")
此外，如果你写的模块文件名有-符合，例如my-mod.py，那么用
import my-mod
将无法运行
但下面语句可以：
__import__("my-mod")
也可以利用下面的语句：
exec("import my-mod")
阅读(...) 评论()