【Python】正则表达式 re 库的常见使用

正则表达式 re 库的常见使用

1. 正则表达式特殊字符

^       匹配最后面，即^后一个字符在要匹配的字符串中是第一个，否则返回空列表                           
$       匹配最后面，即$前一个字符在要匹配的字符串中是最后一个，否则返回空列表         
.       匹配任意单个字符，即可用 . 进行占位，例：a.b —> 可匹配 abb,acb,a1b等
？      匹配之前项的1次或者0次，即?可匹配前一个字符也可不匹配，如 ab? —> 可匹配 a 也被匹配 ab
+       匹配之前项的1次或者多次，即+可匹配前一个字符也可不匹配，如 ab? —> 可匹配 ab 也被匹配 abb
*       匹配之前项的0次或者多次，即?可匹配前一个字符也可不匹配，如 ab? —> 可匹配 a 也被匹配 abbb
()      匹配括号中的字符，完全匹配（可以与以上字符配合使用）
[]      匹配包含在中括号中的任意单个字符
[^]     匹配包含在中括号中的字符之外的字符
[-]     匹配指定范围的任意单个字符
{i}     匹配之前项的 i 次
{i,k}   匹配之前项最小 i 次,最大 k 次
{i,}    配置之前项至少 i 次，直到取完

\w	    匹配字母数字及下划线
\W	    匹配非字母数字及下划线
\s     	匹配任意空白字符，等价于 [ \t\n\r\f]。
\S     	匹配任意非空字符
\d     	匹配任意数字，等价于 [0-9].
\D     	匹配任意非数字
\A	    匹配字符串开始
\Z	    匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z     	匹配字符串结束
\G     	匹配最后匹配完成的位置。
\b     	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	    匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n \t	匹配换行符,匹配一个制表符
\1..\9	匹配第n个分组的内容。
\10     匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

2. 正则表达式方法

(1). re.match(匹配的正则表达式, 要匹配的字符串, 正则表达式的匹配方式)
 从字符串的起始位置匹配，如果是起始位置匹配成功的话，返回一个匹配的对象，否则返回none
 
(2). re.search(匹配的正则表达式, 要匹配的字符串, 正则表达式的匹配方式)
 扫描整个字符串并返回第一个成功的匹配

(3). re.sub(匹配的正则表达式,替换字符串也可为函数,原始字符串,替换的最大次数默认替换所有)
替换字符串中的匹配项，返回被替换后的字符串

(4). re.compile(匹配的正则表达式)
用于编译正则表达式，生成一个正则表达式（ Pattern ）对象

(5). re.findall(待匹配的字符串,字符串的起始位置,字符串的结束位置)
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表

(6). re.finditer(匹配的正则表达式,要匹配的字符串)
和 findall 类似，区别是作为一个迭代器返回

(7). re.split(匹配的正则表达式,要匹配的字符串)
按照能够匹配的子串将字符串分割，返回列表

3. 特殊字符使用实例（方法为findall）

import re

# . 匹配任意一个字符
r= re.findall(".s.","abbcsd")
print(".",r)
# ^找最前面的
r_1 = re.findall("^m","m abc dsds asc d adc")
print("^",r_1)
# $找最后面的
r_2 = re.findall("c$","abc dsds asc d adc")
print("$",r_2)
# *匹配0个或多个
r_3 = re.findall("ab*","abbbbbbbccccacc")
print("*",r_3)
# +匹配1个或多个
r_4 = re.findall("ab+","abbbbbbbccccacc")
print("+",r_4)
# ?值匹配0个或者1个
r_5 = re.findall("ab?","abbbbbbbccccacc")
print("?",r_5)

# ()匹配括号中的字符，完全匹配
r_5 = re.findall("(ab)","abbbbbbbccccdcc")
print("(ab)",r_5)

# []匹配括号中的任意单个字符
r_5 = re.findall("[ab]","abbbbbbbccccdcc")
print("[ab]",r_5)
# [^]匹配除括号中的字符以外的任意单个字符
r_5 = re.findall("[^ab]","abbbbbbbccccdcc")
print("[^ab]",r_5)
#[^-]匹配除括号中的指定范围的字符以外的任意单个字符
r_5 = re.findall("[^a-c]","abbbbbbbccccdcc")
print("[^a-c]",r_5)
# [-]匹配括号中指定范围的任意单个字符
r_5 = re.findall("[a-c]","abbbbbbbccccdcc")
print("[a-c]",r_5)

# {i}取匹配项自定义个
r_5 = re.findall("ab{2}","abbbbbbbccccacc")
print("{i}",r_5)
# {i,k}取匹配项自定义个，至少i个，最多k个
r_5 = re.findall("ab{2,3}","abbbbbbbccccacc")
print("{i,k}",r_5)
# {i,k}取匹配项自定义个，至少i个，直到取完
r_5 = re.findall("ab{2,}","abbbbbbbccccacc")
print("{i,}",r_5)
# 前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配，按最少次数匹配（0次）
r_6 = re.findall('abc*?','"abbbbbbbccccacc"')
print(r_6)

import re

# \d 匹配任意数字，等价于 [0-9]
r = re.findall("\d","123 abcd 321_dcba")
print("\d",r)

# \D 匹配任意非数字
r = re.findall("\D","123 abcd 321_dcba")
print("\D",r)

# \S 匹配任意非空字符
r = re.findall("\S","123 abcd 321_dcba")
print("\S",r)

# \w 匹配字母数字及下划线
r = re.findall("\w","123 abcd 321_dcba")
print("\w",r)

4. 方法的使用实例（findall方法请看第3点）

import re

# match 从字符串的起始位置匹配，如果是起始位置匹配成功，返回一个匹配的对象，否则返回none
r = re.match('12', '124222221343333333')
print("match",r)
print(r.span()) # 返回匹配到的字符串所在的位置(开始,结束)
print(r.group()) # 返回匹配到的字符串

# search 在字符串中匹配，如果匹配成功，返回一个匹配的对象，否则返回none
r = re.search('.4', '124222221343333333')
print("search",r)
print(r.span()) # 返回匹配到的字符串所在的位置(开始,结束)
print(r.group()) # 返回匹配到的字符串

# sub 替换字符串中的匹配项，返回被替换后的字符串
r = re.sub('124',"abd", '124222221343333333')
print("sub",r)

# compile 封装编译正则表达式，生成一个正则表达式（ Pattern ）对象
pattern = re.compile('1.4')
r = pattern.findall("124222221343333333")
print("compile",r)

# split 按照能够匹配的子串将字符串分割
r = re.split('1.',"124222221343333333")
print("split",r)