Python之路【第六篇】:模块与包

一、模块

1. 什么是模块?

　　一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

2. 为什么要使用模块?

　　1. 如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

　　2. 随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。

3. 模块分类

自定义模块
内置标准模块（又称标准库）
开源模块

自定义模块和开源模块的使用参考: http://www.cnblogs.com/wupeiqi/articles/4963027.html

模块的使用(import)

示例文件：spam.py，文件名spam.py,模块名为spam

下文以此模块示例

#spam.py
print('from the spam.py')

money=1000

def read1():
    print('spam->read1->money',money)

def read2():
    print('spam->read2 calling read')
    read1()

def change():
    global money
    money=0

1.1 知识点1

模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下 :

#!/usr/bin/env python
#-*- coding:utf-8 -*-

#test.py
import spam     #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.
import spam
import spam
import spam

'''
执行结果：
from the spam.py
'''

test.py

我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

#我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。
import sys
import spam
dic = sys.modules
print(dic)

'''
# 执行结果
from the spam.py
{'errno': <module 'errno' (built-in)>, 'spam': <module 'spam' from 'E:\YQLFC\study\day04\spam.py'>, 'ntpath': <module 'ntpath' from 'C:\python35\lib\ntpath.py'>, 'genericpath': <module 'genericpath' from 'C:\python35\lib\genericpath.py'>, '__main__': <module '__main__' from 'E:/YQLFC/study/day04/testspam.py'>, '_locale': <module '_locale' (built-in)>, '_sitebuiltins': <module '_sitebuiltins' from 'C:\python35\lib\_sitebuiltins.py'>, '_weakref': <module '_weakref' (built-in)>, 'nt': <module 'nt' (built-in)>, 'os': <module 'os' from 'C:\python35\lib\os.py'>, 'sys': <module 'sys' (built-in)>, 'sysconfig': <module 'sysconfig' from 'C:\python35\lib\sysconfig.py'>, '_multibytecodec': <module '_multibytecodec' (built-in)>, 'marshal': <module 'marshal' (built-in)>, 'encodings': <module 'encodings' from 'C:\python35\lib\encodings\__init__.py'>, '_warnings': <module '_warnings' (built-in)>, '_bootlocale': <module '_bootlocale' from 'C:\python35\lib\_bootlocale.py'>, 'os.path': <module 'ntpath' from 'C:\python35\lib\ntpath.py'>, 'encodings.aliases': <module 'encodings.aliases' from 'C:\python35\lib\encodings\aliases.py'>, 'encodings.gbk': <module 'encodings.gbk' from 'C:\python35\lib\encodings\gbk.py'>, 'stat': <module 'stat' from 'C:\python35\lib\stat.py'>, '_thread': <module '_thread' (built-in)>, '_imp': <module '_imp' (built-in)>, '_stat': <module '_stat' (built-in)>, '_frozen_importlib_external': <module '_frozen_importlib_external' (frozen)>, 'builtins': <module 'builtins' (built-in)>, '_collections_abc': <module '_collections_abc' from 'C:\python35\lib\_collections_abc.py'>, '_frozen_importlib': <module '_frozen_importlib' (frozen)>, 'encodings.utf_8': <module 'encodings.utf_8' from 'C:\python35\lib\encodings\utf_8.py'>, 'site': <module 'site' from 'C:\python35\lib\site.py'>, '_codecs': <module '_codecs' (built-in)>, 'codecs': <module 'codecs' from 'C:\python35\lib\codecs.py'>, 'winreg': <module 'winreg' (built-in)>, 'encodings.mbcs': <module 'encodings.mbcs' from 'C:\python35\lib\encodings\mbcs.py'>, '_codecs_cn': <module '_codecs_cn' (built-in)>, '_weakrefset': <module '_weakrefset' from 'C:\python35\lib\_weakrefset.py'>, 'zipimport': <module 'zipimport' (built-in)>, '_signal': <module '_signal' (built-in)>, 'encodings.latin_1': <module 'encodings.latin_1' from 'C:\python35\lib\encodings\latin_1.py'>, '_io': <module 'io' (built-in)>, 'io': <module 'io' from 'C:\python35\lib\io.py'>, 'abc': <module 'abc' from 'C:\python35\lib\abc.py'>}
'''

sys.module

1.2 知识点2

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突。

#测试一:money与spam.money不冲突
#test.py
import spam 
money=10
print(spam.money)

'''
执行结果：
from the spam.py
1000
'''

测试一

#测试二：read1与spam.read1不冲突
#test.py
import spam
def read1():
    print('========')
spam.read1()

'''
执行结果:
from the spam.py
spam->read1->money 1000
'''

测试二

#测试三：执行spam.change()操作的全局变量money仍然是spam中的
#test.py
import spam
money=1
spam.change()
print(money)

'''
执行结果：
from the spam.py
1
'''

测试三

1.3 import模块初始化

为源文件(spam模块)创建新的名称空间，在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。
在新创建的命名空间中执行模块中包含的代码，见初始导入import spam

1 提示:导入模块时到底执行了什么？
In fact function definitions are also ‘statements’ that are ‘executed’; the execution of a module-level function definition enters the function name in the module’s global symbol table.
事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放入模块全局名称空间表，用globals()可以查看

创建名字spam来引用该命名空间

这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式可以访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自两个完全不同的地方。

1.4 模块别名(as)

import spam as sm　　　　# spam模块设置别名为sm
print(sm.money)

为已经导入的模块起别名的方式对编写可扩展的代码很有用，假设有两个模块xmlreader.py和csvreader.py，它们都定义了函数read_data(filename):用来从文件中读取一些数据，但采用不同的输入格式。可以编写代码来选择性地挑选读取模块，例如:

应用:

if file_format == 'xml':
    import xmlreader as reader
elif file_format == 'csv':
    import csvreader as reader
data=reader.read_date(filename)

1.5 同一行导入多个模块

import sys,os,re

from... import ...

1. from... import... 剖析

对比import spam，会将源文件的名称空间'spam'带到当前名称空间中，使用时必须是spam.名字的方式,而from 语句相当于import，也会创建新的名称空间，但是将spam中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了。

from spam import read1,read2,money　　# 导入模块中的函数及变量

这样在当前位置直接使用read1和read2就好了，执行时，仍然以spam.py文件全局名称空间

#测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money
#test.py
from spam import read1
money=1000
read1()
'''
执行结果:
from the spam.py
spam->read1->money 1000
'''

测试一

#测试二:导入的函数read2，执行时需要调用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print('==========')
read2()       # read2中调用了read1

'''
执行结果:
from the spam.py
spam->read2 calling read
spam->read1->money 1000
'''

测试二

如果当前有重名read1或者read2，那么会有覆盖效果。即当前文件级别的代码中有同名函数，会被覆盖，当前文件中的同名函数或变量优先生效

#测试三:导入的函数read1，被当前位置定义的read1覆盖掉了
#test.py
from spam import read1
def read1():
    print('==========')
read1()
'''
执行结果:
from the spam.py
==========
'''

示例

注: 需要特别强调的一点是：python中的变量赋值不是一种存储操作，而只是一种绑定关系

from spam import money,read1
money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取spam.py中的名字money,仍然为1000

'''
from the spam.py
100
spam->read1->money 1000
'''

示例

2. 支持as

from spam import read1 as read　　　　# 在当前文件执行read函数，相当于调用spam模块中的read1函数

3. 支持导入多行

from spam import (read1,
                  read2,
                  money)

4. from spam import *

from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

from spam import * #将模块spam中所有的名字都导入到当前名称空间
print(money)
print(read1)
print(read2)
print(change)

'''
执行结果:
from the spam.py
1000
<function read1 at 0x1012e8158>
<function read2 at 0x1012e81e0>
<function change at 0x1012e8268>
'''

可以使用__all__来控制*（用来发布新版本）

在spam.py中新增一行，在被作为模块导入的文件中添加

__all__=['money','read1'] # 这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字,*一般和__all__搭配使用

5. 优缺点

优点: 方便，不用加前缀
缺点：容易跟当前文件的名称空间冲突

把模块当做脚本执行

我们可以通过模块的全局变量__name__来查看模块名：
当做脚本运行：
__name__ 等于'__main__'

当做模块导入：
__name__= 模块名

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑，当作脚本运行时if __name__ == '__main__':下面的逻辑代码会执行，当作模块导入时不会运行，一般用于脚本使用或测试程序时

if __name__ == '__main__':

#fib.py

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

示例

执行

#python fib.py <arguments>
python fib.py 50 #在命令行

模块搜索路径

python解释器在启动时会自动加载一些模块，可以使用sys.modules查看

在第一次导入某个模块时（比如spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用

如果没有，解释器则会查找同名的内建模块，如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。

总结:

模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块

注意: 我们自定义的模块名不应该与系统内置模块重名。虽然每次都说，但是仍然会有人不停的犯错。

在初始化后，python程序可以修改sys.path,路径放到前面的优先于标准库被加载,搜索时按照sys.path中从左到右的顺序查找，位于列表前面的优先被查找。

import sys
print("默认的sys.path: ",sys.path)
sys.path.append('/data/pypath/')
sys.path.insert(0,'/data/pypath/lib') # 排在前的目录，优先被搜索
print("修改sys.path后",sys.path)

'''
默认的sys.path:  ['/data/learnpy', '/usr/local/lib/python3.5/site-packages/prettytable-0.7.2-py3.5.egg', '/usr/local/lib/python35.zip', '/usr/local/lib/python3.5', '/usr/local/lib/python3.5/plat-linux', '/usr/local/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/site-packages']
修改sys.path后:  ['/data/pypath/lib', '/data/learnpy', '/usr/local/lib/python3.5/site-packages/prettytable-0.7.2-py3.5.egg', '/usr/local/lib/python35.zip', '/usr/local/lib/python3.5', '/usr/local/lib/python3.5/plat-linux', '/usr/local/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/site-packages', '/data/pypath/']
'''

注意：搜索时按照sys.path中从左到右的顺序查找，位于前的优先被查找，sys.path中还可能包含.zip归档文件和.egg文件，python会把.zip归档文件当成一个目录去处理。

#首先制作归档文件：zip module.zip foo.py bar.py

import sys
sys.path.append('module.zip')
import foo,bar
#也可以使用zip中目录结构的具体位置
sys.path.append('module.zip/lib/python')

#windows下的路径不加r开头，会语法错误
sys.path.insert(0,r'C:UsersAdministratorPycharmProjectsscripts')

至于.egg文件是由setuptools创建的包，这是按照第三方python库和扩展时使用的一种常见格式，.egg文件实际上只是添加了额外元数据(如版本号，依赖项等)的.zip文件。

强调：只能从.zip文件中导入.py，.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载（此时setuptools等打包系统有时能提供一种规避方法），且从.zip中加载文件不会创建.pyc或者.pyo文件，因此一定要事先创建他们，来避免加载模块时所带来的性能下降。

编译python文件

为了提高模块的加载速度，Python缓存编译的版本，每个模块在__pycache__目录的以module.version.pyc的形式命名，通常包含了python的版本号，如在CPython版本3.3，关于spam.py的编译版本将被缓存成__pycache__/spam.cpython-33.pyc，这种命名约定允许不同的版本，不同版本的Python编写模块共存。

Python检查源文件的修改时间与编译的版本进行对比，如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的，所以相同的库可以在不同的架构的系统之间共享，即pyc使一种跨平台的字节码，类似于JAVA火.NET,是由python虚拟机来执行的，但是pyc的内容跟python的版本相关，不同的版本编译后的pyc文件不同，2.5编译的pyc文件不能到3.5上执行，并且pyc文件是可以反编译的，因而它的出现仅仅是用来提升模块的加载速度的。

如下图所示:

提示：

1.模块名区分大小写，bar.py与BAR.py代表的是两个模块

2.你可以使用-O或者-OO转换python命令来减少编译模块的大小

1 -O转换会帮你去掉assert语句
2 -OO转换会帮你去掉assert语句和__doc__文档字符串
3 由于一些程序可能依赖于assert语句或文档字符串，你应该在在确认需要的情况下使用这些选项。

3.在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快，只有在模块被加载时，.pyc文件才是更快的

4.只有使用import语句是才将文件自动编译为.pyc文件，在命令行或标准输入中指定运行脚本则不会生成这类文件，因而我们可以使用compieall模块为一个目录中的所有模块创建.pyc文件

模块可以作为一个脚本（使用python -m compileall）编译Python源
 
python -m compileall /module_directory 递归着编译
如果使用python -O -m compileall /module_directory -l则只一层
 
命令行里使用compile()函数时，自动使用python -O -m compileall
 
详见：https://docs.python.org/3/library/compileall.html#module-compileall

标准库

python提供了一个标准模块库，一些模块被内置到解释器中，这些提供了不属于语言核心部分的操作的访问，但它们是内置的，无论是为了效率还是提供对操作系统原语的访问。这些模块集合是依赖于底层平台的配置项，如winreg模块只能用于windows系统。特别需要注意的是，sys模块内建在每一个python解释器

sys.ps1
sys.ps2
这俩只在命令行有效，得出的结果，标识了解释器是在交互式模式下。

变量sys.path是一个决定了模块搜索路径的字符串列表，它从环境变量PYTHONOATH中初始化默认路径，如果PYTHONPATH没有设置则从内建中初始化值，我们可以修改它
sys.path.append

import os

path='/Users/Administrator/TEST/\a1/\\aa.py/../..\'
print(os.path.normpath(path))      # 规范化路径，转换path的大小写和斜杠

'''
# 结果
UsersAdministratorTEST
'''

#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)
print(sys.path)

'''
['E:\YQLFC\study\day05', 'E:\YQLFC\study\day05\day5\模块', 'E:\YQLFC\study', 'E:\YQLFC\study\day05\day5\模块', 'C:\python35\python35.zip', 'C:\python35\DLLs', 'C:\python35\lib', 'C:\python35', 'C:\python35\lib\site-packages']
'''

os一种好的处理路径的方式

dir()函数

内建函数dir是用来查找模块中定义的名字，返回一个有序字符串列表

import spam
print(dir(spam))
'''
from the spam.py
['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'change', 'money', 'read1', 'read2']  # 有自带的也有自定义的变量和自定义的函数
'''

如果没有参数,dir()列举出当前定义的名字

import spam
print(dir())

'''
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'spam']　　　　# spam元素是当前导入的spam模块名
'''

dir()不会列举出内建函数或者变量的名字，它们都被定义到了标准模块builtin中，可以列举出它们

import builtins
print(dir(builtins)

import builtins
print(dir(builtins))
'''
# 内建函数
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 
'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 
'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 
'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 
'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 
'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 
'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 
'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', 
'__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',
 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 
 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 
 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod',
  'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
'''

内建函数

二. 包

Packages are a way of structuring Python’s module namespace by using “dotted module names”

包是一种通过使用'.模块名'来组织python模块名称空间的方式。

注意事项:

1. 无论是import形式还是from...import形式，凡是在导入语句中(而不是在使用时)遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法.
2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）.
3. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件.

以下是一个包的目录结构:

glance/                   # Top-level package

├── __init__.py      　　  # Initialize the glance package

├── api                   # Subpackage for api

│   ├── __init__.py

│   ├── policy.py

│   └── versions.py

├── cmd                   # Subpackage for cmd

│   ├── __init__.py

│   └── manage.py

│── db                   # Subpackage for db

│    ├── __init__.py

│    └── models.py

│__study.py　　　　　　    # 外部文件调用包

各文件内容：

#文件内容

#policy.py
def get():
    print('from policy.py')

#versions.py
def create_resource(conf):
    print('from version.py: ',conf)

#manage.py
def main():
    print('from manage.py')

#models.py
def register_models(engine):
    print('from models.py: ',engine)

注意事项:

1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.salt.saltapi,但都必须遵循这个原则。
2.对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
3.对比import salt 和from salt import saltapi的应用场景：如果我们想直接使用saltapi那必须使用后者。

init.py

不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，也可以存放一些初始化包的代码。

import

我们在与包glance同级别目录的文件study.py中进行测试 (包的外部进行调用)

方式一:

import glance.api.policy   　　　　　　 # 点的左边必须是一个包       
glance.api.policy.get()　　　　　　　　　# 直接可以调用

方式二:

# 步骤一
import glance       # 直接导入包名,此时会执行glance.__init__.py文件进行初始化
glance.api.policy.get()

# 步骤二
# 修改E:YQLFCstudyday05pack\__init__.py文件内容
# 添加: import glance.api.policy

from... import...

注意: from后面import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from glance import api.versions是错误语法

我们在与包glance同级别目录的文件study.py中进行测试 (包的外部进行调用)

from glance.api import versions     # 文件versions.py的名称
versions.create_resource('setting')
'''
from version.py:  setting
'''

from glance.cmd.manage import main   # manage.py文件中的函数main
main()                               # 直接调用
'''
from manage.py
'''

from glance.cmd import manage.main    # 语法错误
main()
'''
  File "E:/YQLFC/study/day05/pack/study.py", line 27
    from glance.cmd import manage.main 
                                 ^
SyntaxError: invalid syntax
'''

from... import *

切记: *与__all__一起搭配使用

此处是想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___:

# 步骤一
from glance import *    # 此时将会调用glance.__init__.py文件进行初始化,把可以调用的函数或变量导入这个文件中即可
policy.get()
'''
from policy.py
'''
versions.create_resource('1.0.1')
'''
from version.py:  1.0.1
'''
print(api.x)　　　　# api包中__init__.py文件中的变量
'''
'''
# 步骤二
# 修改__init__.py文件内容,即包glance的__init__.py文件
# 添加: from glance.api import * 

# 步骤三
# 修改api\__init__.py文件内容,即包api的__init__.py文件
# 添加: x = 100 __all__=['policy','versions']

示例一

# 步骤一
from glance.api import *    # 此时将会调用glance.__init__.py文件进行初始化,把可以调用的函数或变量导入这个文件中即可
from glance.db import *

# 步骤二
# 修改\__init__.py文件内容,即包glance的__init__.py文件
# 添加: from glance.api import *     from glance.db import *


# 步骤三
# 修改api\__init__.py文件内容,即包api的__init__.py文件
# 添加: __all__=['policy','versions']

# 步骤四
# 修改db\__init__.py文件内容,即包api的__init__.py文件
# 添加: __all__ = ['models']

# 包api
policy.get()
'''
from policy.py
'''

# 包db
models.register_models('mysql')
'''
from models.py:  mysql
'''

示例二

此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容，不在__all__列表中定义的内容不可以被调用

绝对导入和相对导入

我们的最顶级的包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

绝对导入：以glance作为起始

相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

# 在glanceapipolicy.py文件中

# 绝对导入
from glance.cmd import manage
manage.main()

# 相对导入
from ..cmd import manage
manage.main()

测试:注意一定要在于glance同级的文件study.py中进行测试

from glance.api import policy

'''
from manage.py
from manage.py
'''

注意: 在使用pycharm时，有的情况会为你多做一些事情，这是软件相关的东西，会影响你对模块导入的理解，因而在测试时，一定要回到命令行去执行，模拟我们生产环境

注意事项：
1. 可以用import导入内置或者第三方模块(已经在sys.path中)
2. 绝对避免使用import来导入自定义包的子模块(没有在sys.path中)
3. 应该使用from... import ...的绝对导入或者相对导入,且包的相对导入只能用from的形式

***需要注意的地方:

比如我们想在glance/api/versions.py中导入glance/api/policy.py，发现这两个模块是在同一个目录下，十分开心的就去做了，如下:

#在version.py中
 
import policy
policy.get()
注: 我们单独运行version.py正常的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到该模块

那么，问题来了...

子包中的模块version.py文件很可能是被一个glance包同级的其他文件导入，比如我们在于glance同级下的一个study.py文件中导入version模块，如下:

from glance.api import versions

'''
执行结果:
ImportError: No module named 'policy'
'''

问题分析: 此时我们在study.py文件中导入versions，即执行versions.py文件，而在versions.py文件中，import policy语句需要从sys.path中查找，也就是从当前目录查找policy.py文件,而当前的目录是和glance同一级别的路径，所以import policy语句执行失败

解决方法: 应该使用from... import ...的绝对导入或者相对导入

单独导入包（import package_name）

单独导入包名称时不会导入包中所有包含的所有子模块，如下:

import glance
glance.db.models.register_models('mysql')
'''
执行结果
AttributeError: module 'glance' has no attribute 'db'
'''

解决方法:

#glance/__init__.py
from . import db

#glance/db/__init__.py
from . import models

再次执行:

# 在glance同级目录的study.py文件中
import glance
glance.db.models.register_models('mysql')
'''
执行结果
from models.py:  mysql
'''

强调:

　　在同一个包内部互相调用时，必须用from... import... 形式导入

在同一个包内部进行互相导入时，推荐的一种调试方式如下:

# 作为脚本文件或调试时，以及作为包使用时的处理方式
if __name__ == '__main__':
    import versions
    versions.create_resource('a.conf')
else:
    from ..db import models
    models.register_models('mysql')

参考了海峰老师(egon)的博客资料: http://www.cnblogs.com/linhaifeng/articles/6379069.html

计算器作业实现: http://www.cnblogs.com/wushank/p/5172792.html