Python Import机制

<h1 class="title_txt"> Python Import机制
<cite class="fav_csdnstylebykimi"><a class="fav_csdnstylebykimi" title="收藏到我的网摘中，并分享给我的朋友">收藏</a>
</cite>

</h1>
<div class="blogstory">
<p><span style="font-size: small;">最近在看《Python源码剖析》，对Python内部运行机制比以前了解的更深入了，感觉自己有机会也可以做个小型的动态脚本语言了，呵呵，当然
是吹牛了。目的当然不是创造一个动态语言，目的只有一个：更好的使用Python。看到模块导入那块的时候，终于对模块导入机制比较了解了，以防忘记特记
录下来。 </span>

</p>
<h3>
<span style="font-size: small;">模块的搜索路径</span>
</h3>
<p><span style="font-size: small;">模块的搜索路径都放在了sys.path列表中，如果缺省的sys.path中没有含有自己的模块或包的路径，可以动态的加入（sys.path.apend）即可。下面是sys.path在Windows平台下的添加规则。</span>
</p>
<p><span style="font-size: small;">1、sys.path第一个路径往往是主模块所在的目录。在交互环境下添加一个空项，它对应当前目录。 </span>
</p>
<p><span style="font-size: small;">2、如果PYTHONPATH环境变量存在，sys.path会加载此变量指定的目录。</span>
</p>
<p><span style="font-size: small;">3、我们尝试找到Python Home，如果设置了PYTHONHOME环境变量，我们认为这就是Python Home，否则，我们使用python.exe所在目录找到lib/os.py去推断Python Home。</span>
</p>
<p><span style="font-size: small;">如果我们确实找到了Python Home，则相关的子目录（Lib、plat-win、lib-tk等）将以Python Home为基础加入到sys.path，并导入（执行）lib/site.py，将site-specific目录及其下的包加入。</span>
</p>
<p><span style="font-size: small;">如果我们没有找到Python Home，则把注册表Software/Python/PythonCore/2.5/PythonPath的项加入sys.path（HKLM和 HKCU合并后加入），但相关的子目录不会自动添加的。</span>
</p>
<p><span style="font-size: small;">4、如果我们没有找到Python Home，并且没有PYTHONPATH环境变量，并且不能在注册表中找到PythonPath，那么缺省相对路径将加入（如：./Lib;./plat-win等）。</span>
</p>
<p><span style="font-size: small;">总结如下</span>
</p>
<p><span style="font-size: small;">当在安装好的主目录中运行Python.exe时，首先推断Python Home，如果找到了PythonHome，注册表中的PythonPath将被忽略；否则将注册表的PythonPath加入。</span>
</p>
<p><span style="font-size: small;"><strong>如果PYTHONPATH环境变量存在，sys.path肯定会加载此变量指定的目录。</strong>
</span>
</p>
<p><span style="font-size: small;">如果Python.exe在另外的一个目录下（不同的目录，比如通过COM嵌入到其他程序），Python Home将不推断，此时注册表的PythonPath将被使用。</span>
</p>
<p><span style="font-size: small;">如果Python.exe不能发现他的主目录（PythonHome），并且注册表也没有PythonPath，则将加入缺省的相对目录。</span>
</p>
<p><span style="font-size: small;"></span>
</p>
<h3>
<span style="font-size: small;">标准Import</span>
</h3>
<p><span style="font-size: small;">Python中所有加载到内存的模块都放在sys.modules。当import一个模块时首先会在这个列表中查找是否已经加载了此模块，如果加
载了则只是将模块的名字加入到正在调用import的模块的Local名字空间中。如果没有加载则从sys.path目录中按照模块名称查找模块文件，模
块文件可以是py、pyc、pyd，找到后将模块载入内存，并加入到sys.modules中，并将名称导入到当前的Local名字空间。</span>
</p>
<p><span style="font-size: small;">可以看出了，<strong>一个模块不会重复载入</strong>
。多个不同的模块都可以用import引入同一个模块到自己的Local名字空间，其实背后的PyModuleObject对象只有一个。</span>
</p>
<p><span style="font-size: small;">说一个容易忽略的问题，<strong>import只能导入模块，不能导入模块中的对象（类、函数、变量等）。</strong>
如一个模块A（A.py）中有个函数getName，另一个模块不能通过import A.getName将getName导入到本模块，只能用import A。如果想只导入特定的类、函数、变量则用from A import getName即可。</span>
</p>
<h3>
<span style="font-size: small;">嵌套Import</span>
</h3>
<p><span style="font-size: small;">嵌套import，我分两种情况，一种是：本模块导入A模块（import A），而A中又有import语句，会激活另一个import动作，如import B，而B模块又可以import其他模块，一直下去。</span>
</p>
<p><span style="font-size: small;">对这种嵌套比较容易理解，注意一点就是各个模块的Local名字空间是独立的，所以上面的例子，本模块import A完了后本模块只能访问模块A，不能访问B及其他模块。虽然模块B已经加载到内存了，如果要访问还要在明确的在本模块中import B。</span>
</p>
<p><span style="font-size: small;">另外一种嵌套指，在模块A中import B，而在模块B中import A。这时会怎么样呢？这个在Python列表中由RobertChen给出了详细解释，抄录如下：</span>
</p>
<pre><span style="font-size: small;">[A.py]  <br>
from B import D  <br>
class C:pass  <br><br>
[B.py]  <br>
from A import C  <br>
class D:pass<br></span>
<br><br></pre>
<p><span style="font-size: small;">为什么执行A的时候不能加载D呢？ </span>
</p>
<p><span style="font-size: small;">如果将A.py改为：import B就可以了。 </span>
</p>
<p><span style="font-size: small;">这是怎么回事呢？ </span>
</p>
<p><span style="font-size: small;">RobertChen：这跟Python内部import的机制是有关的，具体到from B import D，Python内部会分成几个步骤：</span>
</p>
<ol type="1">
<li>
<span style="font-size: small;">在sys.modules中查找符号"B" </span>
</li>
<li>
<span style="font-size: small;">果符号B存在，则获得符号B对应的module对象&lt;module B&gt;。
</span>
<p><span style="font-size: small;">从&lt;module B&gt;的__dict__中获得符号"D"对应的对象，如果"D"不存在，则抛出异常 </span>
</p>
</li>
<li>
<p><span style="font-size: small;">如果符号B不存在，则创建一个新的module对象&lt;module B&gt;，注意，这时，module对象的__dict__为空。</span>
</p>
<span style="font-size: small;">执行B.py中的表达式，填充&lt;module B&gt;的__dict__ 。
</span>
<p><span style="font-size: small;">从&lt;module B&gt;的__dict__中获得"D"对应的对象，如果"D"不存在，则抛出异常。</span>
</p>
</li>
</ol>
<p><span style="font-size: small;">所以，这个例子的执行顺序如下： </span>
</p>
<p><span style="font-size: small;">1、执行A.py中的from B import D</span>
</p>
<p><span style="font-size: small;">由于是执行的python A.py，所以在sys.modules中并没有&lt;module
B&gt;存在，首先为B.py创建一个module对象(&lt;module
B&gt;)，注意，这时创建的这个module对象是空的，里边啥也没有，在Python内部创建了这个module对象之后，就会解析执行B.py，
其目的是填充&lt;module B&gt;这个dict。</span>
</p>
<p><span style="font-size: small;">2、执行B.py中的from A import C</span>
</p>
<p><span style="font-size: small;">在执行B.py的过程中，会碰到这一句，首先检查sys.modules这个module缓存中是否已经存在&lt;module
A&gt;了，由于这时缓存还没有缓存&lt;module
A&gt;，所以类似的，Python内部会为A.py创建一个module对象(&lt;module
A&gt;)，然后，同样地，执行A.py中的语句。</span>
</p>
<p><span style="font-size: small;">3、再次执行A.py中的from B import D</span>
</p>
<p><span style="font-size: small;">这时，由于在第1步时，创建的&lt;module
B&gt;对象已经缓存在了sys.modules中，所以直接就得到了&lt;module
B&gt;，但是，注意，从整个过程来看，我们知道，这时&lt;module
B&gt;还是一个空的对象，里面啥也没有，所以从这个module中获得符号"D"的操作就会抛出异常。如果这里只是import
B，由于"B"这个符号在sys.modules中已经存在，所以是不会抛出异常的。</span>
</p>
<p><span style="font-size: small;">上面的解释已经由Zoom.Quiet收录在<a href="http://wiki.woodpecker.org.cn/moin/MiscItems/2008-11-25" target="_blank">啄木鸟</a>
了，里面有图，可以参考一下。</span>
</p>
<h3>
<span style="font-size: small;">Package（包） Import</span>
</h3>
<p><span style="font-size: small;">包（Package）可以看成模块的集合，只要一个文件夹下面有个__init__.py文件，那么这个文件夹就可以看做是一个包。包下面的文件夹
还可以成为包（子包）。更进一步，多个较小的包可以聚合成一个较大的包，通过包这种结构，方便了类的管理和维护，也方便了用户的使用。比如
SQLAlchemy等都是以包的形式发布给用户的。</span>
</p>
<p><span style="font-size: small;">包和模块其实是很类似的东西，如果查看包的类型import SQLAlchemy type(SQLAlchemy)，可以看到其实也是&lt;type 'module'&gt;。import包的时候查找的路径也是sys.path。</span>
</p>
<p><span style="font-size: small;">包导入的过程和模块的基本一致，只是导入包的时候会执行此包目录下的<strong>__init__.py</strong>
而不是模块里面的语句了。另外，如果只是单纯的导入包，而包的__init__.py中又没有明确的其他初始化操作，那么此包下面的模块是不会自动导入的。如：</span>
</p>
<p><span style="font-size: small;">PA</span>
</p>
<p><span style="font-size: small;">--__init__.py</span>
</p>
<p><span style="font-size: small;">--wave.py</span>
</p>
<p><span style="font-size: small;">--PB1</span>
</p>
<p><span style="font-size: small;">--__init__.py</span>
</p>
<p><span style="font-size: small;">--pb1_m.py</span>
</p>
<p><span style="font-size: small;">--PB2</span>
</p>
<p><span style="font-size: small;">--__init__.py</span>
</p>
<p><span style="font-size: small;">--pb2_m.py</span>
</p>
<p><span style="font-size: small;">__init__.py都为空，如果有以下程序：</span>
</p>
<pre><span style="font-size: small;"></span>
<br><br></pre>
<div class="highlighter">
<ol class="highlighter-py">
<li>
<span style="font-size: small;"><span class="keyword">import</span>
<span>sys</span>
</span>
</li>
<li class="alt">
<span style="font-size: small;"><span class="keyword">import</span>
<span>PA.wave</span>
<span class="comment">#1 </span>
</span>
</li>
<li>
<span style="font-size: small;"><span class="keyword">import</span>
<span>PA.PB1</span>
<span class="comment">#2 </span>
</span>
</li>
<li class="alt">
<span style="font-size: small;"><span class="keyword">import</span>
<span>PA.PB1.pb1_masm1</span>
<span class="comment">#3 </span>
</span>
</li>
<li>
</li>
<li class="alt">
<span style="font-size: small;"><span class="keyword">import</span>
<span>PA.PB2.pb2_m</span>
<span class="comment">#4 </span>
</span>
</li>
<li>
</li>
<li class="alt">
<span style="font-size: small;"><span>PA.wave.getName()</span>
<span class="comment">#5 </span>
</span>
</li>
<li>
</li>
<li class="alt">
<span style="font-size: small;"><span>m1.getName()</span>
<span class="comment">#6 </span>
</span>
</li>
<li>
</li>
<li class="alt">
<span style="font-size: small;"><span>PA.PB2.pb2_m.getName()</span>
<span class="comment">#7</span>
</span>
</li>
</ol>
</div>
<p><span style="font-size: small;">当执行#1后，sys.modules会同时存在PA、PA.wave两个模块，此时可以调用PA.wave的任何类或函数了。但不能调用PA.PB1(2)下的任何模块。当前Local中有了PA名字。</span>
</p>
<p><span style="font-size: small;">当执行#2后，只是将PA.PB1载入内存，sys.modules中会有PA、PA.wave、PA.PB1三个模块，但是PA.PB1下的任何
模块都没有自动载入内存，此时如果直接执行PA.PB1.pb1_m.getName()则会出错，因为PA.PB1中并没有pb1_m。当前Local
中还是只有PA名字，并没有PA.PB1名字。</span>
</p>
<p><span style="font-size: small;">当执行#3后，会将PA.PB1下的pb1_m载入内存，sys.modules中会有PA、PA.wave、PA.PB1、
PA.PB1.pb1_m四个模块，此时可以执行PA.PB1.pb1_m.getName()了。由于使用了as，当前Local中除了PA名字，另外
添加了m1作为PA.PB1.pb1_m的别名。</span>
</p>
<p><span style="font-size: small;">当执行#4后，会将PA.PB2、PA.PB2.pb2_m载入内存，sys.modules中会有PA、PA.wave、PA.PB1、PA.PB1.pb1_m、PA.PB2、PA.PB2.pb2_m六个模块。当前Local中还是只有PA、m1。</span>
</p>
<p><span style="font-size: small;">下面的#5，#6，#7都是可以正确运行的。</span>
</p>
<p><span style="font-size: small;">注意的是：如果PA.PB2.pb2_m想导入PA.PB1.pb1_m、PA.wave是可以直接成功的。最好是采用明确的导入路径，对于./..相对导入路径还是不推荐用。</span>
</p>
</div>