python——正则表达式基础篇，一篇就够了

正则表达式通常用于匹配，替换，分割字符串的操作，并且经常用于python中解析爬虫html格式的数据。

基础的匹配，替换，分割

re.match	起始位置为字符串开头开始匹配，如果匹配不成功则返回None
re.search	从字符串开头匹配，知道有与之匹配的内容，否则返回None
re.fullmatch	用于匹配字符串与正则表达式是否完全匹配，否的话返回None
re.findall	找到字符串中所有与之匹配的内容，以列表形式返回
re.finditer	找到字符串中与之匹配的所有内容，finditer返回一个迭代器，遍历一下，即可得到迭代器中的元素

re.sub	返回替换后的字符串
re.subn	以元组形式返回替换的结果，并返回替换的次数
re.split	返回切割后的内容

正则表达式的使用方法一般包含三个参数。

第一种操作，匹配：

第一个参数：会用一个r 作为前缀，代表正则模式

第二个参数：需要处理的字符串

第三个参数：附加处理方法 如re.I  （忽略大小写）

re.match  起始位置为字符串开头开始匹配，如果匹配不成功则返回None

result = re.match(r"abc", "abcde")
#r:正则表达式模式
#"abc":匹配的正则表达式
#"abcde"：要匹配的字符串
print(result.group())
#group: 返回匹配内容

re.search 从字符串开头匹配，知道有与之匹配的内容，否则返回None

result = re.search(r"abc", "aAcabcdabcde", re.I)
print(result.group(), result.start(), result.end())
#re.I:忽略大小写
#start:查看匹配到的起点位置
#end:查看匹配的结尾位置

re.fullmach 用于匹配字符串与正则表达式是否完全匹配，否的话返回None

result = re.fullmatch(r"abc", "defabcghj")
print(result)
#结果返回为None

re.findall 找到字符串中所有与之匹配的内容，以列表形式返回

result = re.findall(r"abc", "AbcaBcdAbcde", re.I)
print(result)

re.finditer 找到字符串中与之匹配的所有内容，finditer返回一个迭代器，遍历一下，即可得到迭代器中的元素

result = re.finditer(r"abc", "aBcabcdabcde", re.I)
for i in result:
    print(i.group())

第二种操作：替换

第一个参数：会用宇哥 r 作为前缀，代表正则模式

第二个参数：要替换为什么

第三个参数：需要替换的字符串

第四个参数：替换次数

第五个参数：附加表示

re.sub 返回替换结果字符串

result = re.sub(r"abc", "哈哈", "abcddabcdabcde", count=2)
print(result)
#count:替换的次数
#输出结果为：哈哈dd哈哈dabcde

re.subn 以元组形式返回替换的结果，并返回替换的次数

result = re.subn(r"abc", "哈哈", "abcabcdabcde")
print(result)
#输入结果：('哈哈哈哈dabcde', 2)

第三种操作：分割

第一个参数：会用宇哥 r 作为前缀，代表正则模式

第二个参数：需要切割的字符串

第三个参数：最大切割次数

re.spit:返回切割之后的内容

result = re.split(r"abc", "0abcabcdabcde", maxsplit=2)
print(result)
#maxsplit：最大切割次数
#输出结果为：['0', '', 'dabcde']

特殊字符：

\w	数字， 字母 ，下划线
\W	非数字， 字母， 下划线
\d	数字
\D	非数字
\s	空白
\S	非空白
.	任意字符， 除\n之外，除非使用re.S可以匹配所有
^开头	re.M可以匹配\n
$结尾	re.M可以匹配\n
	以下字符为贪婪字符：尽可能的匹配多个 废碳铵：尽可能匹配少的个数（在贪婪模式后面追加一个？号）
*	代表有>=0个
+	代表有>=1个
?	代表有1个或者0个
{n}	匹配n次
{m,n}	匹配m-n次
{m,n}?	非贪婪匹配
[]	匹配其中一个
|	或者
()	分组

案例：

\w

result = re.findall("\w", "abcd_123*@#$")
print(result)
#_可以匹配到
#结果：['a', 'b', 'c', 'd', '_', '1', '2', '3']

\W

result = re.findall("\W", "abcd_123*#$%")
print(result)
#结果：['*', '#', '$', '%']

\d

result = re.findall("\d", "abc_123*#$%")
print(result)
#结果：['1', '2', '3']

\D

result = re.findall("\D", "abc_123*#$%")
print(result)
#结果：['a', 'b', 'c', '_', '*', '#', '$', '%']

\s

result = re.findall("\s", "abc_ 123*#$%")
print(result)
#注意！！这段代码_的后面我敲了一个空格
#结果：[' ']

\S

result = re.findall("\S", "a bc_ 1 2 3* # $ %")
print(result)
#结果：['a', 'b', 'c', '_', '1', '2', '3', '*', '#', '$', '%']

.

result = re.findall(".", "0afn\toiai\n", re.S)
print(result)
#\t:水平制表符
#\n：换行符
#结果：['0', 'a', 'f', 'n', '\t', 'o', 'i', 'a', 'i', '\n']

*  以下列为例，如果不是以“abc"开头，则返回结果为空列表

result = re.findall("^abc","abcdeabc")
print(result)
#结果：['abc']

$  以下列为例，如果不是以c结尾，则输出结果为空列表

result = re.findall("c$", "abcdeafkfc")
print(result)
#结果：['c']

贪婪字符：

*

result = re.findall(r"\d*", "123456abc")
print(result)
#结果：['123456', '', '', '', '']

+

result = re.findall(r"\d+", "123456abc")
print(result)
#结果：['123456']

？

result = re.findall(r"\d?", " 123456abc")
print(result)
#结果：['', '1', '2', '3', '4', '5', '6', '', '', '', '']

{m, n}  表示元素出现m-n次， 以下列为例，如果没有加？则输出结果为['aaaa', 'aa']

{n}  表示元素恰好出现n次

{n,} 表示元素至少出现三次

result = re.findall(r"a{2,4}?", "aaaabababaa")
print(result)
#结果：['aa', 'aa', 'aa']

[]

result = re.findall(r"[a-f]|[1-6]", "abcdef123456")
print(result)
#结果：['a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6']

|  

result = re.findall(r"[a-f]|[1-6]", "abcdefABC123456")
print(result)
#结果：['a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6']

（） 以下列为例，将a-6作为一组， 6-f作为一组

result = re.findall(r"a(.*)6(.*)F", "abcdef123456ABCDEF")
print(result[0][0], result[0][1])
#结果：bcdef12345 ABCDE