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

时间:2022-04-12 20:17:41

目录

  • 一 模块

  • 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文件是可以反编译的,因而它的出现仅仅是用来提升模块的加载速度的。

如下图所示:

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

提示:

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

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