python中的正则表达式

正则表达式中的元字符

在正则表达式中，元字符是具有特殊含义的字符，用于匹配模式中的特定字符或字符集。以下是一些常见的元字符：

1. .：匹配除换行符外的任何字符。
2. ^：匹配输入的开始位置。
3. $：匹配输入的结束位置。
4. *：匹配前一个元素零次或多次。
5. +：匹配前一个元素一次或多次。
6. ?：匹配前一个元素零次或一次。
7. \：用于转义下一个字符，或表示特定的字符类（如\d表示任意数字）。
8. []：匹配方括号内的任何字符。
9. ()：用于分组，控制操作符的范围。
10. |：指示或的关系，匹配两个模式之一。
11. {}：指定前一个元素的数量，如 {3} 表示匹配前一个元素恰好3次。
12. \d：匹配一个数字字符。
13. \w：匹配一个字母、数字或下划线字符。
14. \s：匹配任意空白字符（包括空格、制表符、换行符等）。
15. \b：匹配单词边界，通常用于搜索整个单词而不是单词的一部分。
16. .*:通用的字符串
    这只是一些常见的正则表达式元字符，还有许多其他元字符和特殊序列，用于执行更复杂的模式匹配。熟悉这些元字符及其用法可以帮助您更有效地使用正则表达式进行文本处理和模式匹配。
    

实例

1.匹配多次

2.匹配长度为2的单词：

3.匹配单词

4.匹配数字

5.匹配浮点数

6.匹配ip地址

7.匹配内容

有?是非贪婪模式（即找到第一个haha就停下）

8.匹配网站中的数据

匹配特定位数的数据

正则表达式验证网站

https://regex101.com/
相关教程

re库的主要函数

re库是Python标准库中的一个模块，用于进行正则表达式操作。正则表达式是一种强大的文本匹配和处理工具，通过定义一个模式（pattern）来描述文本中的字符串规则，然后可以使用正则表达式相关的函数在文本中进行匹配、替换、提取等操作。

re库主要提供了以下几种常用的函数：

1. match()：从字符串的开头开始匹配模式，如果匹配成功，则返回一个匹配对象（Match object），否则返回None。

2. search()：在整个字符串中搜索模式，如果匹配成功，则返回一个匹配对象，否则返回None。

3. findall()：在整个字符串中搜索模式，找到所有匹配的结果，并以列表的形式返回。

4. finditer()：在整个字符串中搜索模式，返回一个迭代器，用于遍历所有匹配的结果。

5. sub()：对字符串中匹配到的部分进行替换。

6. split()：根据模式对字符串进行分割，分割后的结果以列表形式返回。

re库还提供了一些用于创建和操作正则表达式的函数和模块级的修饰符，例如：

1. compile()：用于将一个字符串编译为正则表达式模式对象，以便可以复用该模式进行匹配。

2. group()：返回匹配对象中的匹配结果。

3. search()：在模式的开始位置匹配。

4. findall()：返回模式的列表。

5. finditer()：返回模式的迭代器。

例如，下面是re库的一些用法示例：

import re

# 使用match函数进行匹配
pattern = r'hello'
string = 'hello world'
match_obj = re.match(pattern, string)
print(match_obj)  # 输出: <re.Match object; span=(0, 5), match='hello'>

# 使用search函数进行匹配
search_obj = re.search(pattern, string)
print(search_obj)  # 输出: <re.Match object; span=(0, 5), match='hello'>

# 使用findall函数匹配多个结果
results = re.findall(pattern, string)
print(results)  # 输出: ['hello']

# 使用sub函数替换匹配到的部分
new_string = re.sub(pattern, 'hi', string)
print(new_string)  # 输出: hi world

# 使用split函数进行分割
split_results = re.split(r'\s', string)
print(split_results)  # 输出: ['hello', 'world']

需要注意的是，在使用re库进行正则表达式匹配时，需要先编译模式之后再进行匹配，或者直接使用re库的函数进行匹配，函数会自动编译模式。此外，还可以使用re库的修饰符来增加正则表达式的功能，例如忽略大小写、多行匹配等。

re.search

re.search()是re库中的一个函数，用于在给定的字符串中搜索匹配指定正则表达式的子串。

函数签名：

re.search(pattern, string, flags=0)

参数说明：

• pattern：要匹配的正则表达式模式。
• string：要在其内查找匹配项的字符串。
• flags（可选）：用于修改匹配行为的标志。常用的标志包括re.IGNORECASE（忽略大小写）、re.MULTILINE（多行匹配）等。

返回值：

• 如果找到匹配的子串，则返回一个匹配对象（Match object），否则返回None。

使用示例：

import re

pattern = r'apple'
string = 'I have an apple and a banana'

match_obj = re.search(pattern, string)
if match_obj:
    print('找到匹配的子串：', match_obj.group())
else:
    print('未找到匹配的子串')

输出结果：

找到匹配的子串： apple

在上述示例中，re.search()函数会在string字符串中搜索匹配正则表达式pattern的子串。由于string中含有子串’apple’，因此re.search()函数返回一个匹配对象，可以通过调用.group()方法来获取匹配到的子串。

re.match

re.match()是re库中的一个函数，用于尝试从字符串的开头匹配正则表达式。

函数签名：

re.match(pattern, string, flags=0)

参数说明：

• pattern：要匹配的正则表达式模式。
• string：要在其内查找匹配项的字符串。
• flags（可选）：用于修改匹配行为的标志。常用的标志包括re.IGNORECASE（忽略大小写）、re.MULTILINE（多行匹配）等。

返回值：

• 如果从字符串开头找到匹配的子串，则返回一个匹配对象（Match object），否则返回None。

使用示例：

import re

pattern = r'apple'
string = 'I have an apple and a banana'

match_obj = re.match(pattern, string)
if match_obj:
    print('从字符串开头找到匹配的子串：', match_obj.group())
else:
    print('未从字符串开头找到匹配的子串')

输出结果：

未从字符串开头找到匹配的子串

在上述示例中，re.match()函数会尝试从字符串的开头开始匹配正则表达式pattern。由于string的开头并不是子串’apple’，所以re.match()函数返回None，表示未找到匹配的子串。

当我们需要检查一个字符串是否以特定的模式开头时，可以使用re.match()函数。

例如，如果我们要检查一个字符串是否以日期开头，日期的格式为"年-月-日"，可以使用re.match()函数进行匹配。

import re

pattern = r"\d{4}-\d{2}-\d{2}"
string = "2022-07-01 is the start date."

match_obj = re.match(pattern, string)

if match_obj:
    print("The string starts with a valid date.")
else:
    print("The string does not start with a valid date.")

在上述例子中，如果字符串以"年-月-日"的格式开头，比如"2022-07-01 is the start date.“，那么re.match()函数会返回一个匹配对象，表示匹配成功；否则，会返回None，表示匹配失败。在这个例子中，输出结果会是"The string starts with a valid date.”。

re.findall

re.findall()函数可以用于在字符串中查找所有匹配特定模式的子串，并返回一个列表。

例如，我们想要提取字符串中所有的英文单词，可以使用re.findall()函数。

import re

pattern = r"\b\w+\b"
string = "Hello, how are you today?"

matches = re.findall(pattern, string)

print(matches)

运行以上代码，输出结果为：

['Hello', 'how', 'are', 'you', 'today']

在这个例子中，我们使用正则表达式模式\b\w+\b来匹配单词。\b表示单词的边界，\w+表示匹配一个或多个字母、数字或下划线字符。re.findall()函数会查找字符串中满足该模式的所有子串，并返回包含这些子串的列表。所以，输出结果是字符串中所有的单词组成的列表。

re.split

re.split()函数可以接受两个参数：正则表达式模式和需要进行拆分的字符串。

语法：

re.split(pattern, string, maxsplit=0, flags=0)

参数说明：

• pattern：正则表达式模式，用于指定拆分的模式。
• string：需要进行拆分的字符串。
• maxsplit：可选参数，用于指定拆分的最大次数。如果省略或为0，则执行拆分的次数没有限制。
• flags：可选参数，用于控制正则表达式的匹配模式。具体的匹配模式可以参考re模块文档。

需要注意的是，re.split()函数会将符合模式的部分进行拆分，并将拆分后的子串返回列表中。如果模式中包含括号，则括号中的内容也会作为拆分后的子串出现在列表中。

下面是一个例子，展示了re.split()函数的用法：

import re

pattern = r"\d+"   # 匹配一个或多个数字
string = "Hello123World456"

parts = re.split(pattern, string)

print(parts)

运行以上代码，输出结果为：

['Hello', 'World', '']

在这个例子中，我们使用正则表达式模式\d+来指定拆分的模式。\d表示匹配一个数字，+表示匹配一个或多个。re.split()函数会根据该模式将字符串拆分成多个子串，并返回一个列表。所以，输出结果是一个包含"Hello"、"World"和一个空字符串的列表。

re.finditer

re.finditer()函数用于在字符串中搜索匹配正则表达式模式的所有位置。它返回一个迭代器，迭代器的每个元素是一个匹配对象。每个匹配对象包含匹配的内容以及匹配的位置。

语法：

re.finditer(pattern, string, flags=0)

参数说明：

• pattern：正则表达式模式，用于指定搜索的模式。
• string：需要搜索的字符串。
• flags：可选参数，用于控制正则表达式的匹配模式。具体的匹配模式可以参考re模块文档。

需要注意的是，finditer()函数返回的是一个迭代器，我们可以使用迭代器来遍历匹配对象。每个匹配对象都可以使用group()方法来获取匹配的内容，start()方法来获取匹配的起始位置，end()方法来获取匹配的结束位置。

下面是一个例子，展示了finditer()函数的用法：

import re

pattern = r"\d+"   # 匹配一个或多个数字
string = "Hello123World456"

matches = re.finditer(pattern, string)

for match in matches:
    print("匹配内容：", match.group())
    print("匹配起始位置：", match.start())
    print("匹配结束位置：", match.end())
    print()

运行以上代码，输出结果为：

匹配内容： 123
匹配起始位置： 5
匹配结束位置： 8

匹配内容： 456
匹配起始位置： 13
匹配结束位置： 16

在这个例子中，我们使用正则表达式模式\d+指定了需要搜索的模式。\d表示匹配一个数字，+表示匹配一个或多个数字。finditer()函数会根据该模式在字符串中搜索匹配的内容，并返回一个迭代器。我们使用for循环遍历迭代器中的匹配对象，然后打印匹配的内容、起始位置和结束位置。

re.sub

re.sub()函数用于在字符串中搜索匹配正则表达式模式的内容，并将匹配到的内容替换为指定的字符串。它返回替换后得到的新字符串。

语法：

re.sub(pattern, repl, string, count=0, flags=0)

参数说明：

• pattern：正则表达式模式，用于指定搜索的模式。
• repl：替换的字符串。
• string：需要搜索和替换的字符串。
• count：可选参数，用于指定替换的最大次数。默认情况下，会替换所有匹配到的内容。
• flags：可选参数，用于控制正则表达式的匹配模式。具体的匹配模式可以参考re模块文档。

下面是一个例子，展示了sub()函数的用法：

import re

pattern = r"apple"
string = "I have an apple, but I want a banana."

new_string = re.sub(pattern, "banana", string)

print(new_string)

运行以上代码，输出结果为：

I have an banana, but I want a banana.

在这个例子中，我们使用正则表达式模式apple指定了需要搜索的模式。sub()函数会根据该模式在字符串中搜索匹配的内容，并将其替换为指定的字符串banana。最终得到的新字符串new_string为原字符串中所有匹配到的apple替换为banana后得到的结果。

面向对象用法函数

re.compile

re.compile函数是Python标准库中re模块提供的一个函数。re.compile函数用于将一个正则表达式字符串编译为一个正则表达式对象。

语法：
re.compile(pattern, flags=0)

参数说明：

• pattern：要编译的正则表达式字符串。
• flags：可选参数，用于控制正则表达式的匹配模式。常用的标志有 re.IGNORECASE（忽略大小写）、re.MULTILINE（多行匹配）等。可以使用多个标志，使用逻辑或 “|” 进行连接。

返回值：
返回一个正则表达式对象，该对象可以被用于执行匹配操作。

下面是一个使用re.compile函数的示例代码：

import re

# 编译一个匹配邮箱地址的正则表达式
pattern = re.compile(r'^\w+@\w+\.[a-zA-Z]+')

# 执行匹配操作
result = pattern.match('test@example.com')

if result:
    print('匹配成功')
else:
    print('匹配失败')

这个例子中，我们使用re.compile函数编译了一个正则表达式，该正则表达式用于匹配邮箱地址。然后我们使用匹配结果result来判断是否匹配成功。如果成功，则输出"匹配成功"，否则输出"匹配失败"。

re库的match对象

match对象在匹配成功时会返回，它具有以下属性：

• group(): 返回整个匹配的字符串。
• start(): 返回匹配的起始位置。
• end(): 返回匹配的结束位置。
• span(): 返回一个元组，包含匹配的起始和结束位置。

这些属性允许您在匹配结果中获取更多信息。下面是一个示例：

import re

pattern = re.compile(r'\d+')

result = pattern.match('Hello 123')

if result:
    print('匹配成功')
    print('匹配的字符串:', result.group())
    print('匹配起始位置:', result.start())
    print('匹配结束位置:', result.end())
    print('匹配起始和结束位置:', result.span())
else:
    print('匹配失败')

在这个例子中，我们使用re.compile函数编译了一个正则表达式，用于匹配字符串中的数字。然后，我们对字符串’Hello 123’进行匹配，并通过match对象的属性来获取匹配结果的详细信息。

贪婪匹配

"贪婪匹配"是正则表达式(match object)中的一个概念。在正则表达式中，默认情况下，匹配器会尽可能多地匹配字符，这就是所谓的贪婪匹配。

例如，考虑以下正则表达式：.*，它表示匹配任意数量的字符（除换行符外）。如果将其应用于字符串 “Hello, world!”，它会匹配整个字符串，因为匹配器会尽可能多地匹配字符。

贪婪匹配的行为可以通过使用"?"修饰符进行改变。例如，.*?表示非贪婪匹配，匹配尽可能少的字符。使用非贪婪匹配的话，.*?在上述示例中只会匹配 “H”，而不是整个字符串。

请注意，贪婪匹配还可以应用于其他正则表达式中的运算符，例如"+“或”?"。这些运算符的贪婪版本会匹配尽可能多的字符，而非贪婪版本会匹配尽可能少的字符。

以下是一个使用贪婪匹配和非贪婪匹配的示例代码：

import re

# 贪婪匹配示例
pattern = "a.*b"  # 匹配以"a"开始，以"b"结束的字符串
string = "a test string with b"
match = re.search(pattern, string)
print(match.group())  # 输出："a test string with b"

# 非贪婪匹配示例
pattern = "a.*?b"  # 匹配以"a"开始，以"b"结束的字符串，并尽可能少地匹配字符
string = "a test string with b"
match = re.search(pattern, string)
print(match.group())  # 输出："a b"

请注意，在这个例子中，使用贪婪匹配的正则表达式 a.*b 匹配了整个字符串，而使用非贪婪匹配的正则表达式 a.*?b 只匹配了最短的匹配项 “a b”。

正则表达式总流程

在Python中，可以使用内置的re模块来处理正则表达式。以下是一些Python中使用正则表达式的基本操作：

1. 导入re模块：首先需要导入re模块，以便可以使用其中的函数和方法。例如：import re

2. 创建模式对象：使用re模块中的compile()函数可以创建一个模式对象，用于存储正则表达式模式。例如：pattern = re.compile(r'abc')

3. 匹配模式：使用模式对象的match()、search()或findall()等方法来进行模式匹配。

   • match()：从字符串的开头开始匹配模式，并返回一个匹配对象。例如：result = pattern.match(string)

   • search()：在字符串中搜索整个字符串，返回第一个匹配的对象。例如：result = pattern.search(string)

   • findall()：在字符串中搜索所有匹配的内容，并返回一个列表。例如：result = pattern.findall(string)

4. 使用匹配对象：在匹配成功后，可以使用匹配对象的方法和属性来获取匹配的相关信息。

   • group()：返回匹配的字符串。例如：result.group()

   • start()：返回匹配的起始位置。例如：result.start()

   • end()：返回匹配的结束位置。例如：result.end()

   • span()：返回匹配字符串的起始和结束位置。例如：result.span()

5. 其他操作：除了基本的匹配功能外，re模块还提供了一些其他功能，如替换、分割、查找等。

   • sub()：用于替换字符串中的匹配项。例如：result = re.sub(pattern, replacement, string)

   • split()：用于根据匹配项分割字符串，并返回一个列表。例如：result = re.split(pattern, string)

   • finditer()：返回一个迭代器，可以迭代获取所有匹配对象。例如：result = re.finditer(pattern, string)

Python中的正则表达式具有强大的功能，可以用于各种字符串处理和模式匹配的任务。详细了解re模块的使用和特性可以帮助您更好地利用正则表达式进行文本处理。

例子

当涉及到正则表达式时，可以有很多不同的用例。这里举几个简单的例子来说明正则表达式的使用：

1. 匹配邮箱地址：

import re

pattern = re.compile(r'\w+@\w+\.\w+')
string = 'My email address is test@example.com'

result = pattern.search(string)
if result:
    print(result.group())

输出：test@example.com

2. 提取手机号码：

import re

pattern = re.compile(r'\d{3}-\d{4}-\d{4}')
string = 'My phone number is 123-4567-8901'

result = pattern.search(string)
if result:
    print(result.group())

输出：123-4567-8901

3. 替换文本中的敏感词：

import re

pattern = re.compile(r'(badword|curse)')
string = 'I hate badword and curse words'

replacement = '****'
result = pattern.sub(replacement, string)

print(result)

输出：I hate **** and **** words

这只是一些简单的例子，实际上正则表达式可以更复杂和灵活，可以处理各种不同类型的文本匹配和处理任务。根据具体的需求，可以编写更复杂的正则表达式来实现更精确的匹配。