Python之路--Python基础5--模块与包

时间 2019-11-10

原文原文链接

1、模块是啥

模块，用一砣代码实现了某个功能的代码集合。 python

相似于函数式编程和面向过程编程，函数式编程则完成一个功能，其余代码用来调用便可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来说，可能须要多个函数才能完成（函数又能够在不一样的.py文件中），n个 .py 文件组成的代码集合就称为模块。mysql

如：os 是系统相关的模块；file是文件操做相关的模块sql

模块分为三种：shell

自定义模块
内置模块
开源模块

以spam.py为例来介绍模块的使用：文件名spam.py,模块名spam（下面会用到）编程

#spam.py
print('from the spam.py') money=1000

def read1(): print('spam模块：',money) def read2(): print('spam模块') read1() def change(): global money money=0

2、使用模块之import

一、import的使用

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

#test.py
import spam 
#只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',固然其余的顶级代码也都被执行了,只不过没有显示效果.

import spam import spam import spam ''' 执行结果： from the spam.py '''

ps：咱们能够从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否须要从新导入。oracle

二、在第一次导入模块时会作三件事，重复导入会直接引用内存中已经加载好的结果函数式编程

A.为源文件(spam模块)建立新的名称空间，在spam中定义的函数和方法如果使用到了global时访问的就是这个名称空间。函数

B.在新建立的命名空间中执行模块中包含的代码，见初始导入import spam性能

　　提示:导入模块时到底执行了什么？

　　In fact function definitions are also ‘statements’ that are ‘executed’;the execution of a module-level function definition enters the function name in the module’s global symbol table.

　　事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放入模块全局名称空间表，用globals()能够查看

C.建立名字spam来引用该命名空间

　　这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式能够访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自两个彻底不一样的地方。

三、被导入模块有独立的名称空间

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

#test.py

import spam money=10
print(spam.money) ''' 执行结果： from the spam.py
1000 ''' 测试一:money与spam.money不冲突

#test.py
import spam def read1(): print('========') spam.read1() ''' 执行结果: from the spam.py spam模块：1000 ''' 测试二：read1与spam.read1不冲突

#test.py
import spam money=1
 spam.change() print(money) ''' 执行结果： from the spam.py
1 ''' 测试三：执行spam.change()操做的全局变量money仍然是spam中的

四、为模块名起别名

为已经导入的模块起别名的方式对编写可扩展的代码颇有用

import spam as sm print(sm.money)  #输出 1000

举个栗子：有两中sql模块mysql和oracle，根据用户的输入，选择不一样的sql功能

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

再举个栗子：

　　假设有两个模块xmlreader.py和csvreader.py，它们都定义了函数read_data(filename):用来从文件中读取一些数据，但采用不一样的输入格式。能够编写代码来选择性地挑选读取模块

if file_format == 'xml': import xmlreader as reader elif file_format == 'csv': import csvreader as reader data=reader.read_date(filename)

五、在一行导入多个模块

1  import sys,os,re

3、使用模块之from...import...

一、from...import...的使用

from spam import read1,read2

二、from...import 与import的对比

惟一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，因此在当前名称空间中，直接使用名字就能够了、无需加前缀：spam.

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

　　好处：使用起来方便了

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

验证一：当前位置直接使用read1和read2就行了，执行时，仍然以spam.py文件全局名称空间

#测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money #test.py
from spam import read1 money = 10 read1() ''' 执行结果: from the spam.py spam->read1->money 1000 '''


#测试二:导入的函数read2，执行时须要调用read1(),仍然回到spam.py中找read1() #test.py
from spam import read2 def read1(): print('==========') read2() ''' 执行结果: from the spam.py spam->read2 calling read spam->read1->money 1000 '''

验证二：若是当前有重名read1或者read2，那么会有覆盖效果。

#测试三:导入的函数read1，被当前位置定义的read1覆盖掉了 #test.py
from spam import read1 def read1(): print('==========') read1() ''' 执行结果: ========== '''

验证三：导入的方法在执行时，始终是以源文件为准的

from spam import money,read1 money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取spam.py中的名字money,仍然为1000

''' from the spam.py 100 spam->read1->money 1000 '''

三、也支持as

from spam import read1 as read

四、一行导入多个名字

from spam import read1,read2,money

五、from...import *

from spam import * #把spam中全部的不是如下划线(_)开头的名字都导入到当前位置

大部分状况下咱们的python程序不该该使用这种导入方式，由于*你不知道你导入什么名字，颇有可能会覆盖掉你以前已经定义的名字。并且可读性极其的差，在交互式环境中导入时没有问题。

from spam import * #将模块spam中全部的名字都导入到当前名称空间
print(money) print(read1) print(read2) print(change) ''' 执行结果: from the spam.py <function read1 at 0x1012e8158> <function read2 at 0x1012e81e0> <function change at 0x1012e8268> '''

可使用__all__来控制*（用来发布新版本），在spam.py中新增一行

__all__=['money','read1'] #这样在另一个文件中用from spam import *就这能导入列表中规定的两个名字

4、模块的重载（了解）

　　考虑到性能的缘由，每一个模块只被导入一次,放入字典sys.module中，若是你改变了模块的内容，你必须重启程序，python不支持从新加载或卸载以前导入的模块，

　　有的人类可能会想到直接从sys.module中删除一个模块不就能够卸载了吗，注意了，你删了sys.module中的模块对象仍然可能被其余程序的组件所引用，于是不会被清除。

　　特别的对于咱们引用了这个模块中的一个类，用这个类产生了不少对象，于是这些对象都有关于这个模块的引用。

5、py文件区分两种用途：模块与脚本

#编写好的一个python文件能够有两种用途：
 一：脚本，一个文件就是整个程序，用来被执行 二：模块，文件中存放着一堆功能，用来被导入使用 #python为咱们内置了全局变量__name__，
    当文件被当作脚本执行时：__name__  ==  '__main__' 当文件被当作模块导入时：__name__  == 模块名 #做用：用来控制.py文件在不一样的应用场景下执行不一样的逻辑
    if __name__ == '__main__':

6、模块搜索路径

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

模块的查找顺序

一、在第一次导入某个模块时（好比spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），若是有则直接引用

ps：python解释器在启动时会自动加载一些模块到内存中，可使用sys.modules查看

二、若是没有，解释器则会查找同名的内建模块

三、若是尚未找到就从sys.path给出的目录列表中依次寻找spam.py文件。

须要特别注意的是：咱们自定义的模块名不该该与系统内置模块重名。虽然每次都说，可是仍然会有人不停的犯错。

sys.path从如下位置初始化

　　1 执行文件所在的当前目录

　　2 PTYHONPATH（包含一系列目录名，与shell变量PATH语法同样）

　　3 依赖安装时默认指定的

注意：在支持软链接的文件系统中，执行脚本所在的目录是在软链接以后被计算的，换句话说，包含软链接的目录不会被添加到模块的搜索路径中

7、包介绍

一、什么是包

#官网解释
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. 建立包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

二、为什么要使用包

　　包的本质就是一个文件夹，那么文件夹惟一的功能就是将文件组织起来。随着功能越写越多，咱们没法将因此功能都放到一个文件中，因而咱们使用模块去组织功能，而随着模块愈来愈多，咱们就须要用文件夹将模块文件组织起来，以此来提升程序的结构性和可维护性

三、注意事项

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

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

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

四、包的使用

示范文件：

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

#文件内容

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

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

包的使用之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 在glance包下的init文件中添加
from . import cmd #glance/cmd/__init__.py 在glance包下的cmd包下的init文件中添加
from . import manage

执行：

#在于glance同级的test.py中
import glance glance.cmd.manage.main()

包的使用之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')

from glance.api import *

在讲模块时，咱们已经讨论过了从一个模块内导入全部*，此处咱们研究从一个包导入全部*。

此处是想从包api中导入全部，实际上该语句只会导入包api下__init__.py文件中定义的名字，咱们能够在这个文件中定义__all___:

#在__init__.py中定义
x=10

def func(): print('from api.__init.py') __all__=['x','func','policy']

此时咱们在于glance同级的文件中执行from glance.api import *就导入__all__列表中的内容

#与包同级的执行文件中的使用效果以下
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']

五、绝对导入和相对导入

咱们的最顶级包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同级的文件中测试

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

好比咱们想在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, 这必然是找不到的 '''

解决办法：使用相对导入和绝对导入都行