精华内容
下载资源
问答
  • python自定义模块模块引入

    千次阅读 2017-12-17 20:18:43
    到现在才知道怎么把自己写的模块加入到查找路径中,方便在使用过程中解释器能索引到自定义的模块 进入python环境中,首先引入sys模块:import sys 然后使用sys.path查询现有python解释器所查找的模块路径 书写...

    到现在才知道怎么把自己写的模块加入到查找路径中,方便在使用过程中解释器能索引到自定义的模块

    进入python环境中,首先引入sys模块:import sys

    然后使用sys.path查询现有python解释器所查找的模块路径

    书写自己的模块放置到一个文件夹下

    然后使用sys.path.append("my_model_path"),my_model_path就是自定义模块所存放的路径

    这样就可以在写程序的时候,通过import xxx来导入自定义的模块了,这是由于刚刚我们把我们的模块加入到解释器能识别的查找路径中去了


    展开全文
  • 怎么样把自己写的模块加入python默认就有的搜索路径中: 不用每次都import sys 再 sys.path.append("......") 找到python的安装目录 D:\python\Lib\site-packages ,必须以.pth为后缀,写上你要加入模块...

     

    怎么样把自己写的模块加入到python默认就有的搜索路径中:

    不用每次都import sys 再 sys.path.append("......")

    找到python的安装目录

    D:\python\Lib\site-packages

    ,必须以.pth为后缀,写上你要加入的模块文件所在的目录名称就是了。

    具体操作如下:

    1. 在site-packages添加一个路径文件,如mypkpath.pth

    2. 使用编辑器打开,比如我用的是notepad++, 写上你要加入的模块文件所在的目录名称,多个使用换行即可

    3. 检查是否成功,在python下>>>import sys    >>>sys.path

     

     

    转载于:https://www.cnblogs.com/cocowang68/p/8117163.html

    展开全文
  • Python 模块

    2020-08-30 11:32:54
    加入分了10个文件,每个文件里面可能都有相同的功能(函数),怎么办?所以将这些相同的功能封装到一个文件中,那么这个存储着很多常用的功能的py文件,就是模块模块就是文件,存放一堆常用的函数,谁用谁拿。...

    一、模块的定义与分类

    1.1 模块是什么

    一个函数封装一个功能,你使用的软件可能就是由n多个函数组成的(先备考虑面向对象)。比如抖音这个软件,不可能将所有程序都写入一个文件,所以咱们应该将文件划分,这样其组织结构要好并且代码不冗余。加入分了10个文件,每个文件里面可能都有相同的功能(函数),怎么办?所以将这些相同的功能封装到一个文件中,那么这个存储着很多常用的功能的py文件,就是模块。 模块就是文件,存放一堆常用的函数,谁用谁拿。怎么拿?比我们说一个函数就是一个功能,那么把一些常用的函数放在一个py文件中,这个文件就称之为模块,模块,就是一些常用功能的集合体。

    1.2 为什么要使用模块

    • 从文件级别组织程序,更方便管理 随着程序的发展,功能越来越多,为了方便管理,我们通常将程序分成一个个的文件,这样做程序的结构更清晰,方便管理。这时我们不仅仅可以把这些文件当做脚本去执行,还可以把他们当做模块来导入到其他的模块中,实现了功能的重复利用

    • 拿来主义,提升开发效率 同样的原理,我们也可以下载别人写好的模块然后导入到自己的项目中使用,这种拿来主义,可以极大地提升我们的开发效率,避免重复造轮子。

    • ps:人们常说的脚本是什么?

      • 如果你退出python解释器然后重新进入,那么你之前定义的函数或者变量都将丢失,因此我们通常将程序写到文件中以便永久保存下来,需要时就通过python test.py方式去执行,此时test.py被称为脚本script。所以,脚本就是一个python文件

    1.3 模块的分类

    Python语言中,模块分为三类。

    • 第一类:内置模块,也叫做标准库。此类模块就是python解释器给你提供的,比如我们之前见过的time模块,os模块。标准库的模块非常多(200多个,每个模块又有很多功能)

    • 第二类:第三方模块,第三方库。一些python大神写的非常好用的模块,必须通过pip install 指令安装的模块,比如BeautfulSoup, Django,等等。大概有6000多个。

    • 第三类:自定义模块。我们自己在项目中定义的一些模块。

    我们先定义一个模块,定义一个模块其实很简单就是写一个文件,里面写一些代码(变量,函数)即可。此文件的名字为module_one.py,文件内容如下:

    ### 当前是module_one.py文件,即被导入文件(模块)
    print('from the module_one.py file')
    name = '这是模块module_one!!'
    
    def read1():
        print('This is module_one模块中的read1()函数:',name)
    
    def read2():
        print('This is module_one模块中的read2()函数')
        read1()
    
    def change():
        global name
        name = '模块一中的变量name改名了(模块one)!! '
    

    二、import

    2.1 import 使用

    import 翻译过来是一个导入的意思。

    这里一定要给同学强调哪个文件是执行文件,和哪个文件是被执行模块。

    模块可以包含可执行的语句和函数的定义,这些语句的目的是初始化模块,它们只在模块名第一次遇到导入import语句时才执行(import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入,python的优化手段是:第一次导入后就将模块名加载到内存了,后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用,不会重新执行模块内的语句),如下 import module_one.py #只在第一次导入时才执行module_one.py内代码,此处的显式效果是只打印一次’from the module_one.py file’,当然其他的顶级代码也都被执行了,只不过没有显示效果.

    ### 当前是execute_module.py文件,这是执行文件,即导入其它模块的文件
    import  module_one
    import  module_one
    import  module_one
    import  module_one
    import  module_one
    # result
    from the module_one.py file #只是打印一次
    

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

    1. 创建一个以模块名命名的名称空间。
    2. 执行这个名称空间(即导入的模块)里面的代码。
    3. 通过此“模块名. ”的方式引用该模块里面的内容(变量,函数名,类名等)。 这个名字和变量名没什么区别,都是‘第一类的’,且使用module_one.名字的方式可以访问module_one.py文件中定义的名字。

    ps:重复导入会直接引用内存中已经加载好的结果

    2.3 被导入模块有独立的名称空间

    每个模块都是一个独立的名称空间,定义在这个模块中的函数,把这个模块的名称空间当做全局名称空间,这样我们在编写自己的模块时,就不用担心我们定义在自己模块中全局变量会在被导入时,与使用者的全局变量冲突。

    ### 当前是execute_module.py文件,这是执行文件,即导入其它模块的文件
    import  module_one
    name = '这是模块execute_module!!'
    print(name)
    print(module_one.name)
    '''
    from the module_one.py file
    这是模块execute_module!!
    这是模块module_one!!
    '''
    
    def read1():
        print(666)
    module_one.read1()
    '''
    from the module_one.py file
    This is module_one模块中的read1()函数: 这是模块module_one!!
    '''
    
    name = '这是模块execute_module!!'
    module_one.change()
    print(name)
    print(module_one.name)
    '''
    from the module_one.py file
    这是模块execute_module!!
    模块一中的变量name改名了(模块one)!!
    '''
    

    2.4 为模块起别名

    别名其实就是一个外号,我们小的时候,都喜欢给学生们起外号对吧。

    • 好处可以将很长的模块名改成很短,方便使用

      import module_one as m_o
      m_o.read1()
      '''
      from the module_one.py file
      This is module_one模块中的read1()函数: 这是模块module_one!!
      '''
      
    • 有利于代码的扩展和优化。

      # mysql.py
      def db():
          print('this is mysql db!')
      #oracle.py
      def db():
          print('this is oracle db!')
      #test.py
      db_type = input('>>: ')
      if db_type == 'mysql':
          import mysql as db
      elif db_type == 'oracle':
          import oracle as db
      db.db()
      '''
      >>: oracle
      this is oracle db!
      '''
      

    2.5 导入多个模块

    import os,sys,json   # 这样写可以但是不推荐
    
    # 推荐写法
    import os
    import sys
    import json
    

    多行导入:易于阅读 易于编辑 易于搜索 易于维护。

    三、 from … import …

    3.1 from … import … 使用

    ### 当前是execute_module.py文件,这是执行文件,即导入其它模块的文件
    from module_one import name
    from module_one import read1
    print(name)
    read1()
    '''
    from the module_one.py file
    这是模块module_one!!
    This is module_one模块中的read1()函数: 这是模块module_one!!
    '''
    

    3.2 from…import… 与import对比

    唯一的区别就是:使用from…import…则是将spam中的名字直接导入到当前的名称空间中,所以在当前名称空间中,直接使用名字就可以了、无需加前缀:module_one.

    from…import…的方式有好处也有坏处

    • 好处:使用起来方便了
    • 坏处:容易与当前执行文件中的名字冲突

    示例演示:

    • 执行文件有与模块同名的变量或者函数名,会有覆盖效果

      def read1():
          print(000000)
      name = '666'
      from module_one import name
      from module_one import read1
      print(name)
      read1()
      '''
      from the module_one.py file
      这是模块module_one!!
      This is module_one模块中的read1()函数: 这是模块module_one!!
      '''
      
      from module_one import name
      from module_one import read1
      name = '666'
      def read1():
          print(000000)
      print(name)
      read1()
      '''
      666
      0
      '''
      
    • 当前位置直接使用read1和read2就好了,执行时,仍然以tbjx.py文件全局名称空间

      from module_one import read1
      name = '666'
      read1()
      '''
      from the module_one.py file
      This is module_one模块中的read1()函数: 这是模块module_one!!
      '''
      
      from module_one import read2
      def read1():
          print('666')
      read2()
      '''
      from the module_one.py file
      This is module_one模块中的read2()函数
      This is module_one模块中的read1()函数: 这是模块module_one!!
      '''
      
      from module_one import read1 as read
      read()
      '''
      from the module_one.py file
      This is module_one模块中的read1()函数: 这是模块module_one!!
      '''
      

    3.3 一行导入多个

    from module_one import read1,read2,name
    

    3.4 from … import *

    from spam import * 把tbjx中所有的不是以下划线(_)开头的名字都导入到当前位置

    大部分情况下我们的python程序不应该使用这种导入方式,因为*你不知道你导入了什么名字,很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差,在交互式环境中导入时没有问题。

    可以使用__all__来控制*(用来发布新版本),在module_one.py中新增一行

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

    3.5 模块循环导入问题

    模块循环/嵌套导入抛出异常的根本原因是由于在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 "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/aa.py", line 1, in <module>
        import m1
      File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
        from m2 import y
      File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/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.py抛出异常
    正在导入m1
    正在导入m2
    正在导入m1
    Traceback (most recent call last):
      File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
        from m2 import y
      File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
        from m1 import x
      File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/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 import y,由于m1已经被导入过了,所以无需继续导入而直接问m2要y,然而y此时并没有存在于m2中所以报错
    
    
    
    # 解决方法:
    方法一:导入语句放到最后
    #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文件在不同的应用场景下执行不同的逻辑(或者是在模块文件中测试代码)

    ### 当前是module_one.py模块,即被导入文件(模块)
    print('from the module_one.py file')
    name = '这是模块module_one!!'
    
    def read1():
        print('This is module_one模块中的read1()函数:',name)
    
    def read2():
        print('This is module_one模块中的read2()函数')
        read1()
    
    def change():
        global name
        name = '模块一中的变量name改名了(模块one)!!'
    __all__ = ['read1','change']
    if __name__ == '__main__':
        '''
         # 在模块文件中测试read1()函数
         # 此模块被导入时 __name__ == module_one 所以不执行下面的read1()       
        '''
        read1()
    
    ### execute_module.py
    import module_one
    print(__name__) # 本文件
    module_one.read1()
    print(module_one.__name__) # 被导入文件
    '''
    from the module_one.py file
    __main__
    This is module_one模块中的read1()函数: 这是模块module_one!!
    module_one
    '''
    

    五、模块的搜索路径

    当你引用一个模块时,不见得每次都可以import到:

    上面的示例可以得知,引用模块也是按照一定规则进行引用的。

    Python中引用模块是按照一定的规则以及顺序去寻找的,这个查询顺序为:先从内存中已经加载的模块进行寻找找不到再从内置模块中寻找,内置模块如果也没有,最后去sys.path中路径包含的模块中寻找。它只会按照这个顺序从这些指定的地方去寻找,如果最终都没有找到,那么就会报错。

    内存中已经加载的模块->内置模块->sys.path路径中包含的模块

    模块的查找顺序

    1. 在第一次导入某个模块时(比如module_one),会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存),如果有则直接引用(ps:python解释器在启动时会自动加载一些模块到内存中,可以使用sys.modules查看)
    2. 如果没有,解释器则会查找同名的内置模块
    3. 如果还没有找到就从sys.path给出的目录列表中依次寻找module_one.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文件,因此一定要事先创建他们,来避免加载模块是性能下降。
    

    六、包

    6.1 什么是包

    官网解释
    Packages are a way of structuring Python’s module namespace by using “dotted module names”
    包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

    具体的:包就是一个包含有_init_.py文件的文件夹,所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

    需要强调的是:

       1. 在python3中,即使包下没有\__init__.py文件,import 包仍然不会报错,而在python2中,包下一定要有该文件,否则import 包报错
      2. 创建包的目的不是为了运行,而是被导入使用,记住,包只是模块的一种形式而已,包的本质就是一种模块
    

    6.2 为何要使用

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

    6.3 注意事项

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

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

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

    6.4 包的使用

    6.4.1 示例文件

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LGdtnytH-1598758242753)(../../Typora/Image/image-20200829140107272.png)]

    6.4.2 文件内容

    #文件内容
    
    #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)
    

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OEuOPDMt-1598758242766)(../../Typora/Image/image-20200829141854103.png)]

    import glance.db.models
    glance.db.models.register_models('mysql')
    '''
    from models.py:  mysql
    '''
    

    6.4.3 包的使用之import

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

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

    解决方法:

    #glance/__init__.py
    from . import cmd
    
    #glance/cmd/__init__.py
    from . import manage
    '''
    from manage.py
    '''
    

    执行:

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

    6.4.4 包的使用之from … import …

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

    from glance.db import models
    models.register_models('oracle')
    '''
    from models.py:  oracle
    '''
    from glance.db.models import register_models
    register_models('MongoDB')
    '''
    from models.py:  MongoDB
    '''
    

    6.4.5 from glance.api import *

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

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

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

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

    from glance.api import *
    print(x)
    func()
    policy.get()
    
    '''
    66
    from api.__init__.py
    from policy.py
    '''
    

    练习:

    #执行文件中的使用效果如下,请处理好包的导入
    from glance import *
    get()
    create_resource('a.conf')
    main()
    register_models('oracle')
    '''
    from policy.py
    from version.py a.conf
    from manage.py
    from models.py:  oracle
    '''
    
    #在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']
    

    6.4.6 绝对导入和相对导入

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

    绝对导入:以glance作为起始

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

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

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

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

    # 在execute_module.py中
    from glance.api import versions
    '''
    from manage.py
    '''
    

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

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

    import policy
    policy.get()
    '''
    from policy.py
    '''
    

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

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

    from glance.api import versions
    
    '''
    执行结果:
    ImportError: No module named 'policy'
    '''
    
    '''
    分析:
    此时我们导入versions在versions.py中执行
    import policy需要找从sys.path也就是从当前目录找policy.py,
    这必然是找不到的
    '''
    

    6.4.7 绝对导入与相对导入总结

    绝对导入与相对导入
    
    # 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入
    #        优点: 执行文件与被导入的模块中都可以使用
    #        缺点: 所有导入都是以sys.path为起始点,导入麻烦
    
    # 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入
    #        符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹
    #        优点: 导入更加简单
    #        缺点: 只能在导入包中的模块时才能使用
          #注意:
            1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内
            2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包
    
    展开全文
  • 学习python不久,碰到个问题,怎么样把自己写的模块加入python默认就有的搜索路径中呢?不要每次非得 ? 1 2 import sys; sys.path.append(’/home/tony/tst-python

    zz : http://www.osgeo.cn/post/1801.html


    学习python不久,碰到个问题,怎么样把自己写的模块加入到python默认就有的搜索路径中呢?不要每次非得

    ?
    1
    2
    import sys;
    sys.path.append(’/home/tony/tst-python’)

    才可。 上网找了很多久未果,都来我自己糊里糊涂找到了解决方法,那就是在dist-packages即( usr / local /lib /python 2.6 /dist-packages)添加一个路径文件,如mypkpath.pth,必须以.pth为后缀,写上你要加入的文件名称就是了,如我的: /home/tony/tst-python 保存退出,OK!结果自己验证,重启terminal,再次打开python,

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    >>> import sys
    >>> sys.path
        ['', '/usr/lib/python2.6', '/usr/lib/python2.6/plat-linux2', '/usr/lib/python2.6/lib-tk',
         '/usr/lib/python2.6/lib-old', '/usr/lib/python2.6/lib-dynload', '/usr/lib/python2.6/dist-packages',
        '/usr/lib/python2.6/dist-packages/PIL', '/usr/lib/python2.6/dist-packages/gst-0.10',
        '/var/lib/python-support/python2.6', '/usr/lib/python2.6/dist-packages/gtk-2.0',
        '/var/lib/python-support/python2.6/gtk-2.0', '/usr/lib/python2.6/dist-packages/wx-2.6-gtk2-unicode',
        '/usr/local/lib/python2.6/dist-packages', '/home/tony/tst-python', '/usr/local/lib/python2.6/dist-packages']

    展开全文
  • Python添加默认模块搜索包路径

    千次阅读 2016-07-10 15:29:46
    怎么样把自己写的模块加入python默认就有的搜索路径中呢?不要每次非得import sys; sys.path.append(‘/home/fightlikekobe/python’)才可。 上网找了很多久未果,都来我自己糊里糊涂找到了解决方法,那就是在d
  • 小白怎么加入学习行列?Python是目前互联网行业比较火爆的编程语言之一,应用广泛,就业前景广。值得一提的是Python入门简单,即使零基础也能学会,但考虑到学习效率以及学习效果,越来越多的人加入学习行列。接下来...
  • 然后在代码中把test_package的文件的路径加入python解释器可以搜索到的路径列表中。 2、了解Collection模块,编写程序以查询给定列表中最常见的元素。 题目说明: 输入:language = [‘PHP’, ‘PHP’, ‘Python’...
  • python logging模块 之日志等级

    千次阅读 2018-12-28 11:34:53
    今日想在程序中加入更好用的日志功能,利用到了logging模块,直接从网上抄了代码,无奈怎么也输出不了日志 import logging # 获取一个logger对象 logger = logging.getLogger(__name__) #logger.setLevel...
  • ubuntu下面怎么样把自己写的模块加入python默认就有的搜索路径中呢?不要每次非得 import sys sys.path.append(‘/home/fightlikekobe/python’)才可。那就是在dist-packages(即/usr/local/lib/python2.7/dist-...
  • 一定要注意 Colab 中加入自己的模块后第一次运行后 ,如果对模块改名 还是用原来的名进行调用,用改后的模块名调用会报错 但运行改名后的 .ipynb .py文件还是可以的 且导入的模块只能是.py结尾 (暂时知道的是这样) ...
  • 我在ubuntu14.04下用python中的matplotlib模块内的pyplot输出图片不能显示中文,怎么解决呢? 解决: 1.指定默认编码为UTF-8: 在python代码开头加入如下代码 import sys reload(sys) sys....
  • Windows下安装Python 模块的三种方法

    千次阅读 2019-06-20 10:22:49
    首先打开windows上的cmd命令行窗口,再将目录切换到python运行的那个目录下,那怎么查看自己是在那个目录下呢? 鼠标右键点击file,依次点开就可以看到运行路径。在cmd中输入: cd /dD:\py_project\code\class_...
  • anaconda的使用方法:1、执行【conda create...3、执行【conda install】命令安装模块。前提:已经将anaconda加入到系统环境变量中。使用方法介绍:1、打开cmd,创建conda虚拟python环境;命令:conda create -n stu...
  • python学习交流群点击即可加入 最近在学习python,不过有一个正则表达式一直搞不懂,自己直接使用最笨的方法写出了一个百度爬虫,只有短短16行代码。 首先安装模块: pip3 install bs4 pip3 install requests 安装...
  • 1. 前言 本文的文字及图片来源于网络,仅供学习、交流使用,...在实际工作中,为了保证项目进度,我们经常需要针对部分未完成模块及不稳定模块采用 Mock 方式,以验证已开发完的模块 本篇文章将介绍 Python 实现 Moc..
  • 这几天学习了selenium 模块的使用方法,今天我就来说说怎么用这个模块来实现远程关机。   准备的东西: chromedriver,selenium模块 将chromedriver.exe放在python环境下 Path 进行编辑,在变量值后面加入 ...
  • 我们在自己写python模块的时候,怎么样把自己写的模块加入python默认就有的搜索路径中呢?不要每次非得import sys; sys.path.append(‘/home/uestc/researchDocuments/caffeNotebookExamples/’)才可。 解决办法...
  • MoviePy是一个用于视频编辑的python模块,你可以用它实现一些基本的操作(比如视频剪辑,视频拼接,插入标题),实现视频合成,也可以用它加入一些自定义的高级的特效。 MoicePy支持的格式:*.mp4 *.wmv *.rm *.avi...
  • (2)在代码中把test_package的文件的路径加入python解释器可以搜索到的路径列表中,这里就用到了python的包sys模块。 2、了解Collection模块,编写程序以查询给定列表中最常见的元素。 (1)namedtuple():可命名...
  • python免费学习资料以及群交流解答点击即可加入 开发工具 python 3.6.5 pycharm import pdfkit import requests import parsel 相关模块可pip安装 1、获取每篇文章的url地址 如果你不知道怎么写css选择器,不...
  • Python版无重复文件名-带时间戳

    千次阅读 2018-08-21 21:59:53
    在工作中经常会给临时文件起名字,因为担心重复命名,所以有时候都不...Python提供了time模块,该模块中有一个叫time()的函数,它返回从UTC时间开始后的秒数(一种以Unix为参考的时间,起始时间为1970.01.01),可以...
  • 学习Python中有不明白推荐加入交流Q群号:701698587 群里有志同道合的小伙伴,互帮互助, 群里有不错的视频学习教程和PDF! 环境与模块介绍完毕后,就可以来实行我们的操作了。 第一步: 进入淘宝首页: ..
  • 比如说,你有一个客户管理系统,最开始的时候,只有一个查看客户列表的功能,后来你又加入了一个添加客户的功能(add_user)模块, 然后又加入了一个删除客户的功能(del_user)模块,然后又加入了一个修改客户的功能(up_user)...
  • 前言 本文的文字及图片来源于...怎么Python 给程序加个进度条呢? 可以采用以下五种方式: 1、使用time模块,结合python的基础语法(循环、条件判断、字符串格式化)设计进度条 import time for i in range(0, 101,
  • 最近再看Python数据处理,看的有点头疼,想着换个脑子,便写了这个在大神看来比较简易的小说下载的爬虫,输入小说的名字就可以下载小说,并显示小说的章节数量以及下载完成的时间,期间也是来回修改了几次,本来还想...
  • 创建无重复的文件名后,解决了重复命名的问题,不过文件名后面带一串数字还是让人觉得不舒服,怎么不舒服?就是没有哪种“所见即所得”的感觉。 为此我准备在文件名中加入日期。比如原来的文件名叫test,在test后加入...
  • http://outofmemory.cn/python/video/let-us-python/python为程序员服务快来加入群【python爬虫交流群】(群号570070796),发现精彩内容。 一下三个模块完美的实现了模块之间的参数传递。 1、将编写好的代码设置成...
  • 请问 分模块来写要怎么解决这个问题 案例demo ``` # a.py from astar_mesmanager.test.b import change aa = 1 print(aa) print(change()) -------- # b.py def change(): global aa aa = ...
  • Python 之 ImportError: No module named ***

    千次阅读 2015-08-06 20:38:36
    如果想使用非当前模块中的代码,需要使用Import,这个大家都知道。...但是如果要import一个不同目录的文件(例如b.py)该怎么做呢?  首先需要使用sys.path.append方法将b.py所在目录加入到搜素目录中。然后进
  • 首先,import与from import导入模块的操作,python解释器是通过什么来...所有要想导入自定义的模块,必须确保自定义的模块的路径在sys.path列表里面,那么怎么将我们自己的路径加入到系统列表里面的,方法有两种: ...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

python怎么加入模块

python 订阅