import re

# ? 表示前面的字符出现0次或1次
# 0次的情况
result1 = re.search("goog?le", "goole")
print(result1)  # <re.Match object; span=(0, 5), match='goole'>
# 1次的情况
result2 = re.search("goog?le", "google")
print(result2)  # <re.Match object; span=(0, 6), match='google'>
# g出现多次的情况（不符合?的规则）
result3 = re.search("goog?le", "googggggle")
print(result3)  # None

# + 表示前面的字符出现1次或多次
# 0次不符合+规则
result4 = re.search("goog+le", "goole")
print(result4)  # None
# 1次的情况
result5 = re.search("goog+le", "google")
print(result5)  # <re.Match object; span=(0, 6), match='google'>
# 多次的情况
result6 = re.search("goog+le", "googgggggggggggle")
print(result6)  # <re.Match object; span=(0, 17), match='googgggggggggggle'>

# *表示前面的字符出现0次或多次
# 0次的情况
result7 = re.search("goog*le", "goole")
print(result7)  # <re.Match object; span=(0, 5), match='goole'>
# 多次的情况
result8 = re.search("goog*le", "googgggggggggggle")
print(result8)  # <re.Match object; span=(0, 17), match='googgggggggggggle'>

# {3}表示前面的字符恰好出现3次
# 不足3次
result9 = re.search("goog{3}le", "goole")
print(result9)  # None
# 不足3次
result10 = re.search("goog{3}le", "google")
print(result10)  # None
# 超过3次
result11 = re.search("goog{3}le", "googgggggggggle")
print(result11)  # None
# 恰好3次
result12 = re.search("goog{3}le", "googggle")
print(result12)  # <re.Match object; span=(0, 8), match='googggle'>

# {3,6}表示前面的字符出现3到6次
# 不足3次
result13 = re.search("goog{3,6}le", "goole")
print(result13)  # None
# 不足3次
result14 = re.search("goog{3,6}le", "googgle")
print(result14)  # None
# 在范围内
result15 = re.search("goog{3,6}le", "googgggle")
print(result15)  # <re.Match object; span=(0, 9), match='googgggle'>

# {3,}表示前面的字符至少出现3次
# 不足3次
result16 = re.search("goog{3,}le", "goole")
print(result16)  # None
# 不足3次
result17 = re.search("goog{3,}le", "google")
print(result17)  # None
# 至少3次
result18 = re.search("goog{3,}le", "googggle")
print(result18)  # <re.Match object; span=(0, 8), match='googggle'>
# 至少3次
result19 = re.search("goog{3,}le", "googgggggggggggggggle")
print(result19)  # <re.Match object; span=(0, 21), match='googgggggggggggggggle'>

# {,3}表示前面的字符最多出现3次
# 超过3次
result20 = re.search("goog{,3}le", "googgggle")
print(result20)  # None
# 在范围内
result21 = re.search("goog{,3}le", "googgle")
print(result21)  # <re.Match object; span=(0, 7), match='googgle'>
# 在范围内
result22 = re.search("goog{,3}le", "goole")
print(result22)  # <re.Match object; span=(0, 5), match='goole'>

匹配边界字符

import re

tel = "0755-88988888"
pattern = r'(\d{4})-(\d{8})'  # 在字符串前面加上 r 表示原始字符串
result = re.search(pattern, tel)
if result:
    print(result)  # <re.Match object; span=(0, 13), match='0755-88988888'>
    print(result.group(0))  # 0755-88988888
    print(result.group(1))  # 0755
    print(result.group(2))  # 88988888
    print(result.groups())  # ('0755', '88988888')
else:
    print("未找到匹配的电话号码格式")

贪婪和非贪婪

贪婪匹配与非贪婪匹配概念

在正则表达式中，贪婪匹配和非贪婪匹配主要决定了匹配的字符数量。

• 贪婪匹配：在满足匹配条件的情况下，尽可能多地匹配字符。例如，+ 是贪婪匹配的量词，当使用 d+ 时，它会尝试匹配尽可能多的数字。
• 非贪婪匹配：在满足匹配条件的情况下，尽可能少地匹配字符。通过在贪婪量词（如 +、*）后面添加 ? 来实现非贪婪匹配。例如，d+? 会尽可能少地匹配数字。

函数	说明
compile(pattern, flags=0)	编译正则表达式pattern，并返回一个正则表达式对象。flags用于指定正则表达式的匹配模式，如忽略大小写等。
match(pattern, string, flags=0)	从字符串string的起始位置匹配正则表达式pattern。如果匹配成功，返回一个匹配对象；否则返回None。
search(pattern, string, flags=0)	搜索字符串string中第一次出现正则表达式pattern的模式。如果找到匹配项，返回一个匹配对象；否则返回None。
split(pattern, string, maxsplit=0, flags=0)	使用正则表达式pattern作为分隔符拆分字符串string。maxsplit指定最大分割次数，返回分割后的列表。
sub(pattern, repl, string, count=0, flags=0)	使用字符串repl替换字符串string中与正则表达式pattern匹配的所有模式。count指定替换次数，返回替换后的字符串。
fullmatch(pattern, string, flags=0)	如果字符串string与正则表达式pattern完全匹配（从开头到结尾），则返回匹配对象；否则返回None。
findall(pattern, string, flags=0)	查找字符串string中所有与正则表达式pattern匹配的模式，并返回一个包含所有匹配项的列表。
finditer(pattern, string, flags=0)	查找字符串string中所有与正则表达式pattern匹配的模式，并返回一个迭代器，每个元素都是一个匹配对象。
purge()	清除隐式编译的正则表达式的缓存。

标志	说明
re.I 或 re.IGNORECASE	忽略大小写匹配。
re.M 或 re.MULTILINE	多行匹配，改变^和$的行为，使它们分别匹配每一行的开始和结束，而不是整个字符串的开始和结束。

import re
# 1. re.match()
# 匹配字符串是否以指定的正则内容开头，匹配成功返回对象，匹配失败返回None
# 第一个参数：正则表达式
# 第二个参数：要验证的字符串
# 第三个参数：可选参数，正则表达式修饰符
text1 = "abc123"
match_result1 = re.match(r"abc", text1)
if match_result1:
    print("re.match()匹配成功:", match_result1.group())
else:
    print("re.match()匹配失败")

# 2. re.search()
# 匹配字符串中是否包含指定的正则内容，匹配成功返回对象，匹配失败返回None
# 第一个参数：正则表达式
# 第二个参数：要验证的字符串
# 第三个参数：可选参数，正则表达式修饰符
text2 = "hello abc world"
search_result = re.search(r"abc", text2)
if search_result:
    print("re.search()匹配成功:", search_result.group())
else:
    print("re.search()匹配失败")

# 3. re.findall()
# 获取所有匹配的内容，会得到一个列表
# 第一个参数：正则表达式
# 第二个参数：要验证的字符串
text3 = "a1b2c3a4b5"
findall_result = re.findall(r"\d", text3)
print("re.findall()结果:", findall_result)

# 4. re.compile()编译正则表达式，提高正则匹配的效率
string = "0755-89787654"
com = re.compile(r'(\d{4})-(\d{8})')
print(com.findall(string))

# 5. 拆分
# re.split()
print(re.split(r"\d", "sdf1234mkj5431km"))

# 6. 替换
# re.sub()或者re.subn()
str1 = "难以掩盖内心的心情"
print(re.sub(r"\s+", "..", str1))
print(re.subn(r"\s+", "..", str1))

# 7. 匹配中文
chinese = "[\u4e00-\u9fa5]+"
print(re.search(chinese, "hello!世界 345"))