python之块包导入,模块与包

壹.哪些是模块

  一个模块正是二个含有了python定义和注脚的文件,文件名正是模块名字加上.py的后缀

  其实import加载的模块分别为死歌通用项目:

    一.用到pytho编写的代码(.py文件)

    2.已被编写翻译为共享库或DLL的C或C++增加

    三.包好1组模块的包

    4.采纳C编写并链接到python解释器的放手模块

1丶模块

模块

壹、什么是模块?

2个模块就是二个Python文件,文件名就是模块名字加上.py后缀。由此模块名称也亟须符合变量名的命名规范。

  1应用python编写的代码

  二已被编写翻译为共享库或DLL的C或C++扩充

  三包好一组模块的包

python之块包导入,模块与包。  肆用到C编写并链接到python解释器的停放模块

贰、为何要接纳模块?

若果你退出python解释器然后再行进入,那么您前面定义的函数可能变量都将遗失,由此大家平常将次第写到文件中以便永久保存下去,须要时就通过python
test.py格局去执行,此时test.py被称为脚本script。

乘胜程序的发展,成效更是多,为了方便管理,我们家常便饭将次第分成三个个的文件,那样做程序的构造更清楚,方便管理。那时大家不光能够把这些文件作为脚本去实践,还足以把她们作为模块来导入到其余的模块中,实现了作用的重复利用,

三、如何利用模块?

  • 方式一:import
  • 方式二:from …
    import …

一、模块

二.怎么样团结写2个模块

    创设三个py文件,给它起八个适合变量命名规则的名字,这么些名字正是模块名

  我们平常说模块模块的,毕竟什么样是模块呢?

import

先是,自定义叁个模块my_module.py,文件名my_module.py,模块名my_module

美高梅开户网址 1美高梅开户网址 2

name = "我是自定义模块的内容..."def func():    print("my_module: ", name)print("模块中打印的内容...")

my_module

在import一个模块的进度中,爆发了什么样工作?

# 用import导入my_module模块import my_module>>>模块中打印的内容... # 怎么回事,竟然执行了my_module模块中的print语句import my_moduleimport my_moduleimport my_moduleimport my_moduleimport my_module>>>模块中打印的内容... # 只打印一次

从上边的结果能够看看,import三个模块的时候一定于实践了那一个模块,而且三个模块是不会再度被导入的,只会导入3遍(python解释器第一回就把模块名加载到内存中,之后的import都只是在对应的内部存款和储蓄器空间中查找。)成功导入三个模块后,被导入模块与公事之间的命名空间的问题,就改为接下去要搞掌握的定义了。

被导入模块与本文件之间命名空间的涉及?

假诺当前文件也有四个变量为:
name = ‘local file’, 也有2个同名的func方法。

# 本地文件name = "local file"def func():    print    # 本地文件有跟被导入模块同名的变量和函数,究竟用到的是哪个呢?import my_moduleprint(my_module.name)   # 根据结果可以看出,引用的是模块里面的namemy_module.func()        # 执行的是模块里面的func()函数>>>模块中打印的内容...我是自定义模块的内容...my_module:  我是自定义模块的内容...print             # 使用的是本地的name变量func()                  # 使用的是本地的func函数>>>local filelocal file

在import模块的时候发出了上面包车型客车几步:

  一、先找找模块

  2、假若找到了,就在内部存款和储蓄器中开辟1块空间,从上至下执行那几个模块

  三、把这些模块中用到的靶子都选拔到新开发的内部存款和储蓄器空间中

  肆、给那些内部存款和储蓄器空间创造3个变量指向那些空间,用来引用其剧情。

  综上可得,模块与公事之间的内部存款和储蓄器空间始终是隔绝的

美高梅开户网址 3

给导入的模块取外号,用as关键字

万一导入的模块名太长倒霉记,那么能够由此“import 模块名 as
小名”的办法给模块名取贰个小名,但这时本来的模块就不再生效了(也等于成立了新的变量名指向模块内存空间,断掉原模块名的引用)。

# 给my_module模块取别名import my_module as smprint>>>我是自定义模块的内容...print(my_module.name)   # 取了别名后,原来的模块名就不生效了>>>NameError: name 'my_module' is not defined

给模块去小名,还是能使代码更加灵敏,减弱冗余,常用在依照用户输入的例外,调用区别的模块。

# 按照先前的做法,写一个函数,根据用户传入的序列化模块,使用对应的方法def dump:    if method == 'json':        import json        with open('dump.txt', 'wb') as f:            json.dump('xxx', f)    elif method == 'pickle':        import pickle        with open('dump.txt', 'wb') as f:            pickle.dump('xxx', f)# 上面的代码冗余度很高,如果简化代码?通过模块取别名的方式,可以减少冗余def dump:    if method == 'json':        import json as m    elif method == 'pickle':        import pickle as m    with open('dump.txt', 'wb') as f:        m.dump('dump.txt', f)

哪些同时导入多个模块?

方法一:每行导入贰个模块

import osimport sysimport time

措施2:一行导入多少个模块,模块之间通过逗号“,”来分隔

import os, sys, my_module

唯独,依据PEP八规范规定接纳第3种方法,并且三种模块有先后顺序(内置>第一方>自定义)

# 根据PEP8规范import osimport djangoimport my_module

模块搜索路径

由此sys内置模块,大家精晓sys.path存款和储蓄了具有模块的路径,然则寻常的sys.path的门径中除了内置模块,第3方模块所在的门路之外,唯有2个路径是永久正确的,正是当下施行的文件所在目录。三个模块是不是能够被导入,就在于那么些模块所在的目录是还是不是在sys.path中。

python解释器在运营时会自行加载壹些模块,能够采取sys.modules查看

在第2遍导入有些模块时(比如my_module),会先反省该模块是还是不是曾经被加载到内部存款和储蓄器中(当前施行文书的称呼空间对应的内部存款和储蓄器),若是有则平素引用

①旦未有,解释器则会招来同名的内建立模型块,如若还未有找到就从sys.path给出的目录列表中逐壹寻找my_module.py文件。

故而总括模块的搜索顺序是:内部存款和储蓄器中已经加载的模块->内置模块->sys.path路径中富含的模块

亟需尤其注意的是:大家自定义的模块名不应该与系统内置模块重名。

模块宁海平调本

运行八个py文件有两种格局,不过这两种实施措施之间有三个明明的歧异,正是__name__。

美高梅开户网址,  1、已脚本的艺术实施:cmd中“python
xxx.py” 可能pycharm等IDE中履行

    __name__ =
‘__main__’

  贰、导入模块时实施:import模块,会实施该模块。

    __name__ =
模块名

不过,当您有3个py文件既能够看作脚本执行,又有什么不可看作模块提需要其余模块引用时,那时作为模块要求导入时而不显得多余的打字与印刷逻辑/函数调用,所以那个逻辑能够放在“if __name__ = ‘__main__’: xxx”
代码块中。

诸如此类py文件作为脚本执行的时候就可知打字与印刷出来,以模块被导入时,便不会打字与印刷出来。

  一、什么是模块

3.模块的导入

  导入四个模块便是举行3个模块

  模块导入的长河中发出了怎么着:

    一.找到这几个模块

    2.判定那几个模块是还是不是被导入过了

    三.万壹未有被导入过:

      创立1个属于那些模块的命名空间

      让模块的名字指向这几个空间

      执行这些模块中的代码

  给模块起外号:起了外号之后,就只好接纳那么些模块的别称引用变量了

  导入八个模块:

    import os,time

  规范建议:

    模块应该一个一个的导入:

      内置模块

      扩展(第三方)模块

      自定义模块

  from  import  

    模块导入的历程中生出了怎么:

      壹.找到要被导入的模块

      2.判断那几个模块是还是不是被导入过

      三.要是这一个模块没被导入过

        创制四个属于这些模块的命名空间

        执行那些文件

        找到要导入的变量

        给导入的变量创设叁个引用,指向要导入的变量

 1 #测试一:导入的函数read1,执行时仍然回到my_module.py中寻找全局变量money
 2 #demo.py
 3 from my_module import read1
 4 money = 1000
 5 read1()
 6 
 7 #测试二:导入的函数read2,执行时需要调用read1(),仍然回到my_module.py中找read1()
 8 #demp.py
 9 from my_module import read2()
10 def read1():
11     print("1")
12 read2()

假使当前有重名read一或许read贰,那么会有覆盖效果

1 #测试三:导入的函数read1,被当前位置定义的read1覆盖掉了
2 #demo.py
3 from my_module import read1
4 def read1():
5     print("1")
6 read1()
7 执行结果:
8 from the my_module.py
9 1

from my_module import
*把my_module中装有的不是以下划线(_)伊始的名字都导入到当前地点

from my_module import *
print(money)
print(read1)
print(read2)

执行结果:
from the my_module.py
1000

如果my_module.py中的名字前加_,即_money,则frommy_module import
*,_money不可能被导入

模块引用中的境况:模块之间分裂意循环引用

  2个模块便是带有了Python定义和注明的文本,文件名正是模块名字加上.py的后缀

from … import …

from…import是另壹种导入模块的花样,假诺你不想每趟调用模块的靶子都添加模块名,就能够运用那种方式。

在from … import
… 的经过中生出了什么事儿?

from my_module import name, funcprint     # 此时引用模块中的对象时,就不要再加上模块名了。func()

  一、寻找模块

  2、如若找到模块,在内部存储器中开发壹块内部存款和储蓄器空间,从上至下实施模块

  3、把模块中的对应关系总体都保存到新开拓的内部存款和储蓄器空间中

  4、建立三个变量xxx引用改模块空间中对应的xxx,
假诺未有import进来的时候,就动用持续。

from … import …
方式取小名

与import方式如出一辙,通过”from
模块名 import 对象名 as 小名”。

from my_module import name as n, func as f

from … import
*

import *
也便是把那个模块中的所盛名字都引进到当前文件中,不过如果您本身的py文件若是有重名的变量,那么就会发出不佳的熏陶,由此选拔from…import
*时索要严格,不提议使用。

* 与
__all__

__all__是与*同盟使用的,在被导入模块中加进壹行__all__=[‘xxx’,’yyy’],就分明了利用import
*是只好导入在__all__中规定的品质。

# 在my_module模块中定义__all____all__ = ['name']name = 'My module...'def func():    print("my_module: ", name)# 在其他文件中通过import *导入所有属性from my_module import *print>>>My module...func()>>>NameError: name 'func' is not defined

进展知识点:

  pyc文件与pyi文件
*

  pyi文件:跟.py1样,仅仅作为1个python文件的后缀名。

  pyc文件:
python解释器为了增长加载模块的进程,会在__pycache__目录中生成模块编写翻译好的字节码文件,并且相比较修改时间,只有模块改变了,才会另行编写翻译。pyc文件仅仅用于节省了开发银行时间,可是并不可能抓好程序的实践功用。

  模块的导入和修改*

  一.导入模块后,模块就曾经被加载到内部存款和储蓄器中,此后计量对模块进行转移,读取的始末还是内部存款和储蓄器中原来的结果。

  贰.一旦想让改动生效,能够因而“from
importlib import reload”, 供给’reload
模块名’重新加载模块,改动才生效。

  模块的大循环使用
****

  谨记模块的导入必须是单链的,无法有轮回引用,假使存在循环,那么正是先后设计存在难题。

  dir
***

  能够获得该模块中有所的名字,而且是字符串类型的,就足以通过反射去履行它。

    常见的场景:3个模块便是1个包括了python定义和表明的文件,文件名便是模块名字加上.py的后缀。

四.模块的加载与修改

  每种模块只被导入一遍,放入到sys.modules中,即便改动了模块中的内容,必须重启程序

  但实在import加载的模块分为三个通用项目:

包是一种通过‘.模块名’来组织python模块名称空间的诀要。

无论是import方式照旧from
… import
方式,凡是在导入语句中境遇带点的,都要第暂且间提升警觉:那是有关包才有的导入语法

包是目录级的,文件夹是用来整合py文件(包的本质正是二个富含__init__.py文件的目录)

import导入文本时,爆发名称空间中的名字源于与公事,import包,发生的名称空间的名字壹样来自与公事,即包下的__init__.py,导入包本质正是在导入文本

  注意:

    一、在python三中,即便包下未有__init__.py文件,import包依然不会报错,而在python第22中学,包下一定要有该文件,不然import包会报错

    2、成立包的目标不是为着运转,而是被导入使用,记住,包唯有模块的一种样式而已,包即模块

包A和包B下有同超模块也不会抵触,如A.a与B.a来自八个指令空间

以身作则环境如下:

美高梅开户网址 4美高梅开户网址 5

import osos.makedirs('glance/api')os.makedirs('glance/cmd')os.makedirs('glance/db')l = []l.append(open('glance/__init__.py','w'))l.append(open('glance/api/__init__.py','w'))l.append(open('glance/api/policy.py','w'))l.append(open('glance/api/versions.py','w'))l.append(open('glance/cmd/__init__.py','w'))l.append(open('glance/cmd/manage.py','w'))l.append(open('glance/db/models.py','w'))map(lambda f:f.close

创设目录代码美高梅开户网址 6美高梅开户网址 7

glance/                   #Top-level package├── __init__.py      #Initialize the glance package├── api                  #Subpackage for api│   ├── __init__.py│   ├── policy.py│   └── versions.py├── cmd                #Subpackage for cmd│   ├── __init__.py│   └── manage.py└── db                  #Subpackage for db│   ├── __init__.py│   └── models.py

目录结构美高梅开户网址 8美高梅开户网址 9

#文件内容#policy.pydef get():    print('from policy.py')#versions.pydef create_resource:    print('from version.py: ',conf)#manage.pydef main():    print('from manage.py')#models.pydef register_models:    print('from models.py: ',engine)

文件内容

    但实在import加载的模块分为三个通用项目: 

5.把模块当成脚本来使用

  可以由此模块的全局变量__name__来查阅模块名:

    当做脚本运转:

      __name__等于’__main__’

    当做模块导入:

      __name = 模块名

  功用:用来控制.py文件在分裂的选取场景下实施分歧的逻辑

  if __name__ == ‘__main__’:

 1 def fib(n):
 2     a,b = 0,1
 3     while b<n:
 4         print(b,end = '')
 5         a, b = b, a+b
 6     print()
 7 
 8 if __name__ == "__main__":
 9     print(__name__)
10     num = input("num:")
11     fib(int(num))

py文件:直接运转那几个文件,那些文件正是八个本子

    导入这些文件,这一个文件就是3个模块

当一个py文件:

  当做多个本子的时候:能够独立的提供一个效果,能自立实现交互

  当成3个模块的时候,能够被导入那调用这么些功用,无法自主交互

四个文件中的__name__变量:

  当以此文件被作为脚本执行的时候:__name__ == ‘__main__’

  当那一个文件被看作模块导入的时候:__name__ == ‘模块的名字’

    一.行使Python编写的代码

从包中程导弹入模块

从包中程导弹入模块有二种办法,不过无论哪类,无论在怎么着职位,都必须比照一个尺码:(凡是在导入时带点的,点的左手都必须是贰个包),否则违规。

对此导入后,在选用就从未那种限制,点的左手能够是包,模块,函数,类(它们都足以用点的诀窍调用本身的性格)

对待import item 和from
item import
name的运用场景:假诺我们想直接行使name那么必须利用后者。

方式一:import

  例如:
包名1.包名2.包名3.模块名

# 在与包glance同级别的文件中测试import glance.db.modelsglance.db.models.register_models('mysql') """执行结果:from models.py mysql"""

方式二:from … import …

  例如:from
包名1.包名2 import 模块名

     from
包名1.包名2.模块名 import 变量名/函数名/变量名

  注意:须求小心的是from后import导入的模块,必须是明摆着的1个不能够带点,不然会有语法错误,如:from
a import b.c是不对语法

# 在与包glance同级别的文件中测试from glance.db import modelsmodels.register_models('mysql')"""执行结果:from models.py mysql"""from glance.cmd import managemanage.main()"""执行结果:from manage.py"""

    一 应用python编写的代码(.py文件)

陆.模块搜索路径

  在率先次导入有个别模块时,会先检查该模块是还是不是业已被加载到内部存款和储蓄器中(当前履行文书的称号空间对应的内部存款和储蓄器),假设有则间接引用,假使未有,解释器则会招来同名的内建立模型块,假诺还不曾找到就从sys.path给出的目录列表中逐条寻找那个模块

由此模块的检索顺序是:内部存储器中已经加载的模块->内置模块->sys.path路径中包涵的模块

 

    二.已被编写翻译为共享库或DLL的C或C++扩展

直白导入包

若是是直接导入三个包,那么一定于履行了这些包中的__init__文件

并不会帮您把那么些包下边的其余包以及py文件自动的导入到内部存款和储蓄器

假使你希望直接导入包之后,全部的那么些包下边的任何包以及py文件都能直接通过包来调用,那么需求您本身处理__init__文件。

__init__.py文件

随正是哪类艺术,只借使第二遍导入包照旧是包的其余别的部分,都会相继执行李包裹下的__init__.py文件;那么些文件能够为空,不过也得以存放1些初叶化包的代码。

相对导入和相持导入

我们的最一流包glance是写给别人用的,然后在glance包内部也会有相互之间互相导入的急需,那时候就有相对导入和绝对导入二种方法:

相对导入:以glance作为先导

对峙导入:用. 或许..
的法子作为伊始(只可以在1个包中使用,不可能用来不相同目录内)

纯属导入和绝对导入示例:

绝对导入:    既然导入包就是执行包下的__init__.py文件,那么尝试在啊glance的__init__.py文件中"import api",执行一下,貌似没有报错,在尝试下在包外导入,情况如何?    在包外创建一个test.py文件,在里面操作如下:    import glance    glance.api    ModuleNotFoundError: No module named 'api'    原因:为什么还会报错?因为一个模块能不能被导入就看在sys.path中有没有路径,在哪里执行文件,sys.path永远记录该文件的目录。    (1)在glance的__init__.py文件中,sys.path的路径是:    'E:\\Python练习\\包\\glance'    所以能够找到同级的api    (2)但是在test文件中导入,此时sys.path的路径是:    'E:\\李彦杰\\Python练习\\包'    所以找不到不同层级的api,所以就会报No module name 'api'    解决办法一:    使用绝对路径(绝对路径为当前执行文件的目录)    (1)在glance包中的__init__.py中通过绝对路径导入:    "from glance import api"    (2)这样在test文件中执行,就能找到同层级的glance,再去里面找api    同理,如果想使用api包中的模块,也要在api包中的__init__.py文件中导入"from glance.api import policy, veersions",    (4)现在在test文件中调用glance下的api下的policy模块就不会报错:        import glance        glance.api.policy.get()        glance.api.versions.create_resource('测试')        执行结果:            from policy.py            from versions.py 测试绝对导入的缺点:如果以后包的路径发生了转移,包内的所有__init__.py文件中的绝对路径都需要改变解决办法二:    使用相对导入        . 表示当前目录        .. 表示上一级目录    (1)在glance包中的__init__.py中通过相对路径的形式导入:     “from . import api”    (2)同理在api包中的__init__.py中通过相对路径的形式导入:     “from . import policy,version”    (3)同样在test文件中调用glance下的api下的policy模块就不会报错:        import glance        glance.api.policy.get()        glance.api.versions.create_resource('测试')        执行结果:            from policy.py            from versions.py 测试相对导入的优点:    包发生路径转移,其中的相对路径都没有改变,所以不用逐个逐个修改。相对导入的缺点:    但凡带着相对导入的文件,只能当做模块导入,不能作为一个脚本单独执行!!!

扩展知识:

  同级目录下的包导入

  需要:现在内需在bin上边包车型客车start文件中程导弹入core目录下的main模块;怎么破?

project├── bin                 #Subpackage for bin    ├── __init__.py    └── start.py├── core                #Subpackage for core    ├── __init__.py    └── main.py

# main.py文件中的内容:def func():    print("In main")

、在start中直接导入,因为路径不对,所以直接报错:

import main # 执行,报错ModuleNotFoundError: No module named 'main'

、由上面报错我们知道肯定路径不对,那么我们想到直接将core路径加进去不就好了吗?是的,这样是可行的

import syspath = 'E:\练习\包\core'   # 复制得到core的绝对路径sys.path.append     # 将core路径添加import main         # 再次导入便不会报错main.func()         # 执行结果:In main

、上面的方法看似可行,但是还是有一个问题,如果我将project打包发给别人,或者我换个环境运行呢?   那么又得更改对应的path。不怎么合理,那么我们看下面的方法:

import sysprint(__file__)ret = __file__.split('/')base_path = '/'.join(ret[:-2])sys.path.append(base_path)from core import mainmain.func()     # In main

 1、__file__ 可以得到当前文件的绝对路径,E:/练习/project/bin/start.py

 2、__file__.split 将当前文件的绝对路径进行处理,按照'/'分隔得到:['E:', '练习', 'project', 'bin', 'start.py']

 3、'/'.join 因为我们只需要拿到project项目的动态路径,所以进行切割,在jojn得到: E:/练习/project

 4、sys.path.append(base_path) 再将得到的路径添加到sys.path中

 5、from core import main   因为我们拿到的是project目录,所以导入是从当前路径的core包导入main模块

 6、main.func()  最后再是模块名.方法。

    二 已被编译为共享库或DLL的C或C++扩充

7.包

  一.文书夹中有一个__init__.py文件

  2.是多少个模块的聚众

  三.无论是import格局如故from..import情势,凡是在导入语句中(而不是在使用时)蒙受带点的,那是有关包才有的导入语法

  四.包是目录级的(文件夹级),文件夹是用来构成py文件(包的本质正是一个暗含__init__.py文件的目录)

  伍.import导入文本时,产生名称空间中的名字来自文件,import包发生的称呼空间的名字如出壹辙来自文件,即包下的__init__.py,导入包本质正是在导入该文件

  陆.导入叁个包也就是实践了这几个包上边的__init__.py文件

至于包相关的导入语句也分为import和from..import..两种,但随便哪一种,在怎么地方,都遵照一个条件:

      凡是在导入时带点的,点的左手都必须是2个包

对此导入后,在接纳时就未有那种限制了,点的左侧能够是包,模块,函数,类(他们都足以用点的办法调用自身的性质)

相对导入:

  在推行一个py脚本的时候,这么些本子以及这一个剧本同级的模块中只好用相对导入

  缺点:

    全体的导入都要从二个根目录下未来解释文件夹之间的涉及

    若是当前导入包的文件和被导入的包的职位关系发出了扭转,那么富有的init文件都要做相应的调动

1 import glance
2 glance.__init__.py
3 import api
4 sys.path = [path]
5 glance.api.policy.get()

绝对导入:

  不须要去反复的修改路径

  只要三个包中的保有文件夹和文书的周旋地方不发出变动,init文件就不必要调动

  不须求去关爱当前以此包和被执行的文本之间的层级关系

  缺点:

    含有相对导入的py文件不可能被一贯实施

    必须放在包中被导入的调用才能平时的运用

如果只是从包中导入模块的话,就不要求做其它多余的操作

如若期望导入包的时候,能够顺便的把模块也导入进来,需求规划init文件夹

    三.包好一组模块的包

    三 包好1组模块的包

    肆.采取C编写并链接到Python解释器的放权模块

    四 行使C编写并链接到python解释器的停放模块

import

  二、为何要运用模块

  fromimport导入的经过中生出了哪些事儿?

    要是您退出python解释器然后重新进入,那么你后边定义的函数或然变量都将遗失,由此大家层见迭出将次第写到文件中以便永久保存下来,须求时就由此python
test.py方式去执            行,此时test.py被称为脚本script。

  一.找到要被导入的模块

           
随着程序的升华,成效越来越多,为了方便管理,大家平日将次第分成二个个的文本,那样做程序的布局更清楚,方便管理。这时大家不仅能够把那个文件作为脚本去履行,
         还足以把她们作为模块来导入到其余的模块中,完结了职能的再度使用

  二.断定那一个模块是不是被导入过

  三、怎样利用模块

  3.倘使这么些模块没被导入

    3.1 import

    创立2个属于这么些模块的命名空间

    示例文件:spam.py,文件名spam.py,模块名spam       

    执行那些文件

spam.py
print('from the spam.py')

money=1000

def read1():
    print('spam->read1->money',money)

def read2():
    print('spam->read2 calling read')
    read1()

def change():
    global money
    money=0

    找到您要导入的变量

    三.1.壹 模块只在模块名第一回相见导入import语句时才实施(import语句是能够在程序中的任意地点接纳的,且针对同一个模块很import多次,为了防止万1你再一次导入,python的优化
             
 手段是:第1遍导入后就将模块名加载到内部存款和储蓄器了,后续的import语句仅是对已经加载大内部存款和储蓄器中的模块对象扩展了2次引用,不会再也履行模块内的说话)

    给你要导入的变量创造多个引用,指向您要导入的变量

#test.py
import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.
import spam
import spam
import spam

'''
执行结果:
from the spam.py
'''

  自定义模块:my_module.py,文件名my_module.py,模块名my_module

import sysprint(sys.modules)  #导入的模块会写在这里面sys.path.append(my_module)    #将my_module模块写入里面import my_module    #导入my_module模块print(my_module.name)    #调用my_module中的name

  我们能够从sys.module中找到当前曾经加载的模块,sys.module是几个字典,内部含有模块名与模块对象的照耀,该字典决定了导入模块时是或不是供给再一次导入。

  为模块起外号

# 给模块起别名import my_moudle as mm.read1#给模块起别名,起了别名之后,使用这个模块就都使用别名引用变量了

  三.1.2 每一个模块都以3个独自的名称空间,定义在那几个模块中的函数,把这么些模块的名号空间作为全局名称空间,那样大家在编排自个儿的模块时,就不要操心大家定义在投机模块
          中全局变量会在被导入时,与使用者的全局变量争辨

  导入八个模块

#导入多个模块import os,timeimport os as o,time as t# 规范建议:先导入内置模块,再导入扩展模块,再导入自定义模块

  三.1.三总计:第③遍导入模块spam时会做3件事:

  from..import

from my_module import read1def read1():    print('in my read1')from my_module import read2read1()

    壹.为源文件(spam模块)创制新的称号空间,在spam中定义的函数和艺术固然使用到了global时访问的正是以此称号空间。

  须求越来越强调的少数是:python中的变量赋值不是1种存款和储蓄操作,而只是壹种绑定关系,如下:

from my_module import money,read1money=100 #将当前位置的名字money绑定到了100print #打印当前的名字read1() #读取my_module.py中的名字money,仍然为1000'''from the my_module.pymy_module->read1->money 1000'''

    二.在新创制的命名空间中实施模块中隐含的代码,见开头导入import
spam

  frommy_moduleimport *

from my_module import * #将模块my_module中所有的名字都导入到当前名称空间printprintprintprint'''执行结果:from the my_module.py<function read1 at 0x1012e8158><function read2 at 0x1012e81e0><function change at 0x1012e8268>'''

    三.创建名字spam来引用该命名空间

  __all__能约束*导入的变量的内容

__all__ = ['name','read1','read2']from my_module import *printread1

        三.1.4 为模块名起别名

  把模块当做脚本执行

    import spam as sm

  当一个py文件

    三.一.伍在1行导入五个模块

    当做2个本子的时候:能够单独的提供三个效用,能自立完毕交互

    import sys,os,re

    当成一个模块的时候,能够被导入这么些调用这一个成效,不能自主交互

    3.2  from…import…

  大家能够透过模块的全局变量__name__来查阅模块名:

    三.2.壹 比较import
spam,会将源文件的称号空间’spam’带到近期名称空间中,使用时务必是spam.名字的不2秘籍

  当做脚本运转:

               而from
语句约等于import,也会创设新的名称空间,不过将spam中的名字直接导入到当前的名目空间中,在眼下名称空间中,直接选拔名字就能够了、

    __name__等于’__main__’

      from spam import read1,read2
    这样在当前位置直接使用read1和read2就好了,执行时,仍然以spam.py文件全局名称空间
    如果当前有重名read1或者read2,那么会有覆盖效果。
    需要特别强调的一点是:python中的变量赋值不是一种存储操作,而只是一种绑定关系
    
    3.2.2 也支持as
    from spam import read1 as read
    3.2.3 也支持导入多行
    from spam import (read1,

                  read2,
                   money)
    3.2.4 from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置,大部分情况下我们的python程序不应该使用这种导入方式,因为*你不知道你导入什么名字,很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差,在交互式环境中导入时没有问题。

    可以使用__all__来控制*(用来发布新版本)

  当做模块导入:

    在*.py中新增壹行

    __name__=模块名

    __all__=['money','read1'] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字

  作用:用来控制.py文件在差异的应用场景下举办分化的逻辑

    能够运用__all__来控制*(用来发布新本子)

  if__name__==’__main__’ 

def fib:       a, b = 0, 1    while b < n:        print(b, end=' ')        a, b = b, a+b    print()if __name__ == "__main__":    print(__name__)    num = input('num :')    fib

    就算spam.py中的名字前加_,即_money,则from spam import
*,则_money不可能被导入

  模块搜索路径

    3.贰.5 考虑到品质的缘由,每种模块只被导入2次,放入字典sys.module中,要是你改变了模块的内容,你不能够不重启程序,python不协理再度加载或卸载此前导入的模块,

  Python解释器在运转时会自行加载壹些模块,能够动用sys.modules查看

    三.3 把模块当做脚本执行

  在率先次导入某些模块时(比如my_module),会先检查该模块是还是不是早已被加载到内部存款和储蓄器中,假设有则一向引用,假诺未有,解释器则会寻找同名的内建模块,借使还未曾找到就送sys.path给出的目录列表中种种寻找my_module.py文件

    大家得以经过模块的全局变量__name__来查看模块名:

  所以总括模块的追寻顺序是:内部存款和储蓄器中已经加载的模块->内置模块->sys.path路径中蕴藏的模块

import sysimport calculateprintpath = r'D:\Learn\day21\模块的循环引用'sys.path.append

     当做脚本运转:
    __name__ 等于’__main__’

  编译Python文件

    当做模块导入:
    __name__=

    1.假诺是在命令中被直接导入模块,则依照那种形式,每一次导入都会再一次编写翻译,并且不会储存编写翻译后的结果

    成效:用来控制.py文件在分化的使用场景下执行分化的逻辑
    if __name__ == ‘__main__’:

    二.假使源文件不存在,那么缓存的结果也不会被选用,假使想在一贯不源文件的景观下来使用编写翻译后的结果,则编写翻译后的结果必须在源目录下

    叁.四模块搜索路径

  dir()函数

    python解释器在运转时会活动加载一些模块,能够行使sys.modules查看

  内建函数dir是用来寻找模块中定义的名字,重返3个稳步字符串列表.倘使没有参数,dir()列举出脚下概念的名字

import my_moduledir(my_module)

    在首先次导入某些模块时(比如spam),会先检查该模块是或不是已经被加载到内部存款和储蓄器中(当前执行文书的称谓空间对应的内部存款和储蓄器),如若有则直接引用

二丶包

  一.无论是import方式依旧from…import格局,凡是在导入语句中相见带点的,都要第暂且间提升警觉:那是有关包才有的导入语法

  二.包是目录级的,文件夹是用来整合py文件(包的实质正是叁个带有__init__.py文件的目录)

  三.import导入文本时,发生名称空间中的名字来自文件,import包,产生的称呼空间的名字如出1辙来自文件,即包下的__init__.py,导入包的实质正是在导入该文件

  强调:

  1.在Python三中,即便包下没有__init__.py文件,import包如故不会报错,而在Python第22中学,包下一定要有该文件,不然import包报错

  2.开立包的目标不是为着运转,而是被导入使用,记住,包只是格局的壹种样式而已,包即模块

美高梅开户网址 10美高梅开户网址 11

import osos.makedirs('glance/api')os.makedirs('glance/cmd')os.makedirs('glance/db')l = []l.append(open('glance/__init__.py','w'))l.append(open('glance/api/__init__.py','w'))l.append(open('glance/api/policy.py','w'))l.append(open('glance/api/versions.py','w'))l.append(open('glance/cmd/__init__.py','w'))l.append(open('glance/cmd/manage.py','w'))l.append(open('glance/db/models.py','w'))map(lambda f:f.close

创办目录代码美高梅开户网址 12美高梅开户网址 13

glance/                   #Top-level package├── __init__.py      #Initialize the glance package├── api                  #Subpackage for api│   ├── __init__.py│   ├── policy.py│   └── versions.py├── cmd                #Subpackage for cmd│   ├── __init__.py│   └── manage.py└── db                  #Subpackage for db    ├── __init__.py    └── models.py

目录结构美高梅开户网址 14美高梅开户网址 15

#文件内容#policy.pydef get():    print('from policy.py')#versions.pydef create_resource:    print('from version.py: ',conf)#manage.pydef main():    print('from manage.py')#models.pydef register_models:    print('from models.py: ',engine)

文件内容

  在导入包时必须信守1个规格:凡是在导入时带点的,点的左手都无法不是1个包

from..import

亟待留意的是from后导入的模块,必须是妇孺皆知的多个不能够带点,不然会有语法错误

from glance.db import modelsmodels.register_models('mysql')from glance.db.models import register_modelsregister_models('mysql')

    假使未有,解释器则会寻找同名的内建模块,如若还从未找到就从sys.path给出的目录列表中相继寻找spam.py文件。

import

import glance.db.modelsglance.db.models.register_models('mysql') 

    所以总计模块的寻找顺序是:内部存款和储蓄器中已经加载的模块->内置模块->sys.path路径中含有的模块

__init__.py文件

    3.5编译python文件

  不管是哪个种类办法,只就算第二遍导入包依旧包的别的其余部分,都会挨个执行李包裹下的__init__.py文件,这些文件能够为空,不过也得以存在有的开始化包的代码

    为了抓好加载模块的快慢。python解释器会在__pycache__目录中下缓存种种模块编写翻译后的本子,格式为:
module.version.pyc。平时会包涵python的版本号。例如,在                  
   
CPython三.三版本下,spam.py模块会被缓存成__pycache__/spam.cpython-3三.pyc。这种命名规范保险了编译后的
              结果多版本共存。

fromglance.apiimport *

二、包

  此处是想从包api中程导弹全数,实际上该语句只会导入包api下__init__.py文件中定义的名字,我们得以在那些文件中定义__all__:

#在__init__.py中定义x=10def func():    print('from api.__init.py')__all__=['x','func','policy']

  包是一种通过利用‘.模块名’来公司python模块名称空间的艺术。

纯属导入和对峙导入

    相对导入:以glance作为开场

    相对导入:用.恐怕..的秘籍最棒开始(只幸好一个包中使用,无法用于区别的目录内)

    例如:我们在glance/api/version.py中想要导入glance/cmd/manage.py

在glance/api/version.py#绝对导入from glance.cmd import managemanage.main()#相对导入from ..cmd import managemanage.main()

  尤其需求专注的是:能够用import导入内置或然第贰方模块(已经在sys.path中),可是要绝对幸免使用import来导入自定义包的子模块(未有在sys.path中),应该选拔from…
import …的相对或然相对导入,且包的相对导入只可以用from的样式。

  1.
无论是import格局依旧from…import情势,凡是在导入语句中(而不是在动用时)遇到带点的,都要第临时间进步警觉:那是有关包才有的导入语法

  相对导入:

美高梅开户网址 16美高梅开户网址 17

glance/                   ├── __init__.py      from glance import api                             from glance import cmd                             from glance import db├── api                  │   ├── __init__.py  from glance.api import policy                              from glance.api import versions│   ├── policy.py│   └── versions.py├── cmd                 from glance.cmd import manage│   ├── __init__.py│   └── manage.py└── db                   from glance.db import models    ├── __init__.py    └── models.py绝对导入

纯属导入

  二.
包是目录级的(文件夹级),文件夹是用来组成py文件(包的原形便是2个涵盖__init__.py文件的目录)

  相对导入:

美高梅开户网址 18美高梅开户网址 19

glance/                   ├── __init__.py      from . import api  #.表示当前目录                     from . import cmd                     from . import db├── api                  │   ├── __init__.py  from . import policy                     from . import versions│   ├── policy.py│   └── versions.py├── cmd              from . import manage│   ├── __init__.py│   └── manage.py    from ..api import policy                        #..表示上一级目录,想再manage中使用policy中的方法就需要回到上一级glance目录往下找api包,从api导入policy└── db               from . import models    ├── __init__.py    └── models.py相对导入

相对导入

  3. import导入文本时,发生名称空间中的名字源于文件,import
包,发生的名号空间的名字如出一辙来自文件,即包下的__init__.py,导入包本质就是在导入该文件

  单独导入包

强调:

  单独导入包名称时不会导入包中全体包罗的全体子模块,如:

#在与glance同级的test.py中import glanceglance.cmd.manage.main()'''执行结果:AttributeError: module 'glance' has no attribute 'cmd''''

  一. 在python3中,即使包下未有__init__.py文件,import
包照旧不会报错,而在python第22中学,包下一定要有该公文,不然import 包报错

  消除办法:

#glance/__init__.pyfrom . import cmd#glance/cmd/__init__.pyfrom . import manage

  二.
开立包的目标不是为着运营,而是被导入使用,记住,包只是模块的一种样式而已,包即模块

  执行:

#在于glance同级的test.py中import glanceglance.cmd.manage.main()

  _init__.py文件

  importglance之后直接调用模块中的方法

美高梅开户网址 20美高梅开户网址 21

glance/                   ├── __init__.py     from .api import *                    from .cmd import *                    from .db import *    ├── api                  │   ├── __init__.py   __all__ = ['policy','versions'] │   ├── policy.py│   └── versions.py├── cmd               __all__ = ['manage']    │   ├── __init__.py│   └── manage.py    └── db                __all__ = ['models']                  ├── __init__.py    └── models.pyimport glancepolicy.get()import glance

View Code

  软件开发规范

美高梅开户网址 22

*  不管是哪一种办法,只假诺率先次导入包依旧是包的别的其余部分,都会挨个执行李包裹下的__init__.py文件(我们能够在各类包的公文内都打字与印刷一行内容来说明一(Wissu)(Dumex)下),那些文件可以为空,不过也能够存放一些早先化包的代码。*

*   2.2 from glance.api import \

*    在讲模块时,大家已经探究过了从二个模块内导入全部\,此处我们切磋从多个包导入全部*。

      此处是想从包api中程导弹入全数,实际上该语句只会导入包api下__init__.py文件中定义的名字,大家得以在那个文件中定义__all___:

   二.三 相对导入和相对导入

    导入和相对导入三种艺术:

    相对导入:以glance作为开局

    相对导入:用.也许..的点子最佳初步(只还好2个包中使用,无法用来不一样目录内)

    越发要求小心的是:能够用import导入内置也许第1方模块(已经在sys.path中),不过要断然制止采纳import来导入自定义包的子模块(没有在sys.path中),应该利用
                  from… import
…的断然或许相对导入,且包的相持导入只好用from的样式。

   2.四单身导入包

    单独导入包名称时不会导入包中全数包涵的全体子模块,如

 

 

 

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图