精华内容
下载资源
问答
  • as 别名5、from 模块名 import 方法名 as 别名注意:import可以在程序中的任意位置使用,第一次使用import关键字导入模块后,会将模块加载到内存中,后续针对同一模块的import不会重新执行模块内的语句。第一次导入...

    模块导入的五种方式

    1、import 模块名

    2、from 模块名 import 方法名

    3、from 模块名 import *

    4、import 模块名 as 别名

    5、from 模块名 import 方法名 as 别名

    注意:import可以在程序中的任意位置使用,第一次使用import关键字导入模块后,会将模块加载到内存中,后续针对同一模块的import不会重新执行模块内的语句。

    第一次导入模块执行的三件事

    1、创建一个以模块的名称空间

    2、执行这个名称空间里面的代码

    3、可以通过 模块名 '.'的方式引用模块内的变量、方法等。

    import与from…import导入的对比

    1、import需要通过点的方式来引用模块中的元素

    2、from…import是将原模块中的变量直接引入到现有空间,不需要通过点的方式来引用

    3、但是from…imort导入的这种方式会存在变量名冲突的问题

    from … import *

    把模块中所有的不是以下划线(_)开头的名字都导入到当前位置

    python文件的两种功能

    一个编写好的python文件可以有两种用途:用作脚本;用作模块

    脚本:一个文件就是整个程序,用来被执行

    模块:文件中存放着一堆功能,用来被导入使用

    在python中,为我们提供了一个全局变量 name

    当文件被当做脚本时执行时:name 等于’main’

    当文件被当做模块导入时:name 等于 模块名

    模块搜索路径

    模块的引用也是按照一定的顺序进行引用的

    这个顺序是:先从内存中已经加载好的模块寻找,如果没找到则从内置模块中查找,如果内置模块也找不到,那么接下来就去sys.path中路径包含的模块中寻找。如果还找不到就会报错

    注意python中import和from import 的区别

    首先明确:尽量不要为了图省事使用from xxx import *

    python中有两种导入模块的方式,一种是import xxx,另一种是from xxx import yyy,两者的区别在于,

    第一种仅仅导入一个模块,并且将该模块执行了一遍,if __main__ =="__main__"里面的没有执行。同时,有在当前的命名空间中导入变量,需要通过xxx.yyy的方式使用导入模块中的变量、函数、类等;

    第二种则将模块中的变量yyy导入了当前命名空间,因此使用时可以直接以yyy调用,使用这种导入方法时,需要注意当前的命名空间是否有重名的,from xxx import *这种方式尽量不要使用,因为这样就破坏了对命名空间的管理。

    ps:使用from xxx import *时是不能导入以单下划线开头的保护属性和以双下划线开头的私有属性的

    首先你要了解 import 与 from…import 的区别。

    import 模块:导入一个模块;注:相当于导入的是一个文件夹,是个相对路径。

    from…import:导入了一个模块中的一个函数;注:相当于导入的是一个文件夹中的文件,是个绝对路径。

    所以使用上的的区别是当引用文件时是:

    import //模块.函数

    from…import // 直接使用函数名使用就可以了

    所以

    from…import *:是把一个模块中所有函数都导入进来; 注:相当于:相当于导入的是一个文件夹中所有文件,所有函数都是绝对路径。

    结论:

    from…import *语句与import区别在于:

    import 导入模块,每次使用模块中的函数都要是定是哪个模块。

    from…import * 导入模块,每次使用模块中的函数,直接使用函数就可以了;注因为已经知道该函数是那个模块中的了。

    展开全文
  • import导入模块,每次使用模块中的函数都要是定是哪个模块。 from…import *导入模块,每次使用模块中的函数,直接使用函数就可以了;注因为已经知道该函数是那个模块中的了。 如: #Python 3.8.5 #from decimal...

    import 导入模块,每次使用模块中的函数都要是定是哪个模块。

    from…import * 导入模块,每次使用模块中的函数,直接使用函数就可以了;注因为已经知道该函数是那个模块中的了。

    如:

    #Python 3.8.5
    #from decimal import *
    import decimal #每次都要指定模块名称:decimal
    decimal.getcontext().prec = 50
    decimal.Decimal.from_float(12.222)
    
    from decimal import * #导入模块名称decimal下的所有函数
    #import decimal
    getcontext().prec = 50
    Decimal.from_float(12.222)
    展开全文
  • 2、为何要使用包包的本质就是一个文件夹,那么文件夹唯一的功能就是将文件组织起来随着功能越写越多,我们无法将所以功能都放到一个文件中,于是我们使用模块去组织功能,而随着模块越来越多,我们就需要用文件夹将...

    2、为何要使用包

    包的本质就是一个文件夹,那么文件夹唯一的功能就是将文件组织起来

    随着功能越写越多,我们无法将所以功能都放到一个文件中,于是我们使用模块去组织功能,而随着模块越来越多,我们就需要用文件夹将模块文件组织起来,以此来提高程序的结构性和可维护性

    3、注意事项

    #1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:凡是在导入时带点的,点的左边都必须是一个包,否则非法。可以带有一连串的点,如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。

    #2、import导入文件时,产生名称空间中的名字来源于文件,import 包,产生的名称空间的名字同样来源于文件,即包下的__init__.py,导入包本质就是在导入该文件

    #3、包A和包B下有同名模块也不会冲突,如A.a与B.a来自俩个命名空间

    4、上课流程

    1 实验一

    准备:

    执行文件为test.py,内容

    #test.py

    import aaa

    同级目录下创建目录aaa,然后自建空__init__.py(或者干脆建包)

    需求:验证导入包就是在导入包下的__init__.py

    解决:

    先执行看结果

    再在__init__.py添加打印信息后,重新执行

    2、实验二

    准备:基于上面的结果

    需求:

    aaa.x

    aaa.y

    解决:在__init__.py中定义名字x和y

    3、实验三

    准备:在aaa下建立m1.py和m2.py

    #m1.py

    def f1():

    print('from 1')

    #m2.py

    def f2():

    print('from 2')

    需求:

    aaa.m1 #进而aaa.m1.func1()

    aaa.m2 #进而aaa.m2.func2()

    解决:在__init__.py中定义名字m1和m2,先定义一个普通变量,再引出如何导入模块名,强调:环境变量是以执行文件为准

    4、实验四

    准备:在aaa下新建包bbb

    需求:

    aaa.bbb

    解决:在aaa的__init__.py内导入名字bbb

    5、实验五

    准备:

    在bbb下建立模块m3.py

    #m3.py

    def f3():

    print('from 3')

    需求:

    aaa.bbb.m3 #进而aaa.bbb.m3.f3()

    解决:是bbb下的名字m3,因而要在bbb的__init__.py文件中导入名字m3,from aaa.bbb import m3

    6、实验六

    准备:基于上面的结果

    需求:

    aaa.m1()

    aaa.m2()

    aaa.m3()

    进而实现

    aaa.f1()

    aaa.f2()

    aaa.f3()

    先用绝对导入,再用相对导入

    解决:在aaa的__init__.py中拿到名字m1、m2、m3

    包内模块直接的相对导入,强调包的本质:包内的模块是用来被导入的,而不是被执行的

    用户无法区分模块是文件还是一个包,我们定义包是为了方便开发者维护

    7、实验七

    将包整理当做一个模块,移动到别的目录下,操作sys.path

    二、包的使用

    1、示范文件

    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

    #文件内容

    #policy.py

    def get():

    print('from policy.py')

    #versions.py

    def create_resource(conf):

    print('from version.py: ',conf)

    #manage.py

    def main():

    print('from manage.py')

    #models.py

    def register_models(engine):

    print('from models.py: ',engine)

    包所包含的文件内容

    执行文件与示范文件在同级目录下

    2、包的使用之import

    1 import glance.db.models

    2 glance.db.models.register_models('mysql')

    单独导入包名称时不会导入包中所有包含的所有子模块,如:

    #在与glance同级的test.py中

    import glance

    glance.cmd.manage.main()

    '''

    执行结果:

    AttributeError: module 'glance' has no attribute 'cmd'

    '''

    解决方法:

    1 #glance/__init__.py

    2 from . import cmd

    3

    4 #glance/cmd/__init__.py

    5 from . import manage

    执行:

    1 #在于glance同级的test.py中

    2 import glance

    3 glance.cmd.manage.main()

    3、包的使用之from ... import ...

    需要注意的是from后import导入的模块,必须是明确的一个不能带点,否则会有语法错误,如:from a import b.c是错误语法

    1 from glance.db import models

    2 models.register_models('mysql')

    3

    4 from glance.db.models import register_models

    5 register_models('mysql')

    4、from glance.api import *

    在讲模块时,我们已经讨论过了从一个模块内导入所有*,此处我们研究从一个包导入所有*。

    此处是想从包api中导入所有,实际上该语句只会导入包api下__init__.py文件中定义的名字,我们可以在这个文件中定义__all___:

    1 #在__init__.py中定义

    2 x=10

    3

    4 def func():

    5 print('from api.__init.py')

    6

    7 __all__=['x','func','policy']

    此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容(versions仍然不能导入)。

    练习:

    #执行文件中的使用效果如下,请处理好包的导入

    from glance import *

    get()

    create_resource('a.conf')

    main()

    register_models('mysql')

    #在glance.__init__.py中

    from .api.policy import get

    from .api.versions import create_resource

    from .cmd.manage import main

    from .db.models import register_models

    __all__=['get','create_resource','main','register_models']

    5、绝对导入和相对导入

    我们的最顶级包glance是写给别人用的,然后在glance包内部也会有彼此之间互相导入的需求,这时候就有绝对导入和相对导入两种方式:

    绝对导入:以glance作为起始

    相对导入:用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)

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

    1 在glance/api/version.py

    2

    3 #绝对导入

    4 from glance.cmd import manage

    5 manage.main()

    6

    7 #相对导入

    8 from ..cmd import manage

    9 manage.main()

    测试结果:注意一定要在于glance同级的文件中测试

    1 from glance.api import versions

    6、包以及包所包含的模块都是用来被导入的,而不是被直接执行的。而环境变量都是以执行文件为准的

    比如我们想在glance/api/versions.py中导入glance/api/policy.py,有的同学一抽这俩模块是在同一个目录下,十分开心的就去做了,它直接这么做

    1 #在version.py中

    2

    3 import policy

    4 policy.get()

    没错,我们单独运行version.py是一点问题没有的,运行version.py的路径搜索就是从当前路径开始的,于是在导入policy时能在当前目录下找到

    但是你想啊,你子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入,比如我们在于glance同级下的一个test.py文件中导入version.py,如下

    1 from glance.api import versions

    2

    3 '''

    4 执行结果:

    5 ImportError: No module named 'policy'

    6 '''

    7

    8 '''

    9 分析:

    10 此时我们导入versions在versions.py中执行

    11 import policy需要找从sys.path也就是从当前目录找policy.py,

    12 这必然是找不到的

    13 '''

    7、 绝对导入与相对导入总结

    绝对导入与相对导入

    # 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入

    # 优点: 执行文件与被导入的模块中都可以使用

    # 缺点: 所有导入都是以sys.path为起始点,导入麻烦

    # 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入

    # 符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹

    # 优点: 导入更加简单

    # 缺点: 只能在导入包中的模块时才能使用

    #注意:

    1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内

    2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包

    展开全文
  • 20_Python-模块与包

    2019-06-05 19:51:43
    二、如何导入模块 当解释器遇到import语句,如果模块在当前的搜索路径就会被导入 1、为什么必须加上模块名调用呢? import 模块名.函数名 因为可能存在这样一种情况:在多个模块中含有相同名称的函数, 如果只是通过...

    一、模块

    模块就是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块
    在这里插入图片描述

    二、如何导入模块

    当解释器遇到import语句,如果模块在当前的搜索路径就会被导入
    在这里插入图片描述
    1、为什么必须加上模块名调用呢?
    import 模块名.函数名
    因为可能存在这样一种情况:在多个模块中含有相同名称的函数,
    如果只是通过函数名来调用,解释器无法知道到底要调用哪个函数。
    所以如果像上述这样引入模块的时候,调用函数必须加上模块名。

    2、如果只需要用到模块中的某个函数/变量/类,如何导入呢?
    from 模块名 import 函数/变量名
    通过这种方式引入的时候,调用函数时只能给出函数名,不能给出模块名,但是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入。

    3、如果导入的模块名/函数名/变量名过长,该如何操作呢?
    import 长模块名 as 短模块名
    from 模块名 import 长函数名 as 短函数名

    4、如果把一个模块的所有内容全部导入,如何操作呢?
    **from 模块名 import ***
    这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

    5、模块中的 __all__有什么作用?
    如果一个文件中有all变量,那么也就意味着这个变量中的元素,不会被from xxx import * 时导入

    三、如何定位模块?

    (1)导入一个模块,Python解析器对模块位置的搜索顺序是:

    1. 当前目录
    2. 如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。
    3. 如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/
    4. 模块搜索路径存储在system模块的sys.path变量中。

    四、包

    (1)包将有联系的模块组织在一起,有效避免模块名称冲突问题,让应用组织结构更加清晰。

    一个普通的python应用程序目录结构:
    在这里插入图片描述
    假设你现在想要设计一个模块集(一个“包”)来统一处理声音文件和声音数据。
    存在几种不同的声音格式(通常由它们的扩展名来标识,例如: .wav, .aiff, .au )
    于是,为了在不同类型的文件格式之间转换,你需要维护一个不断增长的包集合。
    可能你还想要对声音数据做很多不同的操作(例如混音,添加回声,应用平衡 功能,创建一个人造效果)
    所以你要加入一个无限流模块来执行这些操作。你的包可能会是这个样子(通过分级的文件体系来进行分组):

    (2)官方文档中的例子

    import sound.efforts.echo
    导入 sound.effects.echo 子模块。但必须通过完整的名称来引用

    from sound.effects import echo
    加载了 echo 子模块,且使得在没有包前缀的情况下也可以使用

    from sound.effects.echo import echofilter
    加载了 echo 字模块,但这样就可以直接调用它的 echofilter() 函数

    (3)从*导入包

    1、import * 理论上是希望文件系统找出包中所有的子模块,然后导入它们。But 会花长时间,并出现边界效应等。Python 解决方案是提供一个明确的包索引。
    这个索引由 init.py 定义 all 变量,该变量为一列表, 只会导入指定的内容

    五、模块的制作与发布

    1、模块制作
    (1)定义模块
    在Python中,每个Python文件都可以作为一个模块,模块的名字就是文件的名字。
    (2)调用模块
    (3)测试模块
    在实际开中,当一个开发人员编写完一个模块后,为了让模块能够在项目中达到想要的效果,这个开发人员会自行在py文件中添加一些测试信息。

    2、测试代码,应该是单独执行文件时才应该执行的,不应该是其他的文件中引用而执行, 如何解决这个问题呢?
    python在执行一个文件时有个变量 name
    可以根据__name__变量的结果能够判断出,是直接执行的python脚本还是被引入执行的,从而能够有选择性的执行测试代码.

    if   __name__=='__main__':
    	pass
    

    3、模块发布:准备发布
    (1). 为模块文件创建一个文件夹,并将模块文件复制到这个文件中(一般,文件夹的名字和模块的名字一样)

    (2). 在文件夹中创建一个名为『setup.py』的文件,内容如下:

    4、模块发布: 构建发布 & 发布预览
    (1)构建模块并一个发布文件

    python setup.py build
    python setup.py sdist
    

    (2)将发布安装到你的Python本地副本中:

    python setup.py install
    

    (3)发布预览

    展开全文
  • 它们两个的简单区别: import 模块:导入一个模块;注:相当于导入的是一个文件夹,是个... import 导入模块,每次使用模块中的函数都要是定是哪个模块。 from…import * 导入模块,每次使用模块中的函数,直接使
  • import 模块:导入一个模块;注:相当于导入的是一个文件夹,是个相对路径。...import 导入模块,每次使用模块中的函数都要是定是哪个模块。 from…import * 导入模块,每次使用模块中的函数,直接使用函数就可...
  • 导入模块或者模块中的元素要使用关键字________ 。下列哪个函数是用来控制画笔的尺寸的____________。下列语句的输出结果是:'___________'。>>>'abc'3如果我们使用了goto(0,0)的函数调用,请问执行该语句后,海龟的...
  • webpack中的require.context

    2019-06-26 17:29:00
    如果你的 request含有表达式(expressions),就会创建一个上下文(context),因为在编译时(compiletime)并不清楚具体导入哪个模块。 示例: require('./template/' + name + '.ejs'); webpack 解析 require() 调用,...
  • 【判断题】Python 3.x完全兼容Python 2.x。...(2.6分)【单选题】要显示模块math中的所有函数,使用的命令是:(2.0分)【填空题】假设已从标准库functools导入reduce()函数,那么表达式 reduce(lambd...
  • 15.2.7 使用cgi模块 15.2.8 简单的表单 15.3 更进一步:mod_python 15.3.1 安装mod_python 15.3.2 CGI处理程序 15.3.3 PSP 15.3.4 发布 15.4 网络应用程序框架 15.5 Web服务:正确分析 15.5.1 RSS和相关内容 15.5.2 ...
  • 实例044 使用常量指定PI的值计算圆的面积 75 2.2 运算符 75 实例045 自定义数字的加密/解密算法 76 实例046 比较两个时间戳的大小 77 实例047 使用条件运算符判断数字的奇偶性 78 实例048 判断用户是否具有后台管理...

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

导入模块使用哪个语句