正则re

正则表达式

它是约束字符串匹配某种形式的规则

正则表达式有什么用?

1.检测某个字符串是否符合规则.比如:判断手机号,身份证号是否合法
2.提取网页字符串中想要的数据.比如:爬虫中,提取网站天气,信息,股票代码,星座运势等具体关键字

在线测试工具 http://tool.chinaz.com/regex/

import re

正则表达式的种类

正则表达式由一些 [普通字符] 和一些 [元字符] 组成:

(1)普通字符包括大小写字母和数字
(2)元字符具有特殊含义,大体种类分为如下:
1.预定义字符集,字符组
2.量词
3.边界符
4.分组

预定义字符集

预定义字符集	匹配内容
.	匹配任意字符，除了换行符\n
\d	匹配数字
\D	匹配非数字
\w	匹配字母或数字或下划线 (正则函数中,支持中文的匹配)
\W	匹配非字母或数字或下划线
\s	匹配任意的空白符
\S	匹配任意非空白符
\n	匹配一个换行符
\t	匹配一个制表符
[]	匹配中括号内列举的字符

# 匹配数字
strvar = "sdjfklj234&*(&1"
lst = re.findall("\d",strvar)
print(lst)  #out ['2', '3', '4', '1']

# 匹配非数字
strvar = "YWERsdf78_&"
lst = re.findall("\D",strvar)
print(lst) #out ['Y', 'W', 'E', 'R', 's', 'd', 'f', '_', '&']

# \w 匹配字母或数字或下划线     (正则函数中,支持中文的匹配)
strvar = "sadf234_^&*%$^$%你好"
lst = re.findall("\w",strvar)
print(lst) #out ['s', 'a', 'd', 'f', '2', '3', '4', '_', '你', '好']

# \W 匹配非字母或数字或下划线
strvar = "sadf234_^&*%$^$%你好"
lst = re.findall("\W",strvar)
print(lst) #out ['^', '&', '*', '%', '$', '^', '$', '%']

# \s 匹配任意的空白符 ( " "  \t  \n \r )
strvar = " 		 \r "
lst = re.findall("\s",strvar)
print(lst) #[' ', '\t', '\t', ' ', '\r', ' ']

# \S 匹配任意非空白符
strvar = " 		 \r  123_*("
lst = re.findall("\S",strvar)
print(lst) # out ['1', '2', '3', '_', '*', '(']

# \n 匹配一个换行符
strvar = """
今天国庆假期结束了,兄弟们满载	而归,玩的	很困,尽	快调	整.
"""
lst = re.findall(r"\n",strvar)
print(lst)    # ['\n', '\n']

strvar = """
今天国庆假期结束了,兄弟们满载	而归,玩的	很困,尽	快调	整.
"""
# \t 匹配一个制表符
lst = re.findall(r"\t",strvar)
print(lst) # out 4 \t

字符组格式	说明 [默认必须从字符组中选一个]
[...]	匹配字符组中的字符
[^...]	匹配除了字符组内所有内容,之外的所有字符

字符组内容	待匹配字符	匹配结果	说明
[0123456789]	8	True	字符组里枚举的各种字符,必须满足一个,否则返回假,不匹配
[abcdefg]	9	False	由于字符组中没有"9"字符，所以不匹配
[0-9]	7	True	可用 - 表示范围,[0-9] 和 [0123456789]是一个意思
[a-z]	s	True	[a-z]匹配所有的小写字母
[A-Z]	B	True	[A-Z]就表示所有的大写字母
[0-9a-fA-F]	e	True	可以匹配数字,大小写形式的a-f. 该正则可验证十六进制

print(re.findall('a[abc]b','aab abb acb adb')) # aab abb acb

print(re.findall('a[0123456789]b','a1b a2b a3b acb ayb')) # a1b  a2b a3b
# 优化写法 0123456789  => 0-9
print(re.findall('a[0-9]b','a1b a2b a3b acb ayb')) # a1b  a2b a3b

print(re.findall('a[abcdefg]b','a1b a2b a3b acb ayb adb')) # acb adb
# 优化写法 abcdefg => a-g  表达所有的小写字母 a-z
print(re.findall('a[a-g]b','a1b a2b a3b acb ayb adb')) # acb adb

print(re.findall('a[ABCDEFG]b','a1b a2b a3b  aAb aDb aYb')) # aAb aDb
# 优化写法 ABCDEFG => A-G  表达所有的大写字母 A-Z
print(re.findall('a[A-G]b','a1b a2b a3b  aAb aDb aYb')) # aAb aDb
print(re.findall('a[A-Z]b','a1b a2b a3b  aAb aDb aYb')) # aAb aDb aYb

# 注意点: 不能直接写A-z  中间ascii编码中包含了特殊的符号
print(re.findall('a[A-z]b','a1b a2b a3b acb ayb adb a[b'))

# 匹配所有的字母和数字
print(re.findall('a[a-zA-Z0-9]b','a1b a2b a3b acb ayb adb a[b'))
# out ['a1b', 'a2b', 'a3b', 'acb', 'ayb', 'adb']


print(re.findall('a[0-9a-zA-Z]b','a-b aab aAb aWb aqba1b'))  #aab aAb aWb aqb a1b
print(re.findall('a[0-9][*#/]b','a1/b a2b a29b a56b a456b')) # a1/b

# ^ 在字符组开头的位置出现代表 除了...的意思
print(re.findall('a[^-+*/]b',"a%b ccaa*bda&bd")) #a%b a&b

# 匹配^-\等特殊字符时 ,需要前面加上\进行转义
strvar = "a^c a-c a\c"
lst = re.findall(r"a[\^\-\\]c",strvar)
print(lst)  # ['a^c', 'a-c', 'a\\c'] 非隐式转义 
print(lst[-1])    # a\c 转义了 


# 注意点:为了防止转义,在正则表达式中或者要匹配的字符串中,无脑加r实现匹配
strvar = r"a\b"
lst = re.findall(r"a\\b",strvar)
print(lst[0])

量词

量词	用法说明
?	重复0次或1次
+	重复1次或多次 (至少1次)
*	重复0次或多次 (任意次)
	重复n次
	重复n次或更多次 (至少n次)
	重复n到m次
.* .+	贪婪模式匹配 最深度原则
.*? .+?	非贪婪模式匹配

import re
'''1) ? 匹配0个或者1个a '''
print(re.findall('a?b','abbzab abb aab'))   #  ab b  ab ab b ab

'''2) + 匹配1个或者多个a '''
print(re.findall('a+b','b ab aaaaaab abb')) # ab aaaaaab ab

'''3) * 匹配0个或者多个a '''
print(re.findall('a*b','b ab aaaaaab abbbbbbb')) # b ab aaaaaab ab b b b b b b 

'''4) {m,n} 匹配m个至n个a '''
# 1 <= a <= 3 
print(re.findall('a{1,3}b','aaab ab aab abbb aaz aabb')) #aaab ab aab ab aab
# {2}  代表必须匹配2个a
print(re.findall('a{2}b','aaab ab aab abbb aaz aabb')) # aab aab aab
# {2,} 代表至少匹配2个a
print(re.findall('a{2,}b','aaab ab aab abbb aaz aabb')) # aaab aab aab

贪婪算法和非贪婪算法

"""
	匹配符＋量词
"""
strvar = "刘能和刘老根和刘罗锅111子222子"

"""
        .只匹配一个字符
"""
lst = re.findall("刘.",strvar)
print(lst) # lst = re.findall("刘.?",strvar)
lst = re.findall("刘.?",strvar)
print(lst) # lst = re.findall("刘.?",strvar)

# out ['刘能', '刘老', '刘罗']



strvar = "刘能和刘老根和刘罗锅111子222子"

lst = re.findall("刘.+",strvar)
print(lst) # ['刘能和刘老根和刘罗锅111子222子']

lst = re.findall("刘.*",strvar)
print(lst) # ['刘能和刘老根和刘罗锅111子222子']

lst = re.findall("刘.{1,20}",strvar)
print(lst) # ['刘能和刘老根和刘罗锅111子222子']

lst = re.findall("刘.*子",strvar)
print(lst)

# out ['刘能和刘老根和刘罗锅111子222子']  优先匹配量词最多



# 非贪婪匹配(模式)


lst = re.findall("刘.??",strvar)
print(lst) # ['刘', '刘', '刘']

lst = re.findall("刘.+?",strvar)
print(lst) # 刘能 刘老 刘罗

lst = re.findall("刘.*?",strvar)
print(lst) # ['刘', '刘', '刘']

lst = re.findall("刘.{1,20}?",strvar)
print(lst) # ['刘能', '刘老', '刘罗']

lst = re.findall("刘.*?子",strvar)
print(lst)   # 刘能和刘老根和刘罗锅111子  非贪婪匹配

边界符

边界符	说明
\b	匹配一个字符的边界
^	匹配字符串的开始
$	匹配字符串的结尾

"word"
"""
卡主左边界:\bw
卡主右边界:d\b
"""

strvar = "word old fuck"

# 右边界
lst = re.findall(r"d\b",strvar) # ['d', 'd']
lst = re.findall(r".*d\b",strvar) # ['word old']
lst = re.findall(r".*?d\b",strvar) # ['word' 'old']
print(lst) 

# 左边界
lst = re.findall(r"\bw",strvar)
print(lst)  # ['w']
lst = re.findall(r"\bw.*",strvar)
print(lst)  # ['word old fuck']
lst = re.findall(r"\bw.*?",strvar)
print(lst)  # ['w']
lst = re.findall(r"\bw.*? ",strvar)
print(lst)  # ['word ']
# 空格在正则表达式中,不能随意加,是参与匹配的.
lst = re.findall(r"\bw\S*",strvar)
print(lst)  # ['word'] # 贪婪匹配

# (4) ^ $的使用
"""
^ 写在在字符串的开头,表达必须以某个字符开头
$ 写在在字符串的结尾,表达必须以某个字符结尾
当使用了^ $ 代表要把该字符串看成一个整体
"""

strvar = "大哥大嫂大爷"
print(re.findall('大.',strvar))  # ['大哥', '大嫂', '大爷']
print(re.findall('^大.',strvar)) # ['大哥']
print(re.findall('大.$',strvar)) # ['大爷']
print(re.findall('^大.$',strvar))# []
print(re.findall('^大.*?$',strvar))   # ['大哥大嫂大爷']
print(re.findall('^大.*?大$',strvar)) # []
print(re.findall('^大.*?爷$',strvar)) # ['大哥大嫂大爷']


print(re.findall('^g.*? ' , 'giveme 1gfive gay')) # giveme 
print(re.findall('five$' , 'aassfive')) # [five]
print(re.findall('^giveme$' , 'giveme')) # ['giveme']
print(re.findall('^giveme$' , 'giveme giveme')) # []
print(re.findall('giveme' , 'giveme giveme')) # ['giveme', 'giveme']
print(re.findall("^g.*e",'giveme 1gfive gay')) # ['giveme 1gfive']

分组字符

分组	用法说明
a|b	匹配字符a 或 字符b (如果两个当中有重合部分,把更长的那个放前面)
(ab)	匹配括号内的表达式 ，将()作为一个分组
\num	引用分组num匹配到的字符串
(?P)	给分组命名
(?P=name)	引用别名： 把name分组所匹配到的内容引用到这里

import re
# (1)分组
print(re.findall('.*?_good','wusir_good alex_good secret男_good'))
# ['wusir_good', ' alex_good', ' secret男_good']
print(re.findall('(.*?)_good','wusir_good alex_good secret男_good'))
# ['wusir', ' alex', ' secret男']

# (?:) 代表不优先显示分组里面的内容,只是显示正常匹配到的内容
print(re.findall('(?:.*?)_good','wusir_good alex_good secret男_good'))

# (2) | 代表或 , a|b 匹配字符a 或者 匹配字符b . 
import re
strvar = "abceab"
lst = re.findall("a|b",strvar)
print(lst) #['a', 'b', 'a', 'b']

# 注意点:把不容易匹配到的内容放到前面,把容易匹配到的内容放到后面
strvar = "abcdeabc234f"
lst = re.findall("abcd|abc",strvar)
print(lst) #['abcd', 'abc']

# 匹配小数 
strvar = "3....  ....4  .3 ...3   1.3  9.89  10"
lst = re.findall(r"\d+\.\d+",strvar)
print(lst)

# 匹配小数和整数 
lst = re.findall(r"\d+\.\d+|\d+",strvar)
print(lst)

# 使用分组改造
'''findall优先显示括号里的内容,需要加上?:取消哦优先显示,按照匹配到的内容显示'''
lst = re.findall(r"\d+(?:\.\d+)?",strvar)
print(lst)

# 匹配135或171的手机号 
strvar = "13566668888 17366669999 17135178392"
lst = re.findall(r"(?:135|171)\d{8}",strvar)
print(lst)

# 优化,只能匹配出一个手机号
strvar = "13566668888"
lst = re.findall(r"^(?:135|171)\d{8}$",strvar) # 卡住左右边界
print(lst)

strvar = "13566668888"
obj = re.search(r"^(135|171)\d{8}$",strvar)

print(obj) # <re.Match object; span=(0, 11), match='13566668888'>
print(obj.group()) # 13566668888
print(obj.groups()) # ('135',) 显示括号优先匹配的

反向引用

import re
strvar = "<div>明天又要休息了<div>"
# strvar = "<div>明天又要休息了</div><p>还有很多工作要做</p>"  非贪婪会匹配下一个标签

obj = re.search("<(.*?)>(.*?)<(.*?)>",strvar)
# 为了限制第三行的这种情况才用非贪婪 

# 反向引用的语法 \1把第一个括号里面匹配到的内容在引用一次
obj = re.search(r"<(.*?)>(.*?)</\1>",strvar)
print(obj)
print(obj.group())
print(obj.groups())

strvar = " z3d4pzd a1b2cab "
obj = re.search(r"(.*?)\d(.*?)\d(.*?)\1\2",strvar)
print(obj)
print(obj.group())
print(obj.groups())

命名分组

"""
3) (?P<组名>正则表达式) 给这个组起一个名字
4) (?P=组名) 引用之前组的名字,把该组名匹配到的内容放到当前位置
"""
# 写法一
strvar = " z3d4pzd a1b2cab "
obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)\1\2",strvar)
print(obj)
print(obj.group())


# 写法二
strvar = " z3d4pzd a1b2cab "
obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)(?P=tag1)(?P=tag2)",strvar)
print(obj)
print(obj.group())

正则函数

OBJ的返回

group

group(num=0)    
#匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

groups

groups()    
#返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
#就是优先匹配的

修饰符

# 修饰符 
# re.I 使匹配对大小写不敏感
strvar = "<h1>大标题</H1>"
pattern = re.compile("<h1>(.*?)</h1>" , flags=re.I)
obj = pattern.search(strvar)
print(obj.group())


# re.M 使每一行都能够单独匹配(多行匹配)，影响 ^ 和 $
"""单行独立匹配,而不是整体匹配"""
strvar = """
<p>111</p>
<a>222</a>
<strong>333</strong>
"""

pattern = re.compile("^<.*?>(?:.*?)<.*?>$" , flags=re.M)
lst = pattern.findall(strvar)
print(lst)


# re.S         使 . 匹配包括换行在内的所有字符
strvar = """
give
sdfsdfmefive
"""

pattern = re.compile(".*?five" , flags=re.S)
lst = pattern.findall(strvar)
print(lst) # return list ['\ngive\nsdfsdfmefive']


# 多个修饰符一起使用通过|拼接
pattern = re.compile(".*?mefive" , flags = re.S|re.I|re.M )
obj = pattern.search(strvar)
print(obj.group())

re.findall

"""
	在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
	lst = re.findall(正则表达式,字符串)
	return list
"""

re.search

"""
	re.search 扫描整个字符串并返回第一个成功的匹配。即找到就返回
	return obj
	re.search(pattern, string, flags=0)
	obj.出group 或者 groups 获取返回值
"""

re.match

"""
	search在正则表达式的前面加上^ 等价于 match ,其他用法上一模一样
"""

re.split

strvar = "alex|wusir_xboyww@risky"
lst = re.split("[|_@]",strvar)
print(lst)

strvar = "alex2341273894wusir234234xboyww11111risky"
lst = re.split("\d+",strvar)
print(lst)

# out ['alex', 'wusir', 'xboyww', 'risky']

re.sub

# return str
strvar = "alex|wusir_xboyww@risky"
"""
strvar = strvar.replace("|","&")
strvar = strvar.replace("_","&")
strvar = strvar.replace("@","&")
print(strvar)
"""
# sub(正则,替换的字符,原字符串[,替换的次数])
res = re.sub("[|_@]","&",strvar)
res = re.sub("[|_@]","&",strvar,1)
print(res)

re.subn

# return 元祖 替换的个数
res = re.subn("[|_@]","&",strvar)
res = re.subn("[|_@]","&",strvar,2)
print(res) 
# ('alex&wusir&xboyww@risky', 2)

re.finditer

from collections import Iterator, Iterable
strvar = "sdf23647fdgdfg()*()*23423423"
it = re.finditer("\d+",strvar)
print(isinstance(it,Iterator))  # 证明是iter

for obj in it:
	print(obj.group()) # 只返回一组数据

re.compile

# compile  指定一个统一的匹配规则
"""
正常情况下,正则表达式编译一次,执行一次
为了避免反复编译,节省时间空间,可以使用compile统一规则
编译一次,终身受益
第二个参数带有flag
"""
strvar = "asdfs234sdf234"
pattern = re.compile("\d+")

print("<===>")
obj = pattern.search(strvar)
print(obj.group()) #寻找一个

lst = pattern.findall(strvar)
print(lst) #寻找所有 继承寻找方法的obj