Python 模块

原文： http://zetcode.com/lang/python/modules/

在 Python 教程的这一部分中，我们将使用 Python 模块。 几个示例说明了如何创建和使用 Python 模块。

模块是一个包含 Python 代码的文件。 Python 模块具有.py扩展名。

可以使用以下方法管理 Python 代码：

• 函数
• 类
• 模组
• 包装

Python 模块用于组织 Python 代码。 例如，与数据库相关的代码位于数据库模块内部，安全代码位于安全模块中，等等。较小的 Python 脚本可以具有一个模块。 但是较大的程序分为几个模块。 模块组合在一起形成包装。

Python 模块名称

模块名称是带有.py扩展名的文件名。 当我们有一个名为empty.py的文件时，模块名称为空。 __name__是一个变量，其中包含要引用的模块的名称。 当前模块，正在执行的模块（也称为主模块）有一个特殊名称：'__main__'。 使用此名称，可以从 Python 代码中引用它。

当前工作目录中有两个文件：empty.py和test_empty.py。 第二个模块是执行的主模块。 导入第一个模块。 使用import关键字导入模块。

empty.py

"""
An empty module
"""

这是empty.py模块。

test_empty.py

#!/usr/bin/env python
import empty
import sys
print(__name__)
print(empty.__name__)
print(sys.__name__)

在此代码示例中，我们导入两个模块：内置模块sys和一个自定义模块empty。 我们将模块的名称打印到控制台。

$ ./test_empty.py 
__main__
empty
sys

正在执行的模块的名称始终为'__main__'。 其他模块以文件名命名。 可以使用import关键字将模块导入其他模块。

Python 定位模块

导入模块时，解释器首先搜索具有该名称的内置模块。 如果找不到，它将在变量sys.path给定的目录列表中搜索。 sys.path是一个字符串列表，用于指定模块的搜索路径。 它由当前工作目录，在PYTHONPATH环境变量中指定的目录名称以及一些其他与安装有关的目录组成。 如果找不到该模块，则会引发ImportError。

locating_modules.py

#!/usr/bin/env python
import sys
import textwrap
sp = sorted(sys.path)
dnames = ', '.join(sp)
print(textwrap.fill(dnames))

该脚本从sys.path变量打印所有目录。

import textwrap

textwrap模块用于轻松设置段落格式。

sp = sorted(sys.path)

我们从sys.path变量中检索目录列表并对它们进行排序。

dnames = ', '.join(sp)

我们从列表中取出一个字符串。

$ ./locating_modules.py 
/home/janbodnar/.local/lib/python3.5/site-packages,
/home/janbodnar/PycharmProjects/Simple,
/home/janbodnar/PycharmProjects/Simple, /usr/lib/python3.5,
/usr/lib/python3.5/lib-dynload, /usr/lib/python3.5/plat-x86_64-linux-
gnu, /usr/lib/python3/dist-packages, /usr/lib/python35.zip,
/usr/local/lib/python3.5/dist-packages

这是一个示例输出。

Python import关键字

import关键字可以以多种方式使用。

from module import *

此构造会将所有 Python 定义导入另一个模块的名称空间。 有一个例外。 不导入以下划线字符_开头的对象。 预期它们只能由导入的模块在内部使用。 不建议使用这种方式导入模块。

everything.py

#!/usr/bin/python
from math import *
print(cos(3))
print(pi)

此导入构造已从内置math模块导入了所有定义。 我们可以直接调用数学函数，而无需引用math模块。

$ ./everything.py 
-0.9899924966004454
3.141592653589793

使用此导入构造可能会导致名称空间污染。 我们可能有多个同名的对象，并且它们的定义可以被覆盖。

pollution.py

#!/usr/bin/env python
from math import *
pi = 3.14
print(cos(3))
print(pi)

该示例将在控制台上打印 3.14。 这可能不是我们想要的。 在大型项目中，命名空间污染可能变得至关重要。

未导入的 Python 对象

以下示例显示了未使用此import构造导入的定义。

names.py

#!/usr/bin/env python
"""
names is a test module
"""
_version = 1.0
names = ["Paul", "Frank", "Jessica", "Thomas", "Katherine"]
def show_names():
    for i in names:
       print(i)
def _show_version():
    print(_version)

这是names.py模块。

test_names.py

#!/usr/bin/env python
from names import *
print(locals())
show_names()

_version变量和_show_version()函数未导入到test_names模块中。 我们在命名空间中看不到它们。 locals()函数为我们提供了模块中所有可用的定义。

导入特定对象

使用from和import关键字，可以仅导入某些对象。

from module import fun, var

此导入构造仅从模块导入特定对象。 这样，我们仅导入我们需要的定义。

import_specific.py

#!/usr/bin/python
from math import sin, pi
print(sin(3))
print(pi)

我们从math模块导入两个对象。 我们无法引用其他定义（例如cos函数）。

imnames.py

#!/usr/bin/python
from names import _version, _show_version
print(_version)
_show_version()

我们也可以导入下划线开头的定义。 但这是一个不好的做法。

$ ./imnames.py 
1.0
1.0

Python 导入模块

最后一种构造使用最广泛。

import module

它防止名称空间污染，并允许从模块访问所有定义。

impmod.py

#!/usr/bin/env python
import math
pi = 3.14
print(math.cos(3))
print(math.pi)
print(math.sin(3))
print(pi)

在这种情况下，我们通过模块名称引用定义。 如我们所见，我们可以使用两个pi变量。 我们的定义来自math模块。

$ ./impmod.py 
-0.9899924966004454
3.141592653589793
0.1411200080598672
3.14

Python 别名模块

我们可以使用as关键字为模块创建别名。

importas.py

#!/usr/bin/python
# importas.py
import math as m
print(m.pi)
print(m.cos(3))

我们可以更改引用模块的名称。 为此，我们使用as关键字。

$ ./importas.py 
3.14159265359
-0.9899924966

ImportError

如果无法导入模块，则会引发ImportError。

importerror.py

#!/usr/bin/env python
try:
    import empty2
except ImportError as e:
    print('Failed to import:', e)

我们尚未创建empty2模块。 因此引发了异常。

$ ./importerror.py
Failed to import: No module named empty2

示例输出。

执行 Python 模块

模块可以导入其他模块，也可以执行。 模块作者经常创建测试套件来测试模块。 仅当模块作为脚本执行时，__name__属性等于'__main__'。

我们将在斐波那契模块上对此进行演示。 斐波那契数是一个数字序列，其中每个数字都是其两个直接前辈的总和。

fibonacci.py

#!/usr/bin/env python
"""
A module containing the fibonacci
function.
"""
def fib(n):
    a, b = 0, 1
    while b < n:
        print(b, end=" ")
        (a, b) = (b, a + b)
# testing
if __name__ == '__main__':
    fib(500)

通常可以照常导入该模块。 该模块也可以执行。

$ ./fibonacci.py 
1 1 2 3 5 8 13 21 34 55 89 144 233 377

如果确实导入了fibonacci模块，则不会自动执行测试。

>>> import fibonacci as fib
>>> fib.fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

导入了fibonacci模块，并执行了fib()函数。

Python dir函数

内置的dir()函数提供了包含模块定义名称的字符串排序列表。

dirfun.py

#!/usr/bin/env python
"""
This is dirfun module 
"""
import math, sys
version = 1.0
names = ["Paul", "Frank", "Jessica", "Thomas", "Katherine"]
def show_names():
   for i in names:
      print(i)
print(dir())

在此模块中，我们导入两个系统模块。 我们定义一个变量，一个列表和一个函数。

print(dir())

dir()函数返回模块当前名称空间中所有可用的名称。

$ ./dirfun.py
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', 
'__package__', '__spec__', 'math', 'names', 'show_names', 'sys', 'version']

我们可以看到一些内置名称，例如'__file__'或'__name__'，以及我们定义和导入的所有其他名称。

Python 全局函数

globals()函数返回代表当前全局名称空间的字典。 它是全局名称及其值的字典。 它是当前模块的字典。

globalsfun.py

#!/usr/bin/env python
import textwrap
version = 1.0
def myfun():
    pass
gl = globals()
gnames = ', '.join(gl)
print(textwrap.fill(gnames))

我们使用globals()函数来打印当前模块的所有全局名称。

$ ./globalsfun.py
textwrap, __package__, version, __builtins__, __name__, __spec__,
__doc__, gl, __cached__, myfun, __loader__, __file__

这些是当前模块的全局名称。

Python __module__属性

__module__类属性具有定义该类的模块的名称。

animals.py

"""
module animals
"""
class Cat:
    pass
class Dog:
    pass

这是animals.py文件的内容。 我们有两个类。

mclass.py

#!/usr/bin/env python
from animals import Cat
class Being:
    pass
b = Being()
print(b.__module__)
c = Cat()
print(c.__module__)

在此代码中，我们使用__module__属性。

from animals import Cat

从animals模块，我们导入Cat类。

class Being:
    pass

在当前模块中，我们定义一个类Being。

b = Being()
print(b.__module__)

创建Being类的实例。 我们打印其模块的名称。

c = Cat()
print(c.__module__)

我们从Cat类创建一个对象。 我们还将在定义模块的位置打印。

$ ./mclass.py
__main__
animals

当前模块的名称为'__main__'。 Cat's模块的名称是动物。

本章是关于 Python 中的模块的。