1.前言
学习方法不对，事倍功半！学习方法对了，事半功倍。
学编程，要先扎实的学好基础语法和结构，剩下的就是不断的实战应用，同时按需加强相关知识。
Python的包就是这里说的基础语法结构之一。
把手放在胸口上，问问自己，你对Python包的了解有多少？然后认真看完本文。你的今天一定是有进步的。
包是基于模块的，是对模块的组织，建议和另一篇模块文章一起看，融会贯通起来。模块文章链接见文末往期推荐第1篇。
2.Python包
假设你已经开发了一个包含许多模块的非常大的应用程序。随着模块数量的增长，如果将它们都放到一个位置，则很难跟踪所有模块。如果它们有相似的名称或功能，情况会更糟。你可能希望把他们放在不同的文件夹中，这就是Python中的包。
包(package)允许使用点表示法对模块名称空间进行分层结构。就像模块可以避免全局变量名之间的冲突一样，包也可以避免模块名之间的冲突。
创建包非常简单，因为它利用了操作系统固有的分层文件结构。参考下面的目录结构:
pkg
├── mod1.py
└── mod2.py
这里有一个名为pkg的目录，其中包含两个模块，mod1.py和mod2.py。模块的内容有:
mod1.py
def foo():
print('[mod1] foo()')
class Foo:
pass
mod2.py
def bar():
print('[mod2] bar()')
class Bar:
pass
根据这个结构，如果pkg目录位于一个可以找到它的位置(在sys.path中包含的一个目录中)，你可以用点符号引用这两个模块(pkg.mod1, pkg.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'
要实际导入模块或其内容，需要使用上面展示的import例子。
3.包初始化
如果一个名为__init__.py的文件存在于包目录中，它会在导入包或包中的模块时被调用。这可以用于执行包初始化代码，比如包级数据的初始化。
例如以下__init__.py文件:
__init__.py
print(f'Invoking __init__.py for {__name__}')
A = ['quux', 'corge', 'grault']
让我们把上面例子中的这个文件添加到pkg目录中:
pkg
├── __init__.py
├── mod1.py
└── mod2.py
现在，当包被导入时，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 pkg语句只将名称pkg放在调用者的局部符号表中，而不导入任何模块。但是如果pkg目录中的__init__.py包含以下内容:
__init__.py
print(f'Invoking __init__.py for {__name__}')
import pkg.mod1, pkg.mod2
然后当你执行import pkg，模块mod1和mod2自动导入:
>>> import pkg
Invoking __init__.py for pkg
>>> pkg.mod1.foo()
[mod1] foo()
>>> pkg.mod2.bar()
[mod2] bar()
注意:大部分Python文档都声明在创建包时必须在包目录中存在
__init__.py文件。这曾经是必须的。过去，__init__.py的存在对Python来说意味着正在定义一个包。该文件可以包含初始化代码，甚至可以为空，但它必须存在。从Python 3.3开始，引入了隐式命名空间包。这些允许创建一个没有任何__init__.py文件的包。当然，如果需要包初始化，它仍然可以存在。但现在不再是必须的了。
4.Importing * From a Package
为了以下讨论的目的，先前定义的包被扩展以包含一些额外的模块:
pkg
├── mod1.py
├── mod2.py
├── mod3.py
└── mod4.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
正如你所看到，当import *用于一个模块时，该模块中的所有对象都被导入到本地符号表中，除了那些名称以下划线开头的对象:
>>> 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会深入到包目录中，找到它所能找到的所有模块，并将它们全部导入。但正如你所看到的，默认情况下并不是这样的。
相反，Python遵循以下约定:如果包目录中的__init__.py文件包含名为__all__的列表，当遇到import *语句时，它将被视为应该导入的模块列表。
对于现在的例子，假设你像这样在pkg目录中创建一个__init__.py:
pkg/__init__.py
__all__ = [
'mod1',
'mod2',
'mod3',
'mod4'
]
现在用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
现在，pkg.mod1中的import *语句只会导入包含在__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__中。
总之，当import *被指定时，__all__会被包和模块用来控制导入的内容。但是默认行为是不同的:
对于一个包：当__all__没有定义,import *不导入任何东西。对于一个模块：当__all__没有定义,import *导入所有内容(除了以下划线开头的名称)。
5.子包
包可以包含任意深度的嵌套子包。例如，让我们对示例包目录再做一个修改，如下所示:
pkg
├── sub_pkg1
│ ├── mod1.py
│ └── mod2.py
└── sub_pkg2
├── mod3.py
└── mod4.py
四个模块(mod1.py, mod2.py, mod3.py和mod4.py)的定义如前所述。但是现在，它们不是被集中到pkg目录中，而是被分成两个子目录，sub_pkg1和sub_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()
此外，一个子包中的模块可以引用同级子包中的对象(如果同级子包包含你需要的某些功能)。例如，假设你想从mod3模块中导入并执行mod1中的函数foo()。你可以使用绝对导入:
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.py中引用的话也就是sub_pkg2这一层。
..结果为父包(pkg),../sub_pkg1结果为子包sub_pkg1。
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 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、自动化办公等学习教程。带你从零基础系统性的学好Python！
👉Python所有方向的学习路线👈
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取）
👉Python学习视频600合集👈
观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
温馨提示：篇幅有限，已打包文件夹，获取方式在：文末
👉Python70个实战练手案例&源码👈
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
👉Python大厂面试资料👈
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
👉Python副业兼职路线&方法👈
学好 Python 不论是就业还是做副业赚钱都不错，但要学会兼职接单还是要有一个学习规划。
👉 这份完整版的Python全套学习资料已经上传，朋友们如果需要可以扫描下方CSDN官方认证二维码或者点击链接免费领取【保证100%免费】
500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
