Python文件操作与正则表达式实战
项目地址: https://gitcode.com/GitHub_Trending/he/Hello-Python 本文全面介绍了Python中文件操作和正则表达式的核心知识与实战技巧。内容涵盖文件读写操作模式详解（包括r、w、a、x等模式及其组合使用），CSV/JSON/TXT三种常见文件格式的处理方法，以及正则表达式的基础语法和高级应用。通过丰富的代码示例和实际场景演示，帮助读者掌握文本处理的完整技能栈，从基础文件操作到复杂的模式匹配与数据提取。
文件读写操作模式详解
Python提供了多种文件操作模式，每种模式都有其特定的用途和适用场景。掌握这些模式对于高效、安全地进行文件操作至关重要。让我们深入探讨Python中主要的文件读写操作模式。
基本文件操作模式
Python的文件操作模式通过open()函数的第二个参数指定，主要包括以下几种：
| 模式 | 描述 | 文件存在 | 文件不存在 | 文件指针位置 |
|---|---|---|---|---|
r | 只读模式 | 打开文件 | 抛出异常 | 文件开头 |
w | 写入模式 | 清空内容 | 创建文件 | 文件开头 |
a | 追加模式 | 打开文件 | 创建文件 | 文件末尾 |
x | 独占创建 | 抛出异常 | 创建文件 | 文件开头 |
b | 二进制模式 | - | - | - |
t | 文本模式 | - | - | - |
+ | 读写模式 | - | - | - |
读写模式组合
在实际应用中，我们经常使用模式组合来满足不同的需求：
# 读写模式示例
file = open("example.txt", "r+") # 读写模式，文件必须存在
file = open("example.txt", "w+") # 读写模式，会清空文件内容
file = open("example.txt", "a+") # 读写模式，追加到文件末尾
模式详解与示例
1. 只读模式 (r)
只读模式用于读取文件内容，不允许修改：
# 读取文本文件
with open("data.txt", "r") as file:
content = file.read()
print(content)
# 逐行读取
with open("data.txt", "r") as file:
for line in file:
print(line.strip())
2. 写入模式 (w)
写入模式会清空文件原有内容，从头开始写入：
# 写入文本文件
with open("output.txt", "w") as file:
file.write("第一行内容\n")
file.write("第二行内容\n")
# 写入多行内容
lines = ["第一行", "第二行", "第三行"]
with open("output.txt", "w") as file:
file.writelines(line + "\n" for line in lines)
3. 追加模式 (a)
追加模式在文件末尾添加内容，不会清空原有数据：
# 追加内容到文件
with open("log.txt", "a") as file:
import datetime
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
file.write(f"[{timestamp}] 系统启动\n")
4. 读写组合模式
二进制模式操作
二进制模式用于处理非文本文件，如图片、音频、视频等：
# 读取二进制文件
with open("image.jpg", "rb") as file:
image_data = file.read()
# 写入二进制文件
with open("copy.jpg", "wb") as file:
file.write(image_data)
文件指针操作
文件指针控制读写位置，常用的操作方法：
with open("example.txt", "r+") as file:
# 获取当前指针位置
position = file.tell()
print(f"当前位置: {position}")
# 读取前10个字符
content = file.read(10)
print(f"前10个字符: {content}")
# 移动指针到文件开头
file.seek(0)
# 移动到第5个字节
file.seek(5)
# 从当前位置向后移动3个字节
file.seek(3, 1)
# 从文件末尾向前移动5个字节
file.seek(-5, 2)
实战示例：日志文件处理
class LogHandler:
def __init__(self, filename):
self.filename = filename
def read_logs(self):
"""读取日志文件内容"""
try:
with open(self.filename, "r") as file:
return file.readlines()
except FileNotFoundError:
return []
def write_log(self, message):
"""写入日志信息"""
import datetime
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log_entry = f"[{timestamp}] {message}\n"
with open(self.filename, "a") as file:
file.write(log_entry)
def clear_logs(self):
"""清空日志文件"""
with open(self.filename, "w") as file:
file.write("") # 写入空内容清空文件
# 使用示例
logger = LogHandler("app.log")
logger.write_log("应用程序启动")
logger.write_log("用户登录成功")
logs = logger.read_logs()
for log in logs:
print(log.strip())
错误处理与最佳实践
def safe_file_operation(filename, mode, operation):
"""
安全的文件操作封装
"""
try:
with open(filename, mode) as file:
return operation(file)
except FileNotFoundError:
print(f"文件 {filename} 不存在")
return None
except PermissionError:
print(f"没有权限访问文件 {filename}")
return None
except IOError as e:
print(f"文件操作错误: {e}")
return None
# 使用安全封装读取文件
content = safe_file_operation("data.txt", "r", lambda f: f.read())
if content:
print("文件内容:", content)
模式选择指南
根据不同的需求场景，选择合适的文件操作模式：
| 场景 | 推荐模式 | 说明 |
|---|---|---|
| 读取配置文件 | r | 只读，避免意外修改 |
| 写入临时数据 | w | 清空旧内容，写入新数据 |
| 记录日志 | a | 追加模式，保留历史记录 |
| 读写配置文件 | r+ | 需要文件已存在 |
| 创建新数据文件 | w+ | 读写模式，文件不存在时创建 |
| 二进制文件处理 | rb/wb | 处理图片、音频等二进制数据 |
掌握这些文件操作模式，能够帮助你在Python项目中更加灵活和高效地处理文件读写任务。记住始终使用with语句来确保文件正确关闭，避免资源泄漏。
CSV/JSON/TXT文件处理实战
在Python编程中，文件操作是日常开发中不可或缺的重要技能。CSV、JSON和TXT是三种最常见的数据存储格式，每种格式都有其特定的应用场景和处理方式。本文将深入探讨这三种文件格式的Python处理方法，并通过实际代码示例展示如何高效地进行文件读写操作。
CSV文件处理
CSV（Comma-Separated Values）文件是一种以纯文本形式存储表格数据的简单格式，广泛应用于数据交换和数据分析场景。
基本CSV读写操作
import csv
# 写入CSV文件
with open('data.csv', 'w', newline='', encoding='utf-8') as csvfile:
writer = csv.writer(csvfile)
writer.writerow(['姓名', '年龄', '城市', '职业'])
writer.writerow(['张三', 28, '北京', '工程师'])
writer.writerow(['李四', 32, '上海', '设计师'])
writer.writerow(['王五', 25, '广州', '产品经理'])
# 读取CSV文件
with open('data.csv', 'r', encoding='utf-8') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
print(row)
使用字典方式处理CSV
import csv
# 使用DictWriter写入
with open('employees.csv', 'w', newline='', encoding='utf-8') as csvfile:
fieldnames = ['id', 'name', 'department', 'salary']
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
writer.writerow({'id': 1, 'name': '张三', 'department': '技术部', 'salary': 15000})
writer.writerow({'id': 2, 'name': '李四', 'department': '设计部', 'salary': 12000})
writer.writerow({'id': 3, 'name': '王五', 'department': '市场部', 'salary': 10000})
# 使用DictReader读取
with open('employees.csv', 'r', encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
print(f"{row['name']} - {row['department']}: ¥{row['salary']}")
CSV数据处理的高级技巧
import csv
from collections import defaultdict
# 数据统计示例
def analyze_csv_data(filename):
department_stats = defaultdict(lambda: {'count': 0, 'total_salary': 0})
with open(filename, 'r', encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
dept = row['department']
salary = float(row['salary'])
department_stats[dept]['count'] += 1
department_stats[dept]['total_salary'] += salary
# 计算平均薪资
for dept, stats in department_stats.items():
avg_salary = stats['total_salary'] / stats['count']
print(f"{dept}: {stats['count']}人, 平均薪资: ¥{avg_salary:.2f}")
analyze_csv_data('employees.csv')
JSON文件处理
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成。
基本JSON读写操作
import json
# 创建示例数据
user_data = {
"users": [
{
"id": 1,
"name": "张三",
"email": "zhangsan@example.com",
"preferences": {
"theme": "dark",
"language": "zh-CN",
"notifications": True
},
"roles": ["admin", "user"]
},
{
"id": 2,
"name": "李四",
"email": "lisi@example.com",
"preferences": {
"theme": "light",
"language": "en-US",
"notifications": False
},
"roles": ["user"]
}
],
"metadata": {
"version": "1.0",
"created_at": "2024-01-15",
"total_users": 2
}
}
# 写入JSON文件
with open('users.json', 'w', encoding='utf-8') as jsonfile:
json.dump(user_data, jsonfile, ensure_ascii=False, indent=2)
# 读取JSON文件
with open('users.json', 'r', encoding='utf-8') as jsonfile:
loaded_data = json.load(jsonfile)
print(f"版本: {loaded_data['metadata']['version']}")
print(f"用户数量: {loaded_data['metadata']['total_users']}")
for user in loaded_data['users']:
print(f"用户: {user['name']} - {user['email']}")
JSON数据的复杂操作
import json
from datetime import datetime
# 高级JSON操作示例
class UserManager:
def __init__(self, filename='users.json'):
self.filename = filename
self.users = self.load_users()
def load_users(self):
try:
with open(self.filename, 'r', encoding='utf-8') as f:
return json.load(f)
except FileNotFoundError:
return {"users": [], "metadata": {"version": "1.0", "created_at": datetime.now().isoformat()}}
def save_users(self):
self.users['metadata']['updated_at'] = datetime.now().isoformat()
with open(self.filename, 'w', encoding='utf-8') as f:
json.dump(self.users, f, ensure_ascii=False, indent=2)
def add_user(self, name, email, **kwargs):
new_user = {
"id": len(self.users['users']) + 1,
"name": name,
"email": email,
"created_at": datetime.now().isoformat(),
**kwargs
}
self.users['users'].append(new_user)
self.users['metadata']['total_users'] = len(self.users['users'])
self.save_users()
return new_user
def find_user_by_email(self, email):
return next((user for user in self.users['users'] if user['email'] == email), None)
# 使用示例
manager = UserManager()
manager.add_user("王五", "wangwu@example.com", roles=["user"], preferences={"theme": "light"})
user = manager.find_user_by_email("wangwu@example.com")
print(f"找到用户: {user['name']}")
TXT文件处理
纯文本文件是最基础的文件格式，适用于存储简单的文本数据、配置文件、日志文件等。
基本文本文件操作
# 写入文本文件
with open('log.txt', 'w', encoding='utf-8') as txtfile:
txtfile.write("系统日志文件\n")
txtfile.write("=" * 20 + "\n")
txtfile.write("2024-01-15 10:30:15 - 系统启动成功\n")
txtfile.write("2024-01-15 10:35:22 - 用户登录: zhangsan\n")
txtfile.write("2024-01-15 10:40:18 - 数据库连接建立\n")
# 读取整个文件
with open('log.txt', 'r', encoding='utf-8') as txtfile:
content = txtfile.read()
print("文件内容:")
print(content)
# 逐行读取
print("\n逐行读取:")
with open('log.txt', 'r', encoding='utf-8') as txtfile:
for line_num, line in enumerate(txtfile, 1):
print(f"{line_num}: {line.strip()}")
高级文本处理技巧
import re
from collections import Counter
class LogAnalyzer:
def __init__(self, filename):
self.filename = filename
self.lines = self.read_lines()
def read_lines(self):
with open(self.filename, 'r', encoding='utf-8') as f:
return [line.strip() for line in f if line.strip()]
def count_events(self):
"""统计不同类型的事件"""
events = []
pattern = r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} - (.*)'
for line in self.lines:
match = re.search(pattern, line)
if match:
events.append(match.group(1))
return Counter(events)
def filter_by_keyword(self, keyword):
"""根据关键词过滤日志"""
return [line for line in self.lines if keyword.lower() in line.lower()]
def get_timeline(self):
"""获取时间线统计"""
timeline = {}
pattern = r'(\d{4}-\d{2}-\d{2}) \d{2}:\d{2}:\d{2}'
for line in self.lines:
match = re.search(pattern, line)
if match:
date = match.group(1)
timeline[date] = timeline.get(date, 0) + 1
return timeline
# 使用示例
analyzer = LogAnalyzer('log.txt')
print("事件统计:", analyzer.count_events())
print("包含'用户'的日志:", analyzer.filter_by_keyword('用户'))
print("时间线统计:", analyzer.get_timeline())
三种格式的比较与选择
为了更好地理解不同文件格式的特点，下面通过一个对比表格来展示它们的特性：
| 特性 | CSV | JSON | TXT |
|---|---|---|---|
| 数据结构 | 表格形式 | 层次化结构 | 纯文本 |
| 可读性 | 中等 | 高 | 高 |
| 机器解析 | 容易 | 非常容易 | 需要自定义解析 |
| 数据复杂度 | 简单到中等 | 高 | 低 |
| 文件大小 | 较小 | 中等 | 最小 |
| 适用场景 | 表格数据、数据分析 | 配置数据、API响应 | 日志、配置文件 |
综合实战：数据格式转换
在实际项目中，经常需要在不同格式之间进行数据转换。下面展示一个综合示例：
import csv
import json
from datetime import datetime
def csv_to_json(csv_filename, json_filename):
"""将CSV文件转换为JSON格式"""
data = {"records": [], "metadata": {}}
with open(csv_filename, 'r', encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
data["records"].append(row)
data["metadata"] = {
"conversion_date": datetime.now().isoformat(),
"source_format": "CSV",
"target_format": "JSON",
"record_count": len(data["records"])
}
with open(json_filename, 'w', encoding='utf-8') as jsonfile:
json.dump(data, jsonfile, ensure_ascii=False, indent=2)
return data
def json_to_txt(json_filename, txt_filename, template=None):
"""将JSON文件转换为自定义文本格式"""
with open(json_filename, 'r', encoding='utf-8') as jsonfile:
data = json.load(jsonfile)
if template is None:
template = "记录 {index}: {data}\n"
with open(txt_filename, 'w', encoding='utf-8') as txtfile:
txtfile.write(f"数据转换报告\n")
txtfile.write("=" * 40 + "\n")
txtfile.write(f"转换时间: {data['metadata']['conversion_date']}\n")
txtfile.write(f"记录数量: {data['metadata']['record_count']}\n")
txtfile.write("=" * 40 + "\n\n")
for i, record in enumerate(data['records'], 1):
line = template.format(index=i, data=json.dumps(record, ensure_ascii=False))
txtfile.write(line)
# 使用示例
csv_to_json('employees.csv', 'employees.json')
json_to_txt('employees.json', 'employees_report.txt')
错误处理与最佳实践
在处理文件操作时，良好的错误处理机制至关重要：
import json
import csv
import os
def safe_file_operation(operation, filename, *args, **kwargs):
"""安全的文件操作包装器"""
try:
return operation(filename, *args, **kwargs)
except FileNotFoundError:
print(f"错误: 文件 {filename} 不存在")
return None
except PermissionError:
print(f"错误: 没有权限访问文件 {filename}")
return None
except json.JSONDecodeError as e:
print(f"JSON解析错误: {e}")
return None
except Exception as e:
print(f"未知错误: {e}")
return None
# 安全读取JSON
def safe_json_read(filename):
def read_op(fname):
with open(fname, 'r', encoding='utf-8') as f:
return json.load(f)
return safe_file_operation(read_op, filename)
# 安全写入CSV
def safe_csv_write(filename, data, fieldnames):
def write_op(fname):
with open(fname, 'w', newline='', encoding='utf-8') as f:
writer = csv.DictWriter(f, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(data)
return True
return safe_file_operation(write_op, filename)
# 使用示例
data = safe_json_read('users.json')
if data:
print("成功读取JSON数据")
通过本文的详细讲解和代码示例，相信你已经掌握了Python中CSV、JSON和TXT文件处理的核心技能。在实际开发中，根据具体需求选择合适的文件格式，并遵循最佳实践，将大大提高代码的健壮性和可维护性。
正则表达式基础语法
正则表达式（Regular Expression，简称Regex）是一种强大的文本处理工具，它使用特定的语法模式来匹配、查找和操作字符串。在Python中，正则表达式通过内置的re模块提供支持，是处理文本数据的必备技能。
正则表达式基本概念
正则表达式由普通字符（如字母、数字）和特殊字符（称为元字符）组成，这些字符组合在一起形成一个搜索模式。理解正则表达式的核心在于掌握这些元字符的含义和使用方法。
常用元字符及其功能
| 元字符 | 描述 | 示例 | 匹配结果 |
|---|---|---|---|
. | 匹配任意单个字符（除换行符） | h.llo | hello, hallo, hxllo |
^ | 匹配字符串的开始 | ^Hello | Hello World |
$ | 匹配字符串的结束 | World$ | Hello World |
* | 匹配前一个字符0次或多次 | he*llo | hllo, hello, heeeeello |
+ | 匹配前一个字符1次或多次 | he+llo | hello, heeeeello |
? | 匹配前一个字符0次或1次 | he?llo | hllo, hello |
{n} | 匹配前一个字符恰好n次 | he{2}llo | hello |
{n,} | 匹配前一个字符至少n次 | he{2,}llo | hello, heeeeello |
{n,m} | 匹配前一个字符n到m次 | he{1,3}llo | hello, heello, heeello |
字符类与字符集
字符类使用方括号[]定义，用于匹配方括号内的任意一个字符。
import re
# 匹配元音字母
pattern = r"[aeiou]"
text = "Hello World"
result = re.findall(pattern, text)
print(result) # ['e', 'o', 'o']
# 匹配数字
pattern = r"[0-9]"
text = "Year 2024"
result = re.findall(pattern, text)
print(result) # ['2', '0', '2', '4']
# 排除特定字符
pattern = r"[^0-9]" # 匹配非数字字符
text = "Year 2024"
result = re.findall(pattern, text)
print(result) # ['Y', 'e', 'a', 'r', ' ']
预定义字符类
Python提供了一些预定义的字符类，简化了常见模式的编写：
| 字符类 | 等价形式 | 描述 |
|---|---|---|
\d | [0-9] | 匹配任意数字 |
\D | [^0-9] | 匹配任意非数字字符 |
\w | [a-zA-Z0-9_] | 匹配字母、数字、下划线 |
\W | [^a-zA-Z0-9_] | 匹配非字母、数字、下划线字符 |
\s | [ \t\n\r\f\v] | 匹配空白字符 |
\S | [^ \t\n\r\f\v] | 匹配非空白字符 |
import re
# 使用预定义字符类
text = "Contact: email@example.com, Phone: 123-456-7890"
# 匹配所有数字
digits = re.findall(r"\d", text)
print("Digits:", digits) # ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
# 匹配所有单词字符
words = re.findall(r"\w+", text)
print("Words:", words) # ['Contact', 'email', 'example', 'com', 'Phone', '123', '456', '7890']
# 匹配空白字符
spaces = re.findall(r"\s", text)
print("Spaces:", spaces) # [' ', ':', ' ', ',', ' ', ':', ' ']
分组与捕获
圆括号()用于创建捕获组，可以对匹配的内容进行分组和提取：
import re
# 简单的分组示例
text = "John Doe, Jane Smith, Bob Johnson"
# 匹配姓名（名和姓）
pattern = r"(\w+)\s(\w+)"
matches = re.findall(pattern, text)
print("Name matches:", matches) # [('John', 'Doe'), ('Jane', 'Smith'), ('Bob', 'Johnson')]
# 使用分组提取特定信息
email_text = "Emails: john@example.com, jane.doe@company.org"
email_pattern = r"(\w+[\.]?\w+)@(\w+)\.(\w+)"
emails = re.findall(email_pattern, email_text)
print("Email components:", emails) # [('john', 'example', 'com'), ('jane.doe', 'company', 'org')]
选择与或操作
竖线|用于表示"或"操作，可以匹配多个模式中的任意一个：
import re
text = "I like cats and dogs, but I prefer cats."
# 匹配"cats"或"dogs"
pattern = r"cats|dogs"
matches = re.findall(pattern, text)
print("Animals:", matches) # ['cats', 'dogs', 'cats']
# 结合分组使用
pattern = r"(like|prefer)\s(\w+)"
matches = re.findall(pattern, text)
print("Preferences:", matches) # [('like', 'cats'), ('prefer', 'cats')]
实际应用示例
让我们通过一些实际的例子来巩固正则表达式的基础语法：
import re
# 示例1：验证电话号码格式
def validate_phone_number(phone):
pattern = r"^\(\d{3}\) \d{3}-\d{4}$"
return bool(re.match(pattern, phone))
print(validate_phone_number("(123) 456-7890")) # True
print(validate_phone_number("123-456-7890")) # False
# 示例2：提取日期信息
text = "Meeting on 2024-12-25 and 2025-01-01"
pattern = r"(\d{4})-(\d{2})-(\d{2})"
dates = re.findall(pattern, text)
print("Dates:", dates) # [('2024', '12', '25'), ('2025', '01', '01')]
# 示例3：简单的HTML标签匹配
html = "<div>Hello</div><p>World</p>"
pattern = r"<(\w+)>(.*?)</\1>"
tags = re.findall(pattern, html)
print("HTML tags:", tags) # [('div', 'Hello'), ('p', 'World')]
正则表达式流程图
下面通过流程图展示正则表达式的匹配过程：
常见模式总结表
| 模式类型 | 语法 | 示例 | 描述 |
|---|---|---|---|
| 精确匹配 | text | hello | 匹配精确文本 |
| 字符类 | [abc] | [aeiou] | 匹配括号内任意字符 |
| 范围匹配 | [a-z] | [0-9] | 匹配指定范围内的字符 |
| 排除匹配 | [^abc] | [^0-9] | 匹配不在括号内的字符 |
| 任意字符 | . | h.llo | 匹配任意单个字符 |
| 开始匹配 | ^ | ^Hello | 匹配字符串开始 |
| 结束匹配 | $ | end$ | 匹配字符串结束 |
| 零次或多次 | * | he*llo | 匹配前一个字符0次或多次 |
| 一次或多次 | + | he+llo | 匹配前一个字符1次或多次 |
| 零次或一次 | ? | he?llo | 匹配前一个字符0次或1次 |
| 精确次数 | {n} | he{2}llo | 匹配前一个字符恰好n次 |
掌握这些基础语法是使用正则表达式的关键。在实际应用中，这些基本构建块可以组合成复杂的模式来解决各种文本处理问题。记住，正则表达式是一门需要实践的语言，多练习才能熟练掌握。
模式匹配与文本搜索
正则表达式是Python中处理文本模式的强大工具，它能够帮助我们进行复杂的模式匹配和文本搜索操作。在Hello-Python项目的Intermediate目录中，07_regular_expressions.py文件详细展示了正则表达式的各种应用场景。
正则表达式基础操作
Python通过re模块提供正则表达式功能，包含多种核心方法用于模式匹配：
match方法 - 从字符串开头匹配
import re
my_string = "Esta es la lección número 7: Lección llamada Expresiones Regulares"
match = re.match("Esta es la lección", my_string, re.I)
print(match) # 返回匹配对象
start, end = match.span()
print(my_string[start:end]) # 输出匹配的文本
match()方法从字符串开头进行匹配，如果开头不匹配则返回None。re.I参数表示忽略大小写。
search方法 - 搜索整个字符串
search = re.search("lección", my_string, re.I)
print(search)
start, end = search.span()
print(my_string[start:end])
与match()不同，search()会在整个字符串中搜索匹配项，找到第一个匹配即返回。
findall方法 - 查找所有匹配项
findall = re.findall("lección", my_string, re.I)
print(findall) # 返回所有匹配的字符串列表
findall()返回所有非重叠匹配的字符串列表，非常适合批量提取信息。
字符串处理操作
正则表达式还提供了强大的字符串处理功能：
split方法 - 基于模式分割字符串
print(re.split(":", my_string))
# 输出: ['Esta es la lección número 7', ' Lección llamada Expresiones Regulares']
split()方法使用正则表达式模式作为分隔符来分割字符串。
sub方法 - 替换匹配文本
print(re.sub("[l|L]ección", "LECCIÓN", my_string))
# 输出: Esta es la LECCIÓN número 7: LECCIÓN llamada Expresiones Regulares
print(re.sub("Expresiones Regulares", "RegEx", my_string))
# 输出: Esta es la lección número 7: Lección llamada RegEx
sub()方法用于替换匹配的模式，支持复杂的替换逻辑。
正则表达式模式语法
正则表达式的强大之处在于其丰富的模式语法：
常用模式示例
# 字符类模式
pattern = r"[lL]ección" # 匹配"lección"或"Lección"
print(re.findall(pattern, my_string))
pattern = r"[lL]ección|Expresiones" # 匹配"lección"或"Expresiones"
print(re.findall(pattern, my_string))
# 数字匹配
pattern = r"[0-9]" # 匹配单个数字
print(re.findall(pattern, my_string))
pattern = r"\d" # 等价于[0-9]
print(re.findall(pattern, my_string))
pattern = r"\D" # 匹配非数字字符
print(re.findall(pattern, my_string))
# 贪婪匹配
pattern = r"[l].*" # 匹配以'l'开头，后面跟着任意字符
print(re.findall(pattern, my_string))
电子邮件验证实战
正则表达式在数据验证方面特别有用，以下是一个电子邮件验证的完整示例：
email = "mouredev@mouredev.com"
pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z-.]+$"
# 使用不同方法验证
print(re.match(pattern, email)) # 从开头匹配
print(re.search(pattern, email)) # 搜索整个字符串
print(re.findall(pattern, email)) # 查找所有匹配
# 测试不同域名格式
email = "mouredev@mouredev.com.mx"
print(re.findall(pattern, email))
这个模式分解如下：
| 模式部分 | 描述 | 示例匹配 |
|---|---|---|
^[a-zA-Z0-9_.+-]+ | 用户名部分，包含字母、数字、下划线、点、加号和减号 | mouredev |
@ | 必须的@符号 | @ |
[a-zA-Z0-9-]+ | 域名部分 | mouredev |
\. | 必须的点 | . |
[a-zA-Z-.]+$ | 顶级域名 | com 或 com.mx |
实际应用场景
正则表达式在文本处理中有广泛的应用：
- 数据提取：从日志文件、文档或网页中提取特定信息
- 数据验证：验证用户输入的格式（邮箱、电话、URL等）
- 文本清洗：移除或替换不需要的字符或格式
- 字符串分割：基于复杂模式分割文本
- 搜索替换：批量修改文本内容
# 实际应用：提取文本中的所有数字
text = "订单号: 12345, 金额: $99.99, 数量: 3件"
numbers = re.findall(r'\d+\.?\d*', text)
print(numbers) # 输出: ['12345', '99.99', '3']
# 实际应用：验证电话号码格式
phone_pattern = r'^(\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$'
valid_phones = ["+1-234-567-8901", "1234567890", "(123) 456-7890"]
for phone in valid_phones:
if re.match(phone_pattern, phone):
print(f"{phone} 是有效的电话号码")
通过掌握正则表达式的模式匹配和文本搜索技术，你能够高效地处理各种文本处理任务，大大提升编程效率。
总结
本文系统性地讲解了Python文件操作与正则表达式的完整知识体系。文件操作部分详细介绍了各种读写模式的特点和适用场景，以及CSV、JSON、TXT三种格式的处理方法；正则表达式部分则从基础语法到高级应用，涵盖了模式匹配、文本搜索、数据验证等实用技能。通过本文的学习，读者能够掌握高效处理文本数据的综合能力，为实际项目开发奠定坚实基础。建议读者结合实际需求多加练习，才能真正熟练掌握这些强大的文本处理工具。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
