威尼斯人线上娱乐

【威尼斯人线上娱乐】模块和包,python之块包导入

6 4月 , 2019  

1.怎么样是模块

  2个模块正是1个包含了python定义和注解的文件,文件名便是模块名字加上.py的后缀

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

    1.应用pytho编写的代码(.py文件)

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

    三.包好1组模块的包

    四.使用C编写并链接到python解释器的放手模块

一丶模块

模块

1、什么是模块?

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

  壹运用python编写的代码

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

  3包好①组模块的包

  四采取C编写并链接到python解释器的松开模块

2、为何要运用模块?

假若您退出python解释器然后重新进入,那么你在此之前定义的函数或许变量都将遗失,由此大家数见不鲜将顺序写到文件中以便永久保存下来,须求时就因此python
test.py格局去实践,此时test.py被称之为脚本script。

乘势程序的上扬,功效更是多,为了方便管理,大家普通将顺序分成3个个的文件,那样做程序的结构更清晰,方便管理。那时大家不但能够把那几个文件作为脚本去实施,还足以把她们作为模块来导入到其余的模块中,完成了成效的双重使用,

三、如何行使模块?

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

一、模块

2.如何协调写七个模块

    创立2个py文件,给它起二个相符变量命名规则的名字,那个名字正是模块名

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

import

率先,自定义3个模块my_module.py,文件名my_module.py,模块名my_module

威尼斯人线上娱乐 1威尼斯人线上娱乐 2

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

my_module

在import1个模块的长河中,发生了哪些事情?

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

从地点的结果能够看看,import三个模块的时候一定于履行了这一个模块,而且三个模块是不会再一次被导入的,只会导入3次(python解释器第二遍就把模块名加载到内部存款和储蓄器中,之后的import都只是在相应的内部存款和储蓄器空间中追寻。)成功导入1个模块后,被导入模块与公事之间的命名空间的标题,就改为接下去要搞了解的概念了。

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

若果当前文件也有一个变量为:
name = ‘local file’, 也有二个同名的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模块的时候发生了上面包车型地铁几步:

  1、先找找模块

  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

办法二:壹行导入八个模块,模块之间通过逗号“,”来分隔

import os, sys, my_module

可是,依照PEP8规范规定使用第3种办法,并且三种模块有先后顺序(内置>第2方>自定义)

# 根据PEP8规范import osimport djangoimport my_module

模块搜索路径

通过sys内置模块,大家清楚sys.path存款和储蓄了有着模块的门径,可是寻常的sys.path的门路中除去内置模块,第1方模块所在的门道之外,唯有2个路径是恒久正确的,就是当前执行的文本所在目录。叁个模块是还是不是能够被导入,就取决于那么些模块所在的目录是或不是在sys.path中。

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

在第三回导入有些模块时(比如my_module),会先反省该模块是还是不是已经被加载到内部存储器中(当前执行文书的称谓空间对应的内部存储器),固然有则直接引用

若果未有,解释器则会寻找同名的内建立模型块,倘诺还不曾找到就从sys.path给出的目录列表中相继寻找my_module.py文件。

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

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

模块金华昆本

运转二个py文件有二种格局,不过这二种实施措施之间有1个肯定的歧异,就是__name__。

  一、已脚本的秘籍进行:cmd中“python
xxx.py” 只怕pycharm等IDE中施行

    __name__ =
‘__main__’

  二、导入模块时举行:import模块,会履行该模块。

    __name__ =
模块名

唯独,当您有三个py文件既能够作为脚本执行,又足以看成模块提要求任何模块引用时,那时作为模块需求导入时而不彰显多余的打字与印刷逻辑/函数调用,所以那个逻辑能够置身“if __name__ = ‘__main__’: xxx”
代码块中。

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

  一、什么是模块

三.模块的导入

  导入三个模块正是进行贰个模块

  模块导入的经过中生出了什么样:

    壹.找到这么些模块

    二.论断那几个模块是还是不是被导入过了

    三.一旦没有被导入过:

      创造3个属于这些模块的命名空间

      让模块的名字指向那个空间

      执行那一个模块中的代码

  给模块起别称:起了外号之后,就只可以使用这么些模块的外号引用变量了

  导入四个模块:

    import os,time

  规范提出:

    模块应该贰个二个的导入:

      内置模块

      扩展(第三方)模块

      自定义模块

  from  import  

    模块导入的历程中发出了何等:

      一.找到要被导入的模块

      二.论断那些模块是还是不是被导入过

      3.万1那几个模块没被导入过

        成立叁个属于那一个模块的命名空间

        执行那么些文件

        找到要导入的变量

        给导入的变量创造3个引用,指向要导入的变量

 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一也许read2,那么会有覆盖效果

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不可能被导入

模块引用中的情况:模块之间不容许循环引用

  3个模块正是富含了Python定义和注明的公文,文件名正是模块名字加上.py的后缀

from … import …

from…import是另一种导入模块的样式,假如你不想每回调用模块的靶子都添加模块名,就能够利用那种措施。

在from … import
… 的进度中发生了如何事儿?

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

  一、寻找模块

  二、假使找到模块,在内部存款和储蓄器中开发1块内部存款和储蓄器空间,从上至下进行模块

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

  四、建立贰个变量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样,仅仅看做2个python文件的后缀名。

  pyc文件:
python解释器为了增强加载模块的进程,会在__pycache__目录中变化模块编写翻译好的字节码文件,并且相比较修改时间,唯有模块改变了,才会重新编写翻译。pyc文件仅仅用于节省了运营时间,可是并无法增进程序的实践作用。

  模块的导入和改动*

【威尼斯人线上娱乐】模块和包,python之块包导入。  一.导入模块后,模块就曾经被加载到内部存款和储蓄器中,此后测算对模块实行更改,读取的内容照旧内部存款和储蓄器中原来的结果。

  二.如若想让改动生效,能够经过“from
importlib import reload”, 供给’reload
模块名’重新加载模块,改动才生效。

  模块的循环使用
****

  谨记模块的导入必须是单链的,不可能有轮回引用,假使存在循环,那么便是先后设计存在难点。

  dir
***

  能够赢得该模块中具有的名字,而且是字符串类型的,就能够透过反射去实施它。

    常见的情景:贰个模块正是3个分包了python定义和注解的公文,文件名就是模块名字加上.py的后缀。

肆.模块的加载与修改

  每种模块只被导入三遍,放入到sys.modules中,要是改变了模块中的内容,必须重启程序

  但实质上import加载的模块分为多少个通用项目:

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

甭管import格局依然from
… import
方式,凡是在导入语句中遭受带点的,都要第一时间升高警觉:那是关于包才有的导入语法

包是目录级的,文件夹是用来组合py文件(包的真面目即是三个饱含__init__.py文件的目录)

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

  注意:

    壹、在python三中,即便包下未有__init__.py文件,import包照旧不会报错,而在python2中,包下一定要有该公文,不然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文件:直接运转这些文件,这几个文件便是三个剧本

    导入这几个文件,那些文件便是1个模块

当一个py文件:

  当做叁个本子的时候:能够独立的提供1个效率,能独立完成交互

  当成多少个模块的时候,能够被导入那调用这几个意义,无法自主交互

2个文书中的__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导入的模块,必须是远近有名的叁个不能够带点,不然会有语法错误,如: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文件)

6.模块搜索路径

  在率先次导入有个别模块时,会先反省该模块是或不是早已被加载到内部存款和储蓄器中(当前实施文书的名称空间对应的内存),假若有则平昔引用,若是未有,解释器则会寻找同名的内建立模型块,倘使还从未找到就从sys.path给出的目录列表中相继寻找这几个模块

由此模块的检索顺序是:内存中已经加载的模块->内置模块->sys.path路径中含有的模块

 

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

一贯导入包

如假诺一向导入多个包,那么一定于履行了那些包中的__init__文件

并不会帮您把这些包下边包车型客车别的包以及py文件自动的导入到内部存款和储蓄器

倘使你期望平昔导入包之后,全数的那一个包上面包车型大巴别的包以及py文件都能一直通过包来调用,那么要求你协调解和处理理__init__文件。

__init__.py文件

不管是哪类艺术,只倘诺第1回导入包照旧是包的别样别的部分,都会相继执行包下的__init__.py文件;这一个文件能够为空,不过也足以存放一些开首化包的代码。

纯属导入和相持导入

我们的最超级包glance是写给外人用的,然后在glance包内部也会有相互之间相互导入的须要,这时候就有绝对导入和相持导入三种办法:

相对导入:以glance作为开局

争执导入:用. 恐怕..
的不二秘籍作为初阶(只可以在贰个包中使用,不可能用来不一样目录内)

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

绝对导入:    既然导入包就是执行包下的__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.包

  1.文书夹中有二个__init__.py文件

  二.是多少个模块的联谊

  3.无论是import情势依旧from..import情势,凡是在导入语句中(而不是在运用时)境遇带点的,那是有关包才有的导入语法

  4.包是目录级的(文件夹级),文件夹是用来组成py文件(包的本来面目正是3个带有__init__.py文件的目录)

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

  陆.导入贰个包也正是实践了那么些包上面包车型地铁__init__.py文件

关于包相关的导入语句也分为import和from..import..两种,但不管哪一种,在什么岗位,都依据三个规范:

      凡是在导入时带点的,点的右侧都不可能不是三个包

对于导入后,在选拔时就平素不那种范围了,点的左侧可以是包,模块,函数,类(他们都得以用点的章程调用本身的性质)

纯属导入:

  在履行叁个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组模块的包

    3 包好一组模块的包

    四.应用C编写并链接到Python解释器的放权模块

    四 运用C编写并链接到python解释器的放到模块

import

  2、为啥要动用模块

  fromimport导入的经过中发出了怎么着事儿?

    就算你退出python解释器然后再次进入,那么你以前定义的函数或许变量都将遗失,因而大家壹般将次第写到文件中以便永久保存下去,要求时就通过python
test.py方式去执            行,此时test.py被称作脚本script。

  1.找到要被导入的模块

           
随着程序的向上,成效越多,为了方便管理,大家层出不穷将先后分成3个个的文书,那样做程序的构造更清楚,方便管理。那时大家不光可以把这么些文件作为脚本去履行,
         还足以把她们作为模块来导入到其余的模块中,实现了意义的双重利用

  二.判断这一个模块是不是被导入过

  3、怎么样行使模块

  3.要是那么些模块没被导入

    3.1 import

    创立一个属于那几个模块的命名空间

    示例文件: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

    找到您要导入的变量

    三.一.壹 模块只在模块名第一次遇上导入import语句时才实施(import语句是足以在程序中的任意地方运用的,且针对同2个模块很import多次,为了幸免你再度导入,python的优化
             
 手段是:第一遍导入后就将模块名加载到内部存储器了,后续的import语句仅是对已经加载大内部存款和储蓄器中的模块对象扩展了一遍引用,不会再次履行模块内的说话)

    给您要导入的变量创立三个引用,指向您要导入的变量

#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 每一种模块都以三个单独的名号空间,定义在那些模块中的函数,把那么些模块的称呼空间作为全局名称空间,那样大家在编辑本人的模块时,就无须操心大家定义在融洽模块
          中全局变量会在被导入时,与使用者的全局变量争论

  导入四个模块

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

  叁.1.3计算:第二次导入模块spam时会做叁件事:

  from..import

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

    1.为源文件(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'''

    2.在新创造的命名空间中履行模块中蕴藏的代码,见开端导入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>'''

    3.开立名字spam来引用该命名空间

  __all__能约束*导入的变量的剧情

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

        叁.1.四 为模块名起小名

  把模块当做脚本执行

    import spam as sm

  当一个py文件

    叁.1.伍在1行导入三个模块

    当做叁个剧本的时候:可以独立的提供2个功用,能自主完结交互

    import sys,os,re

    当成三个模块的时候,能够被导入那几个调用那一个功能,不能够自主交互

    3.2  from…import…

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

    三.2.一 相比较import
spam,会将源文件的称谓空间’spam’带到当前名称空间中,使用时务必是spam.名字的格局

  当做脚本运维:

               而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不可能被导入

  模块搜索路径

    三.二.五 思虑到品质的缘故,每种模块只被导入一回,放入字典sys.module中,借使您改变了模块的始末,你必须重启程序,python不帮助再度加载或卸载此前导入的模块,

  Python解释器在运维时会活动加载1些模块,能够动用sys.modules查看

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

  在率先次导入有些模块时(比如my_module),会先反省该模块是不是早已被加载到内部存款和储蓄器中,假设有则间接引用,借使未有,解释器则会招来同名的内建立模型块,如若还不曾找到就送sys.path给出的目录列表中逐条寻找my_module.py文件

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

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

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

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

  编译Python文件

    当做模块导入:
    __name__=

    一.比方是在命令中被直接导入模块,则依据那种办法,每便导入都会再也编写翻译,并且不会储存编写翻译后的结果

    功能:用来控制.py文件在不一致的利用场景下举办不一的逻辑
    if __name__ == ‘__main__’:

    贰.若是源文件不设有,那么缓存的结果也不会被利用,假若想在并未有源文件的景况下来使用编译后的结果,则编写翻译后的结果必须在源目录下

    3.四模块搜索路径

  dir()函数

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

  内建函数dir是用来探寻模块中定义的名字,再次回到三个一如既往字符串列表.假使未有参数,dir()列举出当下定义的名字

import my_moduledir(my_module)

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

二丶包

  一.无论是import格局依然from…import格局,凡是在导入语句中相见带点的,都要第权且间进步警惕:那是关于包才有的导入语法

  二.包是目录级的,文件夹是用来构成py文件(包的面目正是三个包含__init__.py文件的目录)

  三.import导入文本时,爆发名称空间中的名字来自文件,import包,发生的名目空间的名字1样来自文件,即包下的__init__.py,导入包的真面目便是在导入该公文

  强调:

  一.在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个条件:凡是在导入时带点的,点的左手都不可能不是多少个包

from..import

内需注意的是from后导入的模块,必须是醒指标2个不能够带点,不然会有语法错误

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文件

  不管是哪个种类办法,只若是第二回导入包依旧包的别样其余1些,都会挨个执行李包裹下的__init__.py文件,这一个文件能够为空,可是也足以存在一些开端化包的代码

    为了增加加载模块的速度。python解释器会在__pycache__目录中下缓存各类模块编写翻译后的版本,格式为:
module.version.pyc。常常会蕴藏python的版本号。例如,在                  
   
CPython三.3本子下,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作为开场

    相对导入:用.只怕..的章程最棒初始(只可以在2个包中使用,不能够用于分化的目录内)

    例如:大家在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方式,凡是在导入语句中(而不是在应用时)蒙受带点的,都要第2时半刻间升高警惕:那是关于包才有的导入语法

  相对导入:

威尼斯人线上娱乐 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文件(包的原形正是多个富含__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相对导入

周旋导入

  三. import导入文本时,产生名称空间中的名字来自文件,import
包,发生的名目空间的名字一样来自文件,即包下的__init__.py,导入包本质正是在导入该公文

  单独导入包

强调:

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

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

  一. 在python三中,即便包下未有__init__.py文件,import
包照旧不会报错,而在python2中,包下一定要有该公文,不然import 包报错

  消除格局:

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

  2.
创设包的目标不是为了运行,而是被导入使用,记住,包只是模块的一种样式而已,包即模块

  执行:

#在于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文件(大家能够在各个包的公文内都打字与印刷一行内容来说明一下),那些文件能够为空,然则也足以存放一些开头化包的代码。*

*   2.2 from glance.api import \

*    在讲模块时,大家早已探究过了从二个模块内导入全部\,此处大家研商从1个包导入全部*。

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

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

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

    相对导入:以glance作为初叶

    相对导入:用.或许..的不二法门最佳初始(只可以在三个包中使用,不能够用来分化目录内)

    尤其供给注意的是:能够用import导入内置可能第二方模块(已经在sys.path中),不过要相对制止采纳import来导入自定义包的子模块(未有在sys.path中),应该利用
                  from… import
…的相对可能相对导入,且包的相对导入只可以用from的格局。

   贰.四独门导入包

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

 

 

 

 

 


相关文章

发表评论

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

网站地图xml地图