正则表达式完全指南：从基础语法到多语言实战 | 2026 最新实践

1
普通文本搜索：搜索 "error"        → 只匹配 error 这个词
2
正则表达式搜索：搜索 "err[a-z]+" → 匹配 error, errors, errcode, errlevel...

1
. * + ? ^ $ { } [ ] ( ) | \

1
import re
2

3
text = """line 1
4
line 2
5
line 3"""
6

7
# 默认：^ 只匹配整个字符串开头
8
print(re.findall(r'^line', text))        # ['line']
9

10
# 多行模式：^ 匹配每行开头
11
print(re.findall(r'^line', text, re.MULTILINE))  # ['line', 'line', 'line']

1
import re
2

3
# 捕获组
4
m = re.search(r'(\d{4})-(\d{2})-(\d{2})', '2026-07-07')
5
print(m.group(1))  # 2026
6
print(m.group(2))  # 07
7
print(m.group(3))  # 07
8

9
# 命名捕获组
10
m = re.search(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})', '2026-07-07')
11
print(m.group('year'))   # 2026
12
print(m.group('month'))  # 07
13

14
# 非捕获组：不保存匹配结果
15
re.findall(r'(?:https?|ftp)://(\S+)', 'visit https://971918.xyz and http://example.com')
16
# ['971918.xyz', 'example.com']  -- 只捕获域名部分

1
文本: <div class="a">content</div>
2
正则: <.*>
3
结果: <div class="a">content</div>  ← 匹配整个标签（到最后一个 >）

1
文本: <div class="a">content</div>
2
正则: <.*?>
3
结果: <div class="a">  ← 只匹配到第一个 >

1
import re
2

3
html = '<a href="1">link1</a><a href="2">link2</a>'
4

5
# 贪婪：匹配整个
6
print(re.findall(r'<a.*>', html))
7
# ['<a href="1">link1</a><a href="2">link2</a>']
8

9
# 非贪婪：逐个匹配
10
print(re.findall(r'<a.*?>', html))
11
# ['<a href="1">', '<a href="2">']
12

13
# 提取所有链接文本
14
print(re.findall(r'<a[^>]*>(.*?)</a>', html))
15
# ['link1', 'link2']

1
import re
2

3
# 正向先行断言：匹配后面跟着 "元" 的数字
4
text = "价格100元，折扣20元，总计80元"
5
print(re.findall(r'\d+(?=元)', text))
6
# ['100', '20', '80']
7

8
# 负向先行断言：匹配不以 ".txt" 结尾的文件名
9
files = "a.txt b.log c.txt d.conf"
10
print(re.findall(r'\S+(?!\.txt)\b', files))
11
# 需要注意断言的位置
12

13
# 正向后行断言：匹配 "价格" 后面的数字
14
text = "价格100，数量5，重量200"
15
print(re.findall(r'(?<=价格)\d+', text))
16
# ['100']
17

18
# 负向后行断言：匹配不以 "$" 开头的数字
19
text = "$100 200 $300 400"
20
print(re.findall(r'(?<!\$)\b\d+', text))
21
# ['200', '400']
22

23
# 组合：提取 HTML 标签内的文本（不含标签本身）
24
html = '<h1>Title</h1><p>Content</p>'
25
print(re.findall(r'(?<=<\w+>).*?(?=</\w+>)', html))
26
# ['Title', 'Content']
27

28
# 密码验证：至少8位，含大小写字母和数字
29
password = "Abc12345"
30
pattern = r'(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}'
31
print(bool(re.match(pattern, password)))
32
# True

1
" 推荐用 \v（very magic）模式，接近 PCRE 语法
2
/\v\d+              " 匹配数字
3
/\v[a-z]+           " 匹配小写字母
4
/\v(error|warn)     " 匹配 error 或 warn
5

6
" 默认魔术模式下 + 需要转义
7
/\d\+               " 匹配数字（默认模式）

1
" === 搜索 ===
2
" 搜索单词 "error"
3
/\<error\>
4

5
" 搜索以 error 开头的行
6
/^error
7

8
" 搜索 3 位数字
9
/\v\d{3}
10

11
" 搜索邮箱地址
12
/\v[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
13

14
" 非贪婪匹配
15
" 匹配 <a> 标签内容
16
/\v\<a[^>]*\>.{-}\<\/a\>
17

18
" === 替换 ===
19
" 全局替换
20
:%s/old/new/g
21

22
" 只替换当前行
23
:s/old/new/g
24

25
" 确认每个替换
26
:%s/old/new/gc
27

28
" 用 \v 模式替换
29
:%s/\v(\d{4})-(\d{2})-(\d{2})/\3\/\2\/\1/g
30
" 2026-07-07 → 07/07/2026
31

32
" 删除行尾空格
33
:%s/\s\+$//
34

35
" 删除空行
36
:g/^$/d
37

38
" 每行行首加序号
39
:let i=1 | g/^/ s//\=i.'. '/ | let i+=1
40

41
" 把多个空格合并为一个
42
:%s/  \+/ /g

1
import re
2

3
# === re.search：搜索第一个匹配 ===
4
m = re.search(r'\d{4}', '日期是2026年7月7日')
5
if m:
6
    print(m.group())  # 2026
7
    print(m.start())  # 3（匹配起始位置）
8
    print(m.end())    # 7（匹配结束位置）
9

10
# === re.match：从字符串开头匹配 ===
11
m = re.match(r'\d+', '123abc')
12
print(m.group())  # 123（从头匹配数字部分）
13

14
m = re.match(r'\d+', 'abc123')
15
print(m)  # None（开头不是数字）
16

17
# === re.fullmatch：整个字符串必须完全匹配 ===
18
print(bool(re.fullmatch(r'\d{4}', '2026')))  # True
19
print(bool(re.fullmatch(r'\d{4}', '2026a'))) # False
20

21
# === re.findall：返回所有匹配 ===
22
print(re.findall(r'\d+', 'a1b22c333'))
23
# ['1', '22', '333']
24

25
# 返回元组（有分组时）
26
print(re.findall(r'(\w+)@(\w+)', 'a@b c@d'))
27
# [('a', 'b'), ('c', 'd')]
28

29
# === re.finditer：返回迭代器（更省内存）===
30
for m in re.finditer(r'\d+', 'a1b22c333'):
31
    print(m.group(), m.span())
32

33
# === re.sub：替换 ===
34
# 基础替换
35
print(re.sub(r'\d+', 'N', 'a1b22c333'))
36
# aNbNcN
37

38
# 使用回调函数
39
def double_num(m):
40
    return str(int(m.group()) * 2)
41
print(re.sub(r'\d+', double_num, 'a1b22c333'))
42
# a2b44c666
43

44
# === re.split：分割 ===
45
print(re.split(r'[,;:\s]+', 'a, b; c: d e'))
46
# ['a', 'b', 'c', 'd', 'e']
47

48
# 保留分隔符
49
print(re.split(r'([,;:\s]+)', 'a, b; c'))
50
# ['a', ', ', 'b', '; ', 'c']
51

52
# === re.compile：预编译（循环中使用可提升性能）===
53
pattern = re.compile(r'\b\w{4}\b')  # 4字母单词
54
print(pattern.findall('the quick brown fox jumps'))
55
# ['quick', 'brown', 'jumps']

1
m = re.search(r'(\d{4})-(\d{2})-(\d{2})', 'Date: 2026-07-07')
2

3
m.group()      # '2026-07-07'  整个匹配
4
m.group(0)     # '2026-07-07'  同上
5
m.group(1)     # '2026'        第1组
6
m.group(2)     # '07'          第2组
7
m.group(3)     # '07'          第3组
8
m.groups()     # ('2026', '07', '07')  所有分组
9
m.start()      # 6   匹配起始位置
10
m.end()        # 16  匹配结束位置
11
m.span()       # (6, 16)  (起始, 结束)
12
m.string       # 'Date: 2026-07-07'  原始字符串

1
import re
2

3
# === 日志解析 ===
4
log_line = '192.168.1.1 - - [07/Jul/2026:10:30:45 +0800] "GET /api/users HTTP/1.1" 200 1234'
5

6
pattern = re.compile(r'''
7
    (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})  # IP
8
    \s.*?\[
9
    ([^\]]+)                                # 时间
10
    \]\s"
11
    (\w+)\s                                 # 方法
12
    (\S+)\s                                 # URL
13
    [^"]*"\s
14
    (\d{3})\s                               # 状态码
15
    (\d+)                                   # 响应大小
16
''', re.VERBOSE)
17

18
m = pattern.search(log_line)
19
if m:
20
    print(f"IP: {m.group(1)}")
21
    print(f"Time: {m.group(2)}")
22
    print(f"Method: {m.group(3)}")
23
    print(f"URL: {m.group(4)}")
24
    print(f"Status: {m.group(5)}")
25
    print(f"Size: {m.group(6)}")
26

27
# === 数据清洗 ===
28
# 提取文本中的所有 URL
29
text = '访问 https://971918.xyz 或 http://example.com/page?q=1'
30
urls = re.findall(r'https?://[^\s<>"\']+', text)
31
print(urls)  # ['https://971918.xyz', 'http://example.com/page?q=1']
32

33
# 敏感信息脱敏
34
text = '手机: 13812345678, 邮箱: test@example.com, 身份证: 110101199001011234'
35
masked = re.sub(r'(\d{3})\d{4}(\d{4})', r'\1****\2', text)
36
print(masked)  # 手机: 138****5678, 邮箱: test@example.com, 身份证: 110****1234
37

38
# === 模板引擎（简单版）===
39
template = 'Hello {name}, your order #{order_id} is {status}.'
40

41
def render(template, **kwargs):
42
    return re.sub(r'\{(\w+)\}', lambda m: str(kwargs.get(m.group(1), m.group(0))), template)
43

44
print(render(template, name='Alice', order_id='12345', status='shipped'))
45
# Hello Alice, your order #12345 is shipped.
46

47
# === 密码强度验证 ===
48
def validate_password(password):
49
    checks = [
50
        (r'.{8,}',        '至少 8 位'),
51
        (r'.*[a-z]',      '至少一个小写字母'),
52
        (r'.*[A-Z]',      '至少一个大写字母'),
53
        (r'.*\d',         '至少一个数字'),
54
        (r'.*[!@#$%^&*]', '至少一个特殊字符'),
55
    ]
56
    for pattern, msg in checks:
57
        if not re.search(pattern, password):
58
            return False, f'密码不符合要求: {msg}'
59
    return True, '密码强度合格'
60

61
print(validate_password('Abc12345!'))  # (True, '密码强度合格')
62
print(validate_password('abc123'))     # (False, '密码不符合要求: 至少 8 位')

1
// 字面量创建（推荐）
2
const re = /pattern/flags;
3

4
// 构造函数（动态生成时使用）
5
const re = new RegExp('pattern', 'flags');
6

7
// 常用标志
8
// g - 全局匹配
9
// i - 忽略大小写
10
// m - 多行模式
11
// s - . 匹配换行（ES2018+）
12
// u - Unicode 模式

1
// === String 方法 ===
2
'2026-07-07'.match(/\d{4}/)        // ['2026']
3
'2026-07-07'.match(/\d+/g)         // ['2026', '07', '07']
4
'a1b22c333'.replace(/\d+/, 'N')    // 'aNb22c333'
5
'a1b22c333'.replace(/\d+/g, 'N')   // 'aNbNcN'
6
'a,b;c:d'.split(/[,;:]/)           // ['a', 'b', 'c', 'd']
7
'2026'.search(/\d{4}/)             // 0（返回位置）
8

9
// === RegExp 方法 ===
10
/\d{4}/.test('2026')               // true
11
/\d{4}/.exec('Date: 2026-07-07')   // ['2026', index: 6, ...]
12

13
// === 命名捕获组（ES2018+）===
14
const m = '2026-07-07'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
15
console.log(m.groups.year)   // 2026
16
console.log(m.groups.month)  // 07
17
console.log(m.groups.day)    // 07
18

19
// === 替换回调 ===
20
'a1b22c333'.replace(/\d+/g, (match) => match * 2)
21
// 'a2b44c666'
22

23
// === 零宽断言（ES2018+）===
24
// 正向后行断言
25
'价格100'.match(/(?<=价格)\d+/)  // ['100']
26

27
// 负向后行断言
28
'$100 200'.match(/(?<!\$)\b\d+/g)  // ['200']

1
// 表单验证
2
const validators = {
3
    email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
4
    phone: /^1[3-9]\d{9}$/,
5
    url: /^https?:\/\/[^\s/$.?#].[^\s]*$/,
6
    ip: /^(\d{1,3}\.){3}\d{1,3}$/,
7
    zip: /^\d{6}$/,
8
};
9

10
function validate(value, type) {
11
    return validators[type]?.test(value) ?? false;
12
}
13

14
console.log(validate('test@example.com', 'email')); // true
15
console.log(validate('13812345678', 'phone'));      // true
16

17
// 千分位格式化
18
'1234567890'.replace(/\B(?=(\d{3})+(?!\d))/g, ',')
19
// '1,234,567,890'
20

21
// 驼峰转下划线
22
'camelCaseString'.replace(/([A-Z])/g, '_$1').toLowerCase()
23
// 'camel_case_string'
24

25
// 下划线转驼峰
26
'snake_case_string'.replace(/_([a-z])/g, (_, c) => c.toUpperCase())
27
// 'snakeCaseString'
28

29
// 去除 HTML 标签
30
'<p>Hello <b>World</b></p>'.replace(/<[^>]+>/g, '')
31
// 'Hello World'
32

33
// 提取查询参数
34
const query = 'name=Alice&age=30&city=Beijing';
35
const params = Object.fromEntries(
36
    [...query.matchAll(/(\w+)=(\w+)/g)].map(m => [m[1], m[2]])
37
);
38
// { name: 'Alice', age: '30', city: 'Beijing' }

1
# IPv4 地址
2
^(\d{1,3}\.){3}\d{1,3}$
3
^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$  # 严格版
4

5
# IPv6 地址（简化版）
6
^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
7

8
# URL
9
^https?://[^\s/$.?#].[^\s]*$
10

11
# 域名
12
^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$
13

14
# 端口号
15
^([1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$
16

17
# MAC 地址
18
^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$

1
# 邮箱（通用版）
2
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
3

4
# 邮箱（RFC 5322 严格版）
5
^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$
6

7
# 中国手机号
8
^1[3-9]\d{9}$
9

10
# 中国身份证号（18位）
11
^\d{17}[\dXx]$
12

13
# 中国邮政编码
14
^\d{6}$
15

16
# 用户名（字母数字下划线，4-20位）
17
^[a-zA-Z0-9_]{4,20}$
18

19
# 密码（至少8位，含大小写字母和数字）
20
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$

1
# 日期 YYYY-MM-DD
2
^\d{4}-\d{2}-\d{2}$
3

4
# 日期 YYYY-MM-DD（严格，含月份校验）
5
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$
6

7
# 时间 HH:MM:SS
8
^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$
9

10
# ISO 8601 时间戳
11
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$
12

13
# 中文日期
14
^\d{4}年\d{1,2}月\d{1,2}日$

1
# 文件扩展名
2
\.([a-zA-Z0-9]{1,5})$
3

4
# 图片文件
5
\.(jpe?g|png|gif|webp|svg|bmp)$
6

7
# 代码注释（单行）
8
(\/\/.*|\/\*.*\*\/|#.*)
9

10
# 十六进制颜色
11
^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$
12

13
# HTML 标签
14
<\/?[a-zA-Z][^>]*>
15

16
# HTML 标签内容
17
(?<=<[^>]+>).*?(?=<[^>]+>)
18

19
# JSON 键名
20
"([^"]+)":\s
21

22
# 版本号
23
^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$

1
# Nginx 日志 IP
2
^(\d{1,3}\.){3}\d{1,3}
3

4
# Nginx 日志时间
5
\[([^\]]+)\]
6

7
# HTTP 状态码
8
\b[1-5]\d{2}\b
9

10
# 错误日志级别
11
\b(ERROR|WARN|CRITICAL|FATAL)\b
12

13
# 日志中的 URL
14
"(GET|POST|PUT|DELETE|PATCH) ([^"]*)"
15

16
# 耗时（毫秒）
17
(\d+)ms$

1
import re
2
import time
3

4
# ❌ 灾难性回溯示例
5
pattern = r'(a+)+b'
6
text = 'a' * 30  # 30个a，没有b
7

8
start = time.time()
9
re.search(pattern, text)
10
print(f'耗时: {time.time() - start:.2f}s')  # 可能耗时几十秒！

1
import re
2

3
# ❌ 1. 避免嵌套量词
4
r'(a+)+b'          # 灾难性回溯风险
5
r'a+b'              # ✅ 简化
6

7
# ❌ 2. 避免模糊的 .* 与量词组合
8
r'.*\w+.*'          # 回溯风险
9
r'\w+'              # ✅ 如果只需要匹配单词
10

11
# ❌ 3. 避免多个可选分支重叠
12
r'(a|a)*b'          # 分支重叠导致回溯
13
r'a*b'              # ✅ 简化
14

15
# ✅ 4. 使用具体字符类替代 .
16
r'<[^>]+>'          # 比 <.*> 高效得多
17
r'"[^"]*"'          # 比 ".*?" 高效得多
18

19
# ✅ 5. 使用锚点缩小搜索范围
20
r'^\d{4}-\d{2}-\d{2}$'  # 加 ^ $ 避免中间匹配
21

22
# ✅ 6. 预编译正则
23
pattern = re.compile(r'\b\w{4}\b')
24
for line in lines:
25
    pattern.findall(line)  # 比每次 re.findall 高效
26

27
# ✅ 7. Python 3.11+ 的原子组和占有量词
28
r'(?>a+)b'          # 原子组：匹配后不回溯
29
r'a++b'              # 占有量词：a+ 后不回溯（Python 3.11+）
30

31
# ✅ 8. 超时保护（Python 3.11+）
32
try:
33
    re.search(r'(a+)+b', 'a' * 30, timeout=1.0)
34
except TimeoutError:
35
    print('正则匹配超时')

1
import re
2
import time
3

4
text = 'x' * 10000 + 'abc'
5

6
# ❌ 慢：模糊匹配
7
start = time.time()
8
re.search(r'.*abc', text)
9
slow = time.time() - start
10

11
# ✅ 快：精确匹配
12
start = time.time()
13
re.search(r'abc$', text)
14
fast = time.time() - start
15

16
print(f'慢: {slow:.6f}s, 快: {fast:.6f}s')

1
import re
2

3
# 1. 用 re.DEBUG 查看编译过程
4
re.compile(r'\d{3}-\d{4}', re.DEBUG)
5

6
# 2. 逐步测试
7
text = 'IP: 192.168.1.1, Port: 8080'
8

9
# 先测简单部分
10
print(re.findall(r'\d+\.\d+\.\d+\.\d+', text))  # ['192.168.1.1']
11

12
# 再组合
13
print(re.findall(r'(\d+\.\d+\.\d+\.\d+).*?(\d+)', text))
14
# [('192.168.1.1', '8080')]
15

16
# 3. 测试边界情况
17
test_cases = [
18
    ('192.168.1.1', True),
19
    ('256.1.1.1', False),    # 256 > 255
20
    ('1.2.3', False),        # 只有3段
21
    ('a.b.c.d', False),      # 非数字
22
    ('192.168.1.1.5', True), # 注意：会匹配
23
]
24

25
ip_pattern = r'\b(\d{1,3}\.){3}\d{1,3}\b'
26
for text, expected in test_cases:
27
    result = bool(re.search(ip_pattern, text))
28
    status = '✅' if result == expected else '❌'
29
    print(f'{status} {text:20s} → {result}')