Python 模块和包 – 简介

阅读 15分钟，理解 60分钟，实践 120分钟

• Python 模块
• 模块搜索路径
• import <module_name>
• from<module_name> import <name(s)>
• from <module_name> import<name> as <alt_name>
• import<module_name> as <alt_name>

模块化编程是指将一个大的、的编程任务分解成单独的、更小的、更易于管理的子任务或模块的过程。然后，可以将各个模块像构建块一样拼凑在一起，以创建更大的应用程序。

在大型应用程序中模块化代码有几个优点：

• 简洁：模块关注问题的相对较小的部分使得开发更容易且不易出错。
• 可维护性：模块通常设计为在不同问题域之间强制实施逻辑边界。最小化了相互依赖性，则对单个模块的修改对程序的其他部分产生影响的可能性就会降低。
• 可 重用：单个模块中定义的功能可以很容易地被应用程序的其他部分重用（通过适当定义的接口）。这消除了复制代码的需要。
• 范围：模块通常定义一个单独的命名空间，这有助于避免程序不同区域中标识符之间的冲突。

Python 模块：概述

有三种不同的方法可以在Python中定义模块：

1. 可以用Python本身编写。
2. 可以用 C 编写并在运行时动态加载
3. 内置模块本质上包含在解释器中

=访问模块内容的方式相同：使用语句。import

用Python编写的模块很酷的地方在于它们非常容易构建。需要做的就是创建一个包含合法 Python 代码的文件，然后为该文件命名并带有扩展名。.py

创建了一个名为 包含以下内容的文件：mod.py

mod.py

s = "If Comrade Napoleon says it, it must be right."
a = [100, 200, 300]

def foo(arg):
    print(f'arg = {arg}')

class Foo:
    pass

中定义了几个对象：mod.py

• s（字符串）
• a（列表）
• foo()（一个函数）
• Foo（一类）

则可以通过import 模块来访问这些对象，如下所示：mod.py

>>>

>>> import mod
>>> print(mod.s)
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo(['quux', 'corge', 'grault'])
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo()
>>> x
<mod.Foo object at 0x03C181F0>

模块搜索路径

看看当 Python 执行语句时会发生什么：

import mod

当解释器执行上述语句时，它会在从以下源组装的目录列表中搜索：importmod.py

• 从中运行输入脚本的目录或当前目录（如果解释器正在交互运行）
• PYTHONPATH 环境变量中包含的目录列表
• 安装 Python 时配置目录

生成的搜索路径可以在 Python 变量中访问，sys.pathsys

>>>

>>> import sys
>>> sys.path
['D:\\zsoft\\project\\python_project\\demo\\数字lfrq',
 'D:\\zsoft\\project\\python_project\\demo', 
 'D:\\zsoft\\project\\python_project\\tool\\bilibli\\biliDownloader_GUI-master', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\python38.zip', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\DLLs', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\lib', 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38', 'D:\\zsoft\\project\\python_project\\demo\\bilibli_env', 'D:\\zsoft\\project\\python_project\\demo\\bilibli_env\\lib\\site-packages']

可以将模块文件放在选择的任何目录中，

>>>

>>> sys.path.append(r'C:\Users\john')
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

导入模块后，可以使用模块的属性确定找到它的位置：__file__

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

的目录部分应该是 中的目录之一。__file__sys.path

import

模块内容随语句一起提供给调用方。

import <module_name>

最简单的形式是上面的形式：

import <module_name>

每个import的模块都可以找到对应 的 .py文件如下

>>>

>>> import os
>>> os
<module 'os' from 'C:\\Users\\admin\\AppData\\Local\\Programs\\Python\\Python38\\lib\\os.py'>
>>> 

>>>

>>> s
NameError: name 's' is not defined
>>> foo('quux')
NameError: name 'foo' is not defined

要在本地上下文中访问，模块中定义的对象名称必须以 ：mod

>>>

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo('quux')
arg = quux

可以在单个语句中指定多个逗号分隔的模块：import

import <module_name>[, <module_name> ...]

from <module_name> import <name(s)>

from <module_name> import <name(s)>

可以在调用方的环境中引用，不带前缀：<name(s)><module_name>

>>>

>>> from mod import s, foo
>>> s
'If Comrade Napoleon says it, it must be right.'
>>> foo('quux')
arg = quux

>>> from mod import Foo
>>> x = Foo()
>>> x
<mod.Foo object at 0x02E3AD50>

由于这种形式将对象名称直接放入调用方的符号表中，因此已存在的任何具有相同名称的对象都将被覆盖

>>>

>>> a = ['foo', 'bar', 'baz']
>>> a
['foo', 'bar', 'baz']

>>> from mod import a
>>> a
[100, 200, 300]

甚至可以从模块中获取所有内容：import

from <module_name> import *

例如：

>>>

>>> from mod import *
>>> s
'If Comrade Napoleon says it, it must be right.'
>>> a
[100, 200, 300]
>>> foo
<function foo at 0x03B449C0>
>>> Foo
<class 'mod.Foo'>

在大规模生产代码中不一定建议这样做。这有点危险，因为正在将名称集体输入到本地符号表中。除非非常了解它们并且能够确信不会发生冲突，否则很有可能无意中覆盖现有名称。

from <module_name> import <name> as <alt_name>

也可以单独使用对象

from <module_name> import <name> as <alt_name>[, <name> as <alt_name> …]

这样就可以将名称直接放入本地符号表中，但避免与先前存在的名称发生冲突：

>>>

>>> s = 'foo'
>>> a = ['foo', 'bar', 'baz']

>>> from mod import s as string, a as alist
>>> s
'foo'
>>> string
'If Comrade Napoleon says it, it must be right.'
>>> a
['foo', 'bar', 'baz']
>>> alist
[100, 200, 300]

import <module_name> as <alt_name>

可以使用别名称导入整个模块：

import <module_name> as <alt_name>

>>>

>>> import mod as my_module
>>> my_module.a
[100, 200, 300]
>>> my_module.foo('qux')
arg = qux

>>>

>>> def bar():
...     from mod import foo
...     foo('corge')
...

>>> bar()
arg = corge

但是，Python 3 不允许在函数中：import *

>>>

>>> def bar():
...     from mod import *
...
SyntaxError: import * only allowed at module level

>>>

>>> try:
...     # Non-existent module
...     import baz
... except ImportError:
...     print('Module not found')
...

Module not found

>>>

>>> try:
...     # Existing module, but non-existent object
...     from mod import baz
... except ImportError:
...     print('Object not found in module')
...

Object not found in module

函数dir()

>>>

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

>>> qux = [1, 2, 3, 4, 5]
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'qux']

>>> class Bar():
...     pass
...
>>> x = Bar()
>>> dir()
['Bar', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'qux', 'x']
：

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

>>> import mod
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'mod']
>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo([1, 2, 3])
arg = [1, 2, 3]

>>> from mod import a, Foo
>>> dir()
['Foo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'a', 'mod']
>>> a
[100, 200, 300]
>>> x = Foo()
>>> x
<mod.Foo object at 0x002EAD50>

>>> from mod import s as string
>>> dir()
['Foo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'a', 'mod', 'string', 'x']
>>> string
'If Comrade Napoleon says it, it must be right.'

该参数是模块的名称，列出模块中定义的名称：dir()

>>>

>>> import mod
>>> dir(mod)
['Foo', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__', 'a', 'foo', 's']

>>>

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']
>>> from mod import *
>>> dir()
['Foo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'a', 'foo', 's']

将模块作为脚本执行

任何包含模块文件本质上也是一个 Python 脚本，没有任何理由不能像一个脚本一样执行。.py

mod.py

s = "If Comrade Napoleon says it, it must be right."
a = [100, 200, 300]

def foo(arg):
    print(f'arg = {arg}')

class Foo:
    pass

作为脚本运行：

C:\Users\john\Documents>python mod.py
C:\Users\john\Documents>
：

mod.py

s = "If Comrade Napoleon says it, it must be right."
a = [100, 200, 300]

def foo(arg):
    print(f'arg = {arg}')

class Foo:
    pass

print(s)
print(a)
foo('quux')
x = Foo()
print(x)

C:\Users\john\Documents>python mod.py
If Comrade Napoleon says it, it must be right.
[100, 200, 300]
arg = quux
<__main__.Foo object at 0x02F101D0>

>>>

>>> import mod
If Comrade Napoleon says it, it must be right.
[100, 200, 300]
arg = quux
<mod.Foo object at 0x0169AD50>

• 当文件作为模块导入时，Python 会将特殊变量__name__设置为模块的名称。
• 但是，如果文件作为独立脚本运行，相应地更改行为：.py __name__'__main__'

mod.py

s = "If Comrade Napoleon says it, it must be right."
a = [100, 200, 300]

def foo(arg):
    print(f'arg = {arg}')

class Foo:
    pass

if (__name__ == '__main__'):
    print('Executing as standalone script')
    print(s)
    print(a)
    foo('quux')
    x = Foo()
    print(x)

现在，如果作为脚本运行，则会得到输出：

C:\Users\john\Documents>python mod.py
Executing as standalone script
If Comrade Napoleon says it, it must be right.
[100, 200, 300]
arg = quux
<__main__.Foo object at 0x03450690>

但是，如果作为模块导入，则不会：

>>>

>>> import mod
>>> mod.foo('grault')
arg = grault

fact.py

def fact(n):
    return 1 if n == 1 else n * fact(n-1)

if (__name__ == '__main__'):
    import sys
    if len(sys.argv) > 1:
        print(fact(int(sys.argv[1])))

可以将该文件视为模块，并导入函数：fact()

>>>

>>> from fact import fact
>>> fact(6)
720

但它也可以通过在命令行上传递整数参数进行测试来独立运行：

C:\Users\john\Documents>python fact.py 6
720

移除广告

重新加载模块

出于效率原因，每个解释器会话仅加载一次模块。这对于函数和类定义来说很好，它们通常构成了模块内容的大部分。

考虑以下文件：mod.py

mod.py

a = [100, 200, 300]
print('a =', a)

>>>

>>> import mod
a = [100, 200, 300]
>>> import mod
>>> import mod

>>> mod.a
[100, 200, 300]

该语句不会在后续导入时执行。

如果对模块进行更改并需要重新加载它，则需要重新启动解释器或使用从模块调用的函数：reload()importlib

>>>

>>> import mod
a = [100, 200, 300]

>>> import mod

>>> import importlib
>>> importlib.reload(mod)
a = [100, 200, 300]
<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>

包

假设开发了一个包含许多模块的非常大的应用程序。随着模块数量的增加，如果将它们倾倒到一个位置，则很难跟踪所有模块。如果它们具有相似的名称或功能，则尤其如此。可能希望有一种对它们进行分组和组织的方法。

包允许使用点表示法对模块命名空间进行分层结构。与模块有助于避免全局变量名称之间的冲突一样，包也有助于避免模块名称之间的冲突。

创建软件包非常简单，因为它利用了操作系统固有的分层文件结构。请考虑以下安排：

在这里，有一个名为的目录，其中包含两个模块，以及 .模块的内容包括：pkgmod1.pymod2.py

mod1.py

def foo():
    print('[mod1] foo()')

class Foo:
    pass

mod2.py

def bar():
    print('[mod2] bar()')

class Bar:
    pass

给定此结构，如果目录位于可以找到它的位置（在 中包含的目录之一中），则可以使用点表示法 （， ） 引用这两个模块，并使用已经熟悉的语法导入它们：pkgsys.pathpkg.mod1pkg.mod2

import <module_name>[, <module_name> ...]

>>>

>>> import pkg.mod1, pkg.mod2
>>> pkg.mod1.foo()
[mod1] foo()
>>> x = pkg.mod2.Bar()
>>> x
<pkg.mod2.Bar object at 0x033F7290>

from <module_name> import <name(s)>

>>>

>>> from pkg.mod1 import foo
>>> foo()
[mod1] foo()

from <module_name> import <name> as <alt_name>

>>>

>>> from pkg.mod2 import Bar as Qux
>>> x = Qux()
>>> x
<pkg.mod2.Bar object at 0x036DFFD0>

也可以使用以下语句导入模块：

from <package_name> import <modules_name>[, <module_name> ...]
from <package_name> import <module_name> as <alt_name>

>>>

>>> from pkg import mod1
>>> mod1.foo()
[mod1] foo()

>>> from pkg import mod2 as quux
>>> quux.bar()
[mod2] bar()

从技术上讲，也可以导入包：

>>>

>>> import pkg
>>> pkg
<module 'pkg' (namespace)>

这是一个语法正确的Python语句，但它并没有做任何有用的事情。它不会将任何模块放入本地命名空间中：pkg

>>>

>>> pkg.mod1
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    pkg.mod1
AttributeError: module 'pkg' has no attribute 'mod1'
>>> pkg.mod1.foo()
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    pkg.mod1.foo()
AttributeError: module 'pkg' has no attribute 'mod1'
>>> pkg.mod2.Bar()
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    pkg.mod2.Bar()
AttributeError: module 'pkg' has no attribute 'mod2'

包初始化

包目录中存在名为__init__.py的文件，则在导入包或包中的模块时将调用该文件。用于执行包初始化代码，

例如，请考虑以下文件：__init__.py

__init__.py

print(f'Invoking __init__.py for {__name__}')
A = ['quux', 'corge', 'grault']

让我们将此文件添加到上面示例中的目录中：pkg

现在，当导入包时，全局列表已初始化：A

>>>

>>> import pkg
Invoking __init__.py for pkg
>>> pkg.A
['quux', 'corge', 'grault']

包中的模块可以通过依次导入全局变量来访问全局变量：

mod1.py

def foo():
    from pkg import A
    print('[mod1] foo() / A = ', A)

class Foo:
    pass

>>>

>>> from pkg import mod1
Invoking __init__.py for pkg
>>> mod1.foo()
[mod1] foo() / A =  ['quux', 'corge', 'grault']

__init__.py还可用于实现从包中自动导入模块，在目录中包含以下内容：import pkgpkg__init__.pypkg

__init__.py

print(f'Invoking __init__.py for {__name__}')
import pkg.mod1, pkg.mod2

执行 时，模块和 会自动导入：import pkgmod1mod2

>>>

>>> import pkg
Invoking __init__.py for pkg
>>> pkg.mod1.foo()
[mod1] foo()
>>> pkg.mod2.bar()
[mod2] bar()

注意：许多 Python 文档都指出，创建包时，文件必须存在于包目录中。这曾经是真的。过去，Python的存在对Python来说意味着正在定义一个包。该文件可以包含初始化代码，甚至可以为空，但它必须存在__init__.py

从 Python 3.3 开始，引入了隐式命名空间包__init__.py不是必需的。

从包导入*

现在目录中定义了四个模块。其内容如下所示：pkg

mod1.py

def foo():
    print('[mod1] foo()')

class Foo:
    pass

mod2.py

def bar():
    print('[mod2] bar()')

class Bar:
    pass

mod3.py

def baz():
    print('[mod3] baz()')

class Baz:
    pass

mod4.py

def qux():
    print('[mod4] qux()')

class Qux:
    pass

（富有想象力，不是吗？

模块中的所有对象都将导入到本地符号表中，但名称以下划线开头的对象除外

>>>

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

>>> from pkg.mod3 import *

>>> dir()
['Baz', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'baz']
>>> baz()
[mod3] baz()
>>> Baz
<class 'pkg.mod3.Baz'>

包的类似语句是这样的：

from <package_name> import *

这是做什么的？

>>>

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

>>> from pkg import *
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

Python会解析包目录，找到它能找到的所有模块，并将它们全部导入，但是也可以控制导入竺为。

包/__init__.py

__all__ = [
        'mod1',
        'mod2',
        'mod3',
        'mod4'
        ]
y

现在导入所有四个模块：from pkg import *

>>>

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

>>> from pkg import *
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'mod1', 'mod2', 'mod3', 'mod4']
>>> mod2.bar()
[mod2] bar()
>>> mod4.Qux
<class 'pkg.mod4.Qux'>

包的默认行为是不导入所有内容。import *import *__all__

也可以在模块中定义，控制导入的内容。例如，修改如下：__all__import *mod1.py

pkg/mod1.py

__all__ = ['foo']

def foo():
    print('[mod1] foo()')

class Foo:
    pass

现在，来自的语句将仅导入以下内容：import *pkg.mod1__all__

>>>

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__']

>>> from pkg.mod1 import *
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
'__package__', '__spec__', 'foo']

>>> foo()
[mod1] foo()
>>> Foo
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    Foo
NameError: name 'Foo' is not defined

foo()（函数）现在在本地命名空间中定义，但（类）不是，因为后者不在 .Foo__all__

包和模块都使用它来控制在指定时导入的内容。但默认行为有所不同：__all__import

• 对于包，如果未定义，则不会导入任何内容。__all__import *
• 对于模块，如果未定义，则导入所有内容（除了 以下划线开头的名称

__all__import *

子包

包可以包含任意深度的嵌套子包。

四个模块（、 和 ）的定义与前面相同。但是现在，它们不是被集中到目录中，而是被拆分为两个子包目录，并且.mod1.pymod2.pymod3.pymod4.pypkgsub_pkg1sub_pkg2

导入的工作方式仍与前面所示相同。语法类似，但使用额外的点表示法将包名称与子包名称分开：

>>>

>>> import pkg.sub_pkg1.mod1
>>> pkg.sub_pkg1.mod1.foo()
[mod1] foo()

>>> from pkg.sub_pkg1 import mod2
>>> mod2.bar()
[mod2] bar()

>>> from pkg.sub_pkg2.mod3 import baz
>>> baz()
[mod3] baz()

>>> from pkg.sub_pkg2.mod4 import qux as grault
>>> grault()
[mod4] qux()

一个子包中的模块可以引用同级子包中的对象。例如，假设要从模块中导入并执行函数（在模块中定义）。可以使用绝对导入：foo()mod1mod3

pkg/sub__pkg2/mod3.py

def baz():
    print('[mod3] baz()')

class Baz:
    pass

from pkg.sub_pkg1.mod1 import foo
foo()

>>>

>>> from pkg.sub_pkg2 import mod3
[mod1] foo()
>>> mod3.foo()
[mod1] foo()

或者，可以使用相对导入，其中指包的一级。在子包中，..mod3.pysub_pkg2

pkg/sub__pkg2/mod3.py

def baz():
    print('[mod3] baz()')

class Baz:
    pass

from .. import sub_pkg1
print(sub_pkg1)

from ..sub_pkg1.mod1 import foo
foo()

>>>

>>> from pkg.sub_pkg2 import mod3
<module 'pkg.sub_pkg1' (namespace)>
[mod1] foo()

结论

• 如何创建 Python 模块
• Python 解释器搜索模块的位置
• 如何使用语句获取对模块中定义的对象的访问权限import
• 如何创建可作为独立脚本执行的模块
• 如何将模块组织成包和子包
• 如何控制包初始化