当模块被引入的时候会先执行一遍模块里面的代码
所有的模块引入都应该尽量往上面写 - 模块的引入循序:
- 内置模块
- 扩展模块（第三方模块）
- 自定义模块
重复引入相同模块模块里的代码只会执行一次 -> 因为他首先会在 sys.modules （sys模块下的modules属性）里面找看一下是否引入了，如果引入了下面重复引入的代码就不会执行，如果没有引入就会依据 sys.path （sys模块下的path属性）路径寻找模块将它引入，如果没找到就会报错
import module
import module
import module
1. import
- 将模块里的变量/函数一次性加载到所引用模块的文件中，通过 模块名.变量名/函数名使用
- import 模块名 -> 引入模块
# use_module.py
import module
# module.py
print('module.py')
data = 100
def fn():
print(data)
- 模块名.变量名/函数名 -> 可以使用模块中所定义的任意变量和函数，(在js中只有导出了变量或函数才能使用)
# use_module.py
import module
m_data = module.data
module.fn()
# module.py
print('module.py')
data = 100
def fn():
print(data)
- import 模块名 as 重命名的模块名 -> 重命名模块名
# use_module.py
import module as m
m_data = m.data
m.fn()
# module.py
print('module.py')
data = 100
def fn():
print(data)
- 重命名模块名的使用场景: 当有两个不同的模块且里面的方法是相同的时候，就可以起相同的别名如果在进行判断使用那个模块
- 有两中 sql模块 mysql 和 oracle ，根据用户的输入，选择不同的sql功能
# use_module.py
db_type = input('>>: ')
if db_type == 'mysql':
import mysql as db
elif db_type == 'oracle':
import oracle as db
db.sqlparse()
# mysql.py
def sqlparse():
print('from mysql sqlparse')
# oracle.py
def sqlparse():
print('from oracle sqlparse')
- import 模块名1, 模块名2 -> 同时引入多个模块 -> 不建议使用 代码可读性差
# use_module.py
import module1, module2
2. from import
- 需要模块中的什么变量/函数就引什么，直接使用引入的变量名/方法名
- from 模块名 import 变量名/函数名
# use_module.py
from module import fn
from module import data
print(data)
fn()
# module.py
print('module.py')
data = 100
def fn():
print(data)
- from 模块名 import 变量名/函数名 as 重命名变量名/函数名
# use_module.py
from module import fn as f
f()
# module.py
print('module.py')
data = 100
def fn():
print(data)
- from 模块名 import 变量名/函数名, 变量名/函数名 -> 同时引入多个 变量名/函数名 -> 不建议使用 代码可读性差
# use_module.py
from module import data, fn
print(data)
fn()
# module.py
print('module.py')
__all__ = ['data']
data = 100
def fn():
print(data)
- from 模块名 import (变量名/函数名, 变量名/函数名) -> 同时引入多个 变量名/函数名 的时候可以加上 () 进行回车
# use_module.py
from module import (
data,
fn
)
print(data)
fn()
# module.py
print('module.py')
__all__ = ['data']
data = 100
def fn():
print(data)
- from 模块名 import * -> 将模块中的所有变量名都放到所引入模块的文件内存中，如果有相同的变量名或函数名就会冲突 -> 不建议使用
# use_module.py
from module import *
print(data)
fn()
# module.py
print('module.py')
data = 100
def fn():
print(data)
- __all__= ['变量名/函数名'] -> __all__ 和 from xxx import * 配套使用的 -> * 所引入的变量名/函数名就是 __all__ 所存的 变量名/函数名
# use_module.py
from module import *
print(data)
# fn() fn 没有被引入
# module.py
__all__ = ['data']
data = 100
def fn():
print(data)
- __name__
- 返回所引入模块的文件名如果是自身模块则返回__main__
- 使用场景1: 如果我们想执行自身模块进行调试的时候，但又不想调试的代码在所引入该模块的文件中执行执行的时候就可以判断 __name__ 是否等于 __main__
# use_module.py
from module import fn
fn()
# module.py
data = 100
def fn():
print(data)
if __name__ == '__main__':
print(__name__)
print('调试代码')
- 使用场景2: u_m1 想执行一段 u_m2 执行不了的代码的时候，或者 u_m2 想执行一段 u_m1 执行不了的代码的时候
# u_m1.py
from module import fn
fn()
# u_m2.py
from module import fn
fn()
# module.py
data = 100
def fn():
print(data)
if __name__ == 'u_m1':
print(__name__)
print('这段代码不会被 u_2.py 执行')
elif __name__ == 'u_m2':
print(__name__)
print('这段代码不会被 u_1.py 执行')