python 模块与包

一、模块

　　1.1 什么是模块

# 什么是模块
#    一组功能的集合，就是模块，在python中一个py文件就一个模块

　　1.2 为什么要使用模块

# 1、可使代码的结构功能分区更清晰
# 2、可重复使用模块的功能，减少代码冗余
# 3、可以像内置模块一样，重复使用，提高开发的效率

　　1. 3 如何使用

#在同目录中有三个文件
#     simple_mod.py
#     test1.py
#     test2.py

# test1.py  和 test2.py 分别以两种方式导入 simple_mod.py 

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

str1 = 'jmz'
str2 = 'block dog'
l = [1,'xx','yy','ufo',('shanghai','hefei')]

def get(index):
    '''
    获取第几个元素
    :param index:
    :return:
    '''
    global l
    if index < len(l):
        return l[int(index)-1]

def add(data):
    global l
    l.append(data)

def find():
    print('''simple_mod:
    str1:%s
    str2:%s'''%(str1,str2))

simple_mod.py  

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

import simple_mod
# 导入simple_mod 模块，就是相当于 引入了 simple_mod 代码
# 用法，在使用simple_mod 的变量或函数时名，需要在变量名或函数名加上 导入的模块名（例如本次的导入的模块名simple_mod）

simple_mod.str1 = 'test1'    #重新赋值 simple_mod 中 str1 变量

print(simple_mod.str2)
# block dog

simple_mod.find()            # 调用simple_mod 中的find函数
# simple_mod:
#     str1:test1
#     str2:block dog

test1.py

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

from simple_mod import *
# 导入 simple_mod 中的所有的代码
# 在当前模块空间 创建simple_mod 的变量名函数名（+引入地址）


print(str1)
# jmz

str1 = 'aaa'     # 当前模块 创建了一个变量名，以及内存地址
str2 = 'bbb'

find()        # 当前模块没有 定义函数 则调用simple_mod的函数，函数内的变量（或函数）皆使用simple_mod模块的变量（或函数）
# simple_mod:
#     str1:jmz
#     str2:block dog

test2.py

　　1.4 图解模块

　　import simple_mod

　　from simple_mod import *

二、模块的导入

　　2.1 绝对路径导入

　　　　2.1.1 下级目录模块导入

# 在同级目录下有这些文件和文件夹
# ├──dir 
# │     ├──m_mod.py
# │     └──dir_dir
# │             └──dir_mod.py
# ├──m1.py　　　　# 执行文件1
# ├──m2.py　　　　# 执行文件2
# └──m3.py　　　　# 执行文件3


# m1.py 导入dir/m_mod.py  方式一
# m2.py 导入dir/m_mod.py  方式二
# m3.py 导入dir/dir_dir/m_mod.py

test = 'jmz'
def fun():
    print('dir_dir/dir_mod.py')

dir/dir_dir/dir_mod.py

addr = '上海'
def get_addr():
    print(addr)

dir/m_mod.py

from dir import m_mod
# 已当前执行文件为基础，进入dir 文件夹 导入m_mod 模块
# 步骤：
# 1、创建模块名称空间m_mod
# 2、执行m_mod 代码

m_mod.get_addr()    #上海

m1.py

from dir.m_mod import get_addr
# 进入dir文件夹下的导入m_mod 模块的get_addr 方法，
# 步骤：
# 1、创建m_mod 模块空间
# 2、将m_mod 模块空间内的get_addr 方法名和引入地址，添加到当前的模块空间的名称空间中

get_addr()

m2.py

from dir.dir_dir import dir_mod
# 进入 dir 文件夹下的dir_dir 文件夹目录下，导入dir_mod 模块

dir_mod.fun()

m3.py

# 总结：

# 根据上面的m1.py,m2.py,m3.py ,我们可以通过from 进入当前执行文件所在目录的下一级目录，导入模块
# from dir import m_mod

# 导入下下一级模块, 需要通过from 当前目录文件夹.下级目录文件夹 导入模块
# from dir/dir_dir import dir_mod

　　2.1.2 上级目录模块导入

# 疑问？？？？
# 我们经常可以看到一些python 文件中 写着如下的代码
# import os
# import sys
# import time
# ......

# 按照上面导入模块的思路，很明显当前的目录是没有这些模块的，哪这些模块哪里来的？？？？

# 导入顺序：
# 模块在导入时会根据sys.path的列表中罗列出的 顺序从左往右依次查找
import sys
print(sys.path)
# 你会发现第一个目录是你的当前文件执行的目录
# 也就是说它会先从当前执行文件的目录开始找模块然后依次往后，
# 这也就是为什么我们有时写一个内置模块一样的名字时，调用时没有找到该方法的原因

# 上面我们已经知道了导入顺序，以及导入方法
# 那我们现在只需要将 我们想导入的模块的那一级模块加入到sys.path中去不就可以了吗

# 在dir/dir_dir 中新建一个new_mod.py 文件，导入m1.py

import os,sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
# __file__   当前文件的相对路径
# os.path.abspath()   获取相对文件路径的绝对路径
# os.path.dirname()   获取文件或文件夹的当前所在目录

import m1

如何导入上级或者更上级的目录呢？

　　2.2 相对路径导入

# 运用场景：
# 　　1、只能在被导入时才可以使用相对模块导入
# 　　2、一般会在包中使用的多

from . import test as test1             # 导入当前目录下的test模块 并起模块名为 test1

from .. import test as test2            # 导入上一级目录的test模块 并起模块名 为test2

from ... import test as test3           # 导入上上一级目录的test模块 并起模块名 为test3


# ....   依次类推 上上上一级模块  

三、包的使用

　　3.1 什么是包？

# 包是一个有层次的文件目录结构，它定义了由n个模块或n个子包组成的python应用程序执行环境。
# 通俗一点：包是一个包含__init__.py 文件的目录，该目录下一定得有这个__init__.py文件和其它模块或子包。

　　3.2 如何使用

# 举例包的场景：
# aaa              # aaa包
# └──__init__.py　 # 包文件
# test.py 


# 在 test.py 文件中 

import aaa 
# 首次导入aaa 包的过程 
# 1、以包下__init__.py为准产生一个名称空间
# 2、执行__init__.py 的代码,将产生的名字放入名称空间
# 3、将aaa指向__init_py的名称空间

print('aaa.__init__')

aaa/__init__.py

import aaa
# aaa.__init__

test.py

　　复杂情况下的使用

# aaa                   # aaa包
# ├──bbb            　　 # aaa 下的子包bbb 
# │     ├──__init__.py
# │     └──m_mod.py     # 子包下的模块
# ├──__init__.py　 # 包文件
# ├──m1.py　　　　# 模块1 
# └──m2.py　　　　# 模块2    
# aaa_mod1.py.       执行入口文件

print('aaa.__init__')

aaa/__init__.py

from . import m_mod

print('bbb.__init__')

aaa/bbb/__init__.py

from .. import m1

def fun_m_mod():
    print('m_mod')

m1.func_m1()
# 在执行代码时调用了

aaa/bbb/m_mod.py

from . import m2

def func_m1():
    print('m1')

aaa/m1.py

def m2():
    print('m2')

aaa/m2.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

from aaa import bbb
# 执行顺序
#   1、先执行包文件aaa/__init__.py
#   2、后执行包文件aaa/bbb/__init__.py

print('aaa_mod1')
bbb.m_mod.fun_m_mod()





# 最后结果
#     aaa.__init__       # 先执行了aaa.__init__py
#     m1                # 在执行bbb/__init__.py 时，先导入了m_mod ,在执行m_mod.py时，
                        # 分别有导入了m1,m2 ,导入完成后执行后续代码，在执行到m1.func_m1()，调用了m1的func_m1方法
#     bbb.__init__      # 导入完后执行了print('bbb.__init__')
#     aaa_mod1          
#     m_mod

aaa_mod1.py 入口执行文件

四、开发规范

# 软件名称                  
# ├──bin            　 # 程序入口文件 
# ├──config　         # 配置信息存放目录
# ├──core　           # 核心包 模块
# ├──db　             # 数据库包
# ├──lib　             # 第三方组件
# ├──log　             # 日志记录目录
# └──REAMDE.md　　　　　# 说明文件 
 

# 更好的管理自己的项目使代码结构更清晰