包与模块

Posted 2020-10-20 冷风中行走~

1.1 模块

1.1.1 模块介绍

常见的场景：一个模块就是一个包含了一组功能的python文件,比如spam.py，模块名为spam，可以通过import spam使用。

在python中，模块的使用方式都是一样的，但其实细说的话，模块可以分为四个通用类别：　

1 使用python编写的.py文件

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

3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）

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

 

1.1.2 为何要使用模块

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

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

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

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

#ps：

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

以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

 

模块使用.py

import spam

 

money=1

print(spam.money)

 

print(spam.read1)

print(spam.read2)

print(spam.change)

 

 

测试一

money=1

print(spam.money)

 

测试二（绝对导入）：

def read1():

    print(\'from current\')

# spam.read1()

spam.read2()

 

测试三：

money=1

spam.change()

print(money)

spam.read1()

 

 

1.2 使用模块之import

1.2.1 import的使用

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

#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是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

 

1.2.2 在第一次导入模块时会做三件事，重复导入会直接引用内存中已经加载好的结果

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

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

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

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

3.创建名字spam来引用该命名空间

    这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式

    可以访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自

    两个完全不同的地方。

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

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

测试一:money与spam.money不冲突

#test.py

import spam

money=10

print(spam.money)

 

\'\'\'

执行结果：

from the spam.py

1000

\'\'\'

 

测试二：read1与spam.read1不冲突

#test.py

import spam

def read1():

    print(\'========\')

spam.read1()

 

\'\'\'

执行结果:

from the spam.py

spam->read1->money 1000

\'\'\'

测试三：执行spam.change()操作的全局变量money仍然是spam中的

#test.py

import spam

money=1

spam.change()

print(money)

 

\'\'\'

执行结果：

from the spam.py

1

\'\'\'

 

 

 

1.2.4 为模块名起别名

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

import spam as sm

print(sm.money)

 

engine=input(\'>>: \')

if engine == \'mysql\':

    import mysql as sql

elif engine == \'oracle\':

    import oracle as sql

 

sql.parse()

 

有两中sql模块mysql和oracle，根据用户的输入，选择不同的sql功能

假设有两个模块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.2.5 在一行导入多个模块

import sys,os,re

 

1.2.6 使用模块之from ... import...

1.2.6.1  from ... import... .的使用

from spam import money,read1,read2,change

 

money=1

print(money)

 

read1=\'read1\'

print(read1)

 

money=1

read1()

 

def read1():

    print(\'from current func\')

 

read2()

 

money=1

change()

print(money)

 

 

1.2.7 from...import 与import的对比

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

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

    好处：使用起来方便了

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

 

read1=1

print(money,read1,read2,change)

 

print(_money)

print(read1,read2,change)

 

from spam import _money

print(_money)

 

import spam

spam.read1()

 

import sys

print(sys.path)

 

sys.path.append(r\'D:\\video\\python20期\\day5\\01_模块\\aaa\')

import spam

print(spam.money)

 

 

import spam,time

time.sleep(10)

import spam

print(spam.money)

 

import sys,spam

print(\'spam\' in  sys.modules)

print(\'time\' in sys.modules)

 

import time

print(time)

time.sleep(3)

 

 

 

1.2.8 from spam import *

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

#大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

 

1.3 py文件区分两种用途:模块与脚本

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

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

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

 

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

    当文件被当做脚本执行时：__name__ 等于\'__main__\'

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

 

#作用：用来控制.py文件在不同的应用场景下执行不同的逻辑

    if __name__ == \'__main__\':

 

1.4 模块搜索路径

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

模块的查找顺序

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

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

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

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

 

1.5 包

1.5.1 什么是包

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

需要强调的是：

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

 

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

1.5.2 为何要使用包

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来

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

注意事项：

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

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

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

1.5.3 包的使用之import

创建包package1,在package1创建package2

在包package1中创建文件init.py

# print(\'__init__.py\')

 

x=1

# m1=\'m1\'

# import m1 #错误

from package1 import m1

 

 

# package2=\'package2\'

# import package2 #错误,单独导入包名称时不会导入包中所有包含的所有子模块

from package1 import package2

 

在包package1中创建文件m1.py

def f1():

    print(\'from f1 func\')

 

在包package2中创建文件m2.py

def f2():
    print(\'f2\')

 

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

1.6 绝对导入和相对导入

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

绝对导入：以glance作为起始

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

1.6.1 相对导入

包的使用.py

# import package1

#

# # package1.f1()

# package1.f2()

 

import sys

sys.path.append(r\'D:\\video\\python20期\\day5\\02_包\\测试三（相对导入）\\aaa\')

 

import package1

package1.f2()

m1.py

def f1():

    print(\'from f1 func\')

 

 

包1_init_.py

from .m1 import f1

from .package2.m2 import f2

 

m2.py

from ..m1 import f1

def f2():

    f1()

    print(\'f2\')

 

1.6.2 绝对导入

包的使用.py

import package1

 

package1.f1()

package1.f2()

 

# import sys

#

# # sys.path.append(r\'D:\\video\\python20期\\day5\\02_包\\测试二（绝对导入）\\package1\\package2\')

# # sys.path.append(r\'D:\\video\\python20期\\day5\\02_包\\测试二（绝对导入）\\package1\')

#

 

m1.py

def f1():
    print(\'from f1 func\')

包1_init_.py

from package1.m1 import f1

from package1.package2.m2 import f2

m2.py

def f2():

    print(\'f2\')

 

包2_init_.py

from package1.package2 import m2

 

1.7 软件开发规范

 

 

图1-1  

 

#===============>star.py

import sys,os

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)

 

from core import src

 

if __name__ == \'__main__\':

    src.run()

 

#===============>settings.py

import os

 

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

DB_PATH=os.path.join(BASE_DIR,\'db\',\'db.json\')

LOG_PATH=os.path.join(BASE_DIR,\'log\',\'access.log\')

LOGIN_TIMEOUT=5

 

 

"""

logging配置

"""

# 定义三种日志输出格式

standard_format = \'[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]\' \\

                  \'[%(levelname)s][%(message)s]\' #其中name为getlogger指定的名字

simple_format = \'[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s\'

id_simple_format = \'[%(levelname)s][%(asctime)s] %(message)s\'

 

# log配置字典

LOGGING_DIC = {

    \'version\': 1,

    \'disable_existing_loggers\': False,

    \'formatters\': {

        \'standard\': {

            \'format\': standard_format

        },

        \'simple\': {

            \'format\': simple_format

        },

    },

    \'filters\': {},

    \'handlers\': {

 

        #打印到终端的日志

 \'console\': {

            \'level\': \'DEBUG\',

            \'class\': \'logging.StreamHandler\',  # 打印到屏幕

            \'formatter\': \'simple\'

        },

 

        #打印到文件的日志,收集info及以上的日志

       

 \'default\': {

            \'level\': \'DEBUG\',

            \'class\': \'logging.handlers.RotatingFileHandler\',  # 保存到文件

            \'formatter\': \'standard\',

            \'filename\': LOG_PATH,  # 日志文件

            \'maxBytes\': 1024*1024*5,  # 日志大小 5M

            \'backupCount\': 5,

            \'encoding\': \'utf-8\',  # 日志文件的编码，再也不用担心中文log乱码了

        },

    },

    \'loggers\': {

 

        #logging.getLogger(__name__)拿到的logger配置

      

  \'\': {

            \'handlers\': [\'default\', \'console\'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

            \'level\': \'DEBUG\',

            \'propagate\': True,  # 向上（更高level的logger）传递

        },

    },

}

 

 

#===============>src.py

from conf import settings

from lib import common

import time

 

logger=common.get_logger(__name__)

 

current_user={\'user\':None,\'login_time\':None,\'timeout\':int(settings.LOGIN_TIMEOUT)}

def auth(func):

    def wrapper(*args,**kwargs):

        if current_user[\'user\']:

            interval=time.time()-current_user[\'login_time\']

            if interval < current_user[\'timeout\']:

                return func(*args,**kwargs)

        name = input(\'name>>: \')

        password = input(\'password>>: \')

        db=common.conn_db()

        if db.get(name):

            if password == db.get(name).get(\'password\'):

                logger.info(\'登录成功\')

                current_user[\'user\']=name

                current_user[\'login_time\']=time.time()

                return func(*args,**kwargs)

        else:

            logger.error(\'用户名不存在\')

 

    return wrapper

 

@auth

def buy():

    print(\'buy...\')

 

@auth

def run():

 

    print(\'\'\'

    1 购物

    2 查看余额

    3 转账

    \'\'\')

    while True:

        choice = input(\'>>: \').strip()

        if not choice:continue

        if choice == \'1\':

            buy()

 

 

 

#===============>db.json

{"egon": {"password": "123", "money": 3000}, "alex": {"password": "alex3714", "money": 30000}, "wsb": {"password": "3714", "money": 20000}}

 

 

#===============>common.py

from conf import settings

import logging

import logging.config

import json

 

def get_logger(name):

    logging.config.dictConfig(settings.LOGGING_DIC)  # 导入上面定义的logging配置

    logger = logging.getLogger(name)  # 生成一个log实例

    return logger

 

 

def conn_db():

    db_path=settings.DB_PATH

    dic=json.load(open(db_path,\'r\',encoding=\'utf-8\'))

    return dic

 

#===============>access.log

[2017-10-21 19:08:20,285][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:08:32,206][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:08:37,166][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:08:39,535][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:08:40,797][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:08:47,093][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:09:01,997][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:09:05,781][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:09:29,878][MainThread:8812][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:09:54,117][MainThread:9884][task_id:core.src][src.py:19][INFO][登录成功]

 

#介绍

# import logging

# logging.basicConfig(

#     # filename=\'access.log\',

#     format=\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',

#     datefmt=\'%Y-%m-%d %H:%M:%S %p\',

#     level=10

# )

#

# logging.debug(\'debug\') # 10

# logging.info(\'info\') # 20

# logging.warning(\'warn\') #30

# logging.error(\'error\') #40

# logging.critical(\'critial\') #50

 

 

1.8 常用模块

1.8.1 日志模块的详细用法：

import logging

1.8.2 Logger：产生日志

logger1=logging.getLogger(\'访问日志\')

# logger2=logging.getLogger(\'错吴日志\')

1.8.3 Filter：几乎不用

1.8.4 Handler：接收Logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件

sh=logging.StreamHandler() #打印到终端

fh1=logging.FileHandler(\'s1.log\',encoding=\'utf-8\')

fh2=logging.FileHandler(\'s2.log\',encoding=\'utf-8\')

 

1.8.5 Formatter：日志格式

formatter1=logging.Formatter(

    fmt=\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',

    datefmt=\'%Y-%m-%d %H:%M:%S %p\',

)

formatter2=logging.Formatter(

    fmt=\'%(asctime)s : %(message)s\',

    datefmt=\'%Y-%m-%d %H:%M:%S %p\',

)

formatter3=logging.Formatter(

    fmt=\'%(asctime)s : %(module)s : %(message)s\',

    datefmt=\'%Y-%m-%d %H:%M:%S %p\',

)

 

 

1.8.6 、为handler绑定日志格式

sh.setFormatter(formatter1)

fh1.setFormatter(formatter2)

fh2.setFormatter(formatter3)

 

1.8.7 、为logger绑定handler

logger1.addHandler(sh)

logger1.addHandler(fh1)

logger1.addHandler(fh2)

 

1.8.8 设置日志级别:logger对象的日志级别应该＜＝handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

sh.setLevel(10)

fh1.setLevel(10)

fh2.setLevel(10)

 

1.8.9 测试

logger1.debug(\'测试着玩\')

logger1.info(\'运行还算正常\')

logger1.warning(\'可能要有bug了\')

logger1.error(\'不好了，真tm出bug了\')

logger1.critical(\'完犊子，推倒重写\')

 

1.9 日志的继承

import logging

1.9.1 Logger：产生日志

logger1=logging.getLogger(\'root\')

logger2=logging.getLogger(\'root.child1\')

logger3=logging.getLogger(\'root.child1.child2\')

 

1.9.2 Filter：几乎不用

 

1.9.3 Handler：接收Logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件

sh=logging.StreamHandler() #打印到终端

 

1.9.4 Formatter：日志格式

formatter1=logging.Formatter(

    fmt=\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',

    datefmt=\'%Y-%m-%d %H:%M:%S %p\',

)

 

 

1.9.5 为handler绑定日志格式

sh.setFormatter(formatter1)

 

1.9.6 为logger绑定handler

logger1.addHandler(sh)

logger2.addHandler(sh)

logger3.addHandler(sh)

 

1.9.7 设置日志级别:logger对象的日志级别应该＜＝handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

logger2.setLevel(10) #

logger3.setLevel(10) #

sh.setLevel(10)

 

1.9.8 测试

logger1.debug(\'爷爷\')

logger2.debug(\'爸爸\')

logger3.debug(\'孙子\')

 

1.10 正则模块

import re

 

# print(re.findall(\'\\w\',\'egon 123 + _ - *\'))

# print(re.findall(\'\\W\',\'egon 123 + _ - *\'))

# print(re.findall(\'\\s\',\'ego\\tn 12\\n3 + _ - *\'))

# print(re.findall(\'\\S\',\'ego\\tn 12\\n3 + _ - *\'))

# print(re.findall(\'\\d\',\'ego\\tn 12\\n3 + _ - *\'))

# print(re.findall(\'\\D\',\'ego\\tn 12\\n3 + _ - *\'))

# print(re.findall(\'\\n\',\'ego\\tn 12\\n3 + _ - *\'))

# print(re.findall(\'\\t\',\'ego\\tn 12\\n3 + _ - *\'))

# print(re.findall(\'e\',\'ego\\tn 12\\n3 +hello _ - *\'))

# print(re.findall(\'^e\',\'ego\\tn 12\\n3 +hello _ - *\'))

# print(re.findall(\'o$\',\'ego\\tn 12\\n3 +hello\'))

 

 

#重复：.|?|*|+|{m,n}|.*|.*?

#.代表任意一个字符

# print(re.findall(\'a.b\',\'a1b a b a-b aaaaaab\'))

                    #   a.b

# print(re.findall(\'a.b\',\'a1b a b a\\nb a-b aaaaaab\',re.DOTALL))

                    #   a.b

 

 

#?:代表?号左边的字符出现0次或者1

# print(re.findall(\'ab?\',\'a ab abb abbbb a1b\')) #[\'a\',\'ab\',\'ab\',\'ab\',\'a\']

#                       #                  ab?

 

 

#*:代表*号左边的字符出现0次或者无穷次

# print(re.findall(\'ab*\',\'a ab abb abbbb a1b\')) #[\'a\',\'ab\',\'abb\',\'abbbb\',\'a\']

                      #                  ab*

 

 

#+:代表+号左边的字符出现1次或者无穷次

# print(re.findall(\'ab+\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

#                       #                  ab+

 

 

# {m,n}:代表左边的字符出现m次到n次

# print(re.findall(\'ab{0,1}\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

# print(re.findall(\'ab?\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

 

# print(re.findall(\'ab{0,}\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

# print(re.findall(\'ab*\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

 

# print(re.findall(\'ab{1,}\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

# print(re.findall(\'ab+\',\'a ab abb abbbb a1b\')) #[\'ab\',\'abb\',\'abbbb\']

 

# print(re.findall(\'ab{2,4}\',\'a ab abb abbbb a1b\')) #[\'abb\', \'abbbb\']

 

 

#.*:贪婪匹配

# print(re.findall(\'a.*b\',\'xxxy123a123b456b\'))

                        #        a.*b

 

#.*?:非贪婪匹配

# print(re.findall(\'a.*?b\',\'xxxy123a123b456b\'))

 

#|:或者

# print(re.findall(\'compan(y|iess)\',\'too many companiess have gone bankrupt, and the next one is my company\'))

# print(re.findall(\'compan(?:y|iess)\',\'too many companiess have gone bankrupt, and the next one is my company\'))

                                 #                                                                         compan(y|iess)

 

# print(re.findall(\'href="(.*?)"\',\'<a href="http://www.baidu.com">点击我</a>\'))

 

#rawstring：

# print(re.findall(r\'a\\\\c\',\'a\\c a1c aBc\')) #a\\\\c->a\\c

 

#[]:取中括号内任意的一个

#以上是关于包与模块的主要内容，如果未能解决你的问题，请参考以下文章
 
 python包与模块
 python 3 包与模块
 Python模块包与面向对象综合案例
 Python基础之包与模块
 第 8 章: 模块, 包与分发---PDF版
 包与模块