1. re.compile(pattern, flags=0)

   通过一个正则表达式创建一个可重复使用的变量。

   生成的对象可以重复的在其他的地方使用，而不是每次传递，再次生成同样的表达式。

   flags参数后面讲。可以通过|来声明多个

   	import re
   	regex = re.compile("\w+")
   	ret = re.findall(regex,"afsd fasd11as 22d")
   	print(ret)
   	ret = re.findall(regex,"afsd fasd112as 223as")
   	print(ret)
   

2. flags

   • re.A re.ASCII

     将w, W, , B, d, D, s and S只匹配ascii，不匹配unicode。

   • re.I re.IGNORECASE

     忽略大小写匹配

     	import re
     	regex = re.compile("[A-Z]+",re.I)
     	ret = re.findall(regex,"afsd fasd11as 22d")
     	print(ret)
     	ret = re.findall(regex,"afsd fasd112as 223as")
     	print(ret)
     

   • re.M re.MULTILINE

     这个会影响^ $的匹配，以及解析模式

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	regex = re.compile("^[A-Z]+$",re.I|re.MULTILINE)
     	ret = re.findall(regex,data)
     	print(ret)
     	ret = re.findall(regex,data)
     	print(ret)
     

   • re.S re.DOTALL

     匹配所有的字符包括换行

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	ret = re.findall("^.+$",data,re.I|re.S)
     	print(ret)
     	ret = re.findall("^.+$",data,re.I)
     	print(ret)
     

3. re.search(pattern, string, flags=0)

   查找第一个满足规则的，并且返回一个match对象

   re.findall是搜索所有的匹配字符串,re.match是从头开始匹配。

   	import re
   	data = """
   	asdfd
   	asdfas
   	basdfdsaf
   	aa asada
   	"""
   	ret = re.search("^.+$",data,re.I|re.S)
   	print(ret)
   

4. re.match(pattern, string, flags=0)

   从头匹配，None是无匹配，匹配长度为0是有匹配，这种与{0,INFINITY}或*或?这种有关

   不匹配和匹配了长度为0是有区别的，匹配长度为0表示你的规则允许匹配长度为0.

   	import re
   	data = """
   	asdfd
   	asdfas
   	basdfdsaf
   	aa asada
   	"""
   	ret = re.match("^.+$",data,re.I|re.S)
   	print(ret)
   	ret = re.match(".*",data)
   	print(ret)
   

5. re.fullmatch(pattern, string, flags=0)

   从头到尾严格匹配，略。

6. re.split(pattern, string, maxsplit=0, flags=0)

   根据分隔规则pattern分隔最多maxsplit个数的字串出来，maxsplit=0表示分隔所有

   	import re
   	data = """
   	asdfd
   	asdfas
   	basdfdsaf
   	aa asada
   	"""
   	ret = re.split("
   ",data,re.I|re.S)
   	print(ret)
   

7. re.findall(pattern, string, flags=0)

   返回一个不重复的字符串集合，这个string从左往右扫描，所有匹配的按照顺序存放，如果有组，则存放的是元组的形式，如果没有匹配就返回空集合。

   一元组是字符串 ""，二元组是元组类型("","")。第一个是第一个左括号出现的地方，且括号配对。

   • 一元组

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	ret = re.findall("a(\w+)d",data,re.I|re.S)
     	print(ret)
     

   • 二元组

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	ret = re.findall("(a(\w+)d)",data,re.I|re.S)
     	print(ret)
     

8. re.finditer(pattern, string, flags=0)

   以迭代器的方式返回。

   	import re
   	data = """
   	asdfd
   	asdfas
   	basdfdsaf
   	aa asada
   	"""
   	ret = re.finditer("(a(\w+)d)",data,re.I|re.S)
   	print(ret)
   	for i in ret:
   		print(i.groups())
   

9. re.sub(pattern, repl, string, count=0, flags=0)

   • pattern : string或regex
   • repl : string或接受一个参数的方法，传入参数为match对象
   • string : 扫描字符串
   • count : 最多替换次数，0表示全部
   • flags : 额外的解析标志，参考链接。

   返回替换后的字符串。repl可以包含组。

   • 字符串替换

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	ret = re.sub("(a(\w+)d)","regex",data,re.I|re.S)
     	print(ret)
     

   • 方法替换

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	ret = re.sub("a(\w+)d",lambda a: a.group()[1:-1],data,re.I|re.S)
     	print(ret)
     

   • 组替换

     	import re
     	data = """
     	asdfd
     	asdfas
     	basdfdsaf
     	aa asada
     	"""
     	ret = re.sub("a(\w+)d","\1",data,re.I|re.S)
     	print(ret)
     

10. re.escape(pattern)

    传入一个字符串，返回这个字符串的regex对象。并且将在正则表达式存在特殊含义的字符转义。

    import re
    data = """.."""
    ret = re.escape(data)
    print(ret)
    

---

参考链接