python模块之自定义模块

模块概述

到此之前，我们都是在一个py文件里操作，接下来，我们学习模块的内容，可以从其他文件引入内容（如函数等）

1. 什么是模块

一个py文件就是一个模块，模块是一些相似功能的集合体

2. 为什么要用模块

模块具有以下好处

（1）减少重复代码，提高开发效率

（2）使代码的组织结构更清晰，有条理性

3. 模块的分类

模块按来源分为三类：

（1）内置模块，也就是python解释器自带的模块，如time, os, sys等

（2）扩展模块（第三方模块），通过pip安装的模块

（3）自定义模块，自己写的模块

自定义模块

1. 创建自定义模块

先来写一个模块，命名为game_of_throne

print("-----来自game_of_throne模块-----")
name = "stack"
 
def hello1():
    print("我是game_of_throne模块的func1")
 
def hello2():
    print("我是game_of_throne模块的func2")

2. 自定义模块的导入及调用

我们引入game_of_throne模块，调用里面的name和func1和func2

 import game_of_throne     # 导入模块
 print(game_of_throne.name)   # 调用模块里的变量
 game_of_throne.func1()    # 调用模块里的函数
 game_of_throne.func2()

执行一下，看看结果

-----来自game_of_throne模块-----
stack
我是game_of_throne模块的func1
我是game_of_throne模块的func2

可以看到，导入模块时，模块里的代码会自动执行，事实上，模块被执行时发生了三件事：

1. 创建了一个以被导入模块名字命名的名称空间

2. 自动执行模块中的代码（将模块中的所有内容加载到内存）

3. 执行模块中的代码需通过模块名. 的方式获取

这里需要注意的是，自动执行仅会在首次导入时进行，之后会直接从内存里引用

 import game_of_throne
 print(game_of_throne.name)
 game_of_throne.func1()
 game_of_throne.func2()
 import game_of_throne   # 重复导入只会从内存中引用
 game_of_throne.func2()

执行结果

-----来自game_of_throne模块-----
stack
我是game_of_throne模块的func1
我是game_of_throne模块的func2
我是game_of_throne模块的func2

import还可以导入多个模块

# 方式一：官方推荐
import time
import os
import sys
 
# 方式二：不推荐
import time,os,sys

模块导入的另外一种方法是：from 模块名 import 内容，来看一段代码

 name = "robert"
 from game_of_throne import name, func1, func2
 print(name)
 func1()
 func2()

执行结果

-----来自game_of_throne模块-----
stack
我是game_of_throne模块的func1
我是game_of_throne模块的func2

可以看到，从game_of_throne模块导入的name把本文件里面的name给覆盖了，如果把本文件的name放在后面呢，来看

# name = "robert"
from game_of_throne import name, func1, func2
name = "robert"
print(name)
func1()
func2()

执行结果

-----来自game_of_throne模块-----
robert
我是game_of_throne模块的func1
我是game_of_throne模块的func2

运用这种方法导入时会与本文件里的重名的内容相互覆盖，所以使用时需慎重，from game_of_throne import name, func1, func2这句话实际上做了两件事：

（1）将模块game_of_throne 中的代码加载到内存（执行一遍）

（2）将name，func1，func2引入到当前的名称空间（可以用globals()验证）

from game_of_throne import name, func1, func2
print(globals())

执行结果

-----来自game_of_throne模块-----
{'__name__': '__main__', '__doc__': '\n模块被执行发生了三件事:\n1. 创建一个以被导入模块的名字命名的名称空间\n2. 自动执行模块中的代码（将模块中的所有内容加载到内存）\n3. 要想执行模块中的代码必须通过模块名. 的方式执行获取\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001AF6D7985F8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/模块.py', '__cached__': None, 'name': 'stack', 'func1': <function func1 at 0x000001AF6D86A950>, 'func2': <function func2 at 0x000001AF6D86A9D8>}

可以看到当前全局变量中有name，func1，func2，说明指定的变量和函数已经被引入到当前的名称空间。

两种导入方式对比：

（1）使用from...import...直接将模块中的内容导入到当前的名称空间中，之后调用直接使用名字就可以

（2）使用from...import...比较方便，但是容易与当前文件中的对象冲突

3. 模块的改名

上面的模块名是不是写着很费劲啊，我们可以给它取一个短一点的名字，就像我们的小名一样，以后就用这个小名来调用

import game_of_throne as got
got.func1()
got.func2()

执行结果

-----来自game_of_throne模块-----
我是game_of_throne模块的func1
我是game_of_throne模块的func2

模块改名除了方便引用外，还有另外一个作用，就是优化代码，方便拓展（统一接口），比如我们有两个模块：mysql.py和oracle.py

# mysql.py
def sqlparse():
    print('from mysql sqlparse')
 
# oracle.py
def sqlparse():
    print('from oracle sqlparse')

有一点这样的代码：

 import mysql.py
 import oracle.py
 db_type = input(">>>")
 if db_type == "mysql":
     mysql.sqlparse()
 elif db_type == "oracle":
     oracle.sqlparse()

我们可以通过模块的改名对其进行优化

 db_type = input(">>>")
 if db_type == "mysql":
     import mysql as db
 elif db_type == "oracle":
     import oracle as db
 db.sqlparse()

from...import...也可以改名

from game_of_throne import func1 as f1

也可以导入所有

from game_of_throne import *

import * 表示导入所有（除去下划线开头的名字），这种方式要慎用，因为导入所有极有可能覆盖掉本文件中的内容，这种方式一般只在两种情况下使用：

（1）对导入的模块了如指掌，里面的所有代码都清楚，确认过导入之后不会覆盖原文件的内容

（2）使用__all__控制 * 的范围（注意__all__放在要导入的模块里，而不是本文件里）

__all__ = ["name", "func2", "func4"]

from game_of_throne import *
 
func1()
 
func3()

执行结果

Traceback (most recent call last):
-----来自game_of_throne模块-----
  File "D:/模块.py", line 161, in <module>
    func1()
NameError: name 'func1' is not defined

报错，fiunc1未找到，说明func1没有被导入到当前的名称空间

文件的两个作用

1. 作为脚本，直接运行

game_of_throne作为脚本直接运行，__name__为__main__

# game_of_throne
print(__name__)

执行结果

__main__

2. 作为模块供别人调用

import game_of_throne
print(__name__)

执行结果

-----来自game_of_throne模块-----
__main__

补充：if __name__ == "__main__"通常作为项目的启动文件用

文件的搜索路径

内存中找-------->built-in内置模块-------->sys.path

先从内存中找，如果内存中有，直接引用；没有的话再在内置模块中找，找不到最后再在sys.path中找。

import sys
print(sys.path

执行结果

['D:\\Day13', 'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib', 'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Program Files\\JetBrains\\PyCharm 2018.3.2\\helpers\\pycharm_matplotlib_backend']

如果要引入的模块不在当前文件所在的文件夹里需要手动将其路径添加到sys.path里

    import game_of_throne
ModuleNotFoundError: No module named 'game_of_throne'

手动添加到sys.path里

sys.path.append("D:/Day12")

执行结果

-----来自game_of_throne模块-----

总结一下：

1. 模块是集成了相似功能的文件

2. 使用模块能够减少重复代码，提高开发效率；使代码组织结构更清晰

3. 模块导入的两种方式

　　import  模块名;

　　from  模块名  import   内容

4. 模块改名：as

5. 文件搜索路径

　　内存

　　内置模块

　　sys.path