正则表达式与类库实战技巧让文本处理事半功倍编程开发必备知识详解从入门到精通应用案例分享提升编程效率

引言

正则表达式（Regular Expression，简称regex或regexp）是一种强大的文本处理工具，它使用特定的字符序列来描述和匹配字符串模式。在当今数据爆炸的时代，文本处理已成为编程开发中不可或缺的技能，而正则表达式则是文本处理的利器。无论是数据验证、信息提取、文本替换还是复杂的模式匹配，正则表达式都能帮助开发者以简洁高效的方式完成任务。

本文将从正则表达式的基础知识入手，逐步深入到高级技巧和实战应用，帮助读者全面掌握这一编程必备技能，并通过丰富的案例分享，展示如何利用正则表达式及其类库提升编程效率，实现文本处理的事半功倍。

正则表达式基础

什么是正则表达式

正则表达式是一种由普通字符（如字母、数字）和特殊字符（称为”元字符”）组成的文字模式，它描述了一种字符串匹配的模式。正则表达式可以用来检查一个字符串是否含有某种子串、将匹配的子串替换或者从某个字符串中取出符合某个条件的子串等。

基本语法

1. 普通字符

普通字符包括所有可打印和不可打印的字符，包括所有大小写字母、数字、标点符号和一些其他符号。例如，正则表达式"cat"可以匹配字符串中的”cat”。

2. 元字符

元字符是正则表达式中具有特殊含义的字符。以下是常用的元字符及其功能：

.：匹配除换行符外的任意单个字符
^：匹配字符串的开始位置
$：匹配字符串的结束位置
*：匹配前面的子表达式零次或多次
+：匹配前面的子表达式一次或多次
?：匹配前面的子表达式零次或一次
{n}：匹配前面的子表达式恰好n次
{n,}：匹配前面的子表达式至少n次
{n,m}：匹配前面的子表达式至少n次，最多m次
[]：定义字符集，匹配其中的任意一个字符
|：选择符，匹配左右两边表达式中的任意一个
()：分组，将括号内的表达式作为一个整体
：转义字符，用于匹配特殊字符本身

3. 预定义字符类

正则表达式提供了一些预定义的字符类，方便我们使用：

d：匹配任意数字，相当于[0-9]
D：匹配任意非数字字符，相当于[^0-9]
w：匹配任意单词字符（字母、数字、下划线），相当于[a-zA-Z0-9_]
W：匹配任意非单词字符，相当于[^a-zA-Z0-9_]
s：匹配任意空白字符（空格、制表符、换行符等）
S：匹配任意非空白字符

量词

量词用来指定匹配的次数：

*：匹配零次或多次
+：匹配一次或多次
?：匹配零次或一次
{n}：匹配恰好n次
{n,}：匹配至少n次
{n,m}：匹配至少n次，最多m次

贪婪与非贪婪模式

默认情况下，量词是”贪婪”的，即它们会尽可能多地匹配字符。例如，正则表达式a.*b对于字符串”aabab”，会匹配整个”aabab”，而不是”ab”。

如果需要”非贪婪”模式，可以在量词后面加上?。例如，a.*?b对于字符串”aabab”，会先匹配”ab”，然后是下一个”ab”。

简单示例

让我们通过一些简单的示例来理解正则表达式的基本用法：

import re # 匹配数字 pattern = r'd+' text = "There are 123 apples and 456 oranges." result = re.findall(pattern, text) print(result) # 输出: ['123', '456'] # 匹配邮箱地址 pattern = r'w+@w+.w+' text = "Contact us at info@example.com or support@company.org" result = re.findall(pattern, text) print(result) # 输出: ['info@example.com', 'support@company.org'] # 匹配HTML标签 pattern = r'<[^>]+>' text = "<div>This is a <b>bold</b> text</div>" result = re.findall(pattern, text) print(result) # 输出: ['<div>', '<b>', '</b>', '</div>']

正则表达式高级技巧

分组与捕获

分组是正则表达式中的一个重要概念，它允许我们将多个字符作为一个单元进行处理。使用圆括号()可以创建一个分组。

1. 捕获组

捕获组不仅可以将多个字符作为一个单元，还可以捕获匹配的文本，以便后续使用。捕获组按照从左到右的顺序编号，从1开始。

import re # 提取日期中的年、月、日 pattern = r'(d{4})-(d{2})-(d{2})' text = "Today's date is 2023-07-15." match = re.search(pattern, text) if match: year = match.group(1) # 第一个捕获组 month = match.group(2) # 第二个捕获组 day = match.group(3) # 第三个捕获组 print(f"Year: {year}, Month: {month}, Day: {day}") # 输出: Year: 2023, Month: 07, Day: 15

2. 非捕获组

有时候我们只需要分组功能，而不需要捕获匹配的文本。这时可以使用非捕获组(?:...)，它可以提高正则表达式的性能。

import re # 使用非捕获组匹配重复的单词 pattern = r'b(w+)(?:s+1b)+' text = "hello hello world world world" matches = re.finditer(pattern, text) for match in matches: print(f"Found repeated word: {match.group(1)}") # 输出: Found repeated word: hello # 输出: Found repeated word: world

断言

断言（Assertion）是正则表达式中的一种高级特性，它用于匹配某些条件，但不消耗字符，即不会将匹配的字符包含在最终结果中。

1. 正向先行断言

正向先行断言(?=...)表示当前位置后面的字符串必须匹配指定的模式，但不包含在匹配结果中。

import re # 匹配后面跟着"apple"的单词 pattern = r'w+(?= apple)' text = "I like red apple and green apple." matches = re.findall(pattern, text) print(matches) # 输出: ['red', 'green']

2. 负向先行断言

负向先行断言(?!...)表示当前位置后面的字符串不能匹配指定的模式。

import re # 匹配不以"un"开头的单词 pattern = r'b(?!un)w+b' text = "happy unhappy able unable" matches = re.findall(pattern, text) print(matches) # 输出: ['happy', 'able']

3. 正向后行断言

正向后行断言(?<=...)表示当前位置前面的字符串必须匹配指定的模式，但不包含在匹配结果中。

import re # 匹配前面是"$"的数字 pattern = r'(?<=$)d+' text = "Price: $100, $200, $300" matches = re.findall(pattern, text) print(matches) # 输出: ['100', '200', '300']

4. 负向后行断言

负向后行断言(?<!...)表示当前位置前面的字符串不能匹配指定的模式。

import re # 匹配不以数字开头的单词 pattern = r'(?<!d)bw+b' text = "123abc abc 456def" matches = re.findall(pattern, text) print(matches) # 输出: ['abc']

反向引用

反向引用允许我们在正则表达式中引用前面捕获组匹配的内容。使用1、2等表示引用第1、第2个捕获组。

import re # 匹配重复的单词 pattern = r'b(w+)s+1b' text = "hello world world hello" matches = re.finditer(pattern, text) for match in matches: print(f"Found repeated word: {match.group(1)}") # 输出: Found repeated word: world

条件匹配

正则表达式支持条件匹配，格式为(?(condition)true-pattern|false-pattern)，其中condition可以是一个捕获组的编号或名称。

import re # 匹配带有引号的字符串，如果以双引号开始，则以双引号结束；如果以单引号开始，则以单引号结束 pattern = r'^(?:(["']))(.*?)1$' text1 = '"Hello, world!"' text2 = "'Hello, world!'" text3 = '"Hello, world!'' print(re.match(pattern, text1).group(2)) # 输出: Hello, world! print(re.match(pattern, text2).group(2)) # 输出: Hello, world! print(re.match(pattern, text3)) # 输出: None

注释与模式修饰符

1. 注释

在复杂的正则表达式中，可以使用(?#comment)添加注释，提高可读性。

import re # 带注释的正则表达式 pattern = r'b(?#Word boundary)(w+)(?#Capture word)(?:s+1b)+(?#One or more repeated words)' text = "hello hello world world world" matches = re.finditer(pattern, text) for match in matches: print(f"Found repeated word: {match.group(1)}") # 输出: Found repeated word: hello # 输出: Found repeated word: world

2. 模式修饰符

模式修饰符（也称为标志）可以改变正则表达式的匹配行为。常见的模式修饰符包括：

i：不区分大小写匹配
m：多行模式，使^和$匹配每行的开始和结束
s：单行模式，使.匹配包括换行符在内的所有字符
x：忽略模式中的空白和注释
g：全局匹配，查找所有匹配项而不仅仅是第一个

import re # 使用模式修饰符 pattern = r'^hello' text = "Hello worldnhello there" # 不区分大小写匹配 matches = re.findall(pattern, text, re.IGNORECASE | re.MULTILINE) print(matches) # 输出: ['Hello', 'hello'] # 单行模式，使.匹配包括换行符在内的所有字符 pattern = r'<div>.*</div>' html = "<div>This is anmultilinenstring</div>" match = re.search(pattern, html, re.DOTALL) if match: print(match.group()) # 输出: <div>This is a # multiline # string</div>

常用编程语言中的正则表达式类库

Python中的re模块

Python的re模块提供了正则表达式匹配操作。以下是re模块的主要函数和用法：

1. re.match()

从字符串的起始位置匹配一个模式，如果起始位置匹配成功，则返回一个匹配对象，否则返回None。

import re pattern = r'd+' text = "123abc" match = re.match(pattern, text) if match: print(f"Match found: {match.group()}") # 输出: Match found: 123 text = "abc123" match = re.match(pattern, text) if match: print(f"Match found: {match.group()}") else: print("No match found") # 输出: No match found

2. re.search()

扫描整个字符串，返回第一个成功匹配的对象。

import re pattern = r'd+' text = "abc123def" match = re.search(pattern, text) if match: print(f"Match found: {match.group()}") # 输出: Match found: 123

3. re.findall()

查找字符串中所有正则表达式匹配的子串，并返回一个列表。

import re pattern = r'd+' text = "abc123def456ghi" matches = re.findall(pattern, text) print(matches) # 输出: ['123', '456']

4. re.finditer()

查找字符串中所有正则表达式匹配的子串，并返回一个迭代器。

import re pattern = r'd+' text = "abc123def456ghi" matches = re.finditer(pattern, text) for match in matches: print(f"Match found: {match.group()} at position {match.start()}-{match.end()}") # 输出: Match found: 123 at position 3-6 # 输出: Match found: 456 at position 9-12

5. re.sub()

替换字符串中所有匹配的子串。

import re pattern = r'd+' text = "abc123def456ghi" result = re.sub(pattern, 'NUM', text) print(result) # 输出: abcNUMdefNUMghi

6. re.split()

根据匹配的子串分割字符串。

import re pattern = r'd+' text = "abc123def456ghi" result = re.split(pattern, text) print(result) # 输出: ['abc', 'def', 'ghi']

7. 编译正则表达式

如果需要多次使用同一个正则表达式，可以先编译它，以提高效率。

import re pattern = re.compile(r'd+') text1 = "abc123def" text2 = "ghi456jkl" match1 = pattern.search(text1) match2 = pattern.search(text2) print(match1.group()) # 输出: 123 print(match2.group()) # 输出: 456

JavaScript中的RegExp对象

JavaScript中的正则表达式可以通过RegExp对象或者字面量（/pattern/flags）来创建。

1. 创建正则表达式

// 使用RegExp构造函数 let pattern1 = new RegExp('\d+'); // 使用字面量 let pattern2 = /d+/; // 带标志的正则表达式 let pattern3 = /d+/g; // g表示全局匹配

2. RegExp对象的方法

// test()方法：测试字符串是否匹配模式 let pattern = /d+/; console.log(pattern.test('abc123')); // 输出: true console.log(pattern.test('abcdef')); // 输出: false // exec()方法：执行匹配，返回结果数组 let text = 'abc123def456'; let result; while ((result = pattern.exec(text)) !== null) { console.log(`Found ${result[0]} at position ${result.index}`); // 输出: Found 123 at position 3 // 输出: Found 456 at position 9 }

3. String对象的方法

// match()方法：返回匹配结果的数组 let text = 'abc123def456'; let pattern = /d+/g; console.log(text.match(pattern)); // 输出: ['123', '456'] // search()方法：返回第一个匹配的位置 console.log(text.search(/d+/)); // 输出: 3 // replace()方法：替换匹配的子串 console.log(text.replace(/d+/g, 'NUM')); // 输出: abcNUMdefNUM // split()方法：根据匹配分割字符串 console.log(text.split(/d+/)); // 输出: ['abc', 'def', '']

Java中的Pattern和Matcher类

Java提供了java.util.regex包来处理正则表达式，主要包括Pattern和Matcher两个类。

1. Pattern类

Pattern类表示编译后的正则表达式模式。

import java.util.regex.Pattern; // 编译正则表达式 Pattern pattern = Pattern.compile("\d+"); // 使用标志 Pattern patternIgnoreCase = Pattern.compile("abc", Pattern.CASE_INSENSITIVE);

2. Matcher类

Matcher类用于执行匹配操作。

import java.util.regex.Matcher; import java.util.regex.Pattern; String text = "abc123def456"; Pattern pattern = Pattern.compile("\d+"); Matcher matcher = pattern.matcher(text); // 查找所有匹配 while (matcher.find()) { System.out.println("Found " + matcher.group() + " at position " + matcher.start() + "-" + matcher.end()); // 输出: Found 123 at position 3-6 // 输出: Found 456 at position 9-12 } // matches()方法：尝试将整个区域与模式匹配 System.out.println(Pattern.matches("\d+", "123")); // 输出: true System.out.println(Pattern.matches("\d+", "abc123")); // 输出: false // replaceAll()方法：替换所有匹配的子串 String result = matcher.replaceAll("NUM"); System.out.println(result); // 输出: abcNUMdefNUM

3. 分组与捕获

import java.util.regex.Matcher; import java.util.regex.Pattern; String text = "John: 30, Jane: 25, Bob: 40"; Pattern pattern = Pattern.compile("(\w+): (\d+)"); Matcher matcher = pattern.matcher(text); while (matcher.find()) { String name = matcher.group(1); // 第一个捕获组 String age = matcher.group(2); // 第二个捕获组 System.out.println(name + " is " + age + " years old."); // 输出: John is 30 years old. // 输出: Jane is 25 years old. // 输出: Bob is 40 years old. }

其他语言中的正则表达式支持

1. C

C#中的System.Text.RegularExpressions命名空间提供了正则表达式支持。

using System; using System.Text.RegularExpressions; class Program { static void Main() { string text = "abc123def456"; // IsMatch()方法：测试字符串是否匹配模式 Console.WriteLine(Regex.IsMatch(text, @"d+")); // 输出: True // Match()方法：返回第一个匹配 Match match = Regex.Match(text, @"d+"); Console.WriteLine(match.Value); // 输出: 123 // Matches()方法：返回所有匹配 MatchCollection matches = Regex.Matches(text, @"d+"); foreach (Match m in matches) { Console.WriteLine(m.Value); // 输出: 123, 然后输出: 456 } // Replace()方法：替换匹配的子串 string result = Regex.Replace(text, @"d+", "NUM"); Console.WriteLine(result); // 输出: abcNUMdefNUM // Split()方法：根据匹配分割字符串 string[] parts = Regex.Split(text, @"d+"); foreach (string part in parts) { Console.WriteLine(part); // 输出: abc, def, } } }

2. Ruby

Ruby内置了对正则表达式的支持，语法简洁。

text = "abc123def456" # 匹配操作 if text =~ /d+/ puts "Match found at position #{$~.begin(0)}" # 输出: Match found at position 3 end # match()方法 match_data = text.match(/d+/) puts match_data[0] if match_data # 输出: 123 # scan()方法：返回所有匹配 matches = text.scan(/d+/) puts matches.inspect # 输出: ["123", "456"] # gsub()方法：替换所有匹配 result = text.gsub(/d+/, 'NUM') puts result # 输出: abcNUMdefNUM # split()方法：根据匹配分割字符串 parts = text.split(/d+/) puts parts.inspect # 输出: ["abc", "def", ""]

3. PHP

PHP提供了preg_系列函数来处理正则表达式。

<?php $text = "abc123def456"; // preg_match()：执行匹配 if (preg_match('/d+/', $text, $matches)) { echo "Match found: " . $matches[0] . "n"; // 输出: Match found: 123 } // preg_match_all()：执行全局匹配 if (preg_match_all('/d+/', $text, $matches)) { print_r($matches[0]); // 输出: Array ( [0] => 123 [1] => 456 ) } // preg_replace()：替换匹配的子串 $result = preg_replace('/d+/', 'NUM', $text); echo $result . "n"; // 输出: abcNUMdefNUM // preg_split()：根据匹配分割字符串 $parts = preg_split('/d+/', $text); print_r($parts); // 输出: Array ( [0] => abc [1] => def [2] => ) ?>

实战案例分享

数据验证

正则表达式在数据验证方面有着广泛的应用，可以高效地验证各种格式的数据。

1. 邮箱验证

import re def validate_email(email): pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$' if re.match(pattern, email): return True return False # 测试 emails = [ "user@example.com", "user.name@sub.domain.co.uk", "invalid.email@.com", "another.invalid@domain", "yet.another@domain." ] for email in emails: print(f"{email}: {'Valid' if validate_email(email) else 'Invalid'}") # 输出: # user@example.com: Valid # user.name@sub.domain.co.uk: Valid # invalid.email@.com: Invalid # another.invalid@domain: Invalid # yet.another@domain.: Invalid

2. 电话号码验证

import re def validate_phone(phone): # 支持多种格式：(123) 456-7890, 123-456-7890, 123.456.7890, 1234567890 pattern = r'^(+d{1,2}s?)?((d{3})|d{3})[s.-]?d{3}[s.-]?d{4}$' if re.match(pattern, phone): return True return False # 测试 phones = [ "(123) 456-7890", "123-456-7890", "123.456.7890", "1234567890", "+1 123 456 7890", "123-456-789" ] for phone in phones: print(f"{phone}: {'Valid' if validate_phone(phone) else 'Invalid'}") # 输出: # (123) 456-7890: Valid # 123-456-7890: Valid # 123.456.7890: Valid # 1234567890: Valid # +1 123 456 7890: Valid # 123-456-789: Invalid

3. 密码强度验证

import re def check_password_strength(password): # 至少8个字符，包含大小写字母、数字和特殊字符 pattern = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*d)(?=.*[@$!%*?&])[A-Za-zd@$!%*?&]{8,}$' if re.match(pattern, password): return "Strong" # 至少6个字符，包含字母和数字 pattern = r'^(?=.*[A-Za-z])(?=.*d)[A-Za-zd]{6,}$' if re.match(pattern, password): return "Medium" return "Weak" # 测试 passwords = [ "Password123!", "password123", "123456", "abcdef", "Abc123" ] for password in passwords: print(f"{password}: {check_password_strength(password)}") # 输出: # Password123!: Strong # password123: Medium # 123456: Weak # abcdef: Weak # Abc123: Medium

文本提取与替换

正则表达式在文本提取与替换方面非常强大，可以处理复杂的文本操作。

1. 提取URL

import re def extract_urls(text): # 匹配HTTP/HTTPS URL pattern = r'https?://(?:[-w.]|(?:%[da-fA-F]{2}))+[/w .-]*??[/w .-=&%]*' return re.findall(pattern, text) # 测试 text = """ Visit our website at https://www.example.com for more information. You can also check out our blog at http://blog.example.com/posts/latest. For support, email us at support@example.com or visit https://help.example.com/faq?id=123&lang=en. """ urls = extract_urls(text) for url in urls: print(url) # 输出: # https://www.example.com # http://blog.example.com/posts/latest # https://help.example.com/faq?id=123&lang=en

2. 提取HTML标签内容

import re def extract_html_tags(html, tag): # 提取指定HTML标签的内容 pattern = f'<{tag}[^>]*>(.*?)</{tag}>' return re.findall(pattern, html, re.DOTALL) # 测试 html = """ <html> <head> <title>Example Page</title> </head> <body> <h1>Welcome to the Example Page</h1> <p>This is a paragraph with <b>bold</b> text.</p> <p>Another paragraph with <i>italic</i> text.</p> </body> </html> """ print("Titles:", extract_html_tags(html, 'title')) print("Headings:", extract_html_tags(html, 'h1')) print("Paragraphs:", extract_html_tags(html, 'p')) print("Bold text:", extract_html_tags(html, 'b')) print("Italic text:", extract_html_tags(html, 'i')) # 输出: # Titles: ['Example Page'] # Headings: ['Welcome to the Example Page'] # Paragraphs: ['This is a paragraph with <b>bold</b> text.', 'Another paragraph with <i>italic</i> text.'] # Bold text: ['bold'] # Italic text: ['italic']

3. 文本清理与格式化

import re def clean_text(text): # 移除多余的空格 text = re.sub(r's+', ' ', text) # 移除特殊字符，只保留字母、数字和标点 text = re.sub(r'[^ws.,!?;:'"-]', '', text) # 确保标点符号前没有空格 text = re.sub(r's+([.,!?;:'"-])', r'1', text) # 确保标点符号后有一个空格 text = re.sub(r'([.,!?;:'"-])(?=[^s])', r'1 ', text) return text.strip() # 测试 text = "This is a test@ text with extra spaces, and... weird@ punctuation!Let's clean it up." cleaned = clean_text(text) print(cleaned) # 输出: This is a test text with extra spaces, and... weird punctuation. Let's clean it up.

日志分析

正则表达式在日志分析中非常有用，可以快速提取关键信息。

1. 解析Apache访问日志

import re def parse_apache_log(log_line): # Apache Common Log Format pattern = r'^(S+) S+ S+ [([w:/]+s[+-]d{4})] "(S+) (S+) (S+)" (d{3}) (d+|-)' match = re.match(pattern, log_line) if match: return { 'ip': match.group(1), 'timestamp': match.group(2), 'method': match.group(3), 'path': match.group(4), 'protocol': match.group(5), 'status': match.group(6), 'size': match.group(7) } return None # 测试 log_line = '127.0.0.1 - - [25/Dec/2021:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234' parsed = parse_apache_log(log_line) if parsed: for key, value in parsed.items(): print(f"{key}: {value}") # 输出: # ip: 127.0.0.1 # timestamp: 25/Dec/2021:10:00:00 +0000 # method: GET # path: /index.html # protocol: HTTP/1.1 # status: 200 # size: 1234

2. 提取错误日志中的关键信息

import re def extract_error_info(log_text): # 匹配错误日志中的时间戳、错误级别和错误消息 pattern = r'^(d{4}-d{2}-d{2} d{2}:d{2}:d{2}),d{3} [(w+)] (.+)$' errors = [] for line in log_text.split('n'): match = re.match(pattern, line) if match and match.group(2) in ['ERROR', 'WARN']: errors.append({ 'timestamp': match.group(1), 'level': match.group(2), 'message': match.group(3) }) return errors # 测试 log_text = """ 2021-12-25 10:00:00,123 INFO Application started 2021-12-25 10:01:00,456 DEBUG Processing request 2021-12-25 10:02:00,789 WARN Connection timeout 2021-12-25 10:03:00,012 ERROR Database connection failed 2021-12-25 10:04:00,345 INFO Retrying connection 2021-12-25 10:05:00,678 ERROR Connection failed again """ errors = extract_error_info(log_text) for error in errors: print(f"{error['timestamp']} [{error['level']}] {error['message']}") # 输出: # 2021-12-25 10:02:00,789 [WARN] Connection timeout # 2021-12-25 10:03:00,012 [ERROR] Database connection failed # 2021-12-25 10:05:00,678 [ERROR] Connection failed again

网页爬虫中的文本处理

正则表达式在网页爬虫中常用于提取特定信息。

1. 提取网页中的所有链接

import re def extract_links(html): # 匹配href属性中的链接 pattern = r'<as+(?:[^>]*?s+)?href="([^"]*)"' return re.findall(pattern, html) # 测试 html = """ <html> <body> <a href="https://www.example.com">Example</a> <a href="/about">About Us</a> <a href="contact.html">Contact</a> <a href="https://www.google.com" target="_blank">Google</a> </body> </html> """ links = extract_links(html) for link in links: print(link) # 输出: # https://www.example.com # /about # contact.html # https://www.google.com

2. 提取产品信息

import re def extract_product_info(html): products = [] # 匹配产品块 product_pattern = r'<div class="product">(.*?)</div>s*</div>' product_blocks = re.findall(product_pattern, html, re.DOTALL) for block in product_blocks: product = {} # 提取产品名称 name_match = re.search(r'<h2>(.*?)</h2>', block) if name_match: product['name'] = name_match.group(1) # 提取产品价格 price_match = re.search(r'<span class="price">$(d+.d{2})</span>', block) if price_match: product['price'] = float(price_match.group(1)) # 提取产品描述 desc_match = re.search(r'<p class="description">(.*?)</p>', block, re.DOTALL) if desc_match: product['description'] = desc_match.group(1).strip() products.append(product) return products # 测试 html = """ <html> <body> <h1>Products</h1> <div class="product"> <h2>Smartphone</h2> <span class="price">$599.99</span> <p class="description"> A powerful smartphone with a large display and advanced camera. </p> </div> <div class="product"> <h2>Laptop</h2> <span class="price">$999.99</span> <p class="description"> High-performance laptop for work and gaming. </p> </div> </body> </html> """ products = extract_product_info(html) for product in products: print(f"Name: {product['name']}") print(f"Price: ${product['price']}") print(f"Description: {product['description']}") print("---") # 输出: # Name: Smartphone # Price: $599.99 # Description: A powerful smartphone with a large display and advanced camera. # --- # Name: Laptop # Price: $999.99 # Description: High-performance laptop for work and gaming. # ---

性能优化技巧

正则表达式虽然强大，但在处理大量文本时可能会遇到性能问题。以下是一些优化正则表达式性能的技巧：

1. 避免回溯

回溯是正则表达式性能问题的常见原因。当正则表达式引擎尝试多种可能的匹配路径时，就会发生回溯。以下是一些减少回溯的技巧：

使用具体字符类代替通配符

import re import time # 低效方式：使用.匹配任意字符 pattern1 = r'<div>.*</div>' # 高效方式：使用具体字符类 pattern2 = r'<div>[^<]*</div>' html = "<div>" + "content" * 1000 + "</div>" # 测试性能 start_time = time.time() re.search(pattern1, html) print(f"Pattern 1 time: {time.time() - start_time:.6f} seconds") start_time = time.time() re.search(pattern2, html) print(f"Pattern 2 time: {time.time() - start_time:.6f} seconds")

使用原子组

原子组(?>...)可以防止回溯，一旦匹配就不会放弃已匹配的字符。

import re # 普通分组 pattern1 = r'(d+)+a' # 原子组 pattern2 = r'(?>d+)+a' text = "1234567890" * 10 + "b" # 注意：这个文本不匹配模式 # 测试性能 try: re.search(pattern1, text) except re.error: print("Pattern 1 caused a catastrophic backtracking!") try: re.search(pattern2, text) except re.error: print("Pattern 2 caused a catastrophic backtracking!")

2. 使用非捕获组

如果不需要捕获匹配的文本，使用非捕获组(?:...)可以提高性能。

import re import time # 使用捕获组 pattern1 = r'(d{4})-(d{2})-(d{2})' # 使用非捕获组 pattern2 = r'(?:d{4})-(?:d{2})-(?:d{2})' text = "2023-07-15 " * 10000 # 测试性能 start_time = time.time() re.findall(pattern1, text) print(f"Pattern 1 time: {time.time() - start_time:.6f} seconds") start_time = time.time() re.findall(pattern2, text) print(f"Pattern 2 time: {time.time() - start_time:.6f} seconds")

3. 预编译正则表达式

如果多次使用同一个正则表达式，预编译它可以提高性能。

import re import time text = "abc123def456ghi789" * 1000 # 不预编译 start_time = time.time() for _ in range(1000): re.findall(r'd+', text) print(f"Without compilation time: {time.time() - start_time:.6f} seconds") # 预编译 pattern = re.compile(r'd+') start_time = time.time() for _ in range(1000): pattern.findall(text) print(f"With compilation time: {time.time() - start_time:.6f} seconds")

4. 使用锚点

使用^和$锚点可以限制匹配范围，提高匹配效率。

import re import time text = "abc123def456ghi789" * 1000 # 不使用锚点 pattern1 = r'd+' # 使用锚点 pattern2 = r'^d+$' # 测试性能 start_time = time.time() re.search(pattern1, text) print(f"Without anchors time: {time.time() - start_time:.6f} seconds") start_time = time.time() re.search(pattern2, text) print(f"With anchors time: {time.time() - start_time:.6f} seconds")

5. 避免过度使用贪婪量词

贪婪量词（如.*、.+）会导致大量回溯，尽可能使用非贪婪量词（如.*?、.+?）或更具体的模式。

import re import time html = "<div>" + "content" * 100 + "</div>" * 100 # 贪婪量词 pattern1 = r'<div>.*</div>' # 非贪婪量词 pattern2 = r'<div>.*?</div>' # 测试性能 start_time = time.time() re.findall(pattern1, html) print(f"Greedy quantifier time: {time.time() - start_time:.6f} seconds") start_time = time.time() re.findall(pattern2, html) print(f"Non-greedy quantifier time: {time.time() - start_time:.6f} seconds")

常见问题与解决方案

1. 匹配换行符

默认情况下，.不匹配换行符。要匹配包括换行符在内的所有字符，可以使用[sS]或启用DOTALL模式。

import re text = "Line 1nLine 2nLine 3" # 不匹配换行符 pattern1 = r'Line 1.*Line 3' print(re.search(pattern1, text)) # 输出: None # 匹配换行符的方法1：使用[sS] pattern2 = r'Line 1[sS]*Line 3' print(re.search(pattern2, text).group()) # 输出: Line 1 # Line 2 # Line 3 # 匹配换行符的方法2：启用DOTALL模式 pattern3 = r'Line 1.*Line 3' print(re.search(pattern3, text, re.DOTALL).group()) # 输出: Line 1 # Line 2 # Line 3

2. 处理Unicode字符

在处理Unicode字符时，需要确保正则表达式支持Unicode，并使用适当的字符类。

import re text = "Hello 你好 こんにちは 안녕하세요" # 匹配所有单词（包括Unicode） pattern1 = r'w+' print(re.findall(pattern1, text)) # 输出: ['Hello', 'u4f60u597d', 'u3053u3093u306bu3061u306f', 'uc548ub155ud558uc138uc694'] # 使用Unicode属性匹配特定语言的字符 pattern2 = r'p{Han}+' # 匹配汉字 print(re.findall(pattern2, text, re.UNICODE)) # 输出: ['你好'] pattern3 = r'p{Hiragana}+' # 匹配平假名 print(re.findall(pattern3, text, re.UNICODE)) # 输出: ['こんにちは'] pattern4 = r'p{Hangul}+' # 匹配韩文 print(re.findall(pattern4, text, re.UNICODE)) # 输出: ['안녕하세요']

3. 处理嵌套结构

正则表达式不适合处理嵌套结构（如括号嵌套），因为它们无法计数。对于这种情况，最好使用专门的解析器。

import re # 尝试匹配嵌套括号（不推荐） text = "((a + b) * (c - d))" pattern = r'(([^()]|(?R))*)' # 使用递归模式（PCRE支持，Python不支持） # 在Python中，可以使用以下方法处理简单的嵌套结构 def match_nested_parens(text): stack = [] result = [] start = -1 for i, char in enumerate(text): if char == '(': if not stack: start = i stack.append(i) elif char == ')': if stack: stack.pop() if not stack: result.append(text[start:i+1]) return result print(match_nested_parens(text)) # 输出: ['((a + b) * (c - d))']

4. 处理大型文本

处理大型文本时，正则表达式可能会消耗大量内存。以下是一些解决方案：

import re # 方法1：使用生成器逐行处理 def process_large_file(file_path, pattern): compiled_pattern = re.compile(pattern) with open(file_path, 'r') as file: for line in file: match = compiled_pattern.search(line) if match: yield match # 方法2：使用re.Scanner进行流式处理 def tokenize_large_text(text): scanner = re.Scanner([ (r'd+', lambda scanner, token: ('NUMBER', token)), (r'[a-zA-Z_]w*', lambda scanner, token: ('IDENTIFIER', token)), (r'[+-*/]', lambda scanner, token: ('OPERATOR', token)), (r's+', None), # 忽略空白 (r'.', lambda scanner, token: ('UNKNOWN', token)), ]) return scanner.scan(text)[0] # 测试 text = "x = 123 + 456" tokens = tokenize_large_text(text) print(tokens) # 输出: [('IDENTIFIER', 'x'), ('OPERATOR', '='), ('NUMBER', '123'), ('OPERATOR', '+'), ('NUMBER', '456')]

5. 调试复杂正则表达式

调试复杂的正则表达式可能很困难。以下是一些调试技巧：

import re # 使用re.DEBUG标志查看正则表达式的匹配过程 pattern = r'(w+)s+1' text = "hello hello world world" print("Debugging pattern:") re.compile(pattern, re.DEBUG) # 使用在线工具可视化正则表达式 # 例如：https://regex101.com/, https://regexper.com/ # 分解复杂正则表达式 def complex_pattern_match(text): # 第一步：匹配单词 word_pattern = r'w+' words = re.finditer(word_pattern, text) # 第二步：检查重复 prev_word = None for match in words: current_word = match.group() if current_word == prev_word: print(f"Found repeated word: {current_word} at position {match.start()}") prev_word = current_word # 测试 complex_pattern_match("hello hello world world") # 输出: Found repeated word: hello at position 6 # 输出: Found repeated word: world at position 17