前言
在Python中，format方法和f-strings是两种常用的字符串插值方法。
name = "Haige"
age = "18"
print(f"{name} is {age} years old.")
# Haige is 18 years old.
而如果是要从字符串中提取期望的值呢？相信很多人的第一或第二想法是使用正则表达式。
熟悉正则表达式的人都明白，学习起来并不困难，写起来也相对容易。
然而，正则表达式几乎不具备可读性，维护起来确实令人头痛。别以为你写的那段正则表达式可以轻易驾驭它，过了一段时间你可能都无法认识它了。
可以毫不夸张地说，对于许多人来说，正则表达式是一种痛苦的经历。
今天，我要介绍给你一个解放你的好工具，让你远离正则表达式的噩梦，那就是 Python 中一个"鲜为人知"的库——parse。
Github地址：https://github.com/r1chardj0n3s/parse
初体验
假设我们有一组文本，其中包含了一些格式化的信息，比如日期、时间和事件。我们想要从这些文本中提取出这些信息。
text = "Event: Meeting Date: 2023-01-15 Time: 14:30 Location: Conference Room"
如果是你，你会怎么做呢？也许上来就是正则一把梭了。就像这样：
import re
text = "Event: Meeting Date: 2023-01-15 Time: 14:30 Location: Conference Room"
# 定义正则表达式模式
pattern = r"Event: (.+) Date: (\d{4}-\d{2}-\d{2}) Time: (\d{2}:\d{2}) Location: (.+)"
# 匹配文本
match = re.match(pattern, text)
if match:
event = match.group(1)
date = match.group(2)
time = match.group(3)
location = match.group(4)
print("Event:", event)
print("Date:", date)
print("Time:", time)
print("Location:", location)
else:
print("Failed to match the text")
输出结果：
Event: Meeting
Date: 2023-01-15
Time: 14:30
Location: Conference Room
不过，也许你该试试
parse库。
首先，我们需要安装 parse 库，可以通过 pip 进行安装：
pip install parse
我们想要从这个文本中提取出事件名称、日期、时间和地点。下面是使用 parse 库的方法：
from parse import parse
# 定义模板
template = "Event: {} Date: {} Time: {} Location: {}"
# 解析文本
result = parse(template, text)
if result:
event, date, time, location = result
print("Event:", event)
print("Date:", date)
print("Time:", time)
print("Location:", location)
else:
print("Failed to parse the text")
输出结果：
Event: Meeting
Date: 2023-01-15
Time: 14:30
Location: Conference Room
在这个示例中，我们首先定义了一个模板，模板中包含了我们要提取的信息的格式。然后，我们使用 parse 函数解析文本，如果解析成功，返回的结果是一个元组，包含了提取出的信息。最后，我们成功地从文本中提取出了事件名称、日期、时间和地点。
通过对比可以看出，使用
parse库进行字符串解析相对更加简洁、清晰，并且不容易出错。
而使用正则表达式虽然也可以完成相同的任务，但是需要编写更长的模式，并且容易出现错误，没有一丝美感可言。
parse库的基本用法
parse 的结果
parse的结果只有两种结果：
- 没有匹配上，
parse的值为None - 如果匹配上，
parse的值则为Result实例
from parse import parse
# 示例字符串
log_string = '192.168.0.1 - - [05/Feb/2024:12:30:45 +0800] "GET /index.html HTTP/1.1" 200 1234'
# 定义解析模式
pattern = '{ip} - - [{timestamp}] "{method} {url}" {status_code} {response_size}'
# 解析字符串
result = parse(pattern, log_string)
# 输出解析结果
if result:
print("IP:", result['ip'])
print("Timestamp:", result['timestamp'])
print("Method:", result['method'])
print("URL:", result['url'])
print("Status Code:", result['status_code'])
print("Response Size:", result['response_size'])
else:
print("匹配失败")
如果我们将正确格式的日志字符串作为输入，将会得到匹配成功的结果：
IP: 192.168.0.1
Timestamp: 05/Feb/2024:12:30:45 +0800
Method: GET
URL: /index.html
Status Code: 200
Response Size: 1234
常用方法
让我来逐个解释并举例说明 parse 库中的 search、findall、compile 和 with_pattern 方法的用法。
1. search 方法
search 方法用于在字符串中搜索与指定模式匹配的第一个结果，并返回解析结果。
from parse import search
# 示例字符串
text = "The price of the apple is $2.50."
# 定义解析模式
pattern = "The price of the {fruit} is ${price}."
# 使用 search 方法解析字符串
result = search(pattern, text)
# 访问解析结果
if result:
print("Fruit:", result['fruit'])
print("Price:", result['price'])
else:
print("未找到匹配项")
输出结果：
Fruit: apple
Price: 2
2. findall 方法
findall 方法用于在字符串中搜索所有与指定模式匹配的结果，并返回解析结果列表。
from parse import findall
# 示例字符串
text = "The prices are $2.50, $3.00, and $4.25."
# 定义解析模式
pattern = "${price:.2f}" # 使用 ":.2f" 匹配包含两位小数的浮点数
# 使用 findall 方法解析字符串
results = findall(pattern, text)
# 访问解析结果
if results:
for idx, price in enumerate(results, start=1):
# 将小数部分格式化为两位
formatted_price = "{:.2f}".format(price['price'])
print(f"Price {idx}: {formatted_price}")
else:
print("未找到匹配项")
输出结果：
Price 1: 2.50
Price 2: 3.00
Price 3: 4.25
3. compile 方法
compile 方法用于将解析模式编译为可重复使用的解析器对象。
from parse import compile
# 定义解析模式
pattern = "The price of the {fruit} is ${price}."
# 编译解析模式
parser = compile(pattern)
# 使用编译后的解析器对象解析字符串
result = parser.parse("The price of the apple is $2.50.")
# 访问解析结果
if result:
print("Fruit:", result['fruit'])
print("Price:", result['price'])
else:
print("未找到匹配项")
输出结果：
Fruit: apple
Price: 2.50
4. with_pattern 方法
with_pattern 方法用于绑定解析模式与要解析的字符串，并返回一个解析结果对象。
from parse import Parser, with_pattern
@with_pattern(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')
def email(text: str) -> str:
return text
compiler = Parser("my email address is {email:Email}", dict(Email=email))
legal_result = compiler.parse("my email address is xx@xxx.com") # legal email
illegal_result = compiler.parse("my email address is xx@xx") # illegal email
print(legal_result["email"])
print(illegal_result)
输出结果：
xx@xxx.com
None
捕获组：
from parse import *
@with_pattern(r'((\d+))', regex_group_count=2)
def parse_number2(text):
return int(text)
obj = parse('Answer: {:Number2} {:Number2}', 'Answer: 42 43', dict(Number2=parse_number2))
print(obj) # <Result (42, 43) {}>
将输入的文本转换为布尔值:
from parse import *
yesno_mapping = {
"yes": True, "no": False,
"on": True, "off": False,
"true": True, "false": False,
}
@with_pattern(r"|".join(yesno_mapping))
def parse_yesno(text):
return yesno_mapping[text.lower()]
obj = parse('Answer: {:bool}', 'Answer: yes', dict(bool=parse_yesno))
print(obj) # <Result (True,) {}>
obj2 = parse('Answer: {:bool}', 'Answer: off', dict(bool=parse_yesno))
print(obj2) # <Result (False,) {}>
匹配并类型转换
有的时候，我们希望提取的时候就按照我们的类型进行转换。
from parse import Parser
# 创建解析器对象并指定解析模式
parser = Parser("I have {count:d} apples", {})
# 示例字符串
text = "I have 5 apples"
# 使用解析器对象解析字符串
result = parser.parse(text)
# 访问解析结果
if result:
count = result['count']
print("Number of apples:", count)
print("Type of count:", type(count))
else:
print("未找到匹配项")
输出结果：
Number of apples: 5
Type of count: <class 'int'>
匹配时间：
from parse import parse
datetime = parse("{:%Y-%m-%d %H:%M:%S}", "2023-11-23 12:56:47")
print(datetime) # <Result (datetime.datetime(2023, 11, 23, 12, 56, 47),) {}>
print(datetime[0]) # 2023-11-23 12:56:47
更多类型请参考官方文档：
特殊对齐
from parse import *
text = "hello world , hello python"
# 右对齐
print(parse('hello {:>} , hello python', text))
# 左对齐
print(parse('hello {:<} , hello python', text))
# 居中对齐
print(parse('hello {:^} , hello python', text))
print(parse('hello{:^} , hello python', text))
输出结果：
<Result ('world ',) {}>
<Result (' world',) {}>
<Result ('world',) {}>
<Result ('world',) {}>
<Result ('world',) {}>
大小写敏感开关
parse库默认是不区分大小写的。如果需要开启大小写敏感模式，可以通过设置case_sensitive参数为True来实现。
from parse import parse
# 原始字符串
file_name = "document.TXT"
# 解析文件名，大小写敏感
result_sensitive = parse("{name}.txt", file_name, case_sensitive=True)
print(result_sensitive) # 输出为 None，因为大小写不匹配
# 解析文件名，大小写不敏感
result_insensitive = parse("{name}.txt", file_name, case_sensitive=False)
print(result_insensitive) # 输出为 ParseResult([('name', 'document')])，大小写不敏感匹配成功
匹配字符数
宽度和精度可用于限制输入匹配文本的大小。宽度指定最小尺寸，精度指定最大尺寸。例如：
from parse import parse
parse('{:.2}{:.2}', 'look') # 指定精度
print(parse('{:4}{:4}', 'look at that')) # 指定宽度
print(parse('{:4}{:.4}', 'look at that')) # 同时指定
print(parse('{:2d}{:2d}', '0440'))
输出结果：
<Result ('look', 'at that') {}>
<Result ('look at ', 'that') {}>
<Result (4, 40) {}>
三个重要属性
- fixed：利用位置提取的匿名字段的元组。
- named：存放有命名的字段的字典。
- spans：存放匹配到字段的位置。
from parse import parse
profile = parse("I am {name}, {age:d} years old, {}", "I am Jack, 27 years old, male")
print(profile.fixed)
print(profile.named)
print(profile.spans)
输出结果：
('male',)
{'name': 'Jack', 'age': 27}
{'name': (5, 9), 'age': (11, 13), 0: (25, 29)}
自定义类型转换
from parse import parse
def custom_upper(string):
return string.upper() + " HAIGE"
print(parse('{:my_upper} world', 'hello world', dict(my_upper=custom_upper)))
输出结果：
<Result ('HELLO HAIGE',) {}>
使用场景
解析nginx日志
#!usr/bin/env python
# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/7 20:02
from parse import parse
import json
import pandas as pd
from typing import List
def parse_nginx_log(log_lines):
template = '{ip} - - [{timestamp}] "{method} {path} HTTP/{http_version}" {status_code} {response_size} "{user_agent}"'
data = []
for log_line in log_lines:
result = parse(template, log_line)
if result:
data.append({
'ip': result['ip'],
'timestamp': result['timestamp'],
'method': result['method'],
'path': result['path'],
'http_version': result['http_version'],
'status_code': int(result['status_code']),
'response_size': int(result['response_size']),
'user_agent': result['user_agent']
})
return data
def build_dataframe(records: List[dict]) -> pd.DataFrame:
result: pd.DataFrame = pd.DataFrame.from_records(records, index='ip')
return result
nginx_log = [
'127.0.0.1 - - [01/Jan/2022:12:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234 "-"',
'127.0.0.1 - - [01/Jan/2022:16:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234 "-"',
'192.168.1.5 - - [01/Jan/2023:12:03:00 +0000] "GET /index3.html HTTP/1.1" 200 1236 "-"',
'192.168.18.36 - - [01/Jan/2024:11:23:00 +0000] "GET /index2.html HTTP/1.1" 200 3234 "-"'
]
parsed_log = parse_nginx_log(nginx_log)
if parsed_log:
json_log = json.dumps(parsed_log)
# print(json_log)
print(build_dataframe(parsed_log))
else:
print('Failed to parse the log line')
输出结果
timestamp method ... response_size user_agent
ip ...
127.0.0.1 01/Jan/2022:12:00:00 +0000 GET ... 1234 -
127.0.0.1 01/Jan/2022:16:00:00 +0000 GET ... 1234 -
192.168.1.5 01/Jan/2023:12:03:00 +0000 GET ... 1236 -
192.168.18.36 01/Jan/2024:11:23:00 +0000 GET ... 3234 -
[4 rows x 7 columns]
解析配置文件中的键值对：
from parse import parse
# 定义配置文件模板
template = "{key}={value}"
# 解析配置文件行
result = parse(template, "debug=True")
if result:
key = result['key']
value = result['value']
print(f"Key: {key}, Value: {value}") # Key: debug, Value: True
小结
在字符串解析处理中，parse库提供了极大的便利。相较于使用正则表达式 (re)，parse简化了模式的定义和匹配过程，极大地提高了开发效率。
在一些简单的场景中，使用parse可比使用re去写正则表达式高出几个level。使用parse编写的代码富有美感，可读性极高，后期维护起来也毫无压力。
综上所述，强烈推荐您在Python开发中使用parse库，它能够让您的代码更加优雅、高效、易读易维护。
更多
parse库用法请翻阅官方文档…
最后
今天的分享就到这里。如果觉得不错，点赞，关注安排起来吧。
