Python脚本如何解析陌生时间格式

本文目录导读：

1. 使用标准库 datetime.strptime()
2. 使用 dateutil.parser (推荐)
3. 处理陌生格式的策略
4. 使用第三方库 pendulum
5. 使用 arrow 库
6. 完整的智能解析器示例
7. 安装依赖
8. 总结建议

我来系统地介绍Python解析各种陌生时间格式的方法。

使用标准库 datetime.strptime()

最基础的方法,需要知道时间格式：

from datetime import datetime
# 已知格式的时间字符串
date_str = "2023-12-25 14:30:00"
parsed = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(parsed)  # 2023-12-25 14:30:00

常用格式化代码：

• %Y - 4位年份
• %m - 月份 (01-12)
• %d - 日期 (01-31)
• %H - 小时 (00-23)
• %M - 分钟 (00-59)
• %S - 秒 (00-59)

使用 dateutil.parser (推荐)

自动解析多种常见格式：

from dateutil import parser
# 各种常见格式
formats = [
    "2023-12-25 14:30:00",
    "12/25/2023 2:30 PM",
    "Dec 25, 2023 14:30",
    "202312251430",
    "2023-12-25T14:30:00Z",
    "25-12-2023 14:30",
    "Mon, 25 Dec 2023 14:30:00 +0800"
]
for fmt in formats:
    try:
        dt = parser.parse(fmt)
        print(f"'{fmt}' -> {dt}")
    except Exception as e:
        print(f"无法解析: {fmt}, 错误: {e}")

处理陌生格式的策略

1 格式猜测器

import re
from datetime import datetime
def guess_and_parse(date_str):
    """尝试识别并解析时间字符串"""
    # 定义可能的格式模式
    patterns = [
        # ISO格式
        (r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$', '%Y-%m-%dT%H:%M:%SZ'),
        (r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2}$', '%Y-%m-%dT%H:%M:%S%z'),
        # 常见分隔符格式
        (r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$', '%Y-%m-%d %H:%M:%S'),
        (r'^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}$', '%Y/%m/%d %H:%M:%S'),
        # 紧凑格式
        (r'^\d{14}$', '%Y%m%d%H%M%S'),
        (r'^\d{8}$', '%Y%m%d'),
        (r'^\d{6}$', '%y%m%d'),
        # 12小时制
        (r'^\d{1,2}/\d{1,2}/\d{4} \d{1,2}:\d{2} (AM|PM)$', '%m/%d/%Y %I:%M %p'),
    ]
    for pattern, fmt in patterns:
        if re.match(pattern, date_str):
            try:
                return datetime.strptime(date_str, fmt)
            except ValueError:
                continue
    return None
# 测试
test_dates = [
    "2023-12-25T14:30:00Z",
    "20231225143000",
    "12/25/2023 2:30 PM",
    "2023-12-25 14:30:00"
]
for date in test_dates:
    result = guess_and_parse(date)
    print(f"{date} -> {result}")

2 多格式尝试解析器

def robust_parse(date_str):
    """尝试多种格式解析时间字符串"""
    formats = [
        # 标准格式
        "%Y-%m-%d %H:%M:%S",
        "%Y-%m-%dT%H:%M:%S",
        "%Y/%m/%d %H:%M:%S",
        "%m/%d/%Y %H:%M:%S",
        "%d/%m/%Y %H:%M:%S",
        # 年月日
        "%Y-%m-%d",
        "%Y/%m/%d",
        "%d-%m-%Y",
        "%m-%d-%Y",
        "%Y%m%d",
        # 带时区
        "%Y-%m-%dT%H:%M:%S%z",
        "%Y-%m-%dT%H:%M:%SZ",
        # 12小时制
        "%I:%M:%S %p",
        "%Y-%m-%d %I:%M:%S %p",
        # 月日年  
        "%b %d %Y %H:%M:%S",
        "%d %b %Y %H:%M:%S",
        "%B %d %Y %H:%M:%S",
    ]
    for fmt in formats:
        try:
            return datetime.strptime(date_str, fmt)
        except ValueError:
            continue
    # 最后尝试用dateutil
    try:
        from dateutil import parser
        return parser.parse(date_str, fuzzy=True)
    except:
        raise ValueError(f"无法解析时间字符串: {date_str}")
# 使用示例
test_cases = [
    "2023-12-25 14:30:00",
    "Dec 25 2023 14:30:00",
    "12/25/2023 02:30:00 PM",
    "2023-12-25T14:30:00+08:00"
]
for case in test_cases:
    try:
        dt = robust_parse(case)
        print(f"'{case}' -> {dt}")
    except ValueError as e:
        print(f"错误: {e}")

使用第三方库 pendulum

更好的时区和格式处理：

import pendulum
# 自动解析
dt = pendulum.parse("2023-12-25 14:30:00")
print(dt)  # 2023-12-25T14:30:00+00:00
dt = pendulum.parse("12/25/2023 2:30 PM")
print(dt)
# 带时区
dt = pendulum.parse("2023-12-25T14:30:00+08:00")
print(dt)

使用 arrow 库

import arrow
# 自动解析
dt = arrow.get("2023-12-25 14:30:00")
print(dt)
# 更多格式
formats = [
    "YYYY-MM-DD HH:mm:ss",
    "YYYY/MM/DD HH:mm:ss",
    "DD/MM/YYYY HH:mm:ss"
]
for fmt in formats:
    try:
        dt = arrow.get("25/12/2023 14:30:00", fmt)
        print(dt)
    except:
        continue

完整的智能解析器示例

import re
from datetime import datetime
from dateutil import parser as dateutil_parser
class SmartDateTimeParser:
    """智能时间解析器"""
    def __init__(self):
        self.custom_patterns = {}
    def add_pattern(self, name, regex, format_str):
        """添加自定义解析模式"""
        self.custom_patterns[name] = (regex, format_str)
    def parse(self, date_str, fuzzy=False):
        """解析时间字符串"""
        # 1. 尝试预定义模式
        if self.custom_patterns:
            for name, (regex, fmt) in self.custom_patterns.items():
                if re.match(regex, date_str):
                    try:
                        return datetime.strptime(date_str, fmt)
                    except ValueError:
                        continue
        # 2. 尝试dateutil自动解析
        try:
            return dateutil_parser.parse(date_str, fuzzy=fuzzy)
        except:
            pass
        # 3. 尝试常见格式
        common_formats = [
            "%Y-%m-%d %H:%M:%S",
            "%Y/%m/%d %H:%M:%S",
            "%m/%d/%Y %H:%M:%S",
            "%d-%m-%Y %H:%M:%S",
            "%Y%m%d%H%M%S",
            "%Y-%m-%d",
            "%d/%m/%Y",
        ]
        for fmt in common_formats:
            try:
                return datetime.strptime(date_str, fmt)
            except ValueError:
                continue
        raise ValueError(f"无法解析时间格式: {date_str}")
# 使用示例
parser = SmartDateTimeParser()
# 添加自定义格式
parser.add_pattern(
    "custom_ts", 
    r'^\d{4}\.\d{2}\.\d{2}_\d{2}-\d{2}-\d{2}$',
    '%Y.%m.%d_%H-%M-%S'
)
# 测试
test_times = [
    "2023.12.25_14-30-00",  # 自定义格式
    "2023-12-25 14:30:00",   # 标准格式
    "Dec 25, 2023 2:30 PM",  # dateutil格式
]
for t in test_times:
    try:
        result = parser.parse(t, fuzzy=True)
        print(f"'{t}' -> {result}")
    except ValueError as e:
        print(f"解析失败: {e}")

安装依赖

pip install python-dateutil pendulum arrow

总结建议

1. 优先使用 dateutil.parser - 能解析90%的常见格式
2. 预先定义已知格式 - 对特定数据源使用 strptime
3. 实现多格式尝试 - 对未知格式进行轮询尝试
4. 正则表达式辅助 - 先用正则判断格式类型
5. 考虑使用专用库 - pendulum、arrow 等提供了更好的API

这样就能处理绝大部分陌生时间格式了。