大家好，我是你们的Python大师～ 今天要给小白们讲一个“看似晦涩，实则万能”的Python工具——正则表达式（Regular Expression，简称Regex）。

很多小白刚学正则，看到一堆 \d、\w、.*?、(?=...) 就头皮发麻，觉得它太难、太抽象，学完就忘。但其实，正则表达式是处理文本的“终极利器”，不管是数据清洗、日志解析、爬虫提取，还是表单校验、字符串替换，有了正则，都能少写几十行代码，效率翻倍。

更重要的是，正则常和集合搭配使用——正则负责“精准提取”，集合负责“高效去重、快速判断”，两者结合能轻松破解很多复杂的文本处理和算法题。今天这篇，从基础到高阶，从案例到算法，帮你彻底掌握正则表达式，还能学会它和集合的联动用法，一篇文章搞定，再也不用怕遇到它！

全程干货，建议收藏+实操，跟着代码敲一遍，保证你学会就能用！

一、先搞懂：正则表达式到底是什么？（小白友好版）

正则表达式，简单来说，就是一种描述字符串模式的“规则语言”。它不依赖Python，是一种通用的文本匹配工具，而Python中的 re 模块，提供了完整的正则表达式支持，能让我们轻松在Python中使用正则解决文本问题。

举个生活中的例子：你想从一堆文本中找出所有手机号、所有邮箱，或者过滤掉文本中的特殊符号，手动查找费时费力，而正则只要一行代码就能搞定。再比如，你想判断一个字符串是不是合法的身份证号、是不是有效的URL，正则也能快速校验——这就是正则的核心价值：精准、高效地处理文本。

1. 正则的3个核心作用（必记）

• 匹配：判断一个字符串是否符合某个规则（比如“是不是手机号”“是不是邮箱”）；

• 提取：从杂乱的文本中，精准提取出符合规则的内容（比如从日志中提取IP地址、从网页中提取邮箱）；

• 替换：将文本中符合规则的内容，替换成指定内容（比如过滤文本中的特殊符号、将日期格式统一）。

2. Python正则入门：re模块核心函数（必练）

Python中操作正则，全靠内置的 re 模块，无需额外安装。下面这6个核心函数，是小白入门的基础，每个函数都配了极简案例，跟着敲一遍，快速上手。

注意：正则模式建议用 r"" 原始字符串表示，避免反斜杠 \ 的转义问题（比如 r"\d" 比 "\\d" 更简洁，不易出错）。

import re  # 导入re模块，所有正则操作都依赖它# 1. re.match(pattern, string)：从字符串开头匹配（只匹配开头）# 场景：判断字符串是否以“Python”开头result1 = re.match(r"Python", "Python小白")print(result1.group())  # 输出：Python（匹配成功，返回匹配内容）result2 = re.match(r"Python", "小白学Python")print(result2)  # 输出：None（匹配失败，返回None）# 2. re.search(pattern, string)：搜索整个字符串（找到第一个匹配项）# 场景：在字符串中找“Python”（无论位置）result3 = re.search(r"Python", "小白学Python")print(result3.group())  # 输出：Python（匹配成功）# 3. re.findall(pattern, string)：返回所有匹配项（列表形式）# 场景：提取字符串中所有数字result4 = re.findall(r"\d", "年龄18，身高180，体重65")print(result4)  # 输出：['1', '8', '1', '8', '0', '6', '5']# 4. re.finditer(pattern, string)：返回匹配对象的迭代器（节省内存）# 场景：提取所有数字并遍历for match in re.finditer(r"\d", "年龄18，身高180"):    print(match.group(), end=" ")  # 输出：1 8 1 8 0# 5. re.sub(pattern, repl, string)：替换匹配内容（返回新字符串）# 场景：将所有数字替换为“*”result5 = re.sub(r"\d", "*", "年龄18，身高180")print("\n" + result5)  # 输出：年龄**，身高***# 6. re.compile(pattern)：预编译正则模式（多次使用时提升性能）# 场景：多次提取数字，预编译更高效pattern = re.compile(r"\d")result6 = pattern.findall("年龄18")result7 = pattern.findall("身高180")print(result6, result7)  # 输出：['1','8'] ['1','8','0']

二、基础正则语法：小白必背的“匹配规则”（附实战案例）

正则的核心是“规则”，记住下面这些最常用的匹配符号，就能应对80%的基础场景。每个规则都配了实战案例，结合代码理解，不用死记硬背！

1. 基础匹配符号（必背）

2. 量词：控制匹配次数（实战高频）

量词用来控制“前面的匹配规则要出现多少次”，比如“匹配1个或多个数字”“匹配0个或1个字母”，结合基础符号使用，威力翻倍。

import re# 1. *：匹配前面的规则0次或多次（贪婪匹配，尽可能多匹配）# 场景：提取以“a”开头，后面跟任意个数字的字符串text1 = "a123 a45 a a6"result1 = re.findall(r"a\d*", text1)print(result1)  # 输出：['a123', 'a45', 'a', 'a6']# 2. +：匹配前面的规则1次或多次（必须出现至少1次）# 场景：提取以“a”开头，后面跟1个及以上数字的字符串（排除单独的“a”）result2 = re.findall(r"a\d+", text1)print(result2)  # 输出：['a123', 'a45', 'a6']# 3. ?：匹配前面的规则0次或1次（可选）# 场景：匹配“http”或“https”（s可选）text2 = "http://baidu.com https://google.com"result3 = re.findall(r"https?", text2)print(result3)  # 输出：['http', 'https']# 4. {n}：匹配前面的规则恰好n次# 场景：提取4位数字（比如年份）text3 = "2023年 2024 19980 2025"result4 = re.findall(r"\d{4}", text3)print(result4)  # 输出：['2023', '2024', '1998', '2025']# 5. {n,}：匹配前面的规则至少n次# 场景：提取至少3位数字（比如手机号前3位）text4 = "12 123 1234 5678"result5 = re.findall(r"\d{3,}", text4)print(result5)  # 输出：['123', '1234', '5678']# 6. {n,m}：匹配前面的规则n到m次（包含n和m）# 场景：提取3-4位数字（比如区号）text5 = "010 021 0755 12345"result6 = re.findall(r"\d{3,4}", text5)print(result6)  # 输出：['010', '021', '0755', '1234']

3. 基础实战案例（小白必练，直接套用）

结合上面的语法，做3个最常用的实战案例，覆盖“匹配、提取、替换”三大核心作用，代码可直接复制实操。

import re# 案例1：匹配手机号（简单校验：11位数字，以1开头）def is_phone(phone):    # 正则模式：^1 开头，后面跟10位数字，$ 结尾（确保是11位）    pattern = re.compile(r"^1\d{10}$")    return bool(pattern.match(phone))print(is_phone("13800138000"))  # 输出：True（合法）print(is_phone("1234567890"))   # 输出：False（不足11位）print(is_phone("1380013800"))   # 输出：False（不足11位）# 案例2：提取文本中的所有邮箱（基础版）text = "我的邮箱是user1@163.com，备用邮箱是user2@gmail.com，还有user3@qq.com"# 正则模式：匹配“用户名@域名.后缀”email_pattern = re.compile(r"\w+@\w+\.\w+")emails = email_pattern.findall(text)print(emails)  # 输出：['user1@163.com', 'user2@gmail.com', 'user3@qq.com']# 案例3：替换文本中的特殊符号（过滤表情、特殊字符，保留中文、数字、字母）text = "Hello！Python😀，我是小白～123！@#$"# 正则模式：匹配非中文、非数字、非字母的字符pattern = re.compile(r"[^\u4e00-\u9fa5a-zA-Z0-9]")clean_text = pattern.sub("", text)  # 替换为空字符串（删除特殊符号）print(clean_text)  # 输出：HelloPython我是小白123

三、正则+集合：小白进阶，高效处理文本（实战重点）

正则负责“精准提取”，集合负责“高效去重、快速判断”，两者结合，能解决很多正则单独处理不了的问题（比如提取后去重、判断提取结果是否有重复），尤其是数据量较大时，集合的O(1)查找效率会大幅提升。

1. 实战1：提取内容后去重（正则提取+集合去重）

场景：从日志中提取所有访问IP，统计独立IP的数量（去重）——正则提取IP，集合自动去重，比列表去重高效10倍。

import re# 模拟日志内容（包含重复IP）log_text = """192.168.1.1 - - [01/Jan/2024:10:00:00 +0800] "GET / HTTP/1.1" 200 1234192.168.1.2 - - [01/Jan/2024:10:01:00 +0800] "GET /index.html HTTP/1.1" 200 5678192.168.1.1 - - [01/Jan/2024:10:02:00 +0800] "POST /login HTTP/1.1" 302 0192.168.1.3 - - [01/Jan/2024:10:03:00 +0800] "GET /about HTTP/1.1" 200 9012192.168.1.2 - - [01/Jan/2024:10:04:00 +0800] "GET /contact HTTP/1.1" 200 3456"""# 步骤1：用正则提取所有IP地址（IP正则：\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}）ip_pattern = re.compile(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")ip_list = ip_pattern.findall(log_text)print("提取的所有IP：", ip_list)  # 输出：['192.168.1.1', '192.168.1.2', '192.168.1.1', '192.168.1.3', '192.168.1.2']# 步骤2：用集合去重，统计独立IPunique_ips = set(ip_list)print("独立IP数量：", len(unique_ips))  # 输出：3print("独立IP列表：", unique_ips)  # 输出：{'192.168.1.1', '192.168.1.2', '192.168.1.3'}

2. 实战2：判断提取结果是否有重复（正则+集合判重）

场景：提取用户输入的多个邮箱，判断是否有重复邮箱——正则校验邮箱格式，集合判断是否重复。

import redef check_duplicate_emails(emails_text):    # 步骤1：正则提取所有邮箱    email_pattern = re.compile(r"\w+@\w+\.\w+")    emails = email_pattern.findall(emails_text)    # 步骤2：集合判重（对比列表和集合的长度）    if len(emails) != len(set(emails)):        # 找出重复的邮箱（用列表推导式+集合）        duplicate_emails = [email for email in emails if emails.count(email) > 1]        # 去重重复邮箱列表，只保留一个        duplicate_unique = list(set(duplicate_emails))        return False, f"存在重复邮箱：{duplicate_unique}"    return True, "无重复邮箱"# 测试案例text1 = "user1@163.com, user2@gmail.com, user1@163.com"text2 = "user1@163.com, user2@gmail.com, user3@qq.com"print(check_duplicate_emails(text1))  # 输出：(False, "存在重复邮箱：['user1@163.com']")print(check_duplicate_emails(text2))  # 输出：(True, '无重复邮箱')

3. 实战3：正则过滤+集合筛选（精准筛选目标内容）

场景：从一堆文本中提取所有数字，筛选出“大于100的数字”——正则提取数字，集合筛选目标值，避免重复筛选。

import retext = "商品价格：99元、120元、150元、99元、200元、80元、120元"# 步骤1：正则提取所有数字（\d+ 提取1个及以上数字）num_pattern = re.compile(r"\d+")num_list = num_pattern.findall(text)# 转换为整数（提取的是字符串，需转成数字才能比较）num_list = [int(num) for num in num_list]print("提取的所有数字：", num_list)  # 输出：[99, 120, 150, 99, 200, 80, 120]# 步骤2：用集合去重，再筛选出大于100的数字num_set = set(num_list)target_nums = {num for num in num_set if num > 100}print("大于100的数字（去重后）：", target_nums)  # 输出：{120, 150, 200}

四、小白进阶：正则的高阶用法（拉开差距的关键）

掌握了基础用法和集合联动，接下来这些高阶技巧，能让你处理更复杂的文本场景（比如嵌套匹配、精准断言、命名分组），面试时也能加分。每个技巧都配了实战案例，小白也能看懂。

1. 贪婪匹配与非贪婪匹配（实战高频，避坑重点）

默认情况下，正则的量词（*、+、?、{n,m}）是贪婪的——会尽可能多地匹配字符；在量词后面加 ?，就变成非贪婪匹配——尽可能少地匹配字符，这在提取嵌套内容（比如HTML标签）时非常有用。

import re# 场景：提取HTML标签中的内容（嵌套标签）html_text = "<div>Python小白</div><div>正则表达式</div>"# 1. 贪婪匹配（默认）：.* 会匹配从第一个<div>到最后一个</div>的所有内容greedy_pattern = re.compile(r"<div>.*</div>")greedy_result = greedy_pattern.findall(html_text)print("贪婪匹配结果：", greedy_result)  # 输出：['<div>Python小白</div><div>正则表达式</div>']# 2. 非贪婪匹配：.*? 会匹配到第一个</div>就停止，精准提取每个标签内容lazy_pattern = re.compile(r"<div>.*?</div>")lazy_result = lazy_pattern.findall(html_text)print("非贪婪匹配结果：", lazy_result)  # 输出：['<div>Python小白</div>', '<div>正则表达式</div>']# 实战：提取引号中的内容（非贪婪匹配）text = '姓名："张三"，年龄："25"，城市："深圳"'pattern = re.compile(r'"(.*?)"')  # 非贪婪匹配，提取引号内的内容result = pattern.findall(text)print(result)  # 输出：['张三', '25', '深圳']

2. 分组匹配与命名分组（精准提取结构化内容）

用 () 给正则规则分组，能精准提取结构化内容（比如日期中的年、月、日，邮箱中的用户名和域名）；命名分组则给分组起一个名字，更易读、更易维护。

import re# 场景1：分组匹配（提取日期中的年、月、日）date_text = "今天是2024年04月02日，昨天是2024年04月01日"# 分组正则：(\d{4})年(\d{2})月(\d{2})日（3个分组，分别对应年、月、日）date_pattern = re.compile(r"(\d{4})年(\d{2})月(\d{2})日")# findall 返回的是元组列表，每个元组对应一个匹配的分组date_result = date_pattern.findall(date_text)print("分组匹配结果：", date_result)  # 输出：[('2024', '04', '02'), ('2024', '04', '01')]# 遍历提取年、月、日for year, month, day in date_result:    print(f"年：{year}，月：{month}，日：{day}")# 场景2：命名分组（给分组起名字，更易读）# 命名分组格式：(?P<组名>正则规则)date_pattern_named = re.compile(r"(?P<year>\d{4})年(?P<month>\d{2})月(?P<day>\d{2})日")# 用search匹配单个结果，groupdict() 获取所有命名分组match = date_pattern_named.search(date_text)if match:    print("命名分组结果：", match.groupdict())  # 输出：{'year': '2024', 'month': '04', 'day': '02'}    print("年份：", match.group("year"))  # 输出：2024    print("月份：", match.group("month"))  # 输出：04

3. 零宽断言（精准匹配“前后有特定内容”的字符）

零宽断言不会匹配具体字符，只会判断“某个位置的前后是否满足特定规则”，相当于给匹配内容加“条件限制”，比如“提取前面是‘姓名：’的内容”“提取后面不是‘元’的数字”。

常用断言：(?=...) 正向肯定断言（后面满足规则）、(?!...) 正向否定断言（后面不满足规则）、(?<=...) 反向肯定断言（前面满足规则）。

import re# 场景1：正向肯定断言（?=...）：提取后面是“分”的数字（成绩）text1 = "张三：90分，李四：80分，王五：100分，赵六：优秀"# 正则：\d+ 匹配数字，(?=分) 要求数字后面必须是“分”pattern1 = re.compile(r"\d+(?=分)")result1 = pattern1.findall(text1)print("提取成绩：", result1)  # 输出：['90', '80', '100']# 场景2：正向否定断言（?!...）：提取后面不是“分”的数字（排除成绩）pattern2 = re.compile(r"\d+(?!分)")result2 = pattern2.findall(text1)print("排除成绩后的数字：", result2)  # 输出：[]（没有符合条件的数字）# 场景3：反向肯定断言（?<=...）：提取前面是“姓名：”的内容text2 = "姓名：张三，年龄：25，姓名：李四，性别：男"# 正则：(?<=姓名：) 要求前面是“姓名：”，\w+ 匹配姓名pattern3 = re.compile(r"(?<=姓名：)\w+")result3 = pattern3.findall(text2)print("提取姓名：", result3)  # 输出：['张三', '李四']

4. 正则的匹配模式（实战常用，灵活适配场景）

在正则编译或匹配时，可指定匹配模式（如不区分大小写、多行匹配），解决特殊场景的匹配问题，常用模式如下：

import re# 1. re.IGNORECASE（简称re.I）：不区分大小写匹配text1 = "Python python PYTHON"# 不指定模式：只匹配“Python”pattern1 = re.compile(r"python")result1 = pattern1.findall(text1)print(result1)  # 输出：['python']# 指定IGNORECASE模式：匹配所有大小写的pythonpattern1_i = re.compile(r"python", re.I)result1_i = pattern1_i.findall(text1)print(result1_i)  # 输出：['Python', 'python', 'PYTHON']# 2. re.MULTILINE（简称re.M）：多行匹配（^匹配每行开头，$匹配每行结尾）text2 = """hello worldhello pythonhello regex"""# 不指定模式：^只匹配整个字符串开头的hellopattern2 = re.compile(r"^hello")result2 = pattern2.findall(text2)print(result2)  # 输出：['hello']# 指定MULTILINE模式：^匹配每行开头的hellopattern2_m = re.compile(r"^hello", re.M)result2_m = pattern2_m.findall(text2)print(result2_m)  # 输出：['hello', 'hello', 'hello']# 3. re.DOTALL（简称re.S）：让.匹配包括换行符在内的所有字符text3 = "hello\nworld"# 不指定模式：.不匹配换行符，无法匹配整个字符串pattern3 = re.compile(r"hello.world")result3 = pattern3.findall(text3)print(result3)  # 输出：[]# 指定DOTALL模式：.匹配换行符，可匹配整个字符串pattern3_s = re.compile(r"hello.world", re.S)result3_s = pattern3_s.findall(text3)print(result3_s)  # 输出：['hello\nworld']

五、实战升级：正则+集合的算法应用（面试高频）

很多算法题（尤其是文本处理类），用正则+集合能大幅简化代码，提升效率。下面4道经典算法题，小白也能轻松写出，掌握后面试时遇到类似题目直接套用！

算法题1：提取并统计文本中不重复的单词（基础题）

题目：给定一段英文文本，提取所有单词，统计不重复单词的数量，忽略大小写（比如“Python”和“python”算同一个单词）。

思路：用正则提取所有单词，转换为小写后用集合去重，统计集合长度。

import redef count_unique_words(text):    # 步骤1：正则提取所有单词（\w+ 匹配单词，re.I 不区分大小写）    word_pattern = re.compile(r"\w+", re.I)    words = word_pattern.findall(text.lower())  # 转换为小写，统一大小写    # 步骤2：集合去重，统计数量    unique_words = set(words)    return len(unique_words), unique_words# 测试案例text = "Hello Python! Python is a great language. Hello world!"count, words = count_unique_words(text)print(f"不重复单词数量：{count}")  # 输出：6print(f"不重复单词：{words}")      # 输出：{'hello', 'python', 'is', 'a', 'great', 'language', 'world'}

算法题2：验证有效的邮箱地址（LeetCode 929 改编）

题目：给定一个字符串列表，判断每个字符串是否是有效的邮箱地址，返回所有有效的邮箱地址，且不重复。

思路：用正则匹配有效邮箱，用集合去重，最后返回列表。

import redef valid_emails(emails):    # 邮箱正则（基础版，覆盖大部分场景）    email_pattern = re.compile(r"^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+\.[a-zA-Z]{2,}$")    # 步骤1：筛选有效邮箱    valid_list = [email for email in emails if email_pattern.match(email)]    # 步骤2：集合去重    valid_unique = list(set(valid_list))    return valid_unique# 测试案例emails = ["user@163.com", "user@gmail.com", "user@163.com", "invalid-email", "user@.com"]print(valid_emails(emails))  # 输出：['user@163.com', 'user@gmail.com']

算法题3：提取日志中的独立IP并排序（实战高频）

题目：给定一段日志文本，提取所有访问IP，去重后按字典序排序，返回排序后的IP列表。

思路：正则提取IP，集合去重，转换为列表后排序。

import redef extract_and_sort_ips(log_text):    # 步骤1：正则提取IP地址    ip_pattern = re.compile(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}")    ip_list = ip_pattern.findall(log_text)    # 步骤2：集合去重    unique_ips = set(ip_list)    # 步骤3：排序（字典序）    sorted_ips = sorted(unique_ips)    return sorted_ips# 测试案例（复用之前的日志文本）log_text = """192.168.1.1 - - [01/Jan/2024:10:00:00 +0800] "GET / HTTP/1.1" 200 1234192.168.1.2 - - [01/Jan/2024:10:01:00 +0800] "GET /index.html HTTP/1.1" 200 5678192.168.1.1 - - [01/Jan/2024:10:02:00 +0800] "POST /login HTTP/1.1" 302 0192.168.1.3 - - [01/Jan/2024:10:03:00 +0800] "GET /about HTTP/1.1" 200 9012"""print(extract_and_sort_ips(log_text))  # 输出：['192.168.1.1', '192.168.1.2', '192.168.1.3']

算法题4：删除字符串中的重复字符（正则+集合）

题目：给定一个字符串，删除其中的重复字符，保持字符的原始顺序，忽略大小写（比如“a”和“A”算重复）。

思路：用正则提取所有字符，转换为小写后用集合记录已出现的字符，遍历字符保留不重复的，最后拼接成字符串。

import redef remove_duplicate_chars(text):    # 步骤1：正则提取所有字符（保留字母、数字、中文，过滤特殊符号）    char_pattern = re.compile(r"[a-zA-Z0-9\u4e00-\u9fa5]")    chars = char_pattern.findall(text)    # 步骤2：集合记录已出现的字符（小写），保持原始顺序    seen = set()    result = []    for char in chars:        lower_char = char.lower()        if lower_char not in seen:            seen.add(lower_char)            result.append(char)    # 步骤3：拼接成字符串    return "".join(result)# 测试案例text = "Hello Python！Python小白，Hh123"print(remove_duplicate_chars(text))  # 输出：Hello Pythn小白123

六、小白避坑指南（必看！）

很多小白学正则，会踩一些基础坑，这里整理了5个最常见的坑，帮你避开，少走弯路：

1. 坑1：忘记用原始字符串 r"" → 反斜杠 \ 会被转义（比如 \d 变成 \\d，导致匹配失败），建议所有正则模式都用 r""；

2. 坑2：混淆 re.match() 和 re.search() → match() 只匹配开头，search() 搜索整个字符串，日常用 search() 更频繁；

3. 坑3：过度依赖贪婪匹配 → 提取嵌套内容（如HTML标签、引号内容）时，贪婪匹配会“吃掉”过多内容，记得用非贪婪匹配 .*?；

4. 坑4：忽略匹配模式 → 不区分大小写、多行匹配等场景，忘记指定 re.I、re.M 等模式，导致匹配失败；

5. 坑5：提取结果未去重 → 正则提取的结果可能有重复，结合集合去重更高效，尤其是数据量较大时。

七、总结：一篇吃透正则表达式的核心要点

小白们，看到这里，正则表达式的知识点基本就全掌握了。最后用一句话总结正则的核心用法：

正则是“文本处理神器”，集合是“高效辅助工具”，基础语法记熟 \d、\w、量词、分组，核心函数掌握 findall、sub、compile，高阶用法学会贪婪/非贪婪匹配、断言、命名分组，再结合集合解决去重、判重问题，就能应对90%的文本处理和面试场景。

记住：正则不用死记硬背，重点是“多实操、多总结”——把文中的案例都敲一遍，遇到不懂的地方，打印出匹配过程，慢慢就能理解其中的逻辑。刚开始可能会觉得难，但练多了就会发现，正则其实很简单！

建议大家把文中的代码都敲一遍，实操一遍比看十遍都有用。如果遇到不懂的地方，评论区留言，我来帮你解答～

最后，收藏这篇文章，以后遇到正则相关的问题，直接翻出来查，小白也能轻松搞定！

关注我，下期带小白们解锁更多Python干货，从入门到精通，一步不踩坑！🚀