包和模块

一、模块的导入方式

'''
模块解释:
    概述:
        大白话: 模块就是工具包, 可以帮助我们实现某些功能.
        专业版: Python中的模块指的是.py文件, 一个.py文件就是一个模块.
    使用方式:
        必须先导入模块, 才能使用模块中的内容.
    导入方式:
        import 模块名
        import 模块名 as 别名
        from 模块名 import 功能名
        from 模块名 import 功能名 as 别名
        from 模块名 import *
'''

# 模块导入方式1: import 模块名
# import time   # 如果这样导入, 则该模块中所有的功能(函数)都能使用.

# print('start')
# 通过 模块名.函数名() 的方式调用函数.
# time.sleep(2)   # 让程序休眠2秒
# print(time.time())  # 获取时间(毫秒值)
# print('end')

# 模块导入方式2: import 模块名 as 别名     功能同上, 只不过简化了模块名写法.
# import time as t
# print('start')
# # 通过 模块名.函数名() 的方式调用函数.
# t.sleep(2)   # 让程序休眠2秒
# print(t.time())  # 获取时间(毫秒值)
# print('end')

# 模块导入方式3: from 模块名 import 功能名      只能用该被导入的功能(函数), 其他函数不能用.
# from time import sleep
# # from time import time
# print('start')
# # 通过 函数名() 的方式调用函数.
# sleep(2)   # 让程序休眠2秒
# # print(time())  # 获取时间(毫秒值), 报错,因为没有导入这个功能(函数)
# print('end')

# 模块导入方式4: from 模块名 import 功能名 as 别名     功能同上, 只不过可以简化函数写法
# from time import sleep as s
# # from time import time
# print('start')
# # 通过 函数名() 的方式调用函数.
# s(2)   # 让程序休眠2秒
# # print(time())  # 获取时间(毫秒值), 报错,因为没有导入这个功能(函数)
# print('end')

# 模块导入方式5: from 模块名 import *        导入该模块下所有的功能(函数)
from time import *

print('start')
# 通过 函数名() 的方式调用函数.
sleep(2)   # 让程序休眠2秒
print(time())  # 获取时间(毫秒值)
print('end')


'''
细节问题:
    import time  和  from time import * 这两种导入方式都能使用time模块中所有的功能(函数), 请问有什么区别?
答案:
    调用函数的格式不一样, 前者是: 模块名.功能名(), 例如: time.sleep(2)
    后者可以直接写功能(函数)名, 例如: sleep(2)
'''

二、自定义模块的使用

'''
所谓的自定义模块的使用其实是:
    1. 自己创建一个 .py文件, 然后在里边写一堆的函数.
    2. 在其他的 .py文件中, 引入上述的 .py文件(模块), 调用函数即可.
    3. 注意: 一个.py文件就是一个模块.
    4. 我们在自定义模块的时候, 要符合 Python的命名规则和规范.
'''

# 1. 导入自定义模块(.py文件) my_model1, 并使用其中的函数.
# import my_model1
#
# my_model1.fun1()
# my_model1.fun2()
#
# sum = my_model1.getSum(10, 20)
# print(sum)


# 2. 演示其他的导入方式
# import my_model1 as m1
# m1.fun1()

# from my_model1 import fun1
# fun2()  报错

# from my_model1 import *
# fun1()
# fun2()
# sum = getSum(11, 22)
# print(sum)

# 虽然上述的代码会导入 my_model1模块中所有的函数, 但是有可能出现这样的情况,
# my_mode1这个模块中的 部分函数是我们经常使用的, 那如何解决这个问题呢?
# 例如: 我们经常用 my_model1这个模块的 fun1 和 fun2 函数, 如何实现只导入它们呢?
# 方式1: 导入两次, 如果函数过多, 太麻烦
# from my_model1 import fun1
# from my_model1 import fun2

# 方式2: 导入所有, 效率太低, 额外占用资源.
# from my_model1 import *

# 方式3: 通过 __all__ 对要导入的函数做限定.
from my_model1 import *
fun1()
fun2()
fun3()
# fun4()  # 报错, 因为在 my_model1模块中, 已经限定了, from my_model1 import * 的时候只导入 fun1, fun2, fun3

三、包详解

'''
包(package)解释:
    概述:
        所谓的包就是文件夹, 它们的本质还是一个模块, 因为里边放的是一堆的模块(.py)文件.
    包的作用:
        1. 用来对模块(.py)进行分类管理的.
        2. 用来区分重名模块(.py)的.
    自定义包:
        就是我们自己新建一个 python package包即可, 该包下默认有一个 __init__.py文件来管理包.
    案例:
        1. 自定义包, 包名: my_package
        2. 该包下有两个模块, 分别是: my_module1, my_module2
        3. 两个模块下分别有一些函数.
        4. 在当前的.py文件(10.Python中的包详解.py)中测试上述的内容.
'''

# 1. 导入包下的模块
# import my_package.my_module1

# 给导入的模块起别名
# import my_package.my_module1 as m
# m.fun1()

# 导入包下的所有的模块.
# from my_package import my_module1,my_module2
# my_module1.fun1()
# my_module1.fun2()
# print('-' * 13)
#
# my_module2.fun1()
# my_module2.fun2()

# 上述的代码虽然实现了导入 my_package包下所有的模块的功能,
# 但是这样写不好, 因为 my_package包下就两个模块, 如果模块多了, 这样做就不合适了.
# 如何解决呢?
# 答案: 通过 from my_package import * 解决, 但是要结合 __all__ 一起使用.

from my_package import *
my_module1.fun1()
my_module1.fun2()
print('-' * 13)

my_module2.fun1()
my_module2.fun2()

四、显示包目录

> import sys
> print '\n'.join(sys.path)

/usr/lib/python2.7
/usr/lib/python2.7/plat-x86_64-linux-gnu
/usr/lib/python2.7/lib-tk
/usr/lib/python2.7/lib-old
/usr/lib/python2.7/lib-dynload
/usr/local/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages

更多参考文章 How does python find packages?

五、all 限定

# __all__ 可以用来限定 from 模块名 import *  这种方式的时候, 导入谁, 不导入谁.
# 如果没写 __all__ , 则默认表示导入该模块下所有的 函数.# 如果没写 __all__ , 则默认表示导入该模块下所有的 函数.
__all__ = ['fun1', 'fun2', 'fun3']

def fun1():
    print(__name__)
    print('my_model1 模块的 fun1 函数')
def fun2():
    print(__name__)
    print('my_model1 模块的 fun2 函数')
def fun3():
    print('my_model1 模块的 fun2 函数')
def fun4():
    print('my_model1 模块的 fun2 函数')
def getSum(a, b):
    return a + b

# 这里边我们可以写测试代码, 因为当我们的 my_model1模块中的函数定义好之后, 我们肯定要测试这些函数,
# 从而知道这些函数是否能正常使用, 但是最后我们如果没有注释这些测试代码, 就会发生一些意想不到的情况.
# fun1()  # 如果这样写测试代码, 则在导入该模块后, 这些代码也会自动执行一次.
# fun2()

# main函数, 也是程序的主入口.
if __name__ == '__main__':
    # 因为 __name__只有在当前模块中才是 __main__, 到其它模块中值就变了.
    fun1()
    fun2()