python re

正则表达式的特殊字符和规则介绍

特殊字符

位置匹配                 
^           匹配行首                                    
$           匹配行尾

字匹配                                    
"."         任意非\n单个字符
"\d" digit 匹配数字
"D"  匹配非数字
"w" word 能匹配单词字符和汉字
"W" 能匹配非单词字符
"s" space 匹配任意的空白符
"S" 匹配非任意的空白符
[] 匹配包含在中括号中的任意字符
[^] 匹配包含在中括号中的字符之外的字符
[-] 匹配指定范围的任意单个字符

符匹配
# "\n" 匹配换行符
# "\t" 匹配制表符
# "\b" 匹配单词的结尾，\表示转义，比如\.表示一个点，所有的字（除.）匹配都要转义

重复匹配
？ 匹配之前项的1次或者0次 
+ 匹配之前项的1次或者多次 
* 匹配之前项的0次或者多次 
{n} 匹配之前项的n次 
{m,n} 匹配之前项最大n次，最小m次 
{n,} 配置之前项至少n次


逻辑匹配
# "a|b" 或匹配
# "()" 匹配括号内的表达式,俗称分组,需要对一个字符串进行整体讨论时,一般用分组
# [^a-z]  除a-z的都匹配

 

flag规则（匹配方法的第三个参数,compile的第二个参数）

"""
　　re.I 忽略大小写
　　re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
　　re.M 多行模式
　　re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
　　re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
　　re.X 为了增加可读性，忽略空格和 # 后面的注释

"""

 

匹配类方法

findall（pattern,string,flag,返回列表）|re_obj.findall(string)

# findall方法，该方法在字符串中查找模式匹配，将所有的匹配字符串以列表的形式返回，如果文本中没有任何字符串匹配模式，则返回一个空的列表

re_str = "hello this is python 2.7.13 and python 3.4.5"
 
pattern = "python [0-9]\.[0-9]\.[0-9]"
res = re.findall(pattern=pattern,string=re_str)
print(res)
 
# ['python 2.7.1', 'python 3.4.5']

 

编译的方式使用正则表达式，compile(patten,flags,返回re对象)

# 编译的方式使用正则性能会提高
re_str = "hello this is python 2.7.13 and Python 3.4.5"
re_obj = re.compile(pattern = "python [0-9]\.[0-9]\.[0-9]",flags=re.IGNORECASE)
res = re_obj.findall(re_str)
print(res)

 

match（pattern,string,flag,返回SRE_Match类型的对象）|re_obj.match(string)

s_true = "what is a boy"
s_false = "What is a boy"
re_obj = re.compile("what")
 
print(re_obj.match(string=s_true))
# <_sre.SRE_Match object; span=(0, 4), match='what'
 

 

search（pattern,string,flag,返回SRE_Match类型的对象）|re_obj.search(string)

# search方法，模式匹配成功后，也会返回一个SRE_Match对象，search方法和match的方法区别在于match只能从头开始匹配，而search可以从
# 字符串的任意位置开始匹配，他们的共同点是，如果匹配成功，返回一个SRE_Match对象，如果匹配失败，返回一个None，这里还要注意，
# search仅仅查找第一次匹配，也就是说一个字符串中包含多个模式的匹配，也只会返回第一个匹配的结果

 

finditer（pattern,string,flag,返回可迭代对象，里面是SRE_Match类型的对象集）|re_obj.finditer(string)

# finditer返回一个迭代器，遍历迭代器可以得到一个SRE_Match对象，比如下面的例子

re_str = "what is a different between python 2.7.14 and python 3.5.4"
 
re_obj = re.compile("\d{1,}\.\d{1,}\.\d{1,}")
 
for i in re_obj.finditer(re_str):
    print(i)
 
# <_sre.SRE_Match object; span=(35, 41), match='2.7.14'>
# <_sre.SRE_Match object; span=(53, 58), match='3.5.4'>

 

修改类方法

以后补

非贪婪匹配与组返回值

非贪婪匹配

# 4、非贪婪匹配，贪婪匹配总是匹配到最长的那个字符串，相应的，非贪婪匹配是匹配到最小的那个字符串，只需要在匹配字符串的时候加一个？即可
 
# 下面的例子，注意两个.
s = "Beautiful is better than ugly.Explicit is better than impliciy."
 
 
re_obj = re.compile("Beautiful.*y\.")
 
print(re_obj.findall(s))
# ['Beautiful is better than ugly.Explicit is better than implicity.']
 
re_obj = re.compile("Beautiful.*?\.")
 
print(re_obj.findall(s))
# ['Beautiful is better than ugly.']

（）组返回值

findall方法返回的是小括号中匹配到的字符串，search.group（）方 法的返回的整个模式匹配到字符串，search.group(1)这个是匹配第一个小括号中的模式匹配到的字符串，search.group(2)这个是 匹配第二个小括号中的模式匹配到的字符串，以此类推

s = "=aa1239d&&& 0a ()--"
rep = re.compile("\w+(&+)")
 
print(rep.findall(s))
# ['&&&']
print(rep.search(s).group())
# aa1239d&&&
print(rep.search(s).group(1))
# &&&