Python常见内置模块详解与实战示例
作为Python运维工程师，熟练掌握Python内置模块是提高工作效率的关键。Python丰富的标准库让我们能够不依赖第三方包就能完成大多数系统管理任务。本文将详细介绍运维工作中最实用的20个内置模块，并提供实际应用示例。
一、系统操作相关模块
1. os模块 - 操作系统接口
import os
# 获取当前工作目录
current_dir = os.getcwd()
print(f"当前目录: {current_dir}")
# 列出目录内容
files = os.listdir('.')
print(f"目录内容: {files}")
# 创建目录
os.makedirs('/tmp/test_dir', exist_ok=True)
# 获取环境变量
path = os.environ.get('PATH')
print(f"PATH环境变量: {path}")
# 执行系统命令
os.system('ls -l')
2. sys模块 - 系统相关功能
import sys
# 获取Python解释器版本
print(f"Python版本: {sys.version}")
# 获取命令行参数
print(f"脚本参数: {sys.argv}")
# 模块搜索路径
print(f"模块路径: {sys.path}")
# 标准输入输出
sys.stdout.write("输出到标准输出\n")
sys.stderr.write("输出到错误输出\n")
# 退出程序
# sys.exit(0) # 正常退出
3. subprocess模块 - 进程管理
import subprocess
# 执行命令并获取输出
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(f"命令输出:\n{result.stdout}")
# 检查服务状态
def check_service(service_name):
try:
result = subprocess.run(
['systemctl', 'is-active', service_name],
capture_output=True, text=True, timeout=10
)
return result.stdout.strip() == 'active'
except subprocess.TimeoutExpired:
return False
# 实时输出命令执行过程
def run_command_with_realtime_output(cmd):
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, text=True)
while True:
output = process.stdout.readline()
if output == '' and process.poll() is not None:
break
if output:
print(output.strip())
return process.poll()
# 使用示例
nginx_status = check_service('nginx')
print(f"Nginx服务状态: {'运行中' if nginx_status else '未运行'}")
二、文件和目录操作
4. pathlib模块 - 面向对象的文件系统路径
from pathlib import Path
# 创建Path对象
current_path = Path('.')
config_path = Path('/etc/nginx/nginx.conf')
# 路径操作
print(f"配置文件是否存在: {config_path.exists()}")
print(f"是否是文件: {config_path.is_file()}")
print(f"父目录: {config_path.parent}")
# 遍历目录
for file_path in current_path.glob('*.py'):
print(f"Python文件: {file_path}")
# 读写文件
log_file = Path('/var/log/app.log')
if log_file.exists():
content = log_file.read_text()
print(f"文件大小: {len(content)} 字节")
5. shutil模块 - 高级文件操作
import shutil
# 复制文件
shutil.copy2('source.txt', 'backup/source_backup.txt')
# 递归复制目录
shutil.copytree('source_dir', 'backup_dir')
# 删除目录
shutil.rmtree('temp_dir', ignore_errors=True)
# 磁盘使用情况
total, used, free = shutil.disk_usage('/')
print(f"磁盘使用情况: 总共{total//(2**30)}GB, 已用{used//(2**30)}GB, 剩余{free//(2**30)}GB")
6. glob模块 - 文件模式匹配
import glob
# 查找所有Python文件
python_files = glob.glob('*.py')
print(f"Python文件: {python_files}")
# 递归查找日志文件
log_files = glob.glob('**/*.log', recursive=True)
print(f"日志文件: {log_files}")
# 查找配置目录下的所有.conf文件
config_files = glob.glob('/etc/*/*.conf')
print(f"配置文件: {config_files}")
三、时间和日期处理
7. datetime模块 - 日期时间处理
from datetime import datetime, timedelta
# 当前时间
now = datetime.now()
print(f"当前时间: {now}")
# 时间格式化
formatted = now.strftime('%Y-%m-%d %H:%M:%S')
print(f"格式化时间: {formatted}")
# 时间计算
one_week_ago = now - timedelta(days=7)
print(f"一周前: {one_week_ago}")
# 日志时间戳
def create_timestamped_log(message):
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
return f"[{timestamp}] {message}"
print(create_timestamped_log("系统启动完成"))
8. time模块 - 时间相关功能
import time
# 获取时间戳
timestamp = time.time()
print(f"当前时间戳: {timestamp}")
# 程序暂停
print("开始执行任务...")
time.sleep(2) # 暂停2秒
print("任务完成!")
# 计算执行时间
def monitor_function_performance():
start_time = time.time()
# 模拟耗时操作
time.sleep(1)
end_time = time.time()
execution_time = end_time - start_time
print(f"函数执行时间: {execution_time:.2f}秒")
monitor_function_performance()
四、数据持久化和交换
9. json模块 - JSON数据处理
import json
# 配置数据
config_data = {
"database": {
"host": "localhost",
"port": 5432,
"username": "admin"
},
"logging": {
"level": "INFO",
"file": "/var/log/app.log"
}
}
# 保存配置到文件
with open('config.json', 'w') as f:
json.dump(config_data, f, indent=2)
# 从文件读取配置
with open('config.json', 'r') as f:
loaded_config = json.load(f)
print(f"数据库主机: {loaded_config['database']['host']}")
10. pickle模块 - Python对象序列化
import pickle
# 要保存的数据
server_stats = {
'cpu_usage': [45, 60, 55, 70],
'memory_usage': 85.5,
'timestamp': datetime.now()
}
# 序列化到文件
with open('stats.pkl', 'wb') as f:
pickle.dump(server_stats, f)
# 从文件反序列化
with open('stats.pkl', 'rb') as f:
loaded_stats = pickle.load(f)
print(f"CPU使用率: {loaded_stats['cpu_usage']}")
五、系统监控和调试
11. psutil模块（需安装）的系统替代方案
import os
import time
def get_system_info():
"""获取基本系统信息"""
# CPU使用率（简单实现）
with open('/proc/loadavg') as f:
load_avg = f.read().split()[0:3]
# 内存信息
with open('/proc/meminfo') as f:
mem_lines = f.readlines()
total_mem = int(mem_lines[0].split()[1])
free_mem = int(mem_lines[1].split()[1])
memory_usage = (total_mem - free_mem) / total_mem * 100
# 磁盘使用情况
statvfs = os.statvfs('/')
disk_total = statvfs.f_blocks * statvfs.f_frsize
disk_free = statvfs.f_bfree * statvfs.f_frsize
disk_usage = (disk_total - disk_free) / disk_total * 100
return {
'load_average': load_avg,
'memory_usage_percent': round(memory_usage, 1),
'disk_usage_percent': round(disk_usage, 1)
}
info = get_system_info()
print(f"系统负载: {info['load_average']}")
print(f"内存使用率: {info['memory_usage_percent']}%")
print(f"磁盘使用率: {info['disk_usage_percent']}%")
12. logging模块 - 日志记录
import logging
import logging.handlers
def setup_logging():
"""配置日志系统"""
logger = logging.getLogger('ops_logger')
logger.setLevel(logging.INFO)
# 文件处理器（按大小轮转）
file_handler = logging.handlers.RotatingFileHandler(
'application.log', maxBytes=10485760, backupCount=5
)
# 控制台处理器
console_handler = logging.StreamHandler()
# 格式化器
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
return logger
# 使用日志
logger = setup_logging()
logger.info("应用程序启动")
logger.warning("磁盘空间不足")
logger.error("数据库连接失败")
六、网络和通信
13. socket模块 - 网络通信
import socket
def check_port(host, port, timeout=3):
"""检查端口是否开放"""
try:
with socket.create_connection((host, port), timeout=timeout):
return True
except (socket.timeout, ConnectionRefusedError):
return False
# 检查常用服务端口
services = {
22: 'SSH',
80: 'HTTP',
443: 'HTTPS',
3306: 'MySQL'
}
host = 'localhost'
print(f"检查主机 {host} 的服务状态:")
for port, service in services.items():
status = "开放" if check_port(host, port) else "关闭"
print(f" {service}(端口{port}): {status}")
14. urllib模块 - URL处理
from urllib import request, parse
def check_website(url):
"""检查网站可访问性"""
try:
response = request.urlopen(url, timeout=10)
return response.getcode(), len(response.read())
except Exception as e:
return None, str(e)
# 检查网站状态
urls = ['https://www.google.com', 'https://www.github.com']
for url in urls:
status_code, content_length = check_website(url)
if status_code:
print(f"{url} - 状态码: {status_code}, 内容长度: {content_length}")
else:
print(f"{url} - 错误: {content_length}")
七、数据处理和压缩
15. csv模块 - CSV文件处理
import csv
def parse_server_logs(csv_file):
"""解析服务器日志CSV文件"""
servers = []
with open(csv_file, 'r') as f:
reader = csv.DictReader(f)
for row in reader:
servers.append(row)
return servers
# 生成服务器清单
def generate_server_inventory(servers, output_file):
with open(output_file, 'w', newline='') as f:
fieldnames = ['hostname', 'ip', 'role', 'environment']
writer = csv.DictWriter(f, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(servers)
# 示例数据
server_data = [
{'hostname': 'web01', 'ip': '192.168.1.10', 'role': 'web', 'environment': 'prod'},
{'hostname': 'db01', 'ip': '192.168.1.20', 'role': 'database', 'environment': 'prod'}
]
generate_server_inventory(server_data, 'servers.csv')
16. gzip/zlib模块 - 数据压缩
import gzip
import zlib
def compress_log_file(source_file, compressed_file):
"""压缩日志文件"""
with open(source_file, 'rb') as f_in:
with gzip.open(compressed_file, 'wb') as f_out:
f_out.writelines(f_in)
print(f"文件已压缩: {source_file} -> {compressed_file}")
def calculate_crc32(file_path):
"""计算文件CRC32校验和"""
with open(file_path, 'rb') as f:
return zlib.crc32(f.read())
# 使用示例
# compress_log_file('app.log', 'app.log.gz')
# crc_value = calculate_crc32('app.log.gz')
# print(f"文件校验和: {crc_value}")
八、其他实用模块
17. argparse模块 - 命令行参数解析
import argparse
def create_cli_parser():
"""创建命令行界面"""
parser = argparse.ArgumentParser(description='服务器监控工具')
parser.add_argument('--host', default='localhost',
help='要监控的主机地址')
parser.add_argument('--port', type=int, default=8080,
help='监控端口')
parser.add_argument('--interval', type=int, default=60,
help='监控间隔（秒）')
parser.add_argument('--log-level', choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
default='INFO', help='日志级别')
parser.add_argument('--config', help='配置文件路径')
return parser
# 使用示例
if __name__ == "__main__":
parser = create_cli_parser()
args = parser.parse_args()
print(f"监控配置: 主机={args.host}, 端口={args.port}, 间隔={args.interval}秒")
18. collections模块 - 容器数据类型
from collections import defaultdict, Counter, deque
# 使用defaultdict统计服务访问次数
service_access = defaultdict(int)
logs = ['web', 'db', 'web', 'cache', 'web', 'db']
for service in logs:
service_access[service] += 1
print(f"服务访问统计: {dict(service_access)}")
# 使用Counter进行频率统计
process_counts = Counter(['nginx', 'mysql', 'nginx', 'redis', 'nginx', 'mysql'])
print(f"进程频率: {process_counts.most_common(2)}")
# 使用deque实现固定长度日志队列
log_queue = deque(maxlen=5)
for i in range(10):
log_queue.append(f"日志条目 {i}")
print(f"最近5条日志: {list(log_queue)}")
19. itertools模块 - 迭代器工具
import itertools
# 生成IP地址范围
def generate_ip_range(base_ip, count):
base_parts = list(map(int, base_ip.split('.')))
for i in range(count):
ip_parts = base_parts.copy()
ip_parts[3] += i
yield '.'.join(map(str, ip_parts))
# 批量处理服务器
servers = [f'server{i:02d}' for i in range(1, 11)]
commands = ['status', 'restart', 'stop']
# 为每个服务器生成命令序列
for server, command in itertools.product(servers, commands):
print(f"在 {server} 上执行: {command}")
# 分批次处理
batch_size = 3
batches = [servers[i:i + batch_size] for i in range(0, len(servers), batch_size)]
for i, batch in enumerate(batches, 1):
print(f"批次 {i}: {batch}")
20. configparser模块 - 配置文件解析
import configparser
def create_sample_config():
"""创建示例配置文件"""
config = configparser.ConfigParser()
config['Database'] = {
'host': 'localhost',
'port': '5432',
'username': 'admin',
'password': 'secret',
'timeout': '30'
}
config['Logging'] = {
'level': 'INFO',
'file': '/var/log/app.log',
'max_size': '10485760',
'backup_count': '5'
}
with open('app.conf', 'w') as f:
config.write(f)
def read_config():
"""读取配置文件"""
config = configparser.ConfigParser()
config.read('app.conf')
db_host = config.get('Database', 'host')
log_level = config.get('Logging', 'level')
print(f"数据库主机: {db_host}")
print(f"日志级别: {log_level}")
return config
# 创建并读取配置
create_sample_config()
read_config()
实战案例：服务器健康检查脚本
#!/usr/bin/env python3
"""
服务器健康检查脚本
结合多个内置模块实现完整的监控功能
"""
import os
import sys
import time
import json
import argparse
from datetime import datetime, timedelta
from pathlib import Path
class ServerHealthChecker:
def __init__(self, config_path='config.json'):
self.config = self.load_config(config_path)
self.results = {}
def load_config(self, config_path):
"""加载配置文件"""
if Path(config_path).exists():
with open(config_path) as f:
return json.load(f)
return {
'checks': ['disk', 'memory', 'services'],
'warning_threshold': 80,
'critical_threshold': 90
}
def check_disk_usage(self):
"""检查磁盘使用率"""
try:
statvfs = os.statvfs('/')
total = statvfs.f_blocks * statvfs.f_frsize
free = statvfs.f_bfree * statvfs.f_frsize
used = total - free
usage_percent = (used / total) * 100
status = 'OK'
if usage_percent > self.config.get('critical_threshold', 90):
status = 'CRITICAL'
elif usage_percent > self.config.get('warning_threshold', 80):
status = 'WARNING'
return {
'status': status,
'usage_percent': round(usage_percent, 1),
'total_gb': round(total / (1024**3), 1),
'used_gb': round(used / (1024**3), 1)
}
except Exception as e:
return {'status': 'ERROR', 'error': str(e)}
def check_memory_usage(self):
"""检查内存使用率"""
try:
with open('/proc/meminfo') as f:
lines = f.readlines()
total = int(lines[0].split()[1])
free = int(lines[1].split()[1])
used = total - free
usage_percent = (used / total) * 100
status = 'OK'
if usage_percent > self.config.get('critical_threshold', 90):
status = 'CRITICAL'
elif usage_percent > self.config.get('warning_threshold', 80):
status = 'WARNING'
return {
'status': status,
'usage_percent': round(usage_percent, 1),
'total_mb': total // 1024,
'used_mb': used // 1024
}
except Exception as e:
return {'status': 'ERROR', 'error': str(e)}
def run_checks(self):
"""执行所有检查"""
print("开始服务器健康检查...")
print("=" * 50)
if 'disk' in self.config.get('checks', []):
self.results['disk'] = self.check_disk_usage()
print(f"磁盘检查: {self.results['disk']}")
if 'memory' in self.config.get('checks', []):
self.results['memory'] = self.check_memory_usage()
print(f"内存检查: {self.results['memory']}")
self.save_results()
return self.results
def save_results(self):
"""保存检查结果"""
timestamp = datetime.now().isoformat()
result_data = {
'timestamp': timestamp,
'results': self.results
}
with open('health_check.json', 'w') as f:
json.dump(result_data, f, indent=2)
print(f"检查结果已保存到 health_check.json")
def main():
parser = argparse.ArgumentParser(description='服务器健康检查工具')
parser.add_argument('--config', default='config.json',
help='配置文件路径')
parser.add_argument('--interval', type=int,
help='连续检查间隔（秒）')
args = parser.parse_args()
checker = ServerHealthChecker(args.config)
if args.interval:
# 连续监控模式
try:
while True:
checker.run_checks()
print(f"等待 {args.interval} 秒后再次检查...\n")
time.sleep(args.interval)
except KeyboardInterrupt:
print("\n监控已停止")
else:
# 单次检查模式
checker.run_checks()
if __name__ == "__main__":
main()
总结
Python的内置模块为运维工作提供了强大的工具集，掌握这些模块可以让我们：
- 提高效率：避免重复造轮子，直接使用经过验证的标准库
- 代码健壮：标准模块经过充分测试，稳定性有保障
- 可移植性：不依赖第三方包，环境部署更简单
- 维护性：使用标准接口，代码更易理解和维护
建议在日常运维工作中多练习使用这些模块，结合实际需求创造更多实用的自动化工具。记住，好的运维工程师不仅是问题的解决者，更是效率的创造者。
进一步学习建议：
- 阅读Python官方文档中每个模块的详细说明
- 参与开源项目，学习实际应用场景
- 定期复习和实践，形成肌肉记忆
希望本文能帮助你在Python运维道路上更进一步！
本文来自博客园，作者：dashery，转载请注明原文链接：https://www.cnblogs.com/ydswin/p/18071263
浙公网安备 33010602011771号