Python 正则表达式RegEx函数

正则表达式是一组具有高度专业化语法的字符，我们可以使用它来查找或匹配其他字符或字符组。 简而言之，正则表达式（或Regex）在UNIX世界中广泛使用。

导入re模块

# Importing re module
import re

在Python中，re模块完全支持Perl风格的正则表达式。每当在实现或使用正则表达式时出现错误时，re模块都会引发re.error异常。

我们将介绍处理正则表达式的关键函数。

但首先，有一个小要点： 许多字母在正则表达式中被称为元字符，具有特定的含义。

大多数符号和字符都能很容易地匹配。（可以启用不区分大小写的功能，使得该正则表达式能够匹配Python或PYTHON）。例如，正则表达式’check’将精确匹配字符串’check’。

这个一般规则也有一些例外，有一些特殊的元字符是不匹配的。相反，它们表示它们必须比较一些不寻常的内容或对RE的其他部分产生影响，通过重复或修改它们的含义。

元字符或特殊字符

顾名思义，有一些具有特殊含义的字符：

字符	意义
.	点号 - 它匹配除换行符之外的任何字符。
^	抑扬符 - 用于匹配字符串的开头。（以……开始）
$	美元符 - 它匹配换行符之前的字符串末尾。（以……结束）
*	星号 - 它匹配零个或多个模式的出现。
+	加号 - 当我们希望匹配至少一个模式时使用。
?	问号 - 它匹配零个或一个模式的出现。
{}	大括号 - 它匹配所指定模式的确切出现次数
[]	方括号 - 它定义一组字符
|	管道符 - 它匹配两个定义的模式之一。

特殊序列：

能够匹配不同符号集合将是正则表达式能够实现的第一个不可通过字符串技术先前实现的功能。另一方面，如果这是它们唯一的额外能力，正则表达式并没有太多的改进。我们还可以定义一些 RE 的部分必须重复指定次数。

我们将首先检查用于重复出现的第一个元字符：。 不会匹配实际字符*，而是指示前面的字母可以匹配0次或多次，而不是只匹配1次。

例如，Ba*t 可以匹配 ‘bt’（零个 ‘a’ 字符）、’bat’（一个 ‘a’ 字符）、’baaat’（三个 ‘a’ 字符）等等。

贪婪重复，例如 *，导致匹配算法尝试尽可能多次地复制 RE。如果序列的后续元素无法匹配，则匹配算法将减少重复次数重试。

特殊序列由 \ 后面跟着下面列出的字符组成。每个字符有不同的含义。

字符	含义
\d	匹配任何数字，相当于[0-9]。
\D	匹配任何非数字字符，相当于[^0-9]。
\s	匹配任何空白字符，相当于[\t\n\r\f\v]。
\S	匹配任何非空白字符，相当于[^\t\n\r\f\v]。
\w	匹配任何字母数字字符，相当于[a-zA-Z0-9]。
\W	匹配任何非字母数字字符，相当于[^a-zA-Z0-9]。
\A	匹配字符串开头处的指定模式。
\b	r”\bxt” – 匹配字符串中单词的开头处的指定模式。 r”xt\b” – 匹配字符串中单词的结尾处的指定模式。
\B	\b的相反操作。
\Z	当模式出现在字符串末尾时返回匹配对象。

正则表达式函数：

• compile - 用于将正则模式转换为正则表达式对象，可用于匹配字符串中的模式。
• search - 用于在给定的字符串中查找正则表达式模式的第一个匹配。
• match - 从字符串开头开始匹配模式。
• fullmatch - 用于将整个字符串与正则表达式模式进行匹配。
• split - 用于根据正则表达式模式拆分字符串。
• findall - 用于在字符串中查找所有不重叠的模式。返回匹配的模式列表。
• finditer - 返回一个生成匹配对象的迭代器。
• sub - 替换模式的第一个匹配，返回替换后的字符串。
• subn - 与’sub’相同，返回一个元组（新字符串，替换次数）。
• escape - 用于在模式中转义特殊字符。
• purge - 用于清除正则表达式表达式缓存。

1. re.compile(pattern, flags=0)

用于创建一个正则表达式对象，可以用于在字符串中匹配模式。

示例：

# Importing re module
import re

# Defining regEx pattern
pattern = "amazing"

# Createing a regEx object
regex_object = re.compile(pattern)

# String
text = "This tutorial is amazing!" 

# Searching for the pattern in the string
match_object = regex_object.search(text)

# Output
print("Match Object:", match_object)

输出:

Match Object: 

这相当于：

re_obj = re.compile(pattern) result = re_obj.search(string)	=	result = re.search(pattern, string)

注意- 当涉及到多次使用正则表达式对象时，re.compile()版本的程序效率更高。

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

• 它从字符串的开头开始匹配模式。
• 如果找到匹配项，则返回一个匹配对象，其中包含开始、结束、跨度等信息。
• 如果找不到匹配项，则返回一个NONE值。

  参数

• pattern: 要匹配的表达式。它必须是一个正则表达式。

• string: 要与模式在字符串开头进行比较的字符串。

• flags: 可以使用位运算符OR（|）来表示多个标志。

  示例：

# Importing re module
import re

# Our pattern
pattern = "hello"

# Returns a match object if found else Null
match = re.match(pattern, "hello world")

print(match) # Printing the match object
print("Span:", match.span()) # Return the tuple (start, end)
print("Start:", match.start()) # Return the starting index
print("End:", match.end()) # Returns the ending index

输出：

Span: (0, 5)
Start: 0
End: 5

另一个在Python中实现re.match()方法的例子。

• 表达式.w“和.w*?将匹配包含字母”w”的单词，而不包含字母”w”的内容将被忽略。
• 在这个Python re.match()的例子中，使用for循环来检查列表中每个元素是否匹配。

代码：

import re  
line = "Learn Python through tutorials on javatpoint"  
match_object = re.match( r'.w* (.w?) (.w*?)', line, re.M|re.I)  

if match_object:  
    print ("match object group : ", match_object.group())  
    print ("match object 1 group : ", match_object.group(1))  
    print ("match object 2 group : ", match_object.group(2))  
else:  
    print ( "There isn't any match!!" ) 

输出:

There isn't any match!!

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

re.search()函数将查找正则表达式的第一个匹配项并返回。它会验证提供的字符串的所有行，而不像Python的re.match()只验证第一行。如果匹配成功，re.search()函数会返回一个匹配对象；否则，返回”null”。

要执行search()函数，我们必须先导入Python的re模块，然后运行程序。将要从主字符串中检查的”sequence”和”content”作为参数传递给Python的re.search()调用。

下面是参数的说明 –

pattern:- 这是要匹配的表达式。它必须是一个正则表达式。

string:- 提供的字符串是要在其中搜索模式的字符串。

flags:- 可以使用按位或（|）来表示多个标志。这些是修改标志，下表列出了它们。

代码

import re

line = "Learn Python through tutorials on javatpoint";

search_object = re.search( r' .*t? (.*t?) (.*t?)', line)
if search_object:
    print("search object group : ", search_object.group())
    print("search object group 1 : ", search_object.group(1))
    print("search object group 2 : ", search_object.group(2))
else:
    print("Nothing found!!")

输出：

search object group :   Python through tutorials on javatpoint
search object group 1 :  on
search object group 2 :  javatpoint

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

• 它用’repl’替换字符串中与模式匹配的部分
• pattern – 简单地说，它是一个用于匹配的正则表达式模式
• repl – repl代表”replacement”，用于替换字符串中的模式
• count – 此参数用于控制替换的次数

示例1：

# Importing re module
import re

# Defining parameters
pattern = "like" # to be replaced
repl = "love" # Replacement
text = "I like Javatpoint!" # String

# Returns a new string with a substituted pattern
new_text = re.sub(pattern, repl, text)

# Output
print("Original text:", text)
print("Substituted text: ", new_text)

输出：

Original text: I like Javatpoint!
Substituted text:  I love Javatpoint!

在上面的示例中，子函数将“like”替换为“love”。

示例2 – 替换3次出现的模式。

# Importing re package
import re

# Defining parameters
pattern = "l" # to be replaced
repl = "L" # Replacement
text = "I like Javatpoint! I also like tutorials!" # String

# Returns a new string with the substituted pattern
new_text = re.sub(pattern, repl, text, 3)

# Output
print("Original text:", text)
print("Substituted text:", new_text)

输出：

Original text: I like Javatpoint! I also like tutorials!
Substituted text: I Like Javatpoint! I aLso Like tutorials!

这里，前三个出现的’l’被替换为”L”。

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

• subn的工作方式与sub函数相同
• 它返回一个元组（new_string，num_of_substitutions）

示例：

# Importing re module
import re

# Defining parameters
pattern = "l" # to be replaced
repl = "L" # Replacement
text = "I like Javatpoint! I also like tutorials!" # String

# Returns a new string with the substituted pattern
new_text = re.subn(pattern, repl, text, 3)

# Output
print("Original text:", text)
print("Substituted text:", new_text)

输出：

Original text: I like Javatpoint! I also like tutorials!
Substituted text: ('I Like Javatpoint! I aLso Like tutorials!', 3)

在以上程序中，subn函数将字符串中的前三个’l’替换为’L’。

6. re.fullmatch(pattern, string, flags=0)

• 它将整个字符串与模式匹配。
• 返回相应的匹配对象。
• 如果找不到匹配项，则返回None。
• 另一方面，search()函数只会搜索与模式匹配的第一个出现位置。

示例：

# Importing re module
import re 

# Sample string
line = "Hello world";  

# Using re.fullmatch()
print(re.fullmatch("Hello", line))
print(re.fullmatch("Hello world", line))

输出：

None

在上面的程序中，只有“Hello world”完全匹配了模式，而“Hello”没有。

Q. 何时使用re.findall()?

Ans 。假设我们有一行文本，并且想要从内容中获取所有出现的内容，那么我们使用Python的re.findall()函数。它会在提供给它的整个内容中搜索。

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

• 返回一个迭代器，该迭代器产生字符串中模式的所有非重叠匹配。
• 字符串从左到右进行扫描。
• 按照发现顺序返回匹配项。

# Importing re module
import re 

# Sample string
line = "Hello world. I am Here!";

# Regex pattern
pattern = r'[aeiou]'

# Using re.finditer()
iter_ = re.finditer(pattern, line)

# Iterating the itre_
for i in iter_:
    print(i)

输出:

<re.Match object; span=(1, 2), match='e'>
<re.Match object; span=(4, 5), match='o'>
<re.Match object; span=(7, 8), match='o'>
<re.Match object; span=(15, 16), match='a'>
<re.Match object; span=(19, 20), match='e'>
<re.Match object; span=(21, 22), match='e'>

8. re.split(pattern，string，maxsplit=0，flags=0)

• 它通过模式的出现来分隔模式。
• 如果maxsplit为零，则进行最大数量的分割。
• 如果maxsplit为1，则它将字符串按照模式的第一个出现进行分割，并将剩余的字符串作为最终结果返回。

示例：

# Import re module
import re  

# Pattern
pattern = ' '
# Sample string
line = "Learn Python through tutorials on javatpoint"  

# Using split function to split the string after ' '
result = re.split( pattern, line) 

# Printing the result
print("When maxsplit = 0, result:", result)

# When Maxsplit is one
result = re.split(pattern, line, maxsplit=1)
print("When maxsplit = 1, result =", result)

输出:

When maxsplit = 0, result: ['Learn', 'Python', 'through', 'tutorials', 'on', 'javatpoint']
When maxsplit = 1, result = ['Learn', 'Python through tutorials on javatpoint']

9. re.escape(pattern)

• 它对模式中的特殊字符进行转义。
• 当字符串中包含正则表达式元字符时，转义函数变得更加重要。

  示例：

# Import re module
import re  

# Pattern
pattern = 'https://www.javatpoint.com/'

# Using escape function to escape metacharacters
result = re.escape( pattern) 

# Printing the result
print("Result:", result)

输出：

Result: https://www\.javatpoint\.com/

转义函数从模式中转义了元字符“。”。当希望把元字符视为普通字符来匹配实际字符本身时，这是很有用的。

10. re.purge()

• 清除函数不接受任何参数，只是清空正则表达式缓存。

示例：

# Importing re module
import re

# Define some regular expressions
pattern1 = r'\d+'
pattern2 = r'[a-z]+'

# Use the regular expressions
print(re.search(pattern1, '123abc'))
print(re.search(pattern2, '123abc'))

# Clear the regular expression cache
re.purge()

# Use the regular expressions again
print(re.search(pattern1, '456def'))
print(re.search(pattern2, '456def'))

输出：

<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(3, 6), match='abc'>
<re.Match object; span=(0, 3), match='456'>
<re.Match object; span=(3, 6), match='def'>

• 在字符串’123abc’中使用pattern1和pattern2进行匹配。
• 我们使用re.purge()清除了缓存。
• 我们再次使用pattern1和pattern2在字符串’456def’中进行匹配。
• 由于正则表达式缓存已被清除。正则表达式被重新编译，并使用新的正则表达式对象在’456def’中进行匹配。

匹配与搜索 – re.match()与re.search()

Python有两个主要的正则表达式函数：match和search。match函数只在字符串开始位置寻找匹配项，而search函数在字符串中的任何位置寻找匹配项。

代码：

# Import re module
import re  

# Sample string
line = "Learn Python through tutorials on javatpoint"  

# Using match function to match 'through'
match_object = re.match( r'through', line, re.M|re.I)  
if match_object:  
    print("match object group : ", match_object)  
else:  
    print( "There isn't any match!!")  

# using search function to search
search_object = re.search( r'through', line, re.M|re.I)  
if search_object:  
    print("Search object group : ", search_object)  
else:  
    print("Nothing found!!")

输出：

There isn't any match!!
Search object group :  

match函数检查字符串是否以’通过’开头，search函数检查字符串中是否存在’通过’。

结论

Python中的re模块支持正则表达式。正则表达式是文本处理和模式匹配的高级工具。我们可以使用re模块找到文本字符串中的模式，并根据模式拆分和替换文本，等等。

此外，使用re模块并不总是一个好主意。如果我们仅仅搜索一个固定的字符串或者特定的字符类，并且没有利用任何re特性，比如IGNORECASE标志，那么就不需要正则表达式的全部功能。字符串提供了各种处理固定字符串的方式，通常比较快速，因为执行是一个简单的C循环，为这个任务进行了优化。