
>>> import sys
>>> sys.path
['', 'D:\\python37\\Lib\\idlelib', 'D:\\python37\\python37.zip', 'D:\\python37\\DLLs', 'D:\\python37\\lib', 'D:\\python37', 'C:\\Users\\administrator\\AppData\\Roaming\\Python\\Python37\\site-packages', 'D:\\python37\\lib\\site-packages']

（二）创建一个包

这里用一个能够运行的例子来演示包机制的内部工作原理。文件名和路径将显示为普通文本，以便明确我们分析的是文件还是目录，还是由该文件/目录定义的模块/包。以下是这个mathproj包的树状结构图：

以下是这个包的代码：

mathroj/__init__.py文件


print("Hello from mathproj init")
__all__ = ['comp']
version = 1.03

mathproj/comp/__init__.py


__all__ = ['c1']
print("Hello from mathproj.comp init")

mathproj/comp/c1.py

x = 1.00

mathproj/comp/numeric/__init__.py

print("Hello from numeric init")

mathproj/comp/numeric/n1.py


from mathproj import version
from mathproj.comp import c1
from mathproj.comp.numeric.n2 import h
def g():
    print("version is ",version)
    print(h())

mathproj/comp/numeric/n2.py


def h():
    return "Called function h in module n2"

当我们把以上代码按照树状结构输入mathproj文件中后，还要确保mathproj在python的当前工作目录。

1）包内的init文件

以上代码中能发现，每个文件夹中都有一个__init__.py文件，这个文件有两个用途：

Python要求，只有包含__init__.py文件的目录才会被识别为包。这可防止意外导入包含其他Python代码的目录。
当第一次加载包或子包时。Python会自动执行__init__.py文件。有了这种自动执行的机制，就能够完成任何必要的包初始化工作。

很多包都不需要在其__init__文件中写入任何内容，只要保证有个空的__init__.py文件就行了。

2）mathproj包的基本用法

当做好以上工作后，保证你的mathproj模块存在于你的IDLE模块检索路径之中时，在Python shell中执行以下语句：


>>> import mathproj
Hello from mathproj init
>>> mathproj.version
1.03

如果一切顺利，Python将会执行__init__.py文件输出一段字符串，并且进入一个新的命令提示符，不会有错误信息。也就是说，第一次加载包的时候会自动执行__init__.py文件。

mathproj/__init__.py文件将把变量version赋值为1.03。变量version在mathproj包命名空间的作用域内，创建完毕后就可以通过mathproj访问，在mathproj/__init__.py文件之外也能够进行访问。

在使用过程中，包看起来与模块类似，都可以通过属性访问到其内部定义的对象。因为包就是模块的汇总。

3）子包和子模块的加载

mathproj包中的各个文件也是可以相互进行交互的。比如我们想访问mathproj/comp/nmeric/n1.py文件中定义的函数g，那么这个模块是否已经加载完毕了。上面已经导入了mathproj包，那么它的子包是否导入了呢：


>>> mathproj.comp.numeric.n1
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    mathproj.comp.numeric.n1
AttributeError: module 'mathproj' has no attribute 'comp'

我们发现访问这个函数会进行报错，也就是说，只加载顶级模块是不够的，这并不会加载其全部子模块。这是符合Python理念的，即清晰比简洁更重要。

解决以上问题，只要导入所需模块即可，然后就可以执行该模块中的函数g了：


>>> import mathproj.comp.numeric.n1
Hello from mathproj init
Hello from mathproj.comp init
Hello from numeric init
>>> mathproj.comp.numeric.n1.g()
version is  1.03
Called function h in module n2

不过这么导入的话，每一个包中的__init__.py文件都会被执行，每一个包都被导入，可以在其中产看上一级包的内存地址判断这个包是否被导入：


>>> mathproj.comp
<module 'mathproj.comp' from 'D:\\python37\\mathproj\\comp\\__init__.py'>
>>> mathproj.comp.numeric
<module 'mathproj.comp.numeric' from 'D:\\python37\\mathproj\\comp\\numeric\\__init__.py'>

4）包内的import语句

包内的文件不会自动获得包内其他文件的访问权限，无法访问同一包内其他文件中定义的对象。我们来看一下n1.py文件中：


from mathproj import version
from mathproj.comp import c1
from mathproj.comp.numeric.n2 import h
def g():
    print("version is ",version)
    print(h())

n1.py文件想要访问其他包和文件中的version以及h函数，需要先进行导入。

因为n2.py和n1.py位于同一个目录中，所以还可以使用相对导入的方式，只要在子模块名前加一个.即可。也就是n1.py的第三行写成这样，一样可以奏效：

from .n2 import h

5）all属性

一般来说，如果外部代码执行了from module inport *语句，就应该从mathproj导入全部的非私有对象名称。实际上着比较难以实现主要问题是，对于不容的操作系统来说，对文件名的定义规则比较含糊，这就导致了子包导入后其确切名称也含糊不定。

例如，写的是from mathproj import *，那么comp会被导入为comp、Comp还是COMP呢？如果只是依赖系统给出的名称，那么结果是不可预测的。

为了解决这个问题，Python引入了__all__属性，__all__属性应该给出一个字符串列表，定义了如果外部代码对这个包使用from module import *时，应该导入的名称。如果没有定义这个属性的话，我们在使用from module import *时，不会对该包执行任何操作。

我们在上面定义的包中输入以下语句：


>>> from mathproj import *
Hello from mathproj init
Hello from mathproj.comp init
>>> comp
<module 'mathproj.comp' from 'D:\\python37\\mathproj\\comp\\__init__.py'>
>>> c1
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    c1
NameError: name 'c1' is not defined
>>> from mathproj.comp import *
>>> c1
<module 'mathproj.comp.c1' from 'D:\\python37\\mathproj\\comp\\c1.py'>

从上面的代码中能看出来，使用from module import *导入时，和前面import module语句一样的规则。

导入包时，只是对这个包的名称，而不会导入这个包里面的包的名称，要想得到这个名称也需要进行一次显式的导入。

6）包的合理使用

大多数包的结构，都不应该像以上例子暗示的那么复杂。有了Python包机制，包设计时的复杂程度和嵌套层次就能有很大的自由度了。

包不应该采用嵌套很深的目录结构。除非代码量极其庞大，否则没有必要这样做。大多数包只需要一个顶级目录即可。两层目录结构就应该能有效处理绝大部分情况。正如Python之禅中所述“平直胜于嵌套”。
只要不在__all__属性中列出，就可以用__all__属性对from module import *隐藏这些对象的名称。尽管如此，但这可能并不算是一种好方案，因为这会导致不同导入方式的结果不一致。如果需要隐藏对象名称，请用前导双下划线让他们称为私有对象。