Python引⽤Fromimport介绍
⼀. 模块的定义与分类
模块是什么？
这⼏天，我们进⼊模块的学习。在学习模块之前，我们⾸先要知道，什么是模块？
⼀个函数封装⼀个功能，你使⽤的软件可能就是由n多个函数组成的（先不考虑⾯向对象）。⽐如抖⾳这个软件，不可能将所有程序都写⼊⼀个⽂件，所以咱们应该将⽂件划分，这样其组织结构要好并且代码不冗余。假如分了10个⽂件，每个⽂件⾥⾯可能都有相同的功能（函数），怎么办？所以将这些相同的功能封装到⼀个⽂件中，那么这个存储着很多常⽤的功能的py⽂件，就是模块。模块就是⽂件，存放⼀堆常⽤的函数，⽐如：我要在⼤草原上策马奔腾，应该怎么样？我应该骑马，你也要去浪，你是不是也要骑马。我们说⼀个函数就是⼀个功能，那么把⼀些常⽤的函数放在⼀个py⽂件中，这个⽂件就称之为模块，模块，就是⼀些列常⽤功能的集合体。
为什么要使⽤模块?
1. 从⽂件级别组织程序，更⽅便管理, 随着程序的发展，功能越来越多，为了⽅便管理，我们通常将程序分成⼀个个的⽂件，这样做程序的结构更清晰，这时我们不仅仅可以把这些⽂件当做脚本去执⾏，还
可以把他们当做模块来导
⼊到其他的模块中，实现了功能的重复利⽤
2. 拿来主义，提升开发效率同样的原理，我们也可以下载别⼈写好的模块然后导⼊到⾃⼰的项⽬中使⽤，这种拿来主义，可以极⼤地提升我们的开发效率，避免重复造轮⼦.
⼈们常说的脚本是什么？
如果你在终端上编写的代码运⾏完后，退出python解释器然后重新进⼊，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到⽂件中以便永久保存下来，需要时就通过python test.py⽅式去执⾏，此时test.py被称为脚本script。
所以，脚本就是⼀个python⽂件，⽐如你之前写的购物车，模拟博客园登录系统的⽂件等等。
如何新建一个php文件模块的分类
Python语⾔中，模块分为三类。
第⼀类：内置模块，也叫做标准库。此类模块就是python解释器给你提供的，⽐如我们之前见过的tim
e模块,os模块。标准库的模块⾮常多（200多个，每个模块⼜有很多功能），我们这⼏天就讲常⽤的⼗⼏种，后⾯课程中还会陆续的讲到。
第⼆类：第三⽅模块，第三⽅库。⼀些python⼤神写的⾮常好⽤的模块，必须通过pip install 指令安装的模块，⽐如BeautfulSoup, Django，等等。⼤概有6000多个。bat批处理命令批量改名
第三类：⾃定义模块。我们⾃⼰在项⽬中定义的⼀些模块。
这⼏天，我们先学第⼀类和第三类模块，第⼆类模块会在我们并发编程开始逐渐的接触学习。
今天，我们先讲第三类，⾃定义模块。
我们先定义⼀个模块，定义⼀个模块其实很简单就是写⼀个⽂件，⾥⾯写⼀些代码（变量，函数）即可。此⽂件的名字为meet.py，⽂件内容如下：
print('from the meet.py')
name = '元宝'
def read1():
print('meet模块：',name)
def read2():
print('meet模块')
read1()
def change():
global name
name = "宝浪"
⼆. import
1.1 import 使⽤
import 翻译过来是⼀个导⼊的意思。
这⾥⼀定要给同学强调哪个⽂件执⾏⽂件，和哪个⽂件是被执⾏模块。
模块可以包含可执⾏的语句和函数的定义，这些语句的⽬的是初始化模块，它们只在模块名第⼀次遇到导⼊import语句时才执⾏（import语句是可以在程序中的任意位置使⽤的，且针对同⼀个模块import很多次，为了防⽌你重复导
⼊，python的优化⼿段是：第⼀次导⼊后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了⼀次引⽤，不会重新执⾏模块内的语句），如下 import meet 只在第⼀次导⼊时才执⾏meet.py内代码，此处的显式效果是只打印⼀次'from the meet.py'，当然其他的顶级代码也都被执⾏了，只不过没有显⽰效果.
import meet
import meet
import meet
import meet
import meet
执⾏结果：只是打印⼀次：
from the meet.py
重复导⼊会直接引⽤内存中已经加载好的结果
1.2 第⼀次导⼊模块执⾏三件事
1.创建⼀个以模块名命名的名称空间。
2.执⾏这个名称空间（即导⼊的模块）⾥⾯的代码。
3.通过此模块名. 的⽅式引⽤该模块⾥⾯的内容（变量，函数名，类名等）。这个名字和变量名没什么区别，都是‘第⼀类的’，且使⽤meet名字的⽅式可以访问meet.py⽂件中定义的名字，meet.名字与test.py中的名字来⾃两个完全不同的地⽅。
1.3 被导⼊模块有独⽴的名称空间
每个模块都是⼀个独⽴的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写⾃⼰的模块时，就不⽤担⼼我们定义在⾃⼰模块中全局变量会在被导⼊时，与使⽤者的全局变量冲突。
⽰例：
当前是test.py
import meet
name = 'alex'
print(name)
print(meet.name)
'''
运⾏结果:
from the meet.py
alex
元宝
'''
def read1():
print(666)
'''
运⾏结果:
from the meet.py
meet模块：元宝
'''
name = '⽇天'
meet.change()
print(name)
print(meet.name)
'''
运⾏结果:
from the meet.py
⽇天
宝浪
'''
让同学们将上⾯的代码练习⼀下。
1.4 为模块起别名
别名其实就是⼀个外号，我们⼩的时候，都喜欢给学⽣们起外号对吧。
1. 好处可以将很长的模块名改成很短,⽅便使⽤.
import tbjx as t
flames
2. 有利于代码的扩展和优化。
#mysql.py
def sqlparse():
print('from mysql sqlparse')
#oracle.py
def sqlparse():
print('from oracle sqlparse')
#test.py
db_type=input('>>: ')
if db_type == 'mysql':
import mysql as db
elif db_type == 'oracle':
import oracle as db
db.sqlparse()
1.5 导⼊多个模块
我们以后再开发过程中，免不了会在⼀个⽂件中，导⼊多个模块，推荐写法是⼀个⼀个导⼊。
import os,sys,json  # 这样写可以但是不推荐
推荐写法
import os
import sys
import json
多⾏导⼊：易于阅读易于编辑易于搜索易于维护。
三. from ... import ...
1.1 from ... import ... 使⽤
from ... import ... 的使⽤⽰例。
from meet import name, read1
print(name)
read1()
'''
执⾏结果：
from the meet.py
⾦星
meet模块：元宝
'''
1. 与import对⽐
唯⼀的区别就是：使⽤则是将spam中的名字直接导⼊到当前的名称空间中，所以在当前名称空间中，直接使⽤名字就可以了、⽆需加前缀：tbjx. 的⽅式有好处也有坏处
好处：使⽤起来⽅便了
坏处：容易与当前执⾏⽂件中的名字冲突
⽰例演⽰：
1. 执⾏⽂件有与模块同名的变量或者函数名，会有覆盖效果。
name = 'oldboy'
from meet import name, read1, read2
print(name)
'''
执⾏结果：
郭宝元
'''
----------------------------------------
from meet import name, read1, read2
name = 'boy'
print(name)
'''
执⾏结果：
boy
html怎样改成js
'''
----------------------------------------
caption of industry
def read1():
print(666)
from meet import name, read1, read2
read1()
'''
执⾏结果：
meet模块：元宝
'''
-
---------------------------------------
from meet import name, read1, read2
def read1():
print(666)
read1()
'''
执⾏结果：
meet模块： 666
'''
2. 当前位置直接使⽤read1和read2就好了，执⾏时，仍然以meet.py⽂件全局名称空间
#测试⼀：导⼊的函数read1，执⾏时仍然回到meet.py中寻全局变量 'alex'
#test.py
from meet import read1
name = 'alex'
read1()
'''
执⾏结果:
from the meet.py
meet->read1->name = '元宝'
'''
#测试⼆：导⼊的函数read2，执⾏时需要调⽤read1()，仍然回到meet.py中
#read1()
#test.py
from meet import read2
def read1():
print('==========')
read2()
'''
执⾏结果:
from the meet.py
meet模块
meet模块：元宝
'''
1.3 from … import也⽀持as
通过这种⽅式引⽤模块也可以对模块进⾏改名。
from meet import read1 as read
read()
1.4 ⼀⾏导⼊多个
from tbjx import read1,read2,name
1.5 from ... import *
from meet import * 把meet中所有的不是以下划线(_)开头的名字都导⼊到当前位置
⼤部分情况下我们的python程序不应该使⽤这种导⼊⽅式，因为*你不知道你导⼊什么名字，很有可能会覆盖掉你之前已经定义的名字。⽽且可读性极其的差，在交互式环境中导⼊时没有问题。
可以使⽤all来控制*（⽤来发布新版本），在meet.py中新增⼀⾏
__all__=['name','read1'] #这样在另外⼀个⽂件中⽤from spam import *就这能导⼊列表中规定的两个名字
1.6 模块循环导⼊问题
模块循环/嵌套导⼊抛出异常的根本原因是由于在python中模块被导⼊⼀次之后，就不会重新导⼊，只会在第⼀次导⼊时执⾏模块内代码
在我们的项⽬中应该尽量避免出现循环/嵌套导⼊，如果出现多个模块都需要共享的数据，可以将共享的数据集中存放到某⼀个地⽅在程序出现了循环/嵌套导⼊后的异常分析、解决⽅法如下（了解，以后尽量避免）
⽰范⽂件内容如下
#创建⼀个m1.py
print('正在导⼊m1')
from m2 import y
x='m1
#创建⼀个m2.py
print('正在导⼊m2')
from m1 import x
y='m2'
#创建⼀个run.py
import m1
#测试⼀
执⾏run.py会抛出异常
正在导⼊m1
正在导⼊m2
Traceback (most recent call last):
File "/python项⽬/run.py", line 1, in <module>
import m1
File "/python项⽬/m1.py", line 2, in <module>
from m2 import y
File "/python项⽬/m2.py", line 2, in <module>
from m1 import x
ImportError: cannot import name 'x'
#测试⼀结果分析
先执⾏run.py--->执⾏import m1，开始导⼊m1并运⾏其内部代码--->打印内容"正在导⼊m1"
--->执⾏from m2 import y 开始导⼊m2并运⾏其内部代码--->打印内容“正在导⼊m2”--->执⾏from m1 import x，由于m1已经被导⼊过了，所以不会重新导⼊，所以直接去m1中拿x，然⽽x此时并没有存在于m1中，所以报错
#测试⼆：执⾏⽂件不等于导⼊⽂件，⽐如执⾏m1.py不等于导⼊了m1
正在导⼊m1
正在导⼊m2
Traceback (most recent call last):
正在导⼊m1
File "/python项⽬/m1.py", line 2, in <module>
from m2 import y
File "/python项⽬/m2.py", line 2, in <module>
from m1 import x
File "/python项⽬/m1.py", line 2, in <module>
from m2 import y
ImportError: cannot import name 'y'
#测试⼆分析
执⾏m1.py，打印“正在导⼊m1”，执⾏from m2 import y ，导⼊m2进⽽执⾏m2.py内部代码--->打印"正在导⼊m2"，执⾏from m1 import x，此时m1是第⼀次被导⼊，执⾏m1.py并不等于导⼊了m1，于是开始导⼊m1并执⾏其内部代码--->打印"正在导⼊m1"，执⾏from m1 # 解决⽅法:
⽅法⼀：导⼊语句放到最后
#m1.py
print('正在导⼊m1')
x='m1'
from m2 import y
#m2.py
print('正在导⼊m2')
y='m2'
from m1 import x
⽅法⼆：导⼊语句放到函数中
#m1.py
print('正在导⼊m1')
def f1():
from m2 import y
print(x,y)
x = 'm1'
# f1()
#m2.py
print('正在导⼊m2')
def f2():
from m1 import x
print(x,y)
y = 'm2'
#run.py
import m1
m1.f1()
⼀. py⽂件的两种功能
编写好的⼀个python⽂件可以有两种⽤途：⼀：脚本，⼀个⽂件就是整个程序，⽤来被执⾏（⽐如你之前写的模拟博客园登录那个作业等）⼆：模块，⽂件中存放着⼀堆功能，⽤来被导⼊使⽤ python为我们内置了全局变量
__name__，当⽂件被当做脚本执⾏时：name 等于'main' 当⽂件被当做模块导⼊时：__name__等于模块名作⽤：⽤来控制.py⽂件在不同的应⽤场景下执⾏不同的逻辑（或者是在模块⽂件中测试代码）
抖音python入门教程
if __name__ == '__main__':
print('from the meet.py')
__all__ = ['name', 'read1',]
name = '元宝'
def read1():
print('meet模块：',name)
def read2():
print('meet模块')
read1()
def change():
global name
name = '宝浪'
if __name__ == '__main__':
# 在模块⽂件中测试read1()函数
# 此模块被导⼊时 __name__ == meet 所以不执⾏
read1()
⼆. 模块的搜索路径
当你引⽤⼀个模块时，不见得每次都可以import到：
当咱们导⼊同⼀个⽬录下的模块的时候就能够使⽤import成功，不是同⼀个⽬录下的导⼊就会报错
上⾯的⽰例可以得知，引⽤模块也是按照⼀定规则进⾏引⽤的。
Python中引⽤模块是按照⼀定的规则以及顺序去寻的，这个查询顺序为：先从内存中已经加载的模块进⾏寻不到再从内置模块中寻，内置模块如果也没有，最后去sys.path中路径包含的模块中寻。它只会按照这个顺序从这些
指定的地⽅去寻，如果最终都没有到，那么就会报错。
内存中已经加载的模块->内置模块->sys.path路径中包含的模块
模块的查顺序
1. 在第⼀次导⼊某个模块时（⽐如meet），会先检查该模块是否已经被加载到内存中（当前执⾏⽂件的名称空间对应的内存），如果有则直接引⽤（ps：python解释器在启动时会⾃动加载⼀些模块到内存中，可以使⽤
2. 如果没有，解释器则会查同名的内置模块
3. 如果还没有到就从sys.path给出的⽬录列表中依次寻meet.py⽂件。
需要特别注意的是：我们⾃定义的模块名不应该与系统内置模块重名。虽然每次都说，但是仍然会有⼈不停的犯错
#在初始化后，python程序可以修改sys.path，路径放到前⾯的优先于标准库被加载。
> > > import sys
> > > sys.path.append('/a/b/c/d')
> > > sys.path.insert(0,'/x/y/z') #排在前的⽬录，优先被搜索
> > > 注意：搜索时按照sys.path中从左到右的顺序查，位于前的优先被查，sys.path中还可能包含.zip归档⽂件和.egg⽂件，python会把.zip归档⽂件当成⼀个⽬录去处理，
#⾸先制作归档⽂件：zip module.zip foo.py bar.py
import sys
sys.path.append('module.zip')
import foo,bar
#也可以使⽤zip中⽬录结构的具体位置
sys.path.append('module.zip/lib/python')
#windows下的路径不加r开头，会语法错误
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a')
#⾄于.egg⽂件是由setuptools创建的包，这是按照第三⽅python库和扩展时使⽤的⼀种常见格式，.egg⽂件实际上只是添加了额外元数据(如版本号，依赖项等)的.zip⽂件。
#需要强调的⼀点是：只能从.zip⽂件中导⼊.py，.pyc等⽂件。使⽤C编写的共享库和扩展块⽆法直接从.zip⽂件中加载（此时setuptools等打包系统有时能提供⼀种规避⽅法），且从.zip中加载⽂件不会创建.pyc或者.pyo⽂件，因此⼀定要事先创建他们，来避免加载模块是明天我们就开始讲解Python常⽤的内置模块，由于Python常⽤的模块⾮常多，我们不可能将所有的模块都讲完，所以只针对于⼯作中经常⽤到模块进⾏讲解。剩下的模块可以在课余时间⾃学。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。