Python知识学习03

一、认识模块的意义

Python 的强大核心在于其丰富的开源模块生态 ------ 全球开发者将各类功能封装为模块开源共享，开发者无需从零编写复杂逻辑，直接导入模块即可实现专业功能，大幅降低开发门槛、提升效率。

1.1 模块的核心定义

模块（Module）是封装了特定功能的代码集合，本质是一个.py 文件（或一组文件组成的包），包含函数、变量、类等可复用的代码单元，按来源可分为三类：

1. 启动加载模块：Python 解释器启动时自动加载的模块（如 str、int、type），无需导入可直接使用；

2. 内置模块：Python 解释器安装时自带的模块（如 math、os、sys、random），需导入后使用；

3. 第三方模块：Python 社区开源的模块（如 psutil、paramiko），需先安装再导入使用。

1.2 模块的典型应用场景

1. 运维工作 ：检测服务器 CPU、内存、磁盘、网络流量等指标，推荐psutil第三方模块；

2. 网络操作 ：远程连接主机、执行命令、上传下载文件，推荐paramiko、fabric第三方模块；

3. 自动化测试 ：Web / 移动端 APP 功能测试，推荐selenium + phantomjs模块。

二、模块导入的语法

除启动加载模块外，内置模块和第三方模块均需导入后才能使用。Python 提供多种导入语法，适配不同使用场景，核心原则是 按需导入、简洁清晰。

2.1 核心术语说明

• 模块：单个.py 文件，封装独立功能；

• 包（Package）：包含多个模块的文件夹，需包含__init__.py文件；

• PyPI：Python 第三方模块索引网站，用于发布和下载第三方模块；

• pip：Python 包管理工具，命令：pip install 模块名。

2.2 模块导入的 6 种核心语法

1. 直接导入模块（推荐） 语法：import 模块名称

   import os
   print(os.listdir("D:/"))

2. 别名导入模块 语法：import 模块名称 as 别名

   import random as rd
   print(rd.randint(1, 5))

3. 从模块中导入指定对象 语法：from 模块 import 函数名1, 变量名1

   from random import randint
   print(randint(1, 5))

4. 从模块中导入对象并指定别名 语法：from 模块 import 函数名 as 别名

   from random import randint as random_num
   print(random_num(1, 5))

5. 直接导入包 语法：import 包名称

   import os
   print(os.path.isdir("D:/Bandicam/"))

6. 从包中导入模块（推荐） 语法：from 包 import 模块

   from datetime import datetime
   d = datetime.today()
   print(d.year, d.month, d.day)

三、容器模块

容器模块是 Python 内置的核心数据结构，用于在一个变量中存储和管理多个数据，核心围绕 CRUD 操作（Create 新增、Read 查询、Update 修改、Delete 删除）展开。

3.1 容器的核心价值

1. 存储批量数据，避免变量冗余；

2. 适配不同读写场景，提升程序性能；

3. 减少内存占用，加快数据读写速度。

3.2 内存模型与数据结构基础

1. 内存区域划分：栈内存（临时变量）、堆内存（对象 / 批量数据）、静态区 / 常量区、方法区；

2. 两种核心数据结构

   • 数组：连续内存，查询 / 修改快，增删慢；

   • 链表：非连续内存，增删快，查询慢。

3.3 四大内置容器模块

容器类型	英文名称	核心特点	底层结构	适用场景
list 列表	list	有序、可重复、可变、支持增删改查	数组	无特殊要求的批量数据，频繁查询修改
tuple 元组	tuple	有序、可重复、不可变、仅支持查询	数组	固定常量、配置项、无需修改的数据
set 集合	set	无序、不可重复、可变、支持增删查	链表	去重数据、集合运算、频繁增删
dict 字典	dict	无序、key 唯一、可变、支持增删改查	哈希表	键值对映射数据，快速查询

3.3.1 list 列表：有序可变的批量数据存储

核心特性

• 关键字：list；有序、可重复、元素类型不限、支持增删改查；

• 适用场景：无特殊要求的批量数据存储（如访问 IP 列表、成绩列表）。

对象声明

# 推荐语法
lst1 = []
# 通用语法
lst2 = list()

CRUD 核心操作（实战：服务器访问 IP 管理）

ips_access = []
# 新增
ips_access.append("192.168.10.101")
ips_access.extend(["192.168.10.98", "192.168.10.101"])
# 删除
ips_access.remove("192.168.10.98")
last_ip = ips_access.pop()
# 修改
ips_access[1] = ips_access[1] + "_last"
# 查询
print(ips_access[0])
print(ips_access[1:])
# 遍历
for idx, ip in enumerate(ips_access):
    print(f"索引{idx}：{ip}")

常见函数

函数名	功能	示例
append(dat)	末尾追加单个	lst.append(10)
extend(seq)	末尾追加多个	lst.extend([20,30])
insert(idx, dat)	指定索引插入	lst.insert(1,15)
remove(dat)	按值删除	lst.remove(20)
pop(idx)	按索引删除	lst.pop(0)
clear()	清空列表	lst.clear()
sort()	排序	lst.sort(reverse=True)

3.3.2 tuple 元组：有序不可变的固定数据存储

核心特性

• 关键字：tuple；有序、可重复、不可增删改，仅支持查询；

• 适用场景：固定常量、配置项。

对象声明

# 空元组
t1 = ()
# 单个元素元组（必须加逗号）
t3 = (1,)
# 多元素元组
t4 = ("春", "夏", "秋", "冬")

核心操作（仅查询）

season = ("春", "夏", "秋", "冬")
print(season[0])
print(season[1:3])
for idx, s in enumerate(season):
    print(f"索引{idx}：{s}")

常见函数

count(dat)：统计次数；index(dat)：查找索引。

3.3.3 set 集合：无序去重的批量数据存储

核心特性

• 关键字：set；无序、不可重复、无索引、支持增删查；

• 适用场景：数据去重、集合运算（交集 / 并集 / 差集）。

对象声明

# 空集合（不能用{}）
s2 = set()
# 自动去重
s3 = {1,2,2,3,4}

CRUD 核心操作（实战：IP 黑白名单）

ips_set = set()
# 新增
ips_set.add("192.168.10.101")
# 删除
ips_set.remove("192.168.10.98")
ips_set.discard("192.168.10.99")
# 修改（先删后增）
if "192.168.10.101" in ips_set:
    ips_set.remove("192.168.10.101")
    ips_set.add("192.168.10.102")
# 查询
print("192.168.10.102" in ips_set)

集合运算

• 并集：union()；交集：intersection()；

• 差集：difference()；对称差集：symmetric_difference()。

3.3.4 dict 字典：键值对映射的数据存储

核心特性

• 关键字：dict；key 唯一、value 可重复、支持增删改查；

• 适用场景：用户信息、配置参数、快速查询映射数据。

对象声明

# 空字典
d1 = {}
d2 = dict()
# 非空字典
d3 = {"username": "admin", "password": "123123"}

CRUD 核心操作（实战：用户信息管理）

user_dict = {}
# 新增
user_dict["username"] = "admin"
user_dict.setdefault("password", "123123")
user_dict.update({"age":20, "sex":"男"})
# 修改
user_dict["age"] = 22
# 查询
print(user_dict.get("sex"))
print(user_dict.items())
# 删除
del user_dict["sex"]
user_dict.pop("password")

常见函数

get(key, default)：安全查询；

update()：批量修改；

pop()：按 key 删除；

items()：遍历键值对。

四、类型模块

Python 内置功能工具，无需自定义逻辑即可直接使用，覆盖时间、数学、随机数、系统交互等场景。

4.1 time 模块：时间处理与程序休眠

函数名	功能	示例
time()	获取时间戳	time.time()
localtime()	本地结构化时间	time.localtime()
strftime()	时间格式化	"%Y-%m-%d %H:%M:%S"
sleep(n)	休眠 n 秒	time.sleep(2)

时间格式符：% Y (年)、% m (月)、% d (日)、% H (时)、% M (分)、% S (秒)

4.2 datetime 模块：便捷日期时间处理

from datetime import datetime
d = datetime.today()
print(d.year, d.month, d.day)
# 格式化
d.strftime("%Y/%m/%d")

4.3 math 模块：数学运算工具

• 取整：ceil()向上、floor()向下、trunc()截断；

• 运算：pow()幂方、sqrt()平方根、gcd()最大公约数、lcm()最小公倍数；

• 常量：pi、e。

4.4 random 模块：随机数生成

函数名	功能
random()	0~1 随机浮点数
randint(a,b)	a~b 随机整数
choice(seq)	随机选 1 个元素
choices(seq,k=n)	随机选 n 个元素
shuffle(seq)	打乱序列

实战：生成随机验证码

import random, string
code = "".join(random.choices(string.ascii_letters, k=8))

5.5 os/sys 模块：系统与解释器交互

两大核心系统模块，分别负责 "与操作系统交互" 和 "与 Python 解释器交互"，是实现跨平台开发、系统自动化的基础。

5.5.1 os 模块（Operation System）

核心定位

Python 内置的操作系统交互模块，通过函数实现文件 / 目录的创建、删除、重命名、路径判断等操作，适配 Windows、Linux、Mac 等系统。

核心函数（按功能分类）

功能分类	函数名	功能描述
目录操作	os.getcwd()	获取当前工作目录（绝对路径）
	os.chdir(path)	切换当前工作目录到path
	os.mkdir(path)	创建单层目录（父目录不存在则报错）
	os.makedirs(path)	创建多层目录（如data/images/headers/，父目录不存在自动创建）
	os.rmdir(path)	删除单层空目录（目录非空则报错）
	os.removedirs(path)	删除多层空目录（从最内层开始删除，直到父目录非空）
文件操作	os.listdir(path)	列出path目录下的所有文件 / 子目录（返回列表）
	os.walk(path)	递归遍历path目录下的所有文件 / 子目录（生成器，返回(root, dirs, files)）
	os.remove(path)	删除指定文件（path为文件路径）
	os.rename(src, dst)	将文件 / 目录从src重命名为dst
路径判断	os.path.isdir(path)	判断path是否为目录
	os.path.isfile(path)	判断path是否为文件
	os.path.exists(path)	判断path是否存在（文件 / 目录均可）
	os.path.splitext(path)	拆分路径为 "目录 + 文件名"（返回元组，如("data", "test.txt")）
文件属性	os.path.getsize(path)	获取文件大小（单位：字节）
	os.path.getctime(path)	获取文件创建时间（ctime=create time）
	os.path.getmtime(path)	获取文件最后修改时间（mtime=modify time）

实战示例

import os

# 1. 目录操作：创建多层目录
os.makedirs("log/data/", exist_ok=True)  # exist_ok=True避免目录已存在报错

# 2. 遍历指定目录下的所有文件（包括子目录）
def list_all_files(path):
    for root, dirs, files in os.walk(path):
        for file in files:
            # 拼接完整文件路径
            full_path = os.path.join(root, file)
            print(f"文件路径：{full_path}，大小：{os.path.getsize(full_path)}字节")

# 3. 调用函数遍历当前目录
list_all_files(".")

# 4. 文件操作：删除空目录
os.removedirs("log/data/")

5.5.2 sys 模块（System）

核心定位

与Python 解释器交互的模块，用于获取脚本参数、控制程序退出、查看解释器信息等，让脚本的灵活性更高。

核心函数

函数名	功能描述
sys.argv	获取脚本执行时的命令行参数（列表形式，第 0 项为脚本路径，后续为参数）
sys.exit(code)	终止程序运行，code=0表示正常退出，非 0 表示异常退出
sys.version	获取 Python 解释器版本信息（如3.12.7 (tags/v3.12.7:0b6f108, Oct 2 2024)）
sys.platform	获取运行平台（如 Windows 返回win32，Linux 返回linux，用于跨平台开发）
sys.path	获取 Python 模块搜索路径（列表形式，可添加自定义路径）

实战示例：批量 IP 探测（结合命令行参数）

import sys
import time

# 1. 验证参数数量（需传入起始IP段和结束IP段，如python test.py 2 100）
if len(sys.argv) < 3:
    print("参数错误！用法：python test.py [起始IP段] [结束IP段]")
    print("示例：python test.py 2 10（探测192.168.0.2~192.168.0.10）")
    sys.exit(1)  # 异常退出，返回非0状态码

# 2. 解析参数（将字符串参数转为整数）
start_no = int(sys.argv[1])
end_no = int(sys.argv[2])

# 3. 批量探测IP
for ip_no in range(start_no, end_no + 1):
    ip = f"192.168.0.{ip_no}"
    print(f"开始探测：{ip}")
    time.sleep(0.5)  # 模拟探测延迟
print("所有IP探测完毕！")

5.6 其他高频内置模块

5.6.1 hashlib 模块

核心函数

函数名	功能描述
hashlib.md5()	使用 MD5 算法创建加密对象（128 位哈希值，输出 32 位十六进制字符串）
hashlib.sha256()	使用 SHA-256 算法创建加密对象（256 位哈希值，输出 64 位十六进制字符串）
update(data)	向加密对象添加明文数据（data需为字节类型，用encode()转换）
hexdigest()	获取加密后的十六进制字符串结果

实战示例 1：基础加密（含盐值混淆）

import hashlib

# 明文数据
plain_text = "hello world"
# 盐值（混淆码，可自定义）
salt = "python@2024"

# 1. MD5加密（含盐值）
md5_obj = hashlib.md5(plain_text.encode())  # 先添加明文
md5_obj.update(salt.encode())  # 再添加盐值
md5_result = md5_obj.hexdigest()
print(f"MD5加密结果（含盐值）：{md5_result}")  # 输出：6153e073bd36d244622772c891bf2693

# 2. SHA-256加密
sha256_obj = hashlib.sha256((plain_text + salt).encode())
sha256_result = sha256_obj.hexdigest()
print(f"SHA-256加密结果：{sha256_result}")

实战示例 2：用户登录密码校验

import hashlib

def encrypt_password(password, salt="secret_salt"):
    """密码加密函数（含固定盐值）"""
    return hashlib.md5((password + salt).encode()).hexdigest()

# 数据库存储的用户信息（用户名+加密后的密码）
db_user = {
    "username": "admin",
    "password": encrypt_password("123123")  # 加密后的密文
}

# 用户登录输入
input_username = input("请输入用户名：")
input_password = input("请输入密码：")

# 校验逻辑
if input_username == db_user["username"]:
    if encrypt_password(input_password) == db_user["password"]:
        print("登录成功！")
    else:
        print("密码错误！")
else:
    print("用户名不存在！")

5.6.2 hmac 模块

核心特点

在 hashlib 基础上增加密钥验证，加密时需指定密钥，安全性更高，适用于需要更严格加密的场景。

核心函数

函数名	功能描述
hmac.new(key, msg, digestmod)	创建 hmac 加密对象：key为密钥（字节类型），msg为明文，digestmod为加密算法（如hashlib.md5）

实战示例

import hmac
import hashlib

# 密钥（需保密，不同于盐值）
key = "admin@key_2024"
# 明文
plain_text = "hello world"

# 创建hmac加密对象（使用MD5算法）
hmac_obj = hmac.new(key.encode(), plain_text.encode(), hashlib.md5)
# 获取加密结果
hmac_result = hmac_obj.hexdigest()
print(f"HMAC-MD5加密结果：{hmac_result}")  # 输出：7ded3b97effe4c5d8549cd802d8fee9e

5.6.3日志管理模块：logging

用于记录脚本 / 应用的运行历史，支持控制台输出和文件存储，可分级记录（调试、信息、警告、错误），便于问题排查和复盘。

核心概念

• 日志级别（从低到高）：DEBUG（调试）→ INFO（普通信息）→ WARNING（警告）→ ERROR（错误）→ CRITICAL（严重错误）；

• 日志处理器（Handler）：控制日志输出位置（如文件、控制台）；

• 日志格式（Formatter）：定义日志记录的内容（如时间、文件名、级别、信息）。

核心函数

函数名	功能描述
logging.getLogger(name)	创建 / 获取日志对象（name通常为脚本名，避免日志冲突）
logger.setLevel(level)	设置日志记录级别（低于该级别的日志不记录）
logging.FileHandler(filepath)	创建文件处理器，将日志写入指定文件
logging.Formatter(fmt)	定义日志格式（fmt为格式字符串，如"%(asctime)s - %(levelname)s: %(message)s"）
logger.addHandler(handler)	为日志对象添加处理器（可同时添加文件和控制台处理器）
logger.debug(msg)	记录 DEBUG 级日志
logger.info(msg)	记录 INFO 级日志
logger.warning(msg)	记录 WARNING 级日志
logger.error(msg)	记录 ERROR 级日志
logger.critical(msg)	记录 CRITICAL 级日志

实战示例：文件日志记录

import logging
import os

# 1. 创建日志对象（名称为当前脚本名）
logger = logging.getLogger("script_log")
logger.setLevel(logging.INFO)  # 只记录INFO及以上级别日志

# 2. 创建文件处理器（日志写入log/run.log）
os.makedirs("log", exist_ok=True)
file_handler = logging.FileHandler("log/run.log", encoding="utf-8")

# 3. 定义日志格式：时间-文件名-级别-信息
formatter = logging.Formatter(
    "%(asctime)s - %(filename)s - %(levelname)s: %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
file_handler.setFormatter(formatter)

# 4. 为日志对象添加处理器
logger.addHandler(file_handler)

# 5. 记录日志（替代print()）
logger.info("脚本开始运行")
try:
    result = 10 / 2
    logger.debug(f"计算结果：{result}")  # DEBUG级别低于INFO，不记录
except Exception as e:
    logger.error(f"脚本执行错误：{str(e)}")
logger.critical("脚本运行结束")

5.6.4 进程管理模块：subprocess

用于执行系统命令、创建子进程，是 Python 实现运维自动化、系统交互的核心模块，支持获取命令执行结果和状态码。

核心函数

函数名	功能描述
subprocess.run(args, capture_output=True, text=True)	执行系统命令，args为命令列表（如["ping", "www.baidu.com"]）；capture_output=True捕获输出；text=True返回字符串结果
subprocess.call(args)	执行命令，返回退出状态码（0 成功，非 0 失败）
subprocess.check_call(args)	执行命令，状态码非 0 则抛出CalledProcessError异常
subprocess.Popen(args)	创建子进程，支持与进程交互（如发送输入、获取输出）

实战示例：探测主机网络连通性

import subprocess

def ping_host(ip):
    """探测指定IP是否连通"""
    # 执行ping命令（Windows用"-n"，Linux用"-c"，结合sys.platform适配跨平台）
    import sys
    if sys.platform == "win32":
        cmd = ["ping", "-n", "2", ip]  # Windows：发送2个数据包
    else:
        cmd = ["ping", "-c", "2", ip]  # Linux/Mac：发送2个数据包
    
    # 执行命令并捕获结果
    result = subprocess.run(cmd, capture_output=True, text=True, encoding="gbk")
    # 返回状态码：0=连通，非0=不通
    return result.returncode == 0

# 测试百度连通性
ip = "www.baidu.com"
if ping_host(ip):
    print(f"{ip} 网络畅通")
else:
    print(f"{ip} 网络阻塞")

5.6.5 网络访问模块：urllib

用于基于 HTTP/HTTPS 协议的网络数据采集，可实现网页爬取、接口调用等功能，是 Python 爬虫的基础模块（Python3 中已整合 Python2 的 urllib2 模块）。

核心组件与函数

组件 / 函数	功能描述
urllib.request.Request(url, headers)	创建请求对象，headers用于伪造浏览器请求（避免被反爬）
urllib.request.urlopen(req)	发送请求并获取响应对象，req为 Request 对象
response.read()	读取响应体数据（字节类型）
response.decode(encoding)	将字节数据解码为字符串（需指定编码，如gbk、utf-8）

实战示例：网络小说数据采集（含请求伪造）

from urllib.request import Request, urlopen

# 1. 目标URL（网络小说章节地址）
url = "https://www.bqg22.com/book/13252/5726048.html"

# 2. 请求伪造（模拟浏览器，避免被网站拒绝）
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0"
}
# 创建请求对象
req = Request(url, headers=headers)

# 3. 发送请求并采集数据
try:
    response = urlopen(req, timeout=10)  # 超时时间10秒
    # 解码数据（根据网站编码调整，此处为gbk）
    html = response.read().decode("gbk")
    # 打印采集到的网页源码（后续可通过正则/BS4提取小说内容）
    print(html[:1000])  # 只打印前1000字符
except Exception as e:
    print(f"采集失败：{str(e)}")

5.6.6 字符串处理模块：str

Python 中操作最频繁的模块，提供字符串的截取、拆分、合并、替换等功能，无需导入，直接通过字符串对象调用方法。

核心函数（按功能分类）

字符串格式化与对齐

函数名	功能描述
s.capitalize()	首字母大写，其余小写（如"hello"→"Hello"）
s.title()	每个单词首字母大写（如"hello world"→"Hello World"）
s.center(width)	居中对齐，填充空格（如"python"→" python "，width=8）
s.ljust(width)	左对齐，右侧填充空格
s.rjust(width)	右对齐，左侧填充空格

字符串清洗与转换

函数名	功能描述
s.strip()	去除两侧空格 / 换行符（\n）/ 制表符（\t）
s.lstrip()	去除左侧空格
s.rstrip()	去除右侧空格
s.upper()	全部转为大写
s.lower()	全部转为小写
s.swapcase()	大小写互换（如"PyThOn"→"pYtHoN"）

字符串查询与拆分

函数名	功能描述
s.find(sub)	从左查找子串sub，返回首次出现的索引（未找到返回 - 1）
s.rfind(sub)	从右查找子串sub，返回首次出现的索引（未找到返回 - 1）
s.index(sub)	与find类似，但未找到子串会抛出ValueError
s.split(sep, maxsplit)	按sep拆分字符串，maxsplit为最大拆分次数（默认 - 1，无限拆分）
s.rsplit(sep)	从右向左拆分字符串
s.partition(sub)	按sub拆分一次，返回(前半部分, sub, 后半部分)（未找到返回(s, "", "")）

字符串判断与替换

函数名	功能描述
s.startswith(prefix)	判断是否以prefix开头（如"http://www.baidu.com"→startswith("http")→True）
s.endswith(suffix)	判断是否以suffix结尾（如"test.txt"→endswith(".txt")→True）
s.isdigit()	判断是否全为数字（0-9）
s.isalpha()	判断是否全为字母
s.replace(old, new)	将old子串替换为new（如"hello"→replace("l", "x")→"hexxo"）
s.join(seq)	用s拼接序列seq中的元素（如"-".join(["a", "b", "c"])→"a-b-c"）

实战示例：IP 地址范围解析

# 需求：解析起始IP和结束IP，遍历所有中间IP
start_ip = "192.168.0.2"
end_ip = "192.168.0.10"

# 1. 拆分IP，获取网络段和主机段
# 从右拆分1次，获取网络段（如"192.168.0.2"→["192.168.0", "2"]）
root_ip = start_ip.rsplit(".", maxsplit=1)[0]
start_host = int(start_ip.rsplit(".", maxsplit=1)[1])
end_host = int(end_ip.rsplit(".", maxsplit=1)[1])

# 2. 遍历所有IP并打印
for host in range(start_host, end_host + 1):
    full_ip = f"{root_ip}.{host}"
    print(f"探测IP：{full_ip}")

六、第三方模块

第三方模块是 Python 社区开发者共享的功能包，不是内置模块，需要先安装才能使用，是自动化运维、数据分析、爬虫、办公自动化的核心工具。

6.1 第三方模块使用流程

1. 安装 ：命令行执行 pip install 模块名

2. 导入 ：脚本中用 import 导入

3. 使用：调用模块的函数 / 类完成功能

6.2 高频第三方模块 + 详细解释 + 可运行实战示例

1. paramiko（SSH 远程连接模块）

作用 ：通过 SSH 协议远程登录服务器 ，执行命令、上传 / 下载文件（运维必备）场景：批量管理 Linux 服务器

安装

pip install paramiko

实战：远程执行 Linux 命令

import paramiko

# 创建 SSH 客户端
client = paramiko.SSHClient()
# 自动接受未知主机密钥
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

try:
    # 连接服务器（IP、用户名、密码）
    client.connect(
        hostname="192.168.1.100",
        username="root",
        password="your_password",
        port=22
    )
    print("连接成功")

    # 执行命令
    stdin, stdout, stderr = client.exec_command("ls -l && free -h")
    # 读取输出
    result = stdout.read().decode("utf-8")
    print("命令执行结果：")
    print(result)

finally:
    client.close()

2. ftputil（FTP 文件传输模块）

作用 ：通过 FTP 协议上传、下载、管理文件 场景：文件服务器、备份数据

安装

pip install ftputil

实战：FTP 下载文件

import ftputil

# 连接 FTP 服务器
with ftputil.FTPHost("ftp.xxx.com", "username", "password") as host:
    # 查看目录
    print("目录文件：", host.listdir("/"))
    
    # 下载文件（远程路径 → 本地路径）
    host.download("/test.txt", "local_test.txt")
    print("文件下载完成")

3. psutil（服务器监控模块）

作用 ：获取本机 CPU、内存、磁盘、网络、进程 实时数据场景：监控脚本、告警系统、性能检测

安装

pip install psutil

实战：查看电脑硬件信息

import psutil

# CPU 使用率
print("CPU 使用率：", psutil.cpu_percent(1), "%")

# 内存信息
mem = psutil.virtual_memory()
print("总内存：", round(mem.total / 1024**3, 2), "GB")
print("已用内存：", round(mem.used / 1024**3, 2), "GB")
print("内存使用率：", mem.percent, "%")

# 磁盘信息
disk = psutil.disk_usage("C:\\")
print("C 盘使用率：", disk.percent, "%")

4. numpy（科学计算、数组运算）

作用 ：高效处理多维数组、矩阵、数学运算 ，是数据分析的基础库场景：AI、数据计算、图像处理

安装

pip install numpy

实战：数组快速计算

import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])
print("数组：", arr)

# 批量运算（比列表快 10~100 倍）
print("+10：", arr + 10)
print("平均值：", np.mean(arr))
print("最大值：", np.max(arr))
print("总和：", np.sum(arr))

5. pandas（Excel/CSV 数据处理神器）

作用 ：读取、清洗、筛选、统计表格数据场景：办公自动化、报表分析、数据清洗

安装

pip install pandas

实战：读取 / 创建 Excel

import pandas as pd

# 1. 创建数据
data = {
    "姓名": ["张三", "李四", "王五"],
    "成绩": [90, 85, 98],
    "班级": ["一班", "二班", "一班"]
}
df = pd.DataFrame(data)

# 2. 保存为 Excel
df.to_excel("成绩表.xlsx", index=False)
print("Excel 保存成功")

# 3. 读取 Excel
read_df = pd.read_excel("成绩表.xlsx")
print("读取内容：")
print(read_df)

6. matplotlib（数据可视化、绘图）

作用 ：生成折线图、柱状图、饼图 等图表场景：数据报告、可视化分析

安装

pip install matplotlib

实战：绘制成绩柱状图

import matplotlib.pyplot as plt

# 数据
names = ["张三", "李四", "王五"]
scores = [90, 85, 98]

# 绘图
plt.bar(names, scores, color=["blue", "green", "orange"])
plt.title("学生成绩统计表")
plt.xlabel("姓名")
plt.ylabel("分数")

# 显示图表
plt.show()

模块总结

模块	用途	核心场景
paramiko	远程服务器管理	Linux 运维
ftputil	FTP 文件传输	文件备份 / 下载
psutil	系统监控	CPU / 内存 / 磁盘查看
numpy	数值计算	数组 / 矩阵运算
pandas	表格处理	Excel/CSV 自动化
matplotlib	图表绘制	数据可视化

七、自定义模块的封装与发布

自定义模块 ：把你写好的函数、变量、类 封装到 .py 文件里，让其他项目、其他文件可以重复导入使用，是 Python 工程化、模块化开发的核心技能。

自定义包：把多个模块放在一个文件夹里，形成可分发的工具包。

7.1 自定义模块封装

核心解释

1. 模块 = 一个 .py 文件

2. 里面可以写：函数、变量、常量、类

3. 其他文件 import 后就能直接调用

4. 好处：代码复用、结构清晰、便于维护

实战示例（完整可运行）

步骤 1：创建模块文件

新建文件：my_tools.py（这就是你的自定义模块）

# my_tools.py  自定义工具模块

# 1. 函数
def add(a, b):
    """加法函数"""
    return a + b

def sub(a, b):
    """减法函数"""
    return a - b

# 2. 变量
VERSION = "v1.0.0"
AUTHOR = "我的Python工具库"

# 3. 类
class Calculator:
    def mul(self, a, b):
        return a * b

步骤 2：在另一个文件中导入使用

新建文件：test.py（和 my_tools.py 放在同一文件夹）

# test.py
# 导入自定义模块
import my_tools

# 使用模块里的函数
print(my_tools.add(10, 5))   # 15
print(my_tools.sub(10, 5))   # 5

# 使用模块里的变量
print(my_tools.VERSION)      # v1.0.0

# 使用模块里的类
cal = my_tools.Calculator()
print(cal.mul(10, 5))        # 50

运行结果

15
5
v1.0.0
50

7.2 自定义模块发布

核心解释

把你的模块打包成 .tar.gz 压缩包，可以：

• 发给别人安装使用

• 上传到 PyPI 平台，全世界都能用 pip install 安装

发布固定三步：

1. 写配置文件 setup.py

2. 打包：python setup.py sdist

3. 发布（可选）：上传 PyPI

实战：打包自定义模块

项目结构（必须这样建）

my_package/          # 文件夹（包名）
    __init__.py      # 必须有（空文件也行）
    my_tools.py      # 你的模块
setup.py             # 打包配置文件

步骤 1：创建包文件夹 + init.py

新建文件夹 my_package在里面新建空文件：__init__.py把刚才的 my_tools.py 放进去

步骤 2：编写 setup.py（打包配置）

# setup.py
from setuptools import setup, find_packages

setup(
    name="my_tools_package",       # 包名（pip install 用的名字）
    version="1.0.0",               # 版本号
    packages=find_packages(),      # 自动识别包
    author="你的名字",
    description="我的第一个Python工具包"
)

步骤 3：执行打包命令

打开命令行 ，进入 setup.py 所在目录，运行：

python setup.py sdist

结果

会自动生成 3 个文件夹：

• build/

• dist/

• my_tools_package.egg-info/

在 dist/ 里能找到：my_tools_package-1.0.0.tar.gz这就是你打包好的模块！

7.3 安装你自己的模块

别人拿到你的 .tar.gz 包，可以直接安装：

pip install dist/my_tools_package-1.0.0.tar.gz

安装后，任何项目都能导入使用：

from my_package import my_tools
print(my_tools.add(10, 20))  # 30

八、综合练习

需求：用户登录验证系统

1. 字典存储用户信息；

2. random 生成验证码；

3. datetime 记录登录时间；

4. 验证用户名、密码、验证码。

   import random
   import string
   from datetime import datetime

   users = {
   "admin": {"password": "123123", "role": "管理员"},
   "guest": {"password": "123456", "role": "游客"}
   }

   def generate_code():
   return "".join(random.choices(string.digits + string.ascii_letters, k=6))

   def login():
   username = input("请输入用户名：")
   password = input("请输入密码：")
   code = generate_code()
   print(f"验证码：{code}")
   user_code = input("请输入验证码：")

    if username not in users:
        print("登录失败：用户名不存在")
        return
    if users[username]["password"] != password:
        print("登录失败：密码错误")
        return
    if user_code.lower() != code.lower():
        print("登录失败：验证码错误")
        return
   
    login_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print(f"登录成功！欢迎{users[username]['role']}{username}，登录时间：{login_time}")

   login()

九、综合实战：远程主机网络探测脚本

结合sys（参数解析）、subprocess（命令执行）、logging（日志记录）、os（目录创建）模块，实现批量 IP 探测并记录日志。

import sys
import subprocess
import logging
import os

# 1. 初始化日志
def init_logger():
    logger = logging.getLogger("ip_scan")
    logger.setLevel(logging.INFO)
    # 创建日志目录
    os.makedirs("ip_scan_log", exist_ok=True)
    # 文件处理器
    file_handler = logging.FileHandler("ip_scan_log/scan.log", encoding="utf-8")
    formatter = logging.Formatter("%(asctime)s - %(levelname)s: %(message)s")
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
    return logger

# 2. 探测单个IP
def scan_ip(ip, logger):
    cmd = ["ping", "-n", "2", ip] if sys.platform == "win32" else ["ping", "-c", "2", ip]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode == 0:
        logger.info(f"{ip} - 网络畅通")
        return True
    else:
        logger.error(f"{ip} - 网络阻塞")
        return False

# 3. 主函数
def main():
    # 验证参数
    if len(sys.argv) != 3:
        print("用法：python ip_scan.py [起始IP] [结束IP]")
        print("示例：python ip_scan.py 192.168.0.10 192.168.0.20")
        sys.exit(1)
    
    start_ip = sys.argv[1]
    end_ip = sys.argv[2]
    logger = init_logger()
    
    # 解析IP范围
    root_ip = start_ip.rsplit(".", maxsplit=1)[0]
    start_host = int(start_ip.rsplit(".", maxsplit=1)[1])
    end_host = int(end_ip.rsplit(".", maxsplit=1)[1])
    
    # 批量探测
    logger.info(f"开始探测IP范围：{start_ip}~{end_ip}")
    for host in range(start_host, end_host + 1):
        ip = f"{root_ip}.{host}"
        scan_ip(ip, logger)
    logger.info("IP探测完成！")

if __name__ == "__main__":
    main()

十、AI 工具辅助学习

推荐使用 AI 工具（如豆包）提升 Python 学习效率，核心用法：

1. 创建专属智能体：定义智能体名称（如 "Python 专家"）和描述（如 "解答 Python 语法、模块使用问题"）；

2. 提问场景：查询模块函数用法、调试代码错误、生成示例代码；

3. 优势：学习效率更高，可根据需求定制化解答，适合快速掌握陌生模块。