七天学会Python基础-第七天3/3-自定义模块和random模块

Posted 2021-05-23 double大博

1. 自定义模块

   • 定义：

     • 什么是模块：

       • 本质就是.py文件，封装语句的最小单位。

         • 写一个模块

           \'\'\'
           对这个模块的注释
           自定义模块
           模块中出现的变量，for循环，if结构，函数的定义，称为模块成员
           \'\'\'
           # 可执行语句，变量的定义、函数的调用
           a=1
           print(a)
           for x in range(3):
               print(x)
           # 函数的定义
           def f():
               print(\'hello world\')
           

     • 什么是自定义文件：

       • 实际上就是定义的.py文件，其中可以包含：变量定义，可执行语句，for循环，函数定义等等。他们统称为函数的成员。

     • 一个模块不宜过大，通常在1000~2000行左右

   • 模块的运行方式：

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

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

     • __name__属性的使用：

       • 自定义模块的导入

         a.py

         \'\'\'
         对这个模块的注释
         自定义模块
         模块中出现的变量，for循环，if结构，函数的定义，称为模块成员
         \'\'\'
         # 可执行语句，变量的定义、函数的调用
         a=1
         print(a)
         for x in range(3):
             print(x)
         # 函数的定义
         def f():
             print(\'hello world\')
         f()
         

         test_import.py

         \'\'\'
         测试自定义模块的导入
         \'\'\'
         # 自定义模块被其他导入时，其中的可执行语句会立即执行
         import a
         

       • Python中提供了一种可以判断自定义模块是属于开发阶段还是使用阶段。

         print(__name__)
         # 以脚本运行时,显示固定的字符串
         # __main__ 
         # 以模块的方式运行时，就是本模块的名字
         if __name__ == \'__main__\':
             for x in range(3):
                 print(x)
         

       • 模块开发阶段，一般会自定义一个函数进行测试

         def main():
             for x in range(3):
             print(x)
         if __name__ == \'__main__\':
             main()
         

   • 使用自定义模块的成员

     import a
     import time
     print(a.a)
     a.f()
     print(time.time())
     

   • 系统在导入模块时的路径问题

     • 内存中：如果之前成功到如果某个模块，直接使用已经存在的模块

     • 内置路径中：Python安装路径下的Lib目录下，第三方模块放在Lib目录下的site-packages目录中

     • sys.path：是一个路径的列表，需要导入自己写的模块时，通常会修改这个列表，使用c语言集成在了解释器中。

       # 查看sys.path内容
       import sys
       print(sys.path)
       # 添加路径到sys.path
       sys.path.append(r\'E:\\A\\Programming\\py\\oldBoy833\\day02\') # 使用绝对路径
       --------------------------------------------------------------
       print(__file__)	# 当前文件的绝对路径
       # 使用os模块获取一个路径的父路径
       import os
       print(os.path.dirname(__file__)+\'/aa\')
       sys.path.append(os.path.dirname(__file__)+\'/aa\') # 使用相对路径
       

       • 如果三个路径都找不到，就报错

     • PYTHONPATH：import时寻找模块的路径（基本不会用）

   • 导入模块的多种方式：

     • import xxx：导入模块的全部成员
     • import aaa,bbb：一次性导入多个模块的成员。不推荐这种写法，分开写
     • from xxx import a：从某模块中导入指定的成员。较为节省空间
     • from xxx import a,b,c：从某个模块中导入多个成员
     • from xxx import *：从某个模块中导入所有

   • import xxx和from xxx import * 的区别

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

   • 怎么解决命名冲突的问题

     • 改用import xxx这种方式导入

     • 自己避免使用同名

     • 使用别名解决冲突（常用）

       • 使用别名(成员)：as（alias）

         # 使用别名来避免命名冲突-成员
         from my_module import age as a
         print(a)
         

       • 使用别名(模块)：

         # 给模块起别名
         import my_module as m
         print(m.age)
         m.f1()
         

   • from xxx import * 控制成员被导入__all__

     • 默认情况下，所有成员都会被导入
     • __all__是一个列表，用于表示本模块可以被外界使用的成员名。元素是成员名（变量名）组成的字符串。
     • __all__属性仅对from xxx import * 的导入方式生效，其余的方式都不生效，

   • 相对导入：

     • 只有一种格式：
       • from 相对路径 import xxx
         • 相对路径：包含了点号的一个相对路径
           • .表示的是当前路径
           • ..表示的是父路径
           • ...表示的是父路径的父路径
     • 子模块之间进行导入（多层模块导入），文件b调用了模块a，模块a中又调用了模块c
     • 相对导入同项目下的模块
       • from ..z import c # 容易向外界暴漏c模块
         • 在文件b中调用模块c中的方法或变量，print(a.c.age)
       • from ..z.c import *
         • 在文件b中调用模块c中的方法或变量，print(a.age)

2. 常用模块Ⅰ

   • 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个数据，组成一个列表返回，可实现变相打乱不可变数据类型