学习篇—Python 正则表达式

正则表达式 介绍

re.findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

import re
string = 'cell call c.ll cll ceel caal ccll cbll c3ll cAll caall c\nll c ll'
re.findall('cell',string)  #['cell']
re.findall('cell|call',string)  #['cell', 'call']
re.findall('c.ll',string)  # .表示一个任意字符，除了\n
re.findall('c.ll',string,re.S)  #匹配所有字符
re.findall('c[abcde]ll',string)  #['cell', 'call', 'ccll', 'cbll']
re.findall('c[a-zA-Z0-9]ll',string)  #['cell', 'call', 'ccll', 'cbll', 'c3ll', 'cAll']
re.findall('c\.ll',string)  #转义 [c.ll]
re.findall('c..ll',string)  #['caall']
re.findall('c[^a-z0-9]ll',string)  #['c.ll', 'cAll', 'c\nll', 'c ll']   ^非
# 量化符 
re.findall('c.{2}ll',string)  #['caall']
re.findall('c[a-z]{2,4}ll',string)  #['caall']
re.findall('c[a-z]?ll',string)  #['cell', 'call', 'cll', 'ccll', 'cbll']    ?{0,1}
re.findall('c[a-z]+ll',string)  #['cell', 'call', 'ccll', 'cbll', 'caall']  +{1,多}
re.findall('c[a-z]*ll',string)  #['cell', 'call', 'cll', 'ccll', 'cbll', 'caall']   *{0，多}
re.findall('c.*ll',string)  #['cell call c.ll cll ceel caal ccll cbll c3ll cAll caall', 'c ll']

import re
string = 'He is Danny.'
re.findall('He is (.*)\.',string)  #['Danny']
re.findall('He is (.+)\.',string)  #['Danny']

import re
data = '666-1258Aoe Syzlska(636) 888-0331Burns, C.Montgomery222-2658Rev. Timothy 6668889'
tel = re.findall('\(?[0-9]{0,3}\)?[ -]?[0-9]{3}[ -]?[0-9]{4}',data)
print(tel)  #['666-1258', '(636) 888-0331', '222-2658', ' 6668889']
name = re.findall('[A-Z][a-zA-Z ,.]+',data)
print(name)  #['Aoe Syzlska', 'Burns, C.Montgomery', 'Rev. Timothy ']

re.search

扫描整个字符串并返回第一个成功的匹配 (能用search就不用match)

import re
content = "strings Hello 1234567 World 8190 Demo"
result = re.search('Hello.*?(\d+).*?Demo',content)
print(result)    #<re.Match object; span=(8, 37), match='Hello 1234567 World 8190 Demo'>
print(result.group(1))    #1234567

import re
content = "strings Hello 1234567 World Demo"
result = re.match('Hello.*?(\d+).*?Demo',content)
print(result)   #None

re.sub

替换字符串

import re
content = "Hello 1234567 World"
content = re.sub('\d+','',content)
print(content)    #Hello  World

import re
content = "Hello 1234567 World"
content = re.sub('\d+','Replacement',content)
print(content)    #Hello Replacement World

import re
content = "Hello 1234567 World"
content = re.sub('(\d+)', r'\1 8910',content) #含有原字符串的字符串替换原字符
print(content) #Hello 1234567 8910 World

re.match

尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

#最常规的匹配
import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match("^Hello\s\d\d\d\s\d{4}\s\w{10}.*Demo$",content)
print(result)   #<re.Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
print(result.group())   #Hello 123 4567 World_This is a Regex Demo
print(result.span())    #(0, 41)

#泛匹配
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match('^Hello.*Demo$',content)
print(result)    #<re.Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
print(result.group())    #Hello 123 4567 World_This is a Regex Demo
print(result.span())    #(0, 41)

#匹配目标
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^Hello\s(\d+)\sWorld.*Demo$",content)
print(result)    #<re.Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
print(result.group(1))    #1234567
print(result.span())    #(0, 40)

#贪婪匹配(.*尽可能的匹配多的字符)
result = re.match('^He.*(\d+).*Demo$',content)
print(result.group(1))    #7

#非贪婪匹配（.*？较少匹配字符）(使用较多)
result = re.match('^He.*?(\d+).*Demo$',content)
print(result.group(1))    #1234567

#匹配模式(re.S或re.DOTALL匹配换行)
#转义 (\字符)

常见匹配模式

模式	描述
\d	匹配任意数字，等价于[0-9]
\D	匹配任意非数字
\s	匹配任意空白字符，等价于[\t\n\r\f]
\S	匹配非空白字符
\w	匹配字母数字及下划线
\W	匹配非字母数字下划线
\z	匹配字符串结束
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\A	匹配字符串开始
\G	匹配最后匹配完成的位置
\n	匹配一个换行符
\t	匹配一个制表符
^	匹配字符串开头
$	匹配字符串末尾
.	匹配任意字符，除换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
*	匹配0或多个的表达式
+	匹配1或多个表达式
?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
[…]	用来表示一组字符,单独列出 : [abc]匹配’a’,‘b’，或’c’
[^…]	不在 [ ] 中的字符 : [^abc]匹配除了a,b,c之外的字符
{n}	精确匹配n个前面表达式
{n,m}	匹配n到m次由前面的正则表达式定义的片段，贪婪方式
a|b	匹配a或者b
()	匹配括号内的表达式，也表示一个组