Python文件引入的流程并不是那么直观,其只是简单的搜索环境变量,与运行目录并没有太大的关系

<h1 id="python">Python引入原理分析</h1>
Python中import引入文件分为绝对引入和相对引入。
<h2 id="heading">绝对引入</h2>
搜索<code>PYTHONPATH</code>环境变量目录里的所有文件,如果存在就引入,不存在就报错
这么就有一个问题,我们经常会有这种需求: 引入一个同级目录的文件 
当不在一个package中时,通常我们会使用绝对引入来引入这个包,如:
<pre style="background-color:#fff">src
├ a.py
└ b.py
</pre>如果想要在<code>a.py</code>中引入<code>b.py</code>,通常会使用<code>import b</code>或<code>from b import x</code> 
为什么这里绝对引入可以使用呢? 
打印出<code>sys.path</code>后可以发现,当我们使用<code>python a.py</code>时,程序会自动将<code>a.py</code>所在的目录加入到<code>PYTHONPATH</code>中
这样绝对引入时,会在当前的代码目录找到<code>b.py</code>并成功引入
<h2 id="heading-1">相对引入</h2>
相对引入只能使用在<code>package</code>中 
相对于绝对引入必须要写明路径,相对引入可以使用<code>.</code>和<code>..</code>来引入同级或上级目录的内容,相对来说非常方便 
当由于某些需要改动了模块间的关系时,改动也比较小
我们可以建立一个如下的文件夹来加深理解 
根目录: <code>root.py</code>, <code>root2.py</code>, <code>pack/</code>
<code>root.py</code>
<pre style="background-color:#fff">import site
import sys

print(&#34;=&#34;*10)
print(&#34;这是root文件&#34;)
print(&#34;运行参数&#34;, *sys.argv)
print(&#34;__name__\t&#34;, __name__)
print(&#34;__package__\t&#34;, __package__)
print(&#34;__file__\t&#34;, __file__)
for path in sys.path:
 print(path)
print(&#34;=&#34;*10)

try:
 from root2 import p1
 p1()
except Exception as e:
 print(&#34;Error&#34;, *e.args)

try:
 from pack.fun import p2, p3
 p2()
except Exception as e:
 print(&#34;Error&#34;, *e.args)
</pre><code>root2.py</code>
<pre style="background-color:#fff">import sys
print(&#34;=&#34;*10)
print(&#34;这是root2文件&#34;)
print(&#34;运行参数&#34;, *sys.argv)
print(&#34;__name__\t&#34;, __name__)
print(&#34;__package__\t&#34;, __package__)
print(&#34;__file__\t&#34;, __file__)
print(&#34;=&#34;*10)


def p1():
 print(&#34;p1&#34;)
</pre><code>pack/</code>目录: <code>__init__.py</code>, <code>fun.py</code>, <code>fun2.py</code>
<code>__init__.py</code>
<pre style="background-color:#fff">import sys
print(&#34;=&#34;*10)
print(&#34;这是包的__init__文件&#34;)
print(&#34;运行参数&#34;, *sys.argv)
print(&#34;__name__\t&#34;, __name__)
print(&#34;__package__\t&#34;, __package__)
print(&#34;__file__\t&#34;, __file__)
print(&#34;=&#34;*10)
</pre><code>fun.py</code>
<pre style="background-color:#fff">import sys

from .fun2 import p3

print(&#34;=&#34;*10)
print(&#34;这是fun文件&#34;)
print(&#34;运行参数&#34;, *sys.argv)
print(&#34;__name__\t&#34;, __name__)
print(&#34;__package__\t&#34;, __package__)
print(&#34;__file__\t&#34;, __file__)
print(&#34;=&#34;*10)


def p2():
 print(&#34;p2&#34;)


p3()
</pre><code>fun2.py</code>
<pre style="background-color:#fff">import sys
print(&#34;=&#34;*10)
print(&#34;这是fun2文件&#34;)
print(&#34;运行参数&#34;, *sys.argv)
print(&#34;__name__\t&#34;, __name__)
print(&#34;__package__\t&#34;, __package__)
print(&#34;__file__\t&#34;, __file__)
print(&#34;=&#34;*10)


def p3():
 print(&#34;p3&#34;)
</pre>输出结果:
<pre style="background-color:#fff">==========
这是root文件
运行参数 e:\pytest\src\root.py
__name__ __main__
__package__ None
__file__ e:\pytest\src\root.py
e:\pytest\src
C:\Users\kongchenhao\AppData\Local\Programs\Python\Python37-32\python37.zip
C:\Users\kongchenhao\AppData\Local\Programs\Python\Python37-32\DLLs
C:\Users\kongchenhao\AppData\Local\Programs\Python\Python37-32\lib
C:\Users\kongchenhao\AppData\Local\Programs\Python\Python37-32
C:\Users\kongchenhao\AppData\Local\Programs\Python\Python37-32\lib\site-packages
==========
==========
这是root2文件
运行参数 e:\pytest\src\root.py
__name__ root2
__package__
__file__ e:\pytest\src\root2.py
==========
p1
==========
这是包的__init__文件
运行参数 e:\pytest\src\root.py
__name__ pack
__package__ pack
__file__ e:\pytest\src\pack\__init__.py
==========
==========
这是fun2文件
运行参数 e:\pytest\src\root.py
__name__ pack.fun2
__package__ pack
__file__ e:\pytest\src\pack\fun2.py
==========
==========
这是fun文件
运行参数 e:\pytest\src\root.py
__name__ pack.fun
__package__ pack
__file__ e:\pytest\src\pack\fun.py
==========
p3
p2
</pre>可以看出,这样写是可以正常运行的,这时候,如果我们直接执行<code>fun.py</code>,会报错: 
<code>ModuleNotFoundError: No module named '__main__.fun2'; '__main__' is not a package</code>
这个很容易就可以看出来,相对引入的相对是对于<code>__main__</code>这个常量的 
当我们使用引入一个包后,<code>__main__</code>的值就是当前包相对于运行的主程序的路径,自然后面跟上<code>.xxx</code>就变成了绝对引入
因此,虽然相对引入比绝对引入更早地加入到Python中,但是相对引入更类似于绝对引入的一个语法糖。
因此,实际上是不能够只执行一个项目中某个Package中的一个文件进行临时性的测试的（如果该文件有引入上层目录或同级目录下的内容）
但是可以通过变通的方式解决该问题：
<ol>
<li>对于有引入上级目录的内容,只需要将原来的函数入口的路径加入到<code>PYTHONPATH</code>中即可。通常来说，尽管可以使用<code>sys.path</code>加入，但是为了可移植性，应该使用命令行来动态加入。 
如powershell中可使用: <code>$env:pythonpath=$env:pythonpath+';'+$pwd;python xx.py</code> 
对于VSCode,可以直接使用<code>&quot;terminal.integrated.env.windows&quot;: { &quot;PYTHONPATH&quot;: &quot;${workspaceFolder}&quot; }</code></li>
<li>对于有同级文件的引入，由于在引入包中，__name__是包路径，但是直接运行文件时，<code>__name__</code>是<code>__main__</code>。因此一方面可以使用绝对引入来引入同级包（但是这样也会造成移植性降低）；同时也可以判断<code>__name__</code>的值来实现该方法。当<code>__name__</code>为<code>__main__</code>时使用相对引入；否则使用绝对引入。</li>
</ol>
这样就实现了在Python中不影响整个项目运行的情况下，执行一个包中的一个文件进行测试等操作。