模块和包

模块

什么是模块

常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

但其实import加载的模块分为四个通用类别：　

1 使用python编写的代码（.py文件）

2 已被编译为共享库或DLL的C或C++扩展

3 包好一组模块的包

4 使用C编写并链接到python解释器的内置模块

 

模块的使用

先定义一个模块

#my_module.py
print('from the my_module.py')

money=1000

def read1():
    print('my_module->read1->money',money)

def read2():
    print('my_module->read2 calling read1')
    read1()

def change():
    global money
    money=0

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

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

'''
执行结果：
from the my_module.py
'''

模块调用时做的事：

1.看看自己的内存里有没有
有就不干活，没有再导进来
2.创建一个命名空间，在这个命名空间中执行代码
3.创建了一个module1这个名字，给命名空间中的变量和module1绑定在一起

依赖倒置原则:底层的内容不应该依赖下一层的代码

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

# 执行my_module.change()操作的全局变量money仍然是my_module中的
#demo.py
import my_module
money=1
my_module.change()
print(money)

'''
执行结果：
from the my_module.py
1
'''

 

import .. as .. 给模块起别名

一般使用的情况：

import的名字太长
当import的模块和我文件中的变量重名的时候
当兼容多个模块的相同操作的时候

# if 是mysql数据库:
#     import myslq as db
# elif 是oracle数据可k
#     import oracle as db
# db.open
# db.write

 

在一行导入多个模块

import sys,os,re

 

导入模块的顺序

先导入内置的模块
再导入扩展模块:requests beautifulsoup django selenium paramiko
最后导入自定义的模块

import os
import re
import requests
import module1  # 自定义的模块

 

from .. import ..

对比import my_module，会将源文件的名称空间'my_module'带到当前名称空间中，使用时必须是my_module.名字的方式

而from 语句相当于import，也会创建新的名称空间，但是将my_module中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以

from my_module import read1,read2

这样在当前位置直接使用read1和read2就好了，执行时，仍然以my_module.py文件全局名称空间

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

#测试二:导入的函数read2，执行时需要调用read1(),仍然回到my_module.py中找read1()
from my_module import read2
def read1():
    print('==========')
read2()

'''
执行结果:
from the my_module.py
my_module->read2 calling read1
my_module->read1->money 1000
'''

如果当前有重名read1或者read2，那么会有覆盖效果

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

 

from .. import *

from my_module import * 把my_module中所有的不是以下划线(_)开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字

在my_module.py中新增一行

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

当要使用这个模块中的多个方法的时候，使用import 模块名
当只使用模块中的一个或两个的时候，使用from 模块名 import 函数名

 

考虑到性能的原因，每个模块只被导入一次,放入字典sys.modules中，如果你改变了模块的内容，你必须重启程序，python不支持重新加载或卸载之前导入的模块，

有的同学可能会想到直接从sys.modules中删除一个模块不就可以卸载了吗，注意了，你删了sys.modules中的模块对象仍然可能被其他程序的组件所引用，因而不会被清除。

特别的对于我们引用了这个模块中的一个类，用这个类产生了很多对象，因而这些对象都有关于这个模块的引用。

 

sys.path

执行python解释器，已经在内存中加载了一些内置的模块
导入模块的时候，如果模块不存在在sys.modules，才从sys.path给的路径中依次去查找
sys.path完全可以决定某个模块能不能被找到(除了已经在内存中加载的一些内置的模块)

 

把模块当脚本执行

我们可以通过模块的全局变量__name__来查看模块名：
当做脚本运行：
__name__ 等于'__main__'

当做模块导入：
__name__= 模块名

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
if __name__ == '__main__':

# __all__ = ['drive','price']

print('小司机')

def drive():
    print('快上车')
    print(price)

price = 100

if __name__ == '__main__':
    drive()

 

pyc文件

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

 

包

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

１. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法

2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）

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

强调：

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

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

 

软件开发规范

bin 程序的入口
core 主函数
log 日志
conf 配置文件
lib 已经封装成模块的py文件或者包
db 数据库