Python正则表达式re库

所谓正则表达式，可以理解为对字符串的一种模式规定。

正则检查，就是判断某个字符串是否满足我们所定义的模式。

一、基本知识

注意点号是表示除了换行符以外的任何单个字符

 [ ]表示字符集，[^ ] 表示非字符集

？	0至1
*	0至∞
+	1至∞
{m}	m
{m，n}	m到n

 \w 字母数字下划线

\s 匹配空白字符

 这个表示正则检查时的一些配置（模式限定），比较重要的三条：

re.I   忽略大小写（助记：ignore）

re.S 使.匹配包括换行符在内的所有字符。因为原先的点号是可以包含除了换行符的任意字符，使用re.S 相当于是扩大了点号的匹配范围。 

二、Re库

 

 主要考虑的是match，sub、findall（search）

新建文件：testRe.py

1.compile（模式）  # 用于创建模式对象

import re
pat=re.compile("AA")

2.search（）  #只找第一个，对比查找，整体找出最大满足项

找到就输出re.match对象（span=第一个匹配项的位置，左含右不含，tuple格式）

找不到返回None

（1）有模式对象，用模式对象.search（待处理字符串）

import re
pat=re.compile("AA")

m=pat.search("CBA")
print(type(m),m)

m=pat.search("CBAA")
print(type(m),m)
print(type(m.span()),m.span())

<class 'NoneType'> None
<class 're.Match'> <re.Match object; span=(2, 4), match='AA'>
<class 'tuple'> (2, 4)

import re
pat=re.compile("[A-B]{2,3}")

m=pat.search("CBABABABA")
print(type(m),m)

m=pat.search("CBAABBBBAA")
print(type(m),m)
print(type(m.span()),m.span())

<class 're.Match'> <re.Match object; span=(1, 4), match='BAB'>
<class 're.Match'> <re.Match object; span=(1, 4), match='BAA'>
<class 'tuple'> (1, 4)

（2）没有模式对象，或者说模式对象写在形参里

m=re.search（模式，待处理对象）

m=re.search(r"^123.*456$","123asdf456")
print(type(m),m)
print(type(m.span()),m.span())

<class 're.Match'> <re.Match object; span=(0, 10), match='123asdf456'>
<class 'tuple'> (0, 10)

3.findall  #找到所有符合标准的字符串（整体找出）

re.findall（规则，待处理字符串）

m=re.findall(r"[A-K]*","26adADDDF")
print(type(m),m)

<class 'list'> ['', '', '', '', 'ADDDF', '']

注意：与search不同之处是，它返回的是一个列表，包含了所有匹配的字符串

括号的作用，以及懒惰匹配与贪婪匹配

#加括号，仅返回括号里的内容
#懒惰匹配(.*?)
m=re.findall(r"AD(.*?)F","26adADDDFADDDF")
print(type(m),m)

#贪婪匹配(.*)
m=re.findall(r"AD(.*)F","26adADDDFADDDF")
print(type(m),m)

#不加括号，全都返回
#懒惰匹配.*?
m=re.findall(r"AD.*?F","26adADDDFADDDF")
print(type(m),m)

#贪婪匹配.*
m=re.findall(r"AD.*F","26adADDDFADDDF")
print(type(m),m)

<class 'list'> ['DD', 'DD']
<class 'list'> ['DDFADDD']
<class 'list'> ['ADDDF', 'ADDDF']
<class 'list'> ['ADDDFADDDF']

(.*)正则表达式
(.*)涉及到贪婪模式。当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。以这个表达式为例：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。

(.*?)正则表达式
有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。
参考文章：

[正则表达式]正则表达式(.*)和(.*?)的字符串匹配问题_凌风1205的博客-CSDN博客

一些其它有趣的现象

#懒惰匹配(.*?)
m=re.findall(r"(.*?)","26adADDDFADDDF")
print(type(m),m)

#贪婪匹配(.*)
m=re.findall(r"(.*)","26adADDDFADDDF")
print(type(m),m)

m=re.findall(r"(.?)","26adADDDFADDDF")
print(type(m),m)

m=re.findall(r"(.)","26adADDDFADDDF")
print(type(m),m)

<class 'list'> ['', '2', '', '6', '', 'a', '', 'd', '', 'A', '', 'D', '', 'D', '', 'D', '', 'F', '', 'A', '', 'D', '', 'D', '', 'D', '', 'F', '']
<class 'list'> ['26adADDDFADDDF', '']
<class 'list'> ['2', '6', 'a', 'd', 'A', 'D', 'D', 'D', 'F', 'A', 'D', 'D', 'D', 'F', '']
<class 'list'> ['2', '6', 'a', 'd', 'A', 'D', 'D', 'D', 'F', 'A', 'D', 'D', 'D', 'F']

4.sub 分隔替换

re.sub（旧正则模式，新字符串，待处理对象）

str=re.sub("[a-z]", "[A-Z]", "sadfscva")
print(type(str),str)
# 搞错了，再来
str=re.sub("[a-z]", "嘿", "sadfscva")
print(type(str),str)

<class 'str'> [A-Z][A-Z][A-Z][A-Z][A-Z][A-Z][A-Z][A-Z]
<class 'str'> 嘿嘿嘿嘿嘿嘿嘿嘿

---

建议在正则表达式前加r，关闭转义