import re

text = "aabbaabb"
# 贪婪匹配：.* 尽可能匹配最长的字符串（从第一个a到最后一个b）
print(re.match(r"a.*b", text).group())  # → "aabbaabb"

# 非贪婪匹配：.*? 尽可能匹配最短的字符串（从第一个a到第一个b）
print(re.match(r"a.*?b", text).group())  # → "aabb"

import re

# 匹配以"hello"开头的字符串
result = re.match(r"hello", "hello world")
print(result.group())  # → "hello"（匹配成功，返回匹配内容）

# 开头不匹配，返回None
result = re.match(r"world", "hello world")
print(result)  # → None

# 在字符串中查找"world"（不在开头）
result = re.search(r"world", "hello world")
print(result.group())  # → "world"

# 提取字符串中所有数字
text = "age: 18, score: 95, weight: 60"
nums = re.findall(r"\d+", text)  # \d+ 匹配1个或多个数字
print(nums)  # → ['18', '95', '60']

text = "a1 b2 c3"
matches = re.finditer(r"\d", text)  # 查找所有单个数字
for m in matches:
    print(m.group())  # 依次输出：1、2、3

# 将所有数字替换为"*"
text = "a1 b2 c3"
new_text = re.sub(r"\d", "*", text)
print(new_text)  # → "a* b* c*"

# 只替换前2个数字
new_text2 = re.sub(r"\d", "*", text, count=2)
print(new_text2)  # → "a* b* c3"

# 按逗号或空格分割字符串
text = "a,b c,d"
parts = re.split(r"[, ]", text)  # 匹配逗号或空格
print(parts)  # → ['a', 'b', 'c', 'd']

# 编译模式（只做一次）
pattern = re.compile(r"\d+")

# 重复使用编译后的对象
print(pattern.findall("age: 18"))  # → ['18']
print(pattern.findall("score: 95"))  # → ['95']

import re

email = "user@example.com"
# 分组匹配：(用户名)@(域名)
pattern = r"(\w+)@(\w+\.\w+)"
result = re.match(pattern, email)

print(result.group(0))  # 整个匹配 → "user@example.com"
print(result.group(1))  # 第一个分组（用户名）→ "user"
print(result.group(2))  # 第二个分组（域名）→ "example.com"
print(result.groups())  # 所有分组组成的元组 → ("user", "example.com")

import re

# 不忽略大小写：无法匹配大写的Hello
print(re.match(r"hello", "Hello"))  # → None

# 忽略大小写：成功匹配
print(re.match(r"hello", "Hello", flags=re.IGNORECASE).group())  # → "Hello"

def is_valid_phone(phone):
    pattern = r"^1\d{10}$"  # ^1：以1开头；\d{10}：10个数字；$：结尾
    return bool(re.match(pattern, phone))

print(is_valid_phone("13812345678"))  # → True
print(is_valid_phone("1234567890"))   # → False（不足11位）

html = '''
<a href="https://www.baidu.com">百度</a>
<a href="https://www.google.com">谷歌</a>
'''
# 分组提取href的值（""中的内容）
urls = re.findall(r'href="(.*?)"', html)  # .*? 非贪婪匹配，避免匹配到多个链接
print(urls)  # → ['https://www.baidu.com', 'https://www.google.com']

import string

text = "Hello, World! It's a test."
# 匹配所有标点符号（string.punctuation包含所有标点）
clean_text = re.sub(rf"[{string.punctuation}]", "", text)
print(clean_text)  # → "Hello World Its a test"

# 匹配IP地址中的点（需转义）
print(re.match(r"192\.168\.1\.1", "192.168.1.1").group())  # → "192.168.1.1"

import re
s = 'helloworld hellobeijing'
ret = re.findall('hello\S+',s)
print(ret)
['helloworld', 'hellobeijing']

import re
# re.search
ret = re.search('h..','hello hello world')
print(ret) # 输出结果：<_sre.SRE_Match object; span=(0, 3), match='hel'>
ret1 = re.search('h..','hello hello world').group()
print(ret1) # 输出结果：hel 只输出第一个符合条件的结果

# re.match
ret = re.match('asd','asdhskdjfksji')
print(ret) # 输出结果：<_sre.SRE_Match object; span=(0, 3), match='asd'>返回的是一个对象。
ret1 = re.match('asd','asdhskdjfasdksjiasd').group()
print(ret1) # 输出结果：asd 调用.group()方法，只返回匹配的第一个结果。

# re.search
s = 'helloworld hellobeijing'
ret = re.search('hellob\S+',s)
print(ret)
<re.Match object; span=(11, 23), match='hellobeijing'>

# re.match
s = 'helloworld hellobeijing'
ret = re.match('hellob\S+',s)
print(ret)
None

import re
s = 'helloworld hellobeijing'
ret = re.split('hello',s)
print(ret)
['', 'world ', 'beijing']

import re
s = 'helloworld hellobeijing'
ret = re.sub('hello','goodbye',s)
print(ret)
goodbyeworld goodbyebeijing

import re
pattern = re.compile('he.{3}')
pattern.match(s)
<re.Match object; span=(0, 5), match='hello'>

import re

s = 'i love python very much'
pat = 'python' 
r = re.search(pat,s)
print(r.span()) #(7,13)

s = '山东省潍坊市青州第1中学高三1班'
pat = '1'
r = re.finditer(pat,s)
for i in r:
    print(i)

# <re.Match object; span=(9, 10), match='1'>
# <re.Match object; span=(14, 15), match='1'>

s = '一共20行代码运行时间13.59s'
pat = r'\d+' # +表示匹配数字(\d表示数字的通用字符)1次或多次
r = re.findall(pat,s)
print(r)
# ['20', '13', '59']

s = '一共20行代码运行时间13.59s'
pat = r'\d+\.?\d+' # ?表示匹配小数点(\.)0次或1次
r = re.findall(pat,s)
print(r)
# ['20', '13.59']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'^[emrt]' # 查找以
r = re.findall(pat,s)
print(r)
# [],因为字符串的开头是字符`T`，不在emrt匹配范围内，所以返回为空

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'^[emrt]' # 查找以
r = re.compile(pat,re.I).search(s)
print(r)
# <re.Match object; span=(0, 1), match='T'> 表明字符串的开头在匹配列表中

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'\s[a-zA-Z]+'  
r = re.findall(pat,s)
print(r) #[' module', ' provides', ' regular', ' expression', ' matching', ' operations', ' similar', ' to', ' those', ' found', ' in', ' Perl']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'\s([a-zA-Z]+)'  
r = re.findall(pat,s)
print(r) #['module', 'provides', 'regular', 'expression', 'matching', 'operations', 'similar', 'to', 'those', 'found', 'in', 'Perl']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'\s?([a-zA-Z]+)'  
r = re.findall(pat,s)
print(r) #['This', 'module', 'provides', 'regular', 'expression', 'matching', 'operations', 'similar', 'to', 'those', 'found', 'in', 'Perl']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'\s+'  
r = re.split(pat,s)
print(r) # ['This', 'module', 'provides', 'regular', 'expression', 'matching', 'operations', 'similar', 'to', 'those', 'found', 'in', 'Perl']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'\s?([mt][a-zA-Z]*)' # 查找以
r = re.findall(pat,s)
print(r) # ['module', 'matching', 'tions', 'milar', 'to', 'those']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'^([mt][a-zA-Z]*)\s' # 查找以
r = re.compile(pat,re.I).findall(s)
print(r) # ['This']

s = 'This module provides regular expression matching operations similar to those found in Perl'
pat = r'\s+'  
r = re.split(pat,s)
res = [i for i in r if re.match(r'[mMtT]',i)] 
print(res) # ['This', 'module', 'matching', 'to', 'those']

content='<h>ddedadsad</h><div>graph</div>bb<div>math</div>cc'
pat=re.compile(r"<div>(.*)</div>")  #贪婪模式
m=pat.findall(content)
print(m) # ['graph</div>bb<div>math']

content='<h>ddedadsad</h><div>graph</div>bb<div>math</div>cc'
pat=re.compile(r"<div>(.*?)</div>")  #贪婪模式
m=pat.findall(content)
print(m) # ['graph', 'math']

content = 'graph math,,english;chemistry' # 这种
pat=re.compile(r"[\s\,\;]+")  #贪婪模式
m=pat.split(content)
print(m) # ['graph', 'math', 'english', 'chemistry']

content="hello 12345, hello 456321"    
pat=re.compile(r'\d+') #要替换的部分
m=pat.sub("666",content)
print(m) # hello 666, hello 666

import re
from urllib import request

#爬虫爬取百度首页内容
data=request.urlopen("http://www.baidu.com/").read().decode()

#分析网页,确定正则表达式
pat=r'<title>(.*?)</title>'

result=re.search(pat,data)
print(result) <re.Match object; span=(1358, 1382), match='<title>百度一下，你就知道</title>'>

result.group() # 百度一下，你就知道

. 匹配任意字符  
^ 匹配字符串始位置 
$ 匹配字符串中结束的位置 
* 前面的原子重复0次1次多次 
? 前面的原子重复一次或者0次 
+ 前面的原子重复一次或多次
{n} 前面的原子出现了 n 次
{n,} 前面的原子至少出现 n 次
{n,m} 前面的原子出现次数介于 n-m 之间
( ) 分组,需要输出的部分

\s  匹配空白字符 
\w  匹配任意字母/数字/下划线 
\W  和小写 w 相反，匹配任意字母/数字/下划线以外的字符
\d  匹配十进制数字
\D  匹配除了十进制数以外的值 
[0-9]  匹配一个0-9之间的数字
[a-z]  匹配小写英文字母
[A-Z]  匹配大写英文字母