快速学习Python基础知识详细图文教程14--模块

来源引用网络知识与某站曹老师视频相互结合学习记录，仅供参考！

Python 基础知识

模块和包

在 Python 的标准安装中，包含了一组自带的模块，这些模块被称为"标准库"；例如常用的 math、random、datetime、os、json 等等；除此之外，还有很多的第三方模块，例如常见的 pymysql、numpy、requests、pandas 等等；通过这些强大的扩展库，形成了 Python 的强大"生态圈"。

模块的概念

一般情况下基本上是用 Python 解释器来编程，如果是从 Python 解释器退出再进入，那么定义的所有的方法和变量就都消失了；为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

Python 中的模块（Module）是一个包含 Python 定义和语句的文件，其实就是以 .py 结尾的 Python 文件，模块里面可以定义类，变量，函数，以及可执行的代码；通过模块，可以将代码组织成可重用的单元，便于管理和维护。只要带入相对应的模块，就可以直接使用这些模块的功能。

模块的作用

• 代码复用：将常用的功能封装到模块中，可以在多个程序中重复使用。
• 命名空间管理：模块可以避免命名冲突，不同模块中的同名函数或变量不会互相干扰。
• 代码组织：将代码按功能划分到不同的模块中，使程序结构更清晰。

模块导入有两种方法：

方法一：import 语句

import 模块名1 as 别名1 , 模块名2 as 别名2 , ..., 模块名n as 别名n

导入整个模块；这里导入的整个模块内的所有成员，包括变量、函数、类等。

import 模块名

# 导包，导入Python内置的random模块
import random

# 因为已经导入random模块，所以里面的所有成员（方法、属性）都可以使用
print(f"打印0~100之间的随机数：{random.randint(0, 100)}")


# 输出结果
打印0~100之间的随机数：64

import 模块名 as 别名

若导入模块有设置别名，则需使用其别名；

# 导包，并设置random模块的别名为rd，这里'rd'就等同于random
import random as rd

# 所以'rd'一样能用random模块里面的所有成员（方法、属性）
print(f"打印0~100之间的随机数：{rd.randint(0, 100)}")


# 输出结果
打印0~100之间的随机数：2

import 模块名1,模块名2

单次可导入多个模块；

# 导入random和time模块，多个模块之间使用逗号隔开
import random, time

print("开始过xx秒后执行")
time.sleep(3)
print(f"打印0~100之间的随机数：{random.randint(0, 100)}")
print('执行结束')


# 输出结果
开始过xx秒后执行
打印0~100之间的随机数：4
执行结束

import 模块名1 as 别名1, 模块名2 as 别名2

别名重复时最后一个模块的别名生效，不建议重复别名名称；

别名重复时前面设置相同的别名的模块会置灰不生效，只有最后一个模块的别名呈高亮状态可使用；

# 导入random和time模块，并分别设置自定义名称别名
import random as rd, time as t

print("开始过xx秒后执行")
t.sleep(3)
print(f"打印0~100之间的随机数：{rd.randint(0, 100)}")
print('执行结束')


# 输出结果
开始过xx秒后执行
打印0~100之间的随机数：31
执行结束

方法二：from ... import 语句

from 模块名 import 成员名1 as 成员别名1, 成员名2 as 成员别名2 ,...,成员名n as 成员别名n

导入模块中指定成员；成员可以是变量、函数、类等。

from 模块名 import 成员名

只导入了某一个成员，所以只能使用这个导入的成员；

# 导入random模块中randint方法
from random import randint

# 此时可以直接使用randint方法，不用再带random，因为import里面只有randint方法，亦不能带random
print(f"打印0~100之间的随机数：{randint(0, 100)}")


# 输出结果
打印0~100之间的随机数：61

from 模块名 import 成员名 as 成员别名

使用成员别名；

# 导入random模块中randint方法并设置成员别名
from random import randint as ri

# 使用成员别名
print(f"打印0~100之间的随机数：{ri(0, 100)}")


# 输出结果
打印0~100之间的随机数：87

from 模块名 import 成员名1, 成员名2

从一个模块里面导入多个成员；

# 导入random模块中randint方法、random方法
from random import randint, random

print(f"打印0~100之间的随机数：{randint(0, 100)}")
print(f"0~1之间（不包括1）的随机浮点数：{random()}")


# 输出结果
打印0~100之间的随机数：100
0~1之间（不包括1）的随机浮点数：0.27403983743632454

from 模块名 import 成员名1 as 成员别名1, 成员名2 as 成员别名2

导入多个成员，可以分别给成员取别名；

# 导入random模块中randint方法、random方法并分别设置成员别名
from random import randint as ri, random as r

print(f"打印0~100之间的随机数：{ri(0, 100)}")
print(f"0~1之间（不包括1）的随机浮点数：{r()}")


# 输出结果
打印0~100之间的随机数：65
0~1之间（不包括1）的随机浮点数：0.7188733769125514

from 模块名 import *

导入所有的成员，* 星号表示所有，导入某个模块里面的所有成员；

# import * 表示导入random模块中所有的成员
from random import *

print(f"打印0~100之间的随机数：{randint(0, 100)}")
print(f"0~1之间（不包括1）的随机浮点数：{random()}")


# 输出结果
打印0~100之间的随机数：23
0~1之间（不包括1）的随机浮点数：0.5636803018046256

自定义模块

Python 中已经有很多的内置模块，以及也有很多的第三方优秀模块，亦可以直接导入使用即可。

当然有些时候也需要自己定义一些自定义模块，来实现项目的某些功能。

先自定义模块文件，判断字符串是否为空的工具方法

新建一个 Python 文件，文件名称自定义即可，例如为"demo147.py"；

# 自定义isEmpty方法，里面传入字符串参数
# 类型注解：(s: str) -- 表示参数s应该是字符串；里面是"参数 :(冒号) 指定str类型"
def isEmpty(s: str):
    """
        函数注释：判断字符串是否为空
    :param s: 传入字符串参数
    :return: 空则返回True，否则返回False
    """
    # 字符串参数有可能时null
    if not s:
        # 判断字符串是不是None，如若是None，也当作是空字符串
        return True
    # 判断字符串长度len，在指定字符串参数类型后，就会有strip()方法：同时去掉左右两边的空格
    elif len(s.strip()) == 0:
        # 若是0的话，就返回True
        return True
    else:
        # 不是0的话，则返回False
        return False

使用 import 语句

再新建一个 Python 文件，文件名称自定义即可，例如"demo148.py"；

# 直接引入全部模块成员
import demo147

# 传入None
print(demo147.isEmpty(None))
# 传入空字符串
print(demo147.isEmpty(""))
# 传入空格
print(demo147.isEmpty("      "))
# 传入字符串
print(demo147.isEmpty("zhangsan"))


# 输出结果
True
True
True
False

使用 from ... import 语句

# 导包引入方法
from demo147 import isEmpty

# 传入None
print(isEmpty(None))
# 传入空字符串
print(isEmpty(""))
# 传入空格
print(isEmpty("      "))
# 传入字符串
print(isEmpty("ZhangSan"))


# 输出结果
True
True
True
False

修改"demo147.py"文件内容，增加测试代码；

# 自定义isEmpty方法，里面传入字符串参数
# 类型注解：isEmpty(s: str) -- 里面是"参数 :冒号 指定str类型"
def isEmpty(s: str):
    """
        函数注释：判断字符串是否为空
    :param s: 传入字符串参数
    :return: 空则返回True，否则返回False
    """
    # 字符串参数有可能时null
    if not s:
        # 判断字符串是不是null，如若是null，也当作是空字符串
        return True
    # 判断字符串长度len，在指定字符串参数类型后，就会有strip()方法：同时去掉左右两边的空格
    elif len(s.strip()) == 0:
        # 若是0的话，就返回True
        return True
    else:
        # 不是0的话，则返回False
        return False

# 测试验证
print("测试代码", isEmpty(None))


# 输出结果
测试代码 True

进程已结束，退出代码为 0

再次执行"demo149.py"文件，查看结果；

经过测试，当使用 from demo147 import isEmpty（from 模块 import 方法） 导入模块时，可执行代码也会一起导入进来，并且执行；

但是一般不需要执行测试代码，所以此时可以借助于所有模块内置的 name 变量进行区分；

# 自定义isEmpty方法，里面传入字符串参数
# 类型注解：isEmpty(s: str) -- 里面是"参数 :冒号 指定str类型"
def isEmpty(s: str):
    """
        函数注释：判断字符串是否为空
    :param s: 传入字符串参数
    :return: 空则返回True，否则返回False
    """
    # 字符串参数有可能时null
    if not s:
        # 判断字符串是不是null，如若是null，也当作是空字符串
        return True
    # 判断字符串长度len，在指定字符串参数类型后，就会有strip()方法：同时去掉左右两边的空格
    elif len(s.strip()) == 0:
        # 若是0的话，就返回True
        return True
    else:
        # 不是0的话，则返回False
        return False

# 测试代码
# print("测试代码", isEmpty(None))
print(__name__)


# 输出结果
__main__

在"demo147.py"文件中执行，相当于在自定义模块中运行；如果运行的是一个模块，"name "的值就是 "main"；

在"demo149.py"文件中执行，相当于是把'demo147.py'自定义模块导入到"demo149.py"文件中；如果是被导入的话，"name "的值就是 "模块名"；

如果直接使用 Python 命令来运行一个模块，"name "变量的值为 "main"；如果该模块被导入其他程序中，"name "变量的值就是 "模块名"；因此，如果希望测试函数只有在使用 Python 命令直接运行时才执行，则可在调用测试函数时增加判断"只有当"name "属性为"main"时才调用测试函数"。

优化自定义模块文件

# 自定义isEmpty方法，里面传入字符串参数
# 类型注解：isEmpty(s: str) -- 里面是"参数 :冒号 指定str类型"
def isEmpty(s: str):
    """
        函数注释：判断字符串是否为空
    :param s: 传入字符串参数
    :return: 空则返回True，否则返回False
    """
    # 字符串参数有可能时null
    if not s:
        # 判断字符串是不是null，如若是null，也当作是空字符串
        return True
    # 判断字符串长度len，在指定字符串参数类型后，就会有strip()方法：同时去掉左右两边的空格
    elif len(s.strip()) == 0:
        # 若是0的话，就返回True
        return True
    else:
        # 不是0的话，则返回False
        return False

# 判断 __name__ 是否等于 '__main__'
if __name__ == '__main__':
    # 当 __name__ 等于 '__main__' 时，才执行测试代码
    print("测试代码：", isEmpty(None))

当一个模块里面有很多个方法或者说很多个成员时，有时只想暴露部分方法或者部分成员，有些成员（方法）仅限模块内部使用，或者暂时不想对外暴露；此时可以使用 all 来指定（实现）。

在 demo147.py 内部再写一个方法，添加代码并使用"all"来指定所有可以被导入使用的成员；

# 自定义isEmpty方法，里面传入字符串参数
# 类型注解：isEmpty(s: str) -- 里面是"参数 :冒号 指定str类型"
def isEmpty(s: str):
    """
        函数注释：判断字符串是否为空
    :param s: 传入字符串参数
    :return: 空则返回True，否则返回False
    """
    # 字符串参数有可能时null
    if not s:
        # 判断字符串是不是null，如若是null，也当作是空字符串
        return True
    # 判断字符串长度len，在指定字符串参数类型后，就会有strip()方法：同时去掉左右两边的空格
    elif len(s.strip()) == 0:
        # 若是0的话，就返回True
        return True
    else:
        # 不是0的话，则返回False
        return False

# 再自定义方法isNotEmpty
def isNotEmpty(s: str):
    """
        判断字符串是否不是空
    :param s: 传入字符串参数
    :return: 字符串不为空返回True，否则返回False
    """
    if s:
        if len(s.strip()) > 0:
            return True
        else:
            return False
    else:
        return False

# 判断 __name__ 是否等于 '__main__'
if __name__ == '__main__':
    # 当 __name__ 等于 '__main__' 时，才执行测试代码
    print("测试代码：", isEmpty(None))


# 使用 __all__ 限制 from 模块名 import * 导入方式 里面的成员
__all__ = ['isEmpty', 'isNotEmpty']

仅限一种情况下使用，针对"from 模块名 import *"导入方式，当使用"* 星号"导入某个模块里面的所有成员时，此时"* 星号"是指代"all "，只能取到 all 里面（列表）的成员；

可以在自定义模块里面使用"all = '成员1', '成员2',...... '成员N'"来定义模块方法是否对外开放。

# __all__ 等于后面是一个列表
__all__ = ['成员1',  '成员2',...... '成员N']

# 列表里面可以为空，即表示模块中所有成员不对外开放
__all__ = []

未完待续......