3.1-自定义模块

自定义模块

模块的定义与分类

什么是模块

一个函数封装一个功能，使用的软件是由多个函数组成的（先不考虑面向对象）。比如抖音这个软件，不可能将所有程序都写入一个文件，所以应该将文件划分。这样其组织结构更好，并且代码不冗余。加入分了10个文件，每个文件里面可能都有相同的功能（函数），可以将这些相同的功能封装到一个文件中，这个存储着很多功能的py文件，就是模块。模块就是文件，存放一堆常用的函数，谁用谁拿。

把一些常用的函数放在一个py文件中，这个文件就称之为模块，模块就是一系列常用功能的集合体；

为什么使用模块

从文件级别组织程序，更方便管理；随着程序的发展，功能越来越多，为了方便管理。通常将程序分为一个个的文件，这样做程序的机构更清晰，方便管理。这时不仅可以把这些文件当做脚本去执行，还可以当做模块来导入到其他的模块中，实现了功能的重复利用；
拿来主义，提高开发效率；可以下载别人写好的模块导入到自己的项目中使用，可以极大地提升开发效率，避免重复造轮子；

ps：脚本是什么：

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

模块的分类

python语言中，模块分为三类

第一类：内置模块，也叫作标准库。此类模块是由python解释器提供的，比如time，os，（200多个);
第二类：第三方模块，第三方库。一些python大神写好的模块，必须通过pip install安装的模块，比如BeautfulSoup， Django （6000多个）；
第三类：自定义模块；我们自己在项目中定义的一些模块；

先定义一个模块，定义一个模块其实就是写一个文件，里面写一些代码（函数，变量）即可

print('from the test.py')
name = '黑色利穆'

def read1():
    print('test模块', name)

def read2():
    print('test模块')
    read1()

def change():
    global name
    name = '白色利穆'

import

import使用

import就是导入

模块可以包含可执行语句和函数的定义，这些语句的目的是初始化模块，他们只在模块名第一次导入impor语句时才执行（import语句是可以在程序中的任意位置使用的，且针对同一个模块很多次import，为了防止重复导入，python优化手段是：第一次导入后就将模块名加载到内存里，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句）。

如下：import test.py 只在第一次导入时才执行test.py中的代码，此处的显示效果是只打印一次，其他顶级代码也都被执行了，只不过没有显示效果

import test
import test
import test
import test
import test
# 执行结果，只打印一次
# from the test.py

第一次导入模块三件事

创建一个以模块名命名的名称空间；
执行这个名称空间（即导入的模块）里面的代码；
通过此模块名.的方式引入该模块里面的内容（变量，函数名，类名等）。这个名字和变量名没有区别，都是第一类的。且使用 test.名字的方式可以访问test.py文件中定义的名字， test.名字与test.py 中的名字来自两个完全不同的地方；

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

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

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

import test
name = '红色利穆'
print(name)
print(test.name)
'''
from the test.py
红色利穆
黑色利穆
'''

def read1():
    print(777)
read1()
test.read1()
# from the test.py
# 777
# test模块 黑色利穆

name = '绿色利穆'
test.change()
print(name)
print(test.name)
# from the test.py
# 绿色利穆
# 白色利穆

为模块起别名

可以将很长的模块名改成很短，方便使用；
有利于代码的扩展和优化；

import test as t
t.read1()
# from the test.py
# test模块 黑色利穆

#mysql.py
def sqlparse():
    print('from mysql sqlparse')

#oracle.py
def sqlparse():
    print('from oracle sqlparse')

# meet.py
db_type = input(">>>:")
if db_type == 'mysql':
    import mysql as db
elif db_type == 'oracle':
    import oracle as db

db.sqlparse()
'''
>>>:mysql
from mysql sqlparse

>>>:oracle
from oracle sqlparse
'''

导入多个模块

在之后的开发过程中，会在一个文件中导入多个模块，推荐写法是一个一个导入；

import os, sys, json    # 可以但是不推荐


import os
import sys
import json
# 多行导入：易于阅读，易于编辑，易于搜索，易于维护；

from ... import ...

from ... import ...使用

from test import name, read1
print(name)
read1()
# from the test.py
# 黑色利穆
# test模块 黑色利穆

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

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

优点：使用起来方便了；
缺点：容易与当前执行文件中的名字冲突；

执行文件有与模块同名的变量或函数名，会有覆盖效果；
当前位置直接使用read1和read2就好了，执行时，仍然以test.py文件全局名称空间；

# test.py
print('from the test.py')
name = '黑色利穆'

def read1():
    print('test模块', name)

def read2():
    print('test模块')
    read1()

def change():
    global name
    name = '白色利穆'

name = '炫彩利穆'
from test import name, read1, read2
print(name)
# from the test.py
# 黑色利穆


from test import name, read1, read2
name = '炫彩利穆'
print(name)
# from the test.py
# 炫彩利穆


def read1():
    print(123123)
from test import name, read1, read2
read1()
# from the test.py
# test模块 黑色利穆


from test import name, read1, read2
def read1():
    print(123123)
read1()
# from the test.py
# 123123

# 测试一：导入函数read1，执行时任然回到test.py中寻找全局变量、
from test import read1
name = 'meet中的黑色利穆'
read1()
# from the test.py
# test模块 黑色利穆


# 测试一：导入函数read2，执行时需要调用read1(), 任然回到test.py中寻找read1()、
from test import read2
name = 'meet中的黑色利穆'
def read1():
    print('--------')
read2()
# from the test.py
# test模块
# test模块 黑色利穆

别名

from test import read1 as rr
rr()
# from the test.py
# test模块 黑色利穆

一行导入多个

from test import name, read1, read2

from ... import *

把所有不是以下划线开头的名字都导入到当前位置；

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

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

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

模块循环导入问题

模块循环/嵌套导入抛出异常的根本原因是由于在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 会抛出异常
Traceback (most recent call last):
  File "D:/赵贺学习python/run.py", line 1, in <module>
    import m1
  File "D:\赵贺学习python\m1.py", line 2, in <module>
    from m2 import copy
  File "D:\赵贺学习python\m2.py", line 2, in <module>
    from m1 import x
ImportError: cannot import name 'x'
正在导入m1
正在导入m2
# 测试一结果分析：
# 先执行run.py  --  执行 import m1（开始导入m1并运行其内部代码)   ---   打印内容“正在导入m1"  ---   执行from m2 import y（开始导入m2并运行其内部代码）  --  打印内容“正在导入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文件在不同的应用场景下执行不同的逻辑（或者在模块文件中测试代码）
if __name__ == '__main__':

print('from the test.py')
__all_ = ['name', 'read1',]
name = '黑色利穆'
def read1():
    print('test模块', name)
def read2():
    print('test模块')
    read1()
def change():
    global name
    name = '白色利穆'

if __name__ == '__main__':
    # 在模块中测试read1()函数
    # 此模块被导入时 __name__ == test 所以不执行
    read1()

模块的搜索路径

当引用一个模块时，不一定每次都可以import到；

python中引用模块的顺序：

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

模块的查找顺序：

第一次导入模块时，会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用（python解释器启动时会自动加载一些模块到内存中，使用sys.modules查看）
如果没有，解释器会查找同名的内置模块；
如果还没有就从sys.path给出的目录列表中一次寻找test.py文件；

ps：自定义的模块名不能和系统内置模块名重名；

# 在初始化之后，python程序可以修改sys.path，路径放在前面的优先于标准库被加载
import sys
print(sys.path)
sys.path.append('/a/b/c/d')
sys.path.insert(0, '/e/f/g/h')      # 排在前面的目录，优先被搜索
# ps：搜索时按照sys.path中从左到右的顺序查找，位于前的优先被查找，
# sys.path中还可能包含.zip归档文件和.egg文件，python会把.zip归档文件当成一个目录处理；


# 制作归档文件zip：module.zip  foo.py    bar.py
import sys
sys.path.append('module.zip')
import foo
import bar
foo.read1()
bar.read2()


# 也可以使用zip中目录结构的具体位置
sys.path.append('module.zip/lib/python')

# windows下的路径不加r开头，语法会报错
sys.path.append(0, r'C:\User\Administrator\PycharmProjects\a')

# .egg文件是由setuptools创建的包，是按照第三方python库和扩展时使用的一种常见格式，
#   .egg文件实际上只是添加了额外元数据（如版本号，依赖项等）的.zip文件

# 只能从.zip文件中导入py， pyc等文件。使用c编写的共享库和扩展块无法直接从.zip文件中加载
#   （此时setuptools等打包系统有时能提供一种规避方法）,且从.zip中加载文件不会创建.pyc或者
#   .pyo文件，因此一定要事先创建，来避免加载模块使性能下降；

posted @ 2020-12-03 18:53 黑色利穆阅读(80) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

黑色利穆