当前位置：移动技术网 > IT编程>脚本编程>Python > 自定义模块

自定义模块

2019年05月19日 | 移动技术网IT编程 | 我要评论

七合圣石战记银月之翼,吉增·佩玛,散文诗杂志

自定义模块

自定义模块：

什么是模块：本质就是.py文件，是封装语句的最小单位。

自定义模块：实际上就是定义 . py ,其中可以包含：变量定义，可执行语句，if结构，for循环，函数定义等等，他们统称模块的成员。

模块的运行方式：

脚本方式：直接用解释器执行。或者pycharm中右键运行。

#自定义模块：（a1.py）--->以脚本方式直接运行
    # 可执行语句
    age = 10
    print(age)

    for x in range(3):
         print(x)

    # 函数定义
    def f1():
        print('hello world')
    f1()

    print(__name__)

    #结果：
    10
    0
    1
    2
    hello world
    __main__  #注意同下面的区别

模块方式：被其他的模块导入。为导入它的模块提供资源（变量，函数定义，类定义等）。

#1：
#自定义模块：（a1.py）--->被其他模块导入
    # 可执行语句
    age = 10
    print(age)

    for x in range(3):
         print(x)

    # 函数定义
    def f1():
        print('hello world')
    f1()

    print(__name__)

 #测试自定义模块的导入： (test.py 该py文件 与 a1.py 在同一个目录下)
  import a1  #import不会导致a1中的不可执行语句（函数定义，类定义等）立刻执行，会导致可执行语句立即执行。仅仅通过该句不能判断a1中没有不可执行语句。

    #运行结果：   #【问题】自定义模块被其他模块导入时，其中的可执行语句会立即执行
    10
    0
    1
    2
    hello world
    a1  #注意同上面的区别，是被导入模块的名字

#2：
  #自定义模块：（a1.py）--->被其他模块导入
    age = 10

    # 函数定义
    def f1():
        print('hello world')

  #测试自定义模块的导入： (test.py 该py文件 与 a1.py 在同一个目录下)
  import a1

    print(a1.age) #使用自定义模块的成员  模块名.变量名

    a1.f1()       #使用自定义模块的成员

    print(a1.__name__)  #使用自定义模块的成员

    #结果：
    10
    hello world
  a1

`name`属性的使用：

在脚本方式运行时，__name__是固定的字符串：__main__

在以模块方式被导入时，__name__就是本模块的名字。

在自定义模块中对__name__进行判断，决定是否执行可执行语句：开发阶段，就执行，被导入使用阶段就不执行。

自定义模块中,通常不会直接包含可以执行的打印语句,循环语句等,而是包含一些变量,函数,类的定义.这些统
称为模块的成员.
自定义模块中,把对模块成员的测试代码放到一个单独的函数中(通常起名为main).根据__name__ 属性的值决
定是否执行这个测试函数.

 #自定义模块：（a1.py）--->以脚本方式直接运行【开发阶段】
    
    age = 10

    # 函数定义
    def f1():
        print('hello world')

    # 测试函数（定义一个函数，包含测试语句），在开发阶段，对本模块中的功能进行测试。
    def main():
        print(age)
        for x in range(3):
            print(x)
        f1()
        print(__name__)
    #python中提供一种可以判断自定义模块是属于开发阶段还是使用阶段。决定是否执行可执行语句：开发阶段，就执行，使用阶段就不执行 
    if __name__ == '__main__':
        main()#可执行语句会执行
    #结果;
    10
    0
    1
    2
    hello world
    __main__
    
    
  #测试自定义模块的导入： (test.py 该py文件 与 a1.py 在同一个目录下，同一个路径下)
    import a1
    
    #test.py以脚本方式运行，什么都不显示，可执行语句没有执行。

系统导入模块的路径

导入一个模块时：（import xxx 去哪些路径寻找模块xxx？）

内存中：如果之前成功导入过某个模块，会拿过来直接使用已经存在的模块。（如果两次导入同一个模块，如果第一次导入成功，第二次导入时就不会再导入）
内置路径中：安装路径下：lib （如果内存中没有，就去内置路径下寻找）
pythonpath: import 时寻找模块的路径。
sys.path：是一个路径的列表。（如果在内存中和内置路径下都没找到某个模块，就回去sys.path这个列表里去找）【列表可修改】

如果上面都找不到，就报错。

有三种解决方案:

把我们自定义的模块放到系统默认的路径中,例如:d:\mysoft\python36\lib
在环境变量中定义pythonpath,在其中保存被导入模块的路径.
手动修改sys.path表示的列表.将自定义的模块的路径添加到其中.
第一种方案并不好,因为会污染系统自带的模块库.

第二种方案也不好,因为系统环境变量的改变会影响到其他的项目.

通常的做法是采用第三种方案.即不会污染系统内置路径也不会影响其他项目.只在当前项目中有效.

问题：两个py文件在同一个路径下，可以进行模块导入。系统自带的模块，也可以导入。但是，如果两个py文件不在同一路径下，直接引用模块就会报错。modulenotfounderror: no module named 'a1'
解决：导入自己写的模块时，通常会修改sys.path，在列表中添加一个路径，把要导入模块a1.py的路径添加到sys.path中。

可以通过动态修改sys.path列表的方式将自定义模块添加到sys.path中。

#测试自定义模块的导入（test.py）
    查看sys.path内容，系统查找模块的路径。
    import sys
    print(sys.path)#是一个列表，第一个元素是当前脚本所在的路径：'d:\\python22\\day15'，第二个元素是当前项目的路径 'd:\\python22'，如果脚本和项目之间有多级路径，路径不会在该列表中
    
    #1:（有缺陷）
        添加a1.py所在的绝对路径到sys.path中
        import sys
        sys.path.append(r'd:\python_22\day15\aa') #这个是绝对路径，如果项目路径修改了，比如不在d盘了，就不能成功导入了
        import a1
        print(a1.age)#10  说明导入成功
    #2：找到a1.py相对于当前脚本文件test.py的相对路径。a1.py和test.py在同一项目下，相对路径不会变。
        使用相对位置找到aa文件夹，首先要知道当前文件的路径
        print(__file__) #d:/python22/day15/test.py  当前文件的绝对路径
         # 使用os模块获取一个路径的父路径，
          os.path.dirname():获取某个路径的父路径。通常用于获取当前模块的相对路径
      
        import os   #用于找到要添加的路径
        print(os.path.dirname(__file__))#d:/python22/day15    当前模块的相对路径
        print(os.path.dirname(__file__)+ '/aa')#d:/python22/day15/aa  因为test.py和aa文件夹在同一文件夹day15下，a1.py在aa文件夹下，所以test.py的相对路径 + aa 就得到了a1.py的相对路径
       #
       import os   
       import sys  #用于添加寻找到的路径
       sys.path.append(os.path.dirname(__file__) + '/aa')
       print(sys.path)# 列表的最后一个元素是：'d:/python22/day15/aa'，说明a1的相对路径添加到了sys.path
       import a1
       print(a1.age)#10  说明导入成功

     #总结：   
        import sys
        import os
        sys.path.append(os.path.dirname(__file__) + '/aa')

导入模块的多种方式：

import xxx:导入一个模块的所有成员
import aaa,bbb:一次性导入多个模块的成员。不推荐这种写法，建议分开写。
from xxx import a:从某个模块中导入指定的成员。
from xxx import a,b,c:从某个模块中导入多个成员。

from xxx import *:从模块中导入所有成员。

#自定义模块：（a1.py）--->被其他模块导入
    age = 10

    # 函数定义
    def f1():
        print('hello world')

#测试自定义模块的导入： (test.py 该py文件 与 文件夹aa 在同一个目录下,a1.py 在 aa 目录下)
    # 把自定义模块的路径添加到sys.path中
    import os
    import sys
    sys.path.append(os.path.dirname(__file__) + '/aa')

    # 使用import xxx(模块名) 导入
     age = 1000
     import a1
     print(a1.age)#10

    # 使用from xxx（模块名） import age（成员名） 的方式导入
     age = 1000
     from a1 import age
   print(age)#10

import xxx 和 from xxx import * 的区别

第一种方式在使用其中成员时，必须使用模块名作为前缀。不容易产生命名冲突。

第二种方式在使用其中成员时，不用使用模块名作为前缀，直接使用成员名即可。但是容易产生命名冲突。在后面定义的成员生效（把前面的覆盖了。）

怎么解决名称冲突的问题

改用import xxx这种方式导入。---> 必须使用模块名作为前缀。不容易产生命名冲突
自己避免使用同名
使用别名解决冲突

使用别名：alias

给成员起别名，避免名称冲突。
- from my_module import age as a
给模块起别名，目的简化书写。
- import my_module as m

    
    #自定义模块：（a1.py）--->被其他模块导入
        age = 10

        # 函数定义
        def f1():
            print('hello world')
    
    
    #测试自定义模块的导入： (test.py 该py文件 与 文件夹aa 在同一个目录下,a1.py 在 aa 目录下)
        # 把自定义模块的路径添加到sys.path中
        import os
        import sys
        sys.path.append(os.path.dirname(__file__) + '/aa')

        # 成员使用别名避免命名冲突
        from a1 import age as a
        age = 1000
        print(age)#1000
        print(a)#10

        # 给模块起别名
        import a1 as m
        print(m.age)#10

from xxx import * 控制成员被导入

默认情况下，所有的成员都会被导入。

__all__是一个列表，用于表示本模块可以被外界使用的成员。元素是成员名的字符串。

注意：

__all__只是对 from xxx import * 这种导入方式生效。其余的方式都不生效。

#自定义模块  （a1.py）--->被其他模块导入

    # 使用__all__控制被导入的成员
    __all__ = [
        'age1',
        'age2',
    ]

    age1 = 10
    age2 = 20
    age3 = 30
    
#测试自定义模块的导入： (test.py 该py文件 与 文件夹aa 在同一个目录下,a1.py 在 aa 目录下)
    import os
    import sys
    sys.path.append(os.path.dirname(__file__) + '/aa')

    # 验证__all__控制的成员
    from a1 import *
    print(age1)#10
    print(age2)#20
    print(age3)#nameerror: name 'age3' is not defined


    # 使用如下方式，可以绕过__all__的限制
    import a1 as m
    print(m.age1)#10
    print(m.age2)#20
    print(m.age3)#30

相对导入

针对某个项目中的不同模块之间进行导入，称为相对导入。相对导入方式通常是用在一个路径(包)的多个子模块互相导入时使用。外界使用这个包中的某个模块时,并不知道这个模块内部是否导入了其他模块。

只有一种格式：

from 相对路径 import xxx

相对路径：包含了点号的一个相对路径。

. 表示的是当前的路径。

..表示的是父路径。

...表示的是父路径的父路径。

#1 相对导入同项目下的模块：
      # from . import abc             # 导入同路径下的abc模块
      # from ..z import zz            # 容易向外界暴露zz模块，不使用此方式
      
     from ..z.zz import *  （使用此方式导入）

#2 不使用相对导入的方式，导入本项目中的模块，通过当前文件的路径找到z的路径
        import os
        import sys
        sys.path.append(os.path.dirname(os.path.dirname(__file__)) + '/z')
        from zz import * （使用此方式导入）
        #import zz  容易向外界暴露zz模块，不使用此方式

#1:  
    模块1：
    #项目中，子模块  (zz.py)  d:/python22/day15/xx/z/zz.py
        age = 10
        def f():
            print('hello')
    
    模块2：在模块2中导入了模块1，模块3不直接导入模块1，模块3导入模块2之后，就可以使用模块1和模块2
    #此模块作为对外引用的入口 (yy.py) d:/python22/day15/xx/y/yy.py
  
        # 相对导入同项目下的模块
        #from ..z import zz             # 容易向外界暴露zz模块，不使用此方式
        from ..z.zz import *        #【使用此方式相对导入同项目下的模块】

        # 定义自己的成员
        age2 = 888
        def f2():
            print('f2')
    
    模块3：
    #测试相对导入  test.py） d:/python22/day15/test.py

        from xx.y import yy
        print(yy.age2)#888
        yy.f2()#f2
        
        #模块2中使用 from ..z import zz  导入zz模块时才可以，否则会报错。但是容易暴露zz，所以相对导入不使用 from ..z import zz 
        print(yy.zz.age)#10
        yy.zz.f()#hello

        #模块2中使用 from ..z.zz import *  导入zz模块时才可以，否则会报错。使用此方式相对导入同项目下的模块
        print(yy.age)#10
        yy.f()#hello

        
   
#2:
    模块1：
    #项目中，子模块  (zz.py)  d:/python22/day15/xx/z/zz.py
        age = 10
        def f():
            print('hello')

    模块2：在模块2中导入了模块1，模块3不直接导入模块1，模块3导入模块2之后，就可以使用模块1和模块2
    #此模块作为对外引用的入口 (yy.py) d:/python22/day15/xx/y/yy.py
 
       # 不使用相对导入的方式，导入本项目中的模块。通过当前文件的路径找到z的路径。
         import os
         import sys
         sys.path.append(os.path.dirname(os.path.dirname(__file__)) + '/z')    #将zz的相对路径添加到sys.pah中： yy.py 的父路径为 y ,y 的父路径为 xx, xx 下的 z，即为 zz 的相对路径
         from zz import *   #在模块 yy 中导入了 模块zz

        # 定义自己的成员
        age2 = 888
        def f2():
            print('f2')
     
    模块3：
    #测试相对导入 （test.py） d:/python22/day15/test.py

        from xx.y import yy  #from 相对路径 import xxx  导入xx文件夹下的y文件夹下的yy.py模块的所有成员
        print(yy.age2)#888
        yy.f2()#f2
        
        #模块2中使用 from zz import * 导入zz模块时才可以，否则会报错
        print(yy.age)#10
        yy.f()#hello
        
        #模块2中使用 import zz 导入zz模块时才可以，否则会报错。【容易向外界暴露zz模块】
        print(yy.zz.age)#10
        yy.zz.f()#hello
        
        
    #自测试--模块3：
        from xx.y.yy import *   #导入xx文件夹下的y文件夹下的yy.py模块的所有成员
        
        #注：模块2中使用 from zz import * 导入zz模块
        print(age2)  #888     #age2,f2,age,f前面不能再加yy
        f2()         #f2

        print(age) #10
        f()        #hello

        
        在模块1（zz.py）和模块2（yy.py）不变的情况下，模块3（test.py）的路径改变，放到aa文件夹下 #d:/python22/day15/aa/test.py
        
        #要想成功导入模块2（使用模块1和模块2），需要把xx文件夹的相对路径添加到sys.path
            import os
            import sys
            # 把项目所在的父路径加到sys.path中
            sys.path.append(os.path.dirname(os.path.dirname(__file__))) #__file__ 是test.py的绝对路径，os.path.dirname(__file__)是其父路径，os.path.dirname(os.path.dirname(__file__))是其父路径的父路径，同时也是xx的父路径。
            print(os.path.dirname(os.path.dirname(__file__)))#d:/python22/day15

            #from day15.xx.y import yy  使用此句添加模块yy，就不用了上面的3行语句了。
            
            from xx.y import yy
            print(yy.age2)#888
            yy.f2()#f2

            print(yy.age)#10
            yy.f()#hello

常用模块：random

此模块提供了和随机数获取相关的方法：

random.random():获取[0.0,1.0)范围内的浮点数
random.randint(a,b):获取[a,b]范围内的一个整数
random.uniform(a,b):获取[a,b)范围内的浮点数
random.shuffle(x):把参数指定的数据中的元素打乱。参数必须是一个可变的数据类型。无返回值

random.sample(x,k):从x中随机抽取k个数据，组成一个列表返回。有返回值

import random
# 获取[0.0,1.0)范围内的浮点数
print(random.random())  #0.3255954890152818
#
# # 获取[a,b)范围内的浮点数
print(random.uniform(3,5))#4.683774922271366
#
# # 获取[a,b]范围内的一个整数
print(random.randint(3,10))#4

lst = list(range(10))
random.shuffle(lst)
print(lst)#[8, 3, 0, 9, 5, 1, 4, 6, 2, 7]

t = (1,2,3)
# random.shuffle(t)
# 通过sample变相实现打乱
lst = random.sample(t,len(t))
print(lst)#[1, 3, 2]

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！点击进行留言回复

python如何查看网页代码

用python查看网页代码的方法：1、使用“import”导入requests包import requests2、使用requests包的get()函数通过网页... [阅读全文]
Python如何用wx模块创建文本编辑器

用python的wx模块创建文本编辑器的方法：1、设置按钮的位置import wxapp = wx.app()win = wx.frame(none,title... [阅读全文]
python如何保存文本文件

python保存文本文件的方法：使用python内置的open()类可以打开文本文件，向文件里面写入数据可以用write()函数，写完之后，使用close()函... [阅读全文]
python如何编写win程序

python可以编写win程序。win程序的格式是exe，下面我们就来看一下使用python编写exe程序的方法。编写好python程序后py2exe模块即可将... [阅读全文]
Python替换NumPy数组中大于某个值的所有元素实例

我有一个2d(二维) numpy数组，并希望用255.0替换大于或等于阈值t的所有值。据我所知，最基础的方法是：shape = arr.shaperesult ... [阅读全文]
使用Numpy对特征中的异常值进行替换及条件替换方式

原始数据为excel文件，由传感器获得，通过pyhton xlrd模块读入，读入后为数组形式，由于其存在部分异常值和缺失值，所以便利用numpy对其中的异常值进... [阅读全文]
Python 实现将numpy中的nan和inf,nan替换成对应的均值

nan：not a numberinf：infinity;正无穷numpy中的nan和inf都是float类型t!=t 返回bool类型的数组(矩阵)np.co... [阅读全文]
给ubuntu18安装python3.7的详细教程

参考文章准备工作安装工具sudo apt updatesudo apt upgradesudo apt install gccsudo apt install ... [阅读全文]
python爬虫把url链接编码成gbk2312格式过程解析

1. 问题　　抓取某个网站，发现请求参数是乱码格式，这是点击 textview，发现请求参数如下图所示3. 那么=%b9%fa%ce%f1%d4%ba%b7%a... [阅读全文]
pyecharts在数据可视化中的应用详解

使用pyecharts进行数据可视化安装 pip install pyecharts也可以在pycharm软件里进行下载pyecharts库包。下载成功后进行查... [阅读全文]