目录
一 模块
3.1 import
3.2 from ... import...
3.3 把模块当做脚本执行
3.4 模块搜索路径
3.5 编译python文件
3.6 标准模块
3.7 dir()函数
二 包
2.2 import
2.3 from ... import ...
2.4 __init__.py文件
2.5 from glance.api import *
2.6 绝对导入和相对导入
2.7 单独导入包
一、模块
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:\Users\Administrator\PycharmProjects\scripts')
至于.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的大小写和斜杠 '''
# 结果
\Users\Administrator\TEST
''' #具体应用
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:\YQLFC\study\day05\pack\__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作为起始
相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）
# 在glance\api\policy.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