第一阶段：Python开发基础 day16 模块的基础使用

第一阶段：Python开发基础 day16 模块的基础使用
目录
上节课内容回顾

https://www.cnblogs.com/foreversun92/p/11359938.html

一、模块的四种形式

一、什么是模块？

模块是一系列功能的集合体，而函数是某一个功能的集合体，因此模块可以看成是一堆函数的集合体。一个py文件内部就可以放一堆函数，因此一个py文件就可以看成一个模块。如果这个py文件的文件名为module.py，模块名则是module。

二、模块的四种形式

在Python中，总共有以下四种形式的模块：
1. 自定义模块：如果你自己写一个py文件，在文件内写入一堆函数，则它被称为自定义模块，即使用python编写的.py文件
2. 第三方模块：已被编译为共享库或DLL的C或C++扩展
3. 内置模块：使用C编写并链接到python解释器的内置模块
4. 包：把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
三、为什么要用模块？
1. 用第三方或者内置的模块是一种拿来主义，可以极大地提升开发效率。
2. 自定义模块，将我们自己程序中用到的公共功能，写入一个python文件，然后程序的各部分组件可以通过导入的方式来引用自定义模块的功能。
四、如何用模块

一般我们使用import和from...import...导入模块。

二、import 和 from...import

一般使用import和from...import...导入模块。

以下述spam.py内的文件代码为例。
```
# 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
```
一、import 模块名
```
# run.py
import spam  # from the spam.py
import spam
```
import首次导入模块发生了3件事：
1. 以模块为准创造一个模块的名称空间
2. 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
3. 在当前执行文件中拿到一个模块名
模块的重复导入会直接饮用之前创造好的结果，不会重复执行模块的文件，即重复导入会发生：spam=spam=模块名称空间的内存地址
```
# run.py
import spam as sm


money = 111111

sm.money
sm.read1()  # 'spam模块：1000'
sm.read2
sm.change()

print(money)  # 1000
```
导入多个模块
```
import spam, time, os

# 推荐使用下述方式
import spam
import time
import os
```
二、from 模块名 import 具体的功能
```
# run.py

from spam import money

money = 10

print(money)  # 10
```
from...import...首次导入模块发生了3件事：
1. 以模块为准创造一个模块的名称空间
2. 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
3. 在当前执行文件的名称空间中拿到一个名字，该名字直接指向模块中的某一个名字，意味着可以不用加任何前缀而直接使用
- 优点：不用加前缀，代码更加精简
- 缺点：容易与当前执行文件中名称空间中的名字冲突
导入文件内所有的功能：
```
# spam.py

__all__ = ['money', 'read1']  # 只允许导入'money'和'read1'
# run.py
from spam import *  # 导入spam.py内的所有功能，但会受限制于__all__
```
三、import和from...import...的异同

相同点：
1. 两者都会执行模块对应的文件，两者都会产生模块的名称空间
2. 两者调用功能时，需要跑到定义时寻找作用域关系，与调用位置无关
不同点:
1. import需要加前缀；from...import...不需要加前缀
三、循环导入问题

一、什么是循环导入？
```
# m1.py
print('from m1.py')
from m2 import x

y = 'm1'
```
1. 创建m2的名称空间
2. 执行m2.py，将执行产生的名字丢到m2.py
3. 在当前执行文件中拿到m2.x
```
# m2.py
print('from m2.py')
from m1 import y

x = 'm2'
```
1. 创建m1的名称空间
2. 执行m1.py，将执行产生的名字丢到m1.py
3. 在当前执行文件中拿到m1.y
```
# run.py
import m1
```
1. 创建m1的名称空间
2. 执行m1.py，将执行产生的名字丢到m1.py
3. 在当前执行文件中拿到m1
- 如果运行run.py，则会报错ImportError: cannot import name 'y'
- 如果运行m1.py，则会报错ImportError: cannot import name 'x'
- 如果运行m2.py，则会报错ImportError: cannot import name 'y'
二、解决方案

我们可以使用函数定义阶段只识别语法的特性解决循环导入的问题，我们也可以从本质上解决循环导入的问题，但是最好的解决方法是不要出现循环导入。

2.1 方案一
```
# m1.py
print('from m1.py')


def func1():
    from m2 import x
    print(x)


y = 'm1'
```
```
# m2.py
print('from m2.py')

def func1():
    from m1 import y
    print(y)


x = 'm2'
```
2.2 方案二
```
# m1.py
print('from m1.py')


y = 'm1'
from m2 import x
```
```
# m2.py

print('from m2.py')

x = 'm2'
from m1 import y
```
三、模块的搜索路径

一、模块搜索路径的顺序

模块其实就是一个文件，如果要执行文件，首先就需要找到模块的路径（某个文件夹）。如果模块的文件路径和执行文件不在同一个文件目录下，我们就需要指定模块的路径。

模块的搜索路径指的就是在导入模块时需要检索的文件夹。

导入模块时查找模块的顺序是：
1. 先从内存中已经导入的模块中寻找
2. 内置的模块
3. 环境变量sys.path中找
```
import sys
print(f"sys.path: {sys.path}")

'''
['/Users/mac/Desktop/video/python/day16', 
'/Users/mac/Desktop/video/python', 
'/Applications/anaconda3/lib/python36.zip', 
'/Applications/anaconda3/lib/python3.6', 
'/Applications/anaconda3/lib/python3.6/lib-dynload', 
'/Applications/anaconda3/lib/python3.6/site-packages', 
'/Applications/PyCharm.app/Contents/helpers/pycharm_matplotlib_backend']
'''
```
强调：sys.path的第一个值是当前执行文件的所在的文件夹

1.1 验证先从内存中找

如果我们在运行run.py文件的时候，快速删除mmm.py文件，我们会发现文件会继续运行，而不会报错，因为mmm已经被导入内存当中。如果我们再一次运行run.py时会报错，因为mmm.py已经被删除了。
```
# mmm.py

def f1():
    print('from mmm.py f1')
```
```
# run.py
import time
import mmm

time.sleep(10)
import mmm
mmm.f1()  # from mmm.py f1
```
1.2 验证先从内置中找
```
# time.py
print('from time.py')
# run.py
import time
print(time)  # <module 'time' (built-in)>
```
1.3 验证从sys.path中找

如果mmm.py在/Users/mac/Desktop/video/python路径下，而执行文件路径为/Users/mac/Desktop/video/python/day16，如果普通导入一定会报错，我们可以把/Users/mac/Desktop/video/python添加到环境变量sys.path中，防止报错。
```
# run.py
import sys
sys.path.append(r'/Users/mac/Desktop/video/python')
print(sys.path)

import mmm
mmm.f1()
```
二、搜索路径以执行文件为准

假设我们有上述的目录结构的文件，文件内代码分别是：
```
# m1.py

import sys
print('模块m1中查看的结果',sys.path)
# import m2
from dir1 import m2
m2.f2()
```
```
# m2.py

import sys
print(sys.path)

def f2():
    print('from f2')
```
```
# run.py
import sys
print('执行文件查看的结果：',sys.path)
from dir1 import m1
```
其中run.py文件的执行路径是/Users/mac/Desktop/video/python/day16/模块搜索路径练习，如果我们在m1.py中直接使用import m2导入m2会报错，而使用from dir1 import m2导入m2则会成功，因为搜索路径以执行文件为准，dir1和run.py是同目录下的，因此run.py的环境变量能找到dir1；而m2和run.py不是同目录下的，因此run.py的环境变量无法直接找到m2。

四、Python 文件的两种用途

一、Python文件的两种用途

python文件总共有两种用途，一种是执行文件；另一种是被当做模块导入。

编写好的一个python文件可以有两种用途：
1. 脚本，一个文件就是整个程序，用来被执行
2. 模块，文件中存放着一堆功能，用来被导入使用
```
# aaa.py

x = 1


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


def f2():
    print('from f2')


f1()
f2()
```
```
# run.py

import aaa
```
如果直接运行run.py会直接运行aaa.py中的f1()和f2()，但是如果我们在aaa.py中加上if __name__ == '__main__':这句话，则可以防止运行run.py时执行f1()和f2()。因为当aaa.py被直接执行，即当做执行文件的时候__name__ == '__main__'；在aaa.py被当做模块直接运行的时候__name__ == 'aaa'。由此可以让aaa.py在不同的场景下有着不同的用法。
```
# aaa.py

x = 1


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


def f2():
    print('from f2')


if __name__ == '__main__':
    f1()
    f2()
```
今日总结

无
相关阅读:
java.lang.RuntimeException: HRegionServer Aborted的问题
 Solr 读数据流程
 Solr 写数据流程
 solr索引创建流程
 Solr 倒排索引
 Solr 核心组成
 Solr的关键特性
 poj3308 Paratroopers --- 最小点权覆盖->最小割
 YII 路由配置
 MySQL具体解释（5）-----------函数超全总结
原文地址：https://www.cnblogs.com/foreversun92/p/11360552.html

第一阶段：Python开发基础 day16 模块的基础使用

上节课内容回顾

一、模块的四种形式

一、什么是模块？

二、模块的四种形式

三、为什么要用模块？

四、如何用模块

二、import 和 from...import

二、from 模块名 import 具体的功能

三、import和from...import...的异同

三、循环导入问题

一、什么是循环导入？

二、解决方案

2.1 方案一

三、模块的搜索路径

一、模块搜索路径的顺序

1.1 验证先从内存中找

1.2 验证先从内置中找

1.3 验证从sys.path中找

二、搜索路径以执行文件为准

四、Python 文件的两种用途

一、Python文件的两种用途

今日总结