模块、自定义模块

一、模块

1. 定义：一个模块就是一个py文件。这个模块存储很多相似的功能,相似的函数的集合体.
2. 模块的分类：
   • 内置模块
   • 第三方模块
   • 自定义模块
3. import
   • import 导入的意思
4. 第一次导入模块执行的三件事
   • 将tbjx.py文件加载到内存.
   • 在内存中创建一个以tbjx命名的名称空间.
   • 通过tbjx名称空间的名字.等方式引用此模块的名字(变量,函数名,类名等等)
5. 被导入模块有独立的名称空间

   坑:通过tbjx.的方式引用此模块的名字时,一定一定是从此模块中寻找.
   
   通过import 引用模块 他有自己的独立名称空间,与当前执行文件没有关系.
   
   name = '李业'
   print(tbjx.name)
   
   def read1():
       print('in 02 模块import')
   
   tbjx.read1()

6. 为模块起别名

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

     import tbjx as t
     t.read1()

   • 有利于代码的扩展和优化。

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

7. 导入多个模块

   在一个文件中，导入多个模块，推荐写法是一个一个导入。

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

二、from ... import ...

1. from ... import ... 使用

   from ... import ... 的使用示例。
   
   from tbjx import name, read1
   print(name)
   read1()
   '''
   执行结果：
   from the tbjx.py
   太白金星
   tbjx模块： 太白金星
   ?
   '''

2. from...import... 与import对比

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

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

   ? 好处：使用起来方便了

   ? 坏处：容易与当前执行文件中的名字冲突

   示例演示：

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

   name = 'oldboy'
   from tbjx import name, read1, read2
   print(name)
   '''
   执行结果：
   太白金星
   '''
   ----------------------------------------
   from tbjx import name, read1, read2
   name = 'oldboy'
   print(name)
   ?
   '''
   执行结果：
   oldboy
   ?
   '''
   ----------------------------------------
   def read1():
       print(666)
   from tbjx import name, read1, read2
   read1()
   ?
   '''
   执行结果：
   tbjx模块： 太白金星
   '''
   ----------------------------------------
   ?
   from tbjx import name, read1, read2
   def read1():
       print(666)
   read1()
   ?
   '''
   执行结果：
   tbjx模块： 666
   '''

   当前位置直接使用read1和read2就好了，执行时，仍然以tbjx.py文件全局名称空间

   #测试一：导入的函数read1，执行时仍然回到tbjx.py中寻找全局变量 'alex'
   #test.py
   from tbjx import read1
   name = 'alex'
   read1()
   '''
   执行结果:
   from the spam.py
   spam->read1->name = '太白金星'
   '''
   ?
   #测试二:导入的函数read2，执行时需要调用read1(),仍然回到tbjx.py中找read1()
   #test.py
   from tbjx import read2
   def read1():
       print('==========')
   read2()
   ?
   '''
   执行结果:
   from the tbjx.py
   tbjx->read2 calling read
   tbjx->read1->tbjx 'barry'
   '''
       4.3.3 也支持as
   
   通过这种方式引用模块也可以对模块进行改名。
   
   from tbjx import read1 as read
   read()

3. 一行导入多个

   from tbjx import read1,read2,name

4. from ... import *

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

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

   可以使用all来控制*（用来发布新版本），在tbjx.py中新增一行

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

三、py文件的两种功能

1. 编写好的一个python文件可以有两种用途：
   一：脚本，一个文件就是整个程序，用来被执行（比如你之前写的模拟博客园登录那个作业等）
   二：模块，文件中存放着一堆功能，用来被导入使用
   ?
   python为我们内置了全局变量__name__，
   当文件被当做脚本执行时：name 等于‘main‘
   当文件被当做模块导入时：__name__等于模块名
   ?
   #作用：用来控制.py文件在不同的应用场景下执行不同的逻辑（或者是在模块文件中测试代码）

   if __name__ == '__main__':![img]

   print('from the tbjx.py')
   
   __all__ = ['name', 'read1',]
   
   name = '太白金星'
   
   def read1():
      print('tbjx模块：',name)
   
   def read2():
      print('tbjx模块')
      read1()
   
   def change():
   
      global name
      name = 'barry'
   
   if __name__ == '__main__':
      # 在模块文件中测试read1()函数
      # 此模块被导入时 __name__ == tbjx 所以不执行
      read1()

四、模块的搜索路径

1. 寻找模块的路径: 内存 ----> 内置模块 ---> sys.path中找

   只要这三个地方:内存 内置模块 sys.path可以找到这个引用的模块的路径,这个模块就可以直接引用到

2. 手动添加路径，来引用其他模块

   ? sys.path.append(r‘D:\s23\day15‘)

原文地址：https://www.cnblogs.com/cuixiaoying/p/11104814.html