13.正则表达式：文本处理的瑞士军刀

最新推荐文章于 2025-07-30 20:55:30 发布
最新推荐文章于 2025-07-30 20:55:30 发布
阅读量599 收藏 8
点赞数 28
CC 4.0 BY-SA版权
分类专栏： python-从基础语法到前言技术 文章标签： 正则表达式 mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_75211380/article/details/149275959

正则表达式：文本处理的瑞士军刀

🎯 前言：当文本遇上神奇的密码

想象一下，你是一个图书管理员，面对着一堆乱七八糟的书籍信息：

  • “联系电话：138-1234-5678”
  • “邮箱地址：zhang.san@gmail.com”
  • “身份证号：110101199001011234”
  • “QQ号码：12345678”

如果让你一个个手工整理，估计你会疯掉。但是，如果你掌握了正则表达式这把"瑞士军刀"，这些看似繁琐的文本处理任务就会变得轻松愉快！

正则表达式（Regular Expression，简称 regex 或 regexp）就像是一种神奇的"文本搜索密码"，它能够帮你在海量文本中精准定位你想要的内容。今天我们就来学习这门让文本处理变得如丝般顺滑的技艺！

📚 目录

🧠 什么是正则表达式

生活中的"模式匹配"

在解释正则表达式之前，我们先来看看生活中的例子。你有没有这样的经历：

  • 在一堆照片中找出所有包含"生日"的文件名
  • 在通讯录中找出所有138开头的手机号
  • 在邮件中找出所有的网址链接

这些其实都是"模式匹配"的过程，而正则表达式就是用来描述这些"模式"的一种特殊语言。

正则表达式的本质

正则表达式本质上就是一个字符串，但这个字符串有特殊的含义——它描述了一种文本模式。比如：

  • \d{3}-\d{4}-\d{4} 描述了"3位数字-4位数字-4位数字"的模式
  • \w+@\w+\.\w+ 描述了基本的邮箱格式模式

📖 基础语法：学会写"文本密码"

字符匹配：最基本的积木

import re

# 直接匹配字符
text = "Hello World"
pattern = "Hello"
result = re.search(pattern, text)
print(result)  # <re.Match object; span=(0, 5), match='Hello'>

特殊字符：正则表达式的"魔法符号"

1. 点号（.）：万能替身
# . 可以匹配任意单个字符（除了换行符）
pattern = "H.llo"
text1 = "Hello"  # 匹配
text2 = "Hallo"  # 匹配
text3 = "H@llo"  # 匹配
text4 = "Hllo"   # 不匹配

for text in [text1, text2, text3, text4]:
    if re.search(pattern, text):
        print(f"'{text}' 匹配成功！")
    else:
        print(f"'{text}' 匹配失败！")
2. 星号（*）：贪婪的小怪兽
# * 表示前面的字符可以出现0次或多次
pattern = "ab*c"
texts = ["ac", "abc", "abbc", "abbbc", "axc"]

for text in texts:
    if re.search(pattern, text):
        print(f"'{text}' 匹配成功！")
    else:
        print(f"'{text}' 匹配失败！")
3. 加号（+）：至少要有一个
# + 表示前面的字符至少出现1次
pattern = "ab+c"
texts = ["ac", "abc", "abbc", "abbbc"]

for text in texts:
    if re.search(pattern, text):
        print(f"'{text}' 匹配成功！")
    else:
        print(f"'{text}' 匹配失败！")
4. 问号（?）：可有可无的存在
# ? 表示前面的字符可以出现0次或1次
pattern = "colou?r"
texts = ["color", "colour", "colouur"]

for text in texts:
    if re.search(pattern, text):
        print(f"'{text}' 匹配成功！")
    else:
        print(f"'{text}' 匹配失败！")

字符类：给字符分分类

1. 方括号：自定义字符集合
# [abc] 匹配a、b、c中的任意一个
pattern = "[abc]at"
texts = ["cat", "bat", "rat", "hat"]

for text in texts:
    if re.search(pattern, text):
        print(f"'{text}' 匹配成功！")
    else:
        print(f"'{text}' 匹配失败！")
2. 范围表示：偷个懒的写法
# [a-z] 匹配任意小写字母
# [0-9] 匹配任意数字
# [A-Za-z0-9] 匹配任意字母或数字

pattern = "[0-9]+"  # 匹配一个或多个数字
text = "我今年25岁，电话是138-1234-5678"
numbers = re.findall(pattern, text)
print(numbers)  # ['25', '138', '1234', '5678']
3. 预定义字符类：常用的简写
# \d 等价于 [0-9]
# \w 等价于 [a-zA-Z0-9_]
# \s 等价于 [ \t\n\r\f\v]（空白字符）

text = "用户名：zhang123，年龄：25岁"

# 提取数字
numbers = re.findall(r'\d+', text)
print(f"数字：{numbers}")  # ['123', '25']

# 提取单词字符
words = re.findall(r'\w+', text)
print(f"单词：{words}")  # ['zhang123', '25']

💻 Python中的正则表达式模块

re模块：Python的正则表达式工具箱

import re

# 常用函数一览
text = "今天是2024年1月1日，明天是2024年1月2日"

# 1. re.search() - 找到第一个匹配
result = re.search(r'\d{4}年\d{1,2}月\d{1,2}日', text)
if result:
    print(f"找到了：{result.group()}")  # 找到了：2024年1月1日

# 2. re.findall() - 找到所有匹配
dates = re.findall(r'\d{4}年\d{1,2}月\d{1,2}日', text)
print(f"所有日期：{dates}")  # ['2024年1月1日', '2024年1月2日']

# 3. re.sub() - 替换匹配的内容
new_text = re.sub(r'\d{4}年', '2025年', text)
print(f"替换后：{new_text}")  # 今天是2025年1月1日，明天是2025年1月2日

# 4. re.split() - 按模式分割字符串
data = "苹果,香蕉;橘子:葡萄"
fruits = re.split(r'[,:;]', data)
print(f"水果列表：{fruits}")  # ['苹果', '香蕉', '橘子', '葡萄']

编译正则表达式：提高效率的小技巧

# 如果同一个正则表达式要使用多次，可以先编译
pattern = re.compile(r'\d{3}-\d{4}-\d{4}')

phones = [
    "我的电话是138-1234-5678",
    "客服热线：400-1234-5678",
    "传真号码：010-8888-9999",
    "这不是电话号码"
]

for phone in phones:
    match = pattern.search(phone)
    if match:
        print(f"找到电话：{match.group()}")
    else:
        print("未找到电话号码")

🚀 实战案例：从简单到复杂

案例1：验证邮箱格式

def validate_email(email):
    """
    验证邮箱格式是否正确
    """
    # 基础版本
    basic_pattern = r'\w+@\w+\.\w+'
    
    # 进阶版本（更严格）
    advanced_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    
    if re.match(advanced_pattern, email):
        return True
    return False

# 测试不同的邮箱
emails = [
    "zhangsan@gmail.com",      # 正确
    "li.si@163.com",           # 正确
    "wang@company.com.cn",     # 正确
    "invalid-email",           # 错误
    "@gmail.com",              # 错误
    "test@",                   # 错误
]

for email in emails:
    result = "✅ 有效" if validate_email(email) else "❌ 无效"
    print(f"{email}: {result}")

案例2：提取网页中的链接

def extract_links(html_content):
    """
    从HTML内容中提取所有链接
    """
    # 匹配 <a href="..."> 标签中的链接
    pattern = r'<a\s+href=["\'](.*?)["\']'
    links = re.findall(pattern, html_content, re.IGNORECASE)
    return links

# 示例HTML内容
html = '''
<html>
<body>
    <a href="https://www.python.org">Python官网</a>
    <a href="mailto:admin@example.com">联系我们</a>
    <a href="/about">关于我们</a>
    <a HREF='https://github.com'>GitHub</a>
</body>
</html>
'''

links = extract_links(html)
print("提取到的链接：")
for i, link in enumerate(links, 1):
    print(f"{i}. {link}")

案例3：解析日志文件

def parse_log_file(log_content):
    """
    解析服务器日志文件
    """
    # 典型的Apache日志格式
    # 127.0.0.1 - - [25/Dec/2023:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234
    
    pattern = r'(\d+\.\d+\.\d+\.\d+).*?\[(.*?)\].*?"(\w+)\s+(.*?)\s+HTTP.*?"\s+(\d+)\s+(\d+)'
    
    matches = re.findall(pattern, log_content)
    
    logs = []
    for match in matches:
        ip, timestamp, method, url, status, size = match
        logs.append({
            'ip': ip,
            'timestamp': timestamp,
            'method': method,
            'url': url,
            'status': int(status),
            'size': int(size)
        })
    
    return logs

# 示例日志内容
log_content = '''
127.0.0.1 - - [25/Dec/2023:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234
192.168.1.1 - - [25/Dec/2023:10:05:00 +0000] "POST /login HTTP/1.1" 302 0
10.0.0.1 - - [25/Dec/2023:10:10:00 +0000] "GET /api/users HTTP/1.1" 404 567
'''

logs = parse_log_file(log_content)
print("解析到的日志：")
for log in logs:
    print(f"IP: {log['ip']}, 状态: {log['status']}, URL: {log['url']}")

案例4：数据清洗与格式化

def clean_phone_numbers(text):
    """
    清洗和格式化电话号码
    """
    # 匹配各种格式的电话号码
    patterns = [
        r'(\d{3})-(\d{4})-(\d{4})',      # 138-1234-5678
        r'(\d{3})\s+(\d{4})\s+(\d{4})',  # 138 1234 5678
        r'(\d{3})\.(\d{4})\.(\d{4})',    # 138.1234.5678
        r'(\d{11})',                     # 13812345678
    ]
    
    def format_phone(match):
        if len(match.groups()) == 3:
            return f"{match.group(1)}-{match.group(2)}-{match.group(3)}"
        else:
            # 对于11位连续数字，分割为3-4-4格式
            phone = match.group(1)
            return f"{phone[:3]}-{phone[3:7]}-{phone[7:]}"
    
    result = text
    for pattern in patterns:
        result = re.sub(pattern, format_phone, result)
    
    return result

# 测试数据
messy_text = '''
联系方式：
张三：138 1234 5678
李四：139.5678.9012
王五：13687654321
赵六：158-7890-1234
'''

cleaned_text = clean_phone_numbers(messy_text)
print("清洗后的文本：")
print(cleaned_text)

🔧 高级技巧：让你的正则更强大

1. 分组捕获：抓住重要信息

# 使用括号创建捕获组
pattern = r'(\d{4})-(\d{2})-(\d{2})'
text = "今天是2024-01-15，明天是2024-01-16"

for match in re.finditer(pattern, text):
    print(f"完整匹配：{match.group(0)}")
    print(f"年份：{match.group(1)}")
    print(f"月份：{match.group(2)}")
    print(f"日期：{match.group(3)}")
    print("---")

2. 命名捕获组：给组起个名字

# 使用 (?P<name>pattern) 创建命名组
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
text = "生日：1990-05-20"

match = re.search(pattern, text)
if match:
    print(f"年份：{match.group('year')}")
    print(f"月份：{match.group('month')}")
    print(f"日期：{match.group('day')}")
    
    # 也可以用字典的方式访问
    date_dict = match.groupdict()
    print(f"日期字典：{date_dict}")

3. 非捕获组：只匹配不捕获

# 使用 (?:pattern) 创建非捕获组
pattern = r'(?:Mr|Mrs|Ms)\.\s+(\w+)'
text = "Mr. Smith 和 Mrs. Johnson 来了"

matches = re.findall(pattern, text)
print(f"姓名：{matches}")  # ['Smith', 'Johnson']

4. 前瞻和后瞻：偷看前后的内容

# 正向前瞻 (?=pattern)
pattern = r'\d+(?=元)'  # 匹配后面跟着"元"的数字
text = "价格是100元，重量是50公斤"
prices = re.findall(pattern, text)
print(f"价格：{prices}")  # ['100']

# 负向前瞻 (?!pattern)
pattern = r'\d+(?!元)'  # 匹配后面不跟着"元"的数字
weights = re.findall(pattern, text)
print(f"非价格数字：{weights}")  # ['50']

5. 贪婪与非贪婪匹配

text = '<div>内容1</div><div>内容2</div>'

# 贪婪匹配（默认）
greedy_pattern = r'<div>.*</div>'
greedy_match = re.search(greedy_pattern, text)
print(f"贪婪匹配：{greedy_match.group()}")
# 结果：<div>内容1</div><div>内容2</div>

# 非贪婪匹配
non_greedy_pattern = r'<div>.*?</div>'
non_greedy_matches = re.findall(non_greedy_pattern, text)
print(f"非贪婪匹配：{non_greedy_matches}")
# 结果：['<div>内容1</div>', '<div>内容2</div>']

🎯 常见应用场景

1. 数据验证工具箱

class DataValidator:
    """数据验证工具类"""
    
    @staticmethod
    def validate_phone(phone):
        """验证手机号码"""
        pattern = r'^1[3-9]\d{9}$'
        return bool(re.match(pattern, phone))
    
    @staticmethod
    def validate_id_card(id_card):
        """验证身份证号码"""
        pattern = r'^\d{17}[\dXx]$'
        return bool(re.match(pattern, id_card))
    
    @staticmethod
    def validate_password(password):
        """验证密码强度（至少8位，包含字母和数字）"""
        pattern = r'^(?=.*[a-zA-Z])(?=.*\d).{8,}$'
        return bool(re.match(pattern, password))
    
    @staticmethod
    def validate_url(url):
        """验证URL格式"""
        pattern = r'^https?://[^\s/$.?#].[^\s]*$'
        return bool(re.match(pattern, url))

# 测试验证器
validator = DataValidator()

test_data = {
    "手机号": "13812345678",
    "身份证": "110101199001011234",
    "密码": "password123",
    "网址": "https://www.example.com"
}

for data_type, value in test_data.items():
    if data_type == "手机号":
        result = validator.validate_phone(value)
    elif data_type == "身份证":
        result = validator.validate_id_card(value)
    elif data_type == "密码":
        result = validator.validate_password(value)
    elif data_type == "网址":
        result = validator.validate_url(value)
    
    status = "✅ 有效" if result else "❌ 无效"
    print(f"{data_type} {value}: {status}")

2. 文本信息提取器

class TextExtractor:
    """文本信息提取器"""
    
    def __init__(self):
        self.patterns = {
            'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
            'phone': r'1[3-9]\d{9}',
            'url': r'https?://[^\s]+',
            'date': r'\d{4}[-/]\d{1,2}[-/]\d{1,2}',
            'money': r'¥?\d+(?:\.\d{2})?',
            'qq': r'[1-9]\d{4,11}',
            'ip': r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
        }
    
    def extract_all(self, text):
        """提取文本中的所有信息"""
        results = {}
        for info_type, pattern in self.patterns.items():
            matches = re.findall(pattern, text)
            if matches:
                results[info_type] = matches
        return results

# 示例文本
sample_text = '''
个人信息：
姓名：张三
电话：13812345678
邮箱：zhangsan@gmail.com
QQ：123456789
生日：1990-05-20
网站：https://www.example.com
IP地址：192.168.1.1
余额：¥1234.56
'''

extractor = TextExtractor()
extracted_info = extractor.extract_all(sample_text)

print("提取到的信息：")
for info_type, values in extracted_info.items():
    print(f"{info_type}: {values}")

3. 日志分析工具

class LogAnalyzer:
    """日志分析工具"""
    
    def __init__(self):
        # 定义不同类型的日志格式
        self.log_patterns = {
            'apache': r'(\d+\.\d+\.\d+\.\d+).*?\[(.*?)\].*?"(\w+)\s+(.*?)\s+HTTP.*?"\s+(\d+)\s+(\d+)',
            'nginx': r'(\d+\.\d+\.\d+\.\d+).*?\[(.*?)\].*?"(\w+)\s+(.*?)\s+HTTP.*?"\s+(\d+)\s+(\d+)',
            'error': r'\[(.*?)\]\s+\[(\w+)\]\s+(.*)',
            'python': r'(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}),\d+\s+(\w+)\s+(.*)'
        }
    
    def analyze_access_log(self, log_content):
        """分析访问日志"""
        pattern = self.log_patterns['apache']
        matches = re.findall(pattern, log_content)
        
        analysis = {
            'total_requests': len(matches),
            'unique_ips': set(),
            'status_codes': {},
            'popular_pages': {},
            'methods': {}
        }
        
        for match in matches:
            ip, timestamp, method, url, status, size = match
            
            analysis['unique_ips'].add(ip)
            
            # 统计状态码
            if status in analysis['status_codes']:
                analysis['status_codes'][status] += 1
            else:
                analysis['status_codes'][status] = 1
            
            # 统计热门页面
            if url in analysis['popular_pages']:
                analysis['popular_pages'][url] += 1
            else:
                analysis['popular_pages'][url] = 1
            
            # 统计请求方法
            if method in analysis['methods']:
                analysis['methods'][method] += 1
            else:
                analysis['methods'][method] = 1
        
        analysis['unique_ips'] = len(analysis['unique_ips'])
        return analysis

# 示例日志分析
log_content = '''
127.0.0.1 - - [25/Dec/2023:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234
192.168.1.1 - - [25/Dec/2023:10:05:00 +0000] "POST /login HTTP/1.1" 302 0
10.0.0.1 - - [25/Dec/2023:10:10:00 +0000] "GET /api/users HTTP/1.1" 404 567
127.0.0.1 - - [25/Dec/2023:10:15:00 +0000] "GET /about HTTP/1.1" 200 890
'''

analyzer = LogAnalyzer()
analysis = analyzer.analyze_access_log(log_content)

print("日志分析结果：")
print(f"总请求数：{analysis['total_requests']}")
print(f"唯一IP数：{analysis['unique_ips']}")
print(f"状态码分布：{analysis['status_codes']}")
print(f"热门页面：{analysis['popular_pages']}")
print(f"请求方法：{analysis['methods']}")

⚡ 性能优化与最佳实践

1. 编译正则表达式

import re
import time

# 测试编译与不编译的性能差异
text = "这是一个测试文本，包含很多数字：12345，67890，13579，24680" * 1000

def test_without_compile():
    """不编译正则表达式"""
    start_time = time.time()
    for _ in range(1000):
        re.findall(r'\d+', text)
    end_time = time.time()
    return end_time - start_time

def test_with_compile():
    """编译正则表达式"""
    pattern = re.compile(r'\d+')
    start_time = time.time()
    for _ in range(1000):
        pattern.findall(text)
    end_time = time.time()
    return end_time - start_time

print(f"不编译耗时：{test_without_compile():.4f}秒")
print(f"编译后耗时：{test_with_compile():.4f}秒")

2. 避免回溯问题

# 不好的正则表达式（可能导致回溯）
bad_pattern = r'(a+)+b'

# 好的正则表达式
good_pattern = r'a+b'

# 测试文本（会导致回溯问题）
problematic_text = 'a' * 20

# 建议：使用具体的量词而不是嵌套的量词

3. 使用正确的函数

text = "Hello World! This is a test."

# 如果只需要知道是否匹配，使用 re.search()
if re.search(r'test', text):
    print("找到了 'test'")

# 如果需要所有匹配，使用 re.findall()
words = re.findall(r'\w+', text)
print(f"所有单词：{words}")

# 如果需要替换，使用 re.sub()
new_text = re.sub(r'test', 'example', text)
print(f"替换后：{new_text}")

🔧 常见问题与解决方案

问题1：特殊字符需要转义

# 错误：直接使用特殊字符
# pattern = r'$100'  # $ 是特殊字符，表示行尾

# 正确：使用转义字符
pattern = r'\$100'  # 正确匹配 "$100"
text = "价格是$100"
result = re.search(pattern, text)
print(result.group() if result else "未找到")

问题2：中文字符处理

# 匹配中文字符
chinese_pattern = r'[\u4e00-\u9fff]+'
text = "Hello 世界！今天天气真好。"
chinese_words = re.findall(chinese_pattern, text)
print(f"中文内容：{chinese_words}")  # ['世界', '今天天气真好']

问题3：多行文本处理

multiline_text = '''第一行
第二行
第三行'''

# 默认情况下，. 不匹配换行符
pattern1 = r'第一行.*第三行'
result1 = re.search(pattern1, multiline_text)
print(f"默认模式：{result1}")  # None

# 使用 re.DOTALL 标志让 . 匹配换行符
pattern2 = r'第一行.*第三行'
result2 = re.search(pattern2, multiline_text, re.DOTALL)
print(f"DOTALL模式：{result2.group() if result2 else None}")

📖 扩展阅读

推荐资源

  • 在线正则表达式测试工具：regex101.com
  • Python re模块官方文档：docs.python.org/3/library/re.html
  • 正则表达式教程：regexone.com
  • 《正则表达式必知必会》：经典的正则表达式入门书籍

实用工具

# 正则表达式调试器
def regex_debugger(pattern, text):
    """正则表达式调试器"""
    try:
        compiled = re.compile(pattern)
        matches = compiled.findall(text)
        print(f"模式：{pattern}")
        print(f"文本：{text}")
        print(f"匹配结果：{matches}")
        print(f"匹配数量：{len(matches)}")
    except re.error as e:
        print(f"正则表达式语法错误：{e}")

# 使用示例
regex_debugger(r'\d+', '我有123个苹果和456个橘子')

🎬 下集预告

在下一篇文章《多线程与并发：让程序同时做多件事》中，我们将探索：

  • 如何让Python程序同时处理多个任务
  • 线程和进程的区别和使用场景
  • 异步编程的魅力
  • 并发编程的陷阱和最佳实践

想象一下，如果你的程序能够同时下载文件、处理数据、响应用户请求，那该多么高效！

📝 总结与思考题

核心要点回顾

  1. 正则表达式是处理文本的强大工具，就像文本处理的"瑞士军刀"
  2. 基础语法包括字符匹配、量词、字符类等
  3. Python的re模块提供了丰富的函数来使用正则表达式
  4. 实际应用包括数据验证、信息提取、日志分析等
  5. 性能优化通过编译正则表达式和选择合适的函数

实践作业

  1. 写一个函数，从一段文本中提取所有的IP地址
  2. 创建一个密码强度检查器，要求包含大小写字母、数字和特殊字符
  3. 解析一个CSV格式的字符串，提取每一列的数据
  4. 编写一个简单的模板引擎，用正则表达式替换模板中的变量

思考题

  1. 为什么说正则表达式是"写时简单，读时困难"？如何提高正则表达式的可读性？
  2. 在什么情况下应该使用正则表达式，什么情况下应该使用字符串的普通方法？
  3. 如何平衡正则表达式的功能性和性能？

记住：正则表达式虽然强大，但也要适度使用。正如一句名言所说："如果你有一个问题，想用正则表达式解决，那么你就有两个问题了。"但是，如果你真正掌握了正则表达式，它就会成为你文本处理的得力助手！

🎉 恭喜你！你已经掌握了正则表达式这把文本处理的"瑞士军刀"。现在你可以轻松地在茫茫文本海洋中找到你需要的信息，就像拥有了一双火眼金睛！

C# 5步征服正则表达式：为什么你的文本还在“乱码”？
java专栏
05-03 362
你已经掌握了C#正则表达式的“5步通关秘籍”！从基础匹配到高级断言，每一步都像给系统装上了“模式扫描仪”和“自动纠错盾”！这不是“代码诅咒”，是你的文本处理里少了“超级英雄正则表达式”！类打造“文本处理变形金刚”！从提取IP到替换手机号，每一步都像给系统装上“模式扫描仪”和“自动纠错盾”！你的文本像“天书”一样乱码成堆？🔥关注墨瑾轩，带你探索编程的奥秘！🔥超萌技术攻略，轻松晋级编程高手🚀。🔥技术宝库已备好，就等你来挖掘🚀。，从基础匹配到分组捕获，用C#的。🔥即刻启航，编程之旅更有趣🚀。
【Python深入浅出㉗】Python3正则表达式：开启高效字符串处理大门
邓邓子的博客
02-11 1046
正则表达式（Regular Expression）是一种用于匹配、搜索和处理字符串的强大工具。它定义了一种字符串的匹配模式，可以用来检查一个字符串是否符合某种规则，或者从一个字符串中提取出符合特定模式的子串。在 Python 中，正则表达式被广泛应用于文本处理、数据清洗、网页爬虫等领域。以判断邮箱格式是否合法为例，假设我们有一个字符串test@example.com，使用正则表达式可以快速判断它是否符合邮箱的格式要求。
Python 正则表达式 使用便签
s651665496的专栏
05-22 1482
pattern_1 = re.compile(r''+ str(tblName) + '\.(?P<fieldname>[\w\d_]+)')
Oracle中对字符串类型的数字正确排序
热门推荐
CoffeMilk的博客
09-27 1万+
一、使用【ORDER BY 字段 ASC】对字符串类型数字排序得不到想要的结果 SELECT 字段名称 FROM 表名称 ORDER BY 字段名称 ASC 二、问题分析 因为排序的字段是字符串类型，所以【排序时字符从左向右依次比较】 三、解决方法 ①使用Oracle中的【CAST】函数将字段转为数字类型然后再排序即可 //CAST函数转换字段类型 CAST(字段名称 AS 数字类型) //比如：将Varchar字段BINN转为INTEGER类型 CAST(BINN AS INTEG.
正则表达式：文本处理的瑞士军刀
q68686的博客
01-15 661
正则表达式是一种用来描述字符串模式的语言。它使用一系列的特殊字符和普通字符来定义一个搜索模式，然后用这个模式去匹配文本中的字符串。正则表达式在各种编程语言、文本编辑器和命令行工具中都有广泛的应用。正则表达式是一种强大的文本处理工具，掌握它能够让你在文本处理方面事半功倍。希望通过这篇文章，你对正则表达式有了更深入的了解。在实际应用中，要根据具体的需求选择合适的正则表达式，并注意性能和可读性。如果你有任何问题或想法，欢迎在评论区留言。其他可以补充的内容：正则表达式的进阶用法：例如，零宽断言、反向引用等。
正则表达式：解锁文本处理的强大工具
2401_87322981的博客
12-08 710
正则表达式作为一种强大的文本处理工具，在数据清洗、日志分析、信息检索等领域发挥着重要作用。通过掌握正则表达式的基本语法和进阶技巧，我们可以更加高效地处理和分析文本数据。未来，随着人工智能和大数据技术的不断发展，正则表达式在文本挖掘、自然语言处理等领域的应用前景将更加广阔。因此，我们应该不断学习和探索正则表达式的应用方法和优化技巧，以适应不断变化的数据处理需求。
JavaScript中的正则表达式：文本处理的瑞士军刀
JakeMa1024的博客
06-04 650
在编程世界中，正则表达式（Regular Expression，简称RegExp）被誉为“文本处理的瑞士军刀”。它能够高效地完成字符串匹配、替换、提取和验证等任务。无论是前端开发中的表单验证，还是后端数据清洗，正则表达式都扮演着不可或缺的角色。本文将带你深入浅出地了解JavaScript中的正则表达式，从基础语法到高级技巧，助你掌握这一强大工具。
正则表达式：文本处理的强大工具
qq_74732076的博客
07-22 1088
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。re模块使Python拥有正则表达式功能。
正则表达式：字符串处理的瑞士军刀
你若盛开，清风自来
12-08 1025
正则表达式（Regular Expression）是一种文本模式，用于描述和匹配字符串的模式。它由一系列字符和特殊元字符组成，可以用来进行字符串匹配、搜索、替换等操作。/正则表达式模式/匹配选项其中，是正则表达式的开始和结束标记，正则表达式模式是用于描述匹配规则的模式，匹配选项是可选的，用于指定匹配模式的一些特殊要求。字符串匹配：用于检查字符串是否符合特定的模式，例如验证电子邮件地址、电话号码、日期格式等。搜索和替换：用于在文本中查找特定的模式，并将其替换为其他内容。
深入理解正则表达式：语法全解析
weixin_32661831的博客
11-14 1579
本文还有配套的精品资源，点击获取 简介：正则表达式是一种用于文本匹配的模式，广泛应用在文本处理、数据验证等领域。本文将全面探讨正则表达式的语法细节，包括字符匹配、元字符、字符类、量词、分组与反向引用、选择与否定、位置锚点、预定义字符集、模式修饰符、回溯控制以及正向先行断言和正向后行断言。掌握这些知识有助于提高编程效率和代码质量。 1. 正则表达式简介 正则表...
文本处理的工具：正则表达式介绍
weixin_70208651的博客
05-07 813
正则表达式作为文本处理的通用语言，其价值不仅在于语法本身，更在于它提供了一种抽象化描述文本模式的方式。从简单的字符串匹配到复杂的日志解析，从用户输入验证到爬虫数据提取，正则表达式以极小的代码量实现了强大的功能。然而，其灵活性也带来了学习门槛——复杂的模式可能导致难以维护的“天书”正则。因此，掌握正则表达式的核心在于：在功能需求与可读性之间找到平衡，通过模块化设计和工具辅助，将这一“利器”转化为提升效率的可靠工具。对于开发者而言，正则表达式不仅是技术栈中的必备技能，更是理解计算机科学中模式匹配思想的窗口。
Python中的正则表达式：解锁文本处理的无限可能.pdf
09-30
正则表达式是一种强大的文本匹配工具，可以用来搜索、编辑或操纵文本。想象一下，如果你需要从成千上万行的日志文件中找出所有含有特定关键词的信息，或者想要自动化地清洗一份脏兮兮的数据集，这时，正则表达式就是...
正则表达式入门：从零开始掌握文本匹配的利器
06-18
正则表达式入门：解锁文本处理的强大工具 正则表达式（Regular Expression）是处理文本的瑞士军刀，它能通过简洁的语法实现复杂的字符串匹配、替换和提取操作。无论是数据清洗、日志分析还是表单验证，正则表达式都...
BGP高级特性之正则表达式
Fanmeang的博客
07-30 772
AS_Path正则表达式在BGP路由过滤中的应用 摘要：AS_Path属性作为BGP路由的重要特征，可通过正则表达式进行匹配过滤。正则表达式由普通字符和特殊字符组成，能够精确描述AS路径模式。常见匹配模式包括：^$匹配本地路由、.*匹配所有路由、^100匹配AS100发起的路由、_100$匹配AS100始发的路由、_100_匹配经过AS100的路由等。不同符号组合可实现灵活的路由过滤策略，如^10_匹配以AS10开头的转发路由。华为设备配置示例展示了如何创建AS路径过滤器来实现特定路由的允许或拒绝，为BGP
【通识】正则表达式
Achenganggyel的博客
07-27 190
正则表达式基础篇
正则表达式
wangqiang996的博客
07-28 428
正则在线测试网站：https://tool.oschina.net/regex#
python基础：数据解析：html页面、正则表达式
最新发布
m0_55284524的博客
07-30 252
本文介绍了数据解析的常用方法，重点讲解了HTML页面结构和正则表达式在爬虫中的应用。HTML作为网页基础结构，与CSS和JavaScript共同构成网页的框架、表现和行为。文章详细列举了正则表达式的常用语法规则，包括字符匹配、数量修饰、边界限定等。最后通过爬取新浪图片的Python案例，展示了正则表达式在实际爬虫项目中的使用流程，包括发送请求、解析数据、处理异常等步骤，并提供了常见错误的解决方案。该案例完整呈现了从网页获取到本地存储的完整爬虫实现过程。
正则表达式 速查速记
码农康康
07-29 851
本文详细介绍了正则表达式的基本语法和使用方法，主要包括：1.基本字符匹配规则（如通配符、字符集等）；2.特殊字符类（如数字\d、空白符\s等）；3.量词（如*、+、{n}等匹配次数控制）；4.定位符（如^、$等边界匹配）；5.分组引用和条件匹配；6.贪婪与非贪婪模式；7.旗标参数设置；8.前瞻后顾机制；9.替换操作中的大小写转换等。文中提供了大量示例说明各语法元素的具体用法，如匹配RGB颜色值、电话号码格式验证等实用案例。该指南全面覆盖了正则表达式的基础功能和高级特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值