python包和模块的使用简书_Python模块和包

一、简介

1. 什么是模块？

模块就是文件，存放一堆常用的函数。一个函数封装一个功能，比如现在有一个软件，不可能将所有程序都写入一个文件，要拆分文件，组织结构要好，代码不冗余，所以要分文件，但是分文件，分了5个文件，每个文件里面可能都有相同的功能(函数)，怎么办？所以将这些相同的功能封装到一个文件中，谁用谁拿。文件名就是模块名字加上.py的后缀。

2. 为何要使用模块？

(1) 从文件级别组织程序，更方便管理

随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

(2) 拿来主义，提升开发效率

同样的原理，我们也可以下载别人写好的模块然后导入到自己的项目中使用，这种拿来主义，可以极大地提升我们的开发效率，避免重复造轮子。

3. 模块的分类

Python语言中，模块分为三类。

第一类：内置模块，也叫做标准库。**此类模块就是python解释器给你提供的**，比如我们之前见过的time模块,os模块。**标准库**的模块非常多(200多个，每个模块又有很多功能)，我们这几天就讲常用的十几种，后面课程中还会陆续的讲到。

第二类：第三方模块，第三方库。一些python大神写的非常好用的模块，**必须通过pip install 指令安装的模块**，比如BeautfulSoup, Django,等等。大概有6000多个。

第三类：自定义模块。我们自己在项目中定义的一些模块。

本节讲的都是自定义模块, 自定义的模块名不应该与系统内置模块重名

二、import

import 翻译过来是一个导入的意思

1. import的使用

模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行(import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句)

我们可以从sys.modules中找到当前已经加载的模块，sys.modules是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

导入一个模块,相当于这个模块从上到下依次被执行了

例如，有一个working.py模块，文件内容如下：

print("你正在导入working模块")

test.py内容，就一句话。文件内容如下：

import working

执行test.py后，输出结果：你正在导入working模块

2. 第一次导入模块执行三件事

1.创建一个以模块名命名的名称空间。

2.执行这个名称空间(即导入的模块)里面的代码。

3.通过此模块名. 的方式引用该模块里面的内容(变量，函数名，类名等)。 这个名字和变量名没什么区别，都是‘第一类的’，且使用module.名字的方式可以访问module.py文件中定义的名字，module.名字与test.py中的名字来自两个完全不同的地方。

例如，working.py模块内容如下：

print("你正在导入working模块")

def func1():

print('in func')

def func2():

print('in func2')

test.py内容如下：

import working

working.func1()

working.func2()

执行test.py后，输出结果：

你正在导入working模块

in func

in func2

test.py也可以这么写

from working import *

func1()

func2()

3. 被导入模块有独立的名称空间

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就**不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突。**

示例：

test.py里面也创建一个func1

import working

def func1():

print("我是test的func1")

func1() # 执行当前模块中的func1函数

working.func1() # 执行working模块中的func1函数

working.func2()

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

4.为模块起别名

相当于内存名改名了，原来的名字就不能用了

为模块起别名的作用：

1)可以将过长的模块命名改成短的，便于操作。

import working as wk

wk.func1() 　　# 执行working模块中的func1函数

2)有利于代码的拓展，优化。

#mysql.py

def sqlparse():

print('from mysql sqlparse')

#oracle.py

def sqlparse():

print('from oracle sqlparse')

#test.py

db_type=input('>>: ')

if db_type == 'mysql':

import mysql as db

elif db_type == 'oracle':

import oracle as db

db.sqlparse()

inp = input('json or pickle>>> ').strip()

if inp == 'json':

import json as m

elif inp == 'pickle':

import pickle as m

else:

print('未定义!')

a = m.dumps({'k':'v'})

print(a)

5. 导入多个模块

# 可以这样写，但是不推荐

import sys,os,json

#推荐应该这样：

import sys

import os

import json

三、from ... import ...

1. from...import...使用

from working import func1

func1()

2. from...import... 与import对比

唯一的区别就是：使用from...import...则是将名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：module.

from...import...的方式有好处也有坏处

好处：使用起来方便了

坏处：容易与当前执行文件中的名字冲突

情形1：

# working 模块如下：

name = "working"

def func1():

print('working模块的func1')

# test.py文件如下：

name = "test"

def func1():

print("我是test的func1")

from working import func1,name

print(name)

func1()

'''

结果输出：

working

working模块的func1

'''

情形2：

# working 模块内容不变，test.py文件如下：

from working import func1,name

name = "test"

def func1():

print("我是test的func1")

print(name)

func1()

'''

结果输出：

test

我是test的func1

'''

3. 支持as

from working import func1 as f1

f1()

4. 一行导入多个

from working import func1,func2,name

5. from ... import

from working import *

# 把working中所有的不是以下划线(_)开头的名字都导入到当前位置.大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

可以使用all来控制(用来发布新版本)，在working.py中新增一行

name = "working"

def func1():

print('working模块的func1')

def func2():

print('working模块的func2')

__all__=['name','func1']

# 这样在另外一个文件中用from working import * 就只能导入列表中规定的两个名字，而func2不会被导入，不可以直接使用

6. 模块循环导入问题

模块循环/嵌套导入抛出异常的根本原因是由于在python中模块被导入一次之后，就不会重新导入，只会在第一次导入时执行模块内代码

在我们的项目中应该尽量避免出现循环/嵌套导入，如果出现多个模块都需要共享的数据，可以将共享的数据集中存放到某一个地方

在程序出现了循环/嵌套导入后的异常分析、解决方法如下(了解，以后尽量避免)

四、py文件的两种功能

编写好的一个python文件可以有两种用途：

脚本，一个文件就是整个程序，用来被执行

模块，文件中存放着一堆功能，用来被导入使用

python为我们内置了全局变量name，

当文件被当做脚本执行时：name 等于'main'

当文件被当做模块导入时：name等于模块名

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑(或者是在模块文件中测试代码)

working中代码

name = "working"

def func1():

print('working模块的func1')

def func2():

print('working模块的func2')

__all__=['name','func1']

if __name__ == '__main__':

# 此模块被导入时 __name__ == tbjx 所以不执行

func1()

test.py中代码

from working import *

结果输出：working模块的func1

五、模块的搜索路径

模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块

比如：working模块

1、在第一次导入时，会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存)，如果有则直接引用(python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看)

2、如果没有，解释器则会查找同名的内建模块

3、如果还没有找到就从sys.path给出的目录列表中依次寻找working.py文件。

#在初始化后，python程序可以修改sys.path,路径放到前面的优先于标准库被加载。

1 >>> import sys

2 >>> sys.path.append('/a/b/c/d')

3 >>> sys.path.insert(0,'/x/y/z') #排在前的目录，优先被搜索

注意：搜索时按照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\a')

#至于.egg文件是由setuptools创建的包，这是按照第三方python库和扩展时使用的一种常见格式，.egg文件实际上只是添加了额外元数据(如版本号，依赖项等)的.zip文件。

#需要强调的一点是：只能从.zip文件中导入.py，.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载(此时setuptools等打包系统有时能提供一种规避方法)，且从.zip中加载文件不会创建.pyc或者.pyo文件，因此一定要事先创建他们，来避免加载模块是性能下降。

六、编译Python文件(了解)

为了提高加载模块的速度，强调强调强调：提高的是加载速度而绝非运行速度。python解释器会在pycache目录中下缓存每个模块编译后的版本，格式为：module.version.pyc。通常会包含python的版本号。例如，在CPython3.3版本下，working.py模块会被缓存成pycache/working.cpython-33.pyc。这种命名规范保证了编译后的结果多版本共存。

Python检查源文件的修改时间与编译的版本进行对比，如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的，所以相同的库可以在不同的架构的系统之间共享，即pyc使一种跨平台的字节码，类似于JAVA火.NET,是由python虚拟机来执行的，但是pyc的内容跟python的版本相关，不同的版本编译后的pyc文件不同，2.5编译的pyc文件不能到3.5上执行，并且pyc文件是可以反编译的，因而它的出现仅仅是用来提升模块的加载速度的，不是用来加密的。

七、模块的重载(了解)

考虑到性能的原因，每个模块只被导入一次,放入字典sys.module中，如果你改变了模块的内容，你必须重启程序，python不支持重新加载或卸载之前导入的模块，直接从sys.module中删除一个模块不可以卸载，删了sys.module中的模块对象仍然可能被其他程序的组件所引用，因而不会被清楚。特别的对于我们引用了这个模块中的一个类，用这个类产生了很多对象，因而这些对象都有关于这个模块的引用。

如果只是你想交互测试的一个模块，使用 importlib.reload()，这只能用于测试环境。

import importlib;

importlib.reload(modulename)

working.py初识内容

def func1():

print('func1')

test.py内容

import working

import time,importlib

time.sleep(20)

# importlib.reload(working)

working.func1()

在20秒的等待时间里，修改working.py中func1的内容

def func1():

print('修改了')

test.py的结果为：func1

打开importlib注释，重新测试，test.py的结果为：修改了

八、包

1. 什么是包？

#官网解释

Packages are a way of structuring Python’s module namespace by using “dotted module names”

包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

具体的：包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

#需要强调的是：

1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错

2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

2. 为何要使用包

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来 随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

3. 注意事项

关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。

import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的init.py，导包本质就是在导入init.py文件

包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

导入一个包，相当于执行了这个包下面的init.py文件

4. 包的使用

1)示例文件

自动创建目录结构

import os

os.makedirs('glance/api')

os.makedirs('glance/cmd')

os.makedirs('glance/db')

l = []

l.append(open('glance/__init__.py','w'))

l.append(open('glance/api/__init__.py','w'))

l.append(open('glance/api/policy.py','w'))

l.append(open('glance/api/versions.py','w'))

l.append(open('glance/cmd/__init__.py','w'))

l.append(open('glance/cmd/manage.py','w'))

l.append(open('glance/db/models.py','w'))

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

2) 文件内容

#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)

执行文件与示范文件在同级目录下

3) 包的使用之import

import glance.db.models

glance.db.models.register_models('mysql')

单独导入包名称时不会导入包中所有包含的所有子模块，如

#在与glance同级的test.py中

import glance

glance.cmd.manage.main()

'''

执行结果：

AttributeError: module 'glance' has no attribute 'cmd'

'''

解决方法：

#glance/__init__.py

from . import cmd

#glance/cmd/__init__.py

from . import manage

重新执行glance同级的test.py中

4) 包的使用之from ... import ...

需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法

from glance.db import models

models.register_models('mysql')

from glance.db.models import register_models

register_models('mysql')

5) from glance.api import

在讲模块时，从一个模块内导入所有，此处我们研究从一个包导入所有。

此处是想从包api中导入所有，实际上该语句只会导入包api下init.py文件中定义的名字，我们可以在这个文件中定义all_:

*在init.py文件中，定义一个all变量，它控制着 from 包名 import 时导入的模块

#在__init__.py中定义

x=10

def func():

print('from api.__init.py')

__all__=['x','func','policy']

此时我们在于glance同级的文件中执行from glance.api import *就导入all中的内容(versions仍然不能导入)。

练习：

#执行文件中的使用效果如下，请处理好包的导入

from glance import *

get()

create_resource('a.conf')

main()

register_models('mysql')

#在glance.__init__.py中

from .api.policy import get

from .api.versions import create_resource

from .cmd.manage import main

from .db.models import register_models

__all__=['get','create_resource','main','register_models']

6)绝对导入和相对导入

我们的最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

绝对导入：以glance作为起始

相对导入：用.或者..的方式最为起始(只能在一个包中使用，不能用于不同目录内)

例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py

在glance/api/version.py

#绝对导入

from glance.cmd import manage

manage.main()

#相对导入

from ..cmd import manage

manage.main()

测试结果：注意一定要在于glance同级的文件中测试

from glance.api import versions

7) 包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的

比如我们想在glance/api/versions.py中导入glance/api/policy.py，这俩模块是在同一个目录下，有人直接这么做

#在version.py中

import policy

policy.get()

没错，我们单独运行version.py是一点问题没有的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到，但是子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入，比如我们在于glance同级下的一个test.py文件中导入version.py，如下

from glance.api import versions

'''

执行结果:

ImportError: No module named 'policy'

'''

'''

分析:

此时我们导入versions在versions.py中执行

import policy需要找从sys.path也就是从当前目录找policy.py,

这必然是找不到的

'''

8) 绝对导入与相对导入总结

绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入

优点: 执行文件与被导入的模块中都可以使用

缺点: 所有导入都是以sys.path为起始点,导入麻烦

相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入

符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹

优点: 导入更加简单

缺点: 只能在导入包中的模块时才能使用

注意:

1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内

2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包

1. import 一个模块相当于执行这个py文件

2.模块不会被重复导入

3.导入的模块存到sys.modules里

4.导入模块的之后发生了什么：

先看看模块在不在sys.modules里，如果不在：生成一个属于模块的命名空间，执行py文件

创建一个与py文件同名的变量来引用这个空间中的名字

把导入的这个模块放到sys.modules里

5.from ... import ...

6.绝对导入和相对导入