热线电话:13121318867

登录
首页大数据时代搞懂Python包之后,感觉学Python轻松多了
搞懂Python包之后,感觉学Python轻松多了
2021-02-07
收藏

来源:麦叔编程

作者:麦叔

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
0x033F7290>
from  import 
>>> from pkg.mod1 import foo >>> foo()
[mod1] foo()
from  import  as 
>>> from pkg.mod2 import Bar as Qux >>> x = Qux() >>> x
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 "", line 1in <module>     pkg.mod1 AttributeError: module 'pkg
has no attribute 'mod1' >>> pkg.mod1.foo()
Traceback (most recent call last):
  File "", line 1in <module>     pkg.mod1.foo() AttributeError: module '
pkghas no attribute 'mod1' >>> pkg.mod2.Bar()
Traceback (most recent call last):
  File "", line 1in <module>     pkg.mod2.Bar() AttributeError: module '
pkghas 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  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 "", line 1in <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()

数据分析咨询请扫描二维码

最新资讯
更多
客服在线
立即咨询