Python正则表达式学习笔记

import re

正则表达式方法

re.findall()方法

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

m = re.findall('abc', 'abcdefgabc')
m

['abc', 'abc']

re.compile()方法

用于编译正则表达式，生成一个正则表达式（Pattern）对象

p = re.compile('^abc')  #以abc开头的字符串

m = p.findall('abc\nabc')
print(m)
m = p.findall('dabc\nabc')
print(m)

['abc']
[]

re.match()方法

从字符串的起始位置匹配一个正则表达式，
如果不是起始位置匹配成功的话，match()就返回none。
默认只匹配一次。

m = re.match('abc', 'abcabc').span()  #span()方法返回匹配到的对象的跨度，类型为元组
print(m)
m = re.match('abc', 'babcabc')
print(m)

(0, 3)
None

re.search()方法

扫描整个字符串并返回第一个成功的匹配。

m = re.search('abc', 'abcabc').span()
print(m)
m = re.search('abc', 'babcabc').span()
print(m)

(0, 3)
(1, 4)

re.sub()方法

用于替换字符串中的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)
参数：
pattern:正则中的模式字符串。
repl:替换的字符串，也可为一个函数。
string:要被查找替换的原始字符串。
count:模式匹配后替换的最大次数，默认0表示替换所有的匹配。
flags:编译时用的匹配模式，数字形式。
前三个必选，后两个可选。

phone = "2004-959-559 # 这是一个电话号码"

# 删除注释
num = re.sub(r'#.*$', "", phone)
print("电话号码 : ", num)

# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print("电话号码 : ", num)

电话号码 :  2004-959-559 
电话号码 :  2004959559

re.finditer()方法

和 findall 类似，
在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

it = re.finditer(r"\d+", "12a32bc43jf3")
for match in it:
    print(match.group())

12
32
43
3

re.split()方法

按照正则表达式将字符串分割后返回列表，
对于一个找不到匹配的字符串而言，split 不会对其作出分割,
会返回以原字符串为单个元素的列表。
maxsplit参数表示分割次数，默认值为0，表示不限制次数。

m = re.split(' ', 'hello world')
m

['hello', 'world']

m = re.split('abc', 'hello world')
m

['hello world']

正则表达式对象及其方法

re.RegexObject对象

即正则表达式对象，re.compile()方法返回此对象。

re.MatchObject对象

即匹配对象，re.match()方法返回此对象。

m = re.match(r'(abc) (defg)', 'abc defg hijkl')

print('m:', m)

#groups()：等价于(group(1),group(2),...)
print('m.groups():', m.groups())

#group()/group(0)：返回被正则表达式所匹配的字符串。
print('m.group():', m.group())
print('m.group(0):', m.group(0))

#span()/span(0)：返回一个元组包含匹配 (开始,结束) 的位置。
print('m.span():', m.span())
print('m.span(0):', m.span(0))

#start()/start(0)：返回匹配开始的位置。
print('m.start():', m.start())
print('m.start(0):', m.start(0))

#end()/end(0)：返回匹配结束的位置。
print('m.end():', m.end())
print('m.end(0):', m.end(0))

#group(n)：返回第n个子串。
print('m.group(1):', m.group(1))

#start(n)：返回第n个子串开始的位置。
print('m.start(1):', m.start(1))

#end(n)：返回第n个子串结束的位置。
print('m.end(1):', m.end(1))

#sapn(n)：返回第n个子串结束的位置。
print('m.span(1):', m.span(1))

print('m.group(2):', m.group(2))
print('m.span(2):', m.span(2))
try:
    print(m.group(3))
except:
    print('m.group(3) is not exist.')

m: <re.Match object; span=(0, 8), match='abc defg'>
m.groups(): ('abc', 'defg')
m.group(): abc defg
m.group(0): abc defg
m.span(): (0, 8)
m.span(0): (0, 8)
m.start(): 0
m.start(0): 0
m.end(): 8
m.end(0): 8
m.group(1): abc
m.start(1): 0
m.end(1): 3
m.span(1): (0, 3)
m.group(2): defg
m.span(2): (4, 8)
m.group(3) is not exist.

正则表达式模式

'[…]'匹配集合中任意一个字符

m = re.findall('a[bcd]e', 'abe ace ade afe')
m

['abe', 'ace', 'ade']

'[^…]'匹配不在集合中的任意一个字符

m = re.findall('a[^bcd]e', 'abe ace ade afe')
m

['afe']

'^re’匹配开头

m = re.findall('^abc', 'abcdabc')
m

['abc']

're$'匹配结尾

m = re.findall('abc$', 'abcabc')
m

['abc']

're?'匹配1个或0个

m = re.findall('ab?', 'aababb')
m

['a', 'ab', 'ab']

're+'匹配至少1个

m = re.findall('ab+', 'aababb')
m

['ab', 'abb']

're*'匹配至少0个

m = re.findall('ab*', 'aababb')
m

['a', 'ab', 'abb']

'+特殊字符’转义字符

也可以通过原始字符串来表示含有转义字符串的re

#r'\t'，等价于\\t
m = re.findall('\\t', 'a\tc')
m
m = re.findall(r'\t', 'a\tc')
m

['\t']

're{n}'匹配n个，只能是n个，多一个少一个都不行

m = re.findall('o{2}', 'food')
m

['oo']

m = re.findall('o{2}', 'dog')  #少一个不行
m

[]

m = re.findall('o{2}', 'ooomg')  #多一个不行
m

['oo']

're{n,}'匹配n个以上，少于n个匹配不了

re{0,}等价于re*
re{1,}等价于re+

m = re.findall('o{2,}', 'ooomg')  #上一例中'o{2}'无法匹配'ooomg'
m

['ooo']

m = re.findall('o{2,}', 'dog')
m

[]

'a|b’匹配a或b

m = re.findall('a|b', 'abcabcabc')
m

['a', 'b', 'a', 'b', 'a', 'b']

'(re)'匹配括号中的正则表达式，也表示一个组

m = re.match('([0-9]{0,})([A-Z]{0,})', '1234567ABCDEFG')
m.groups()

('1234567', 'ABCDEFG')

'(#.*$)'匹配注释

s = 'l = [i for i in range(10)]  #生成一个0-9的列表'
m = re.findall('#.*$', s)
m

['#生成一个0-9的列表']

特殊字符类

‘.‘匹配除了换行符(’\n’)之外的所有字符

m = re.findall('.', 'aa\nbb')
m

['a', 'a', 'b', 'b']

'\d’数字，等价于[0-9]

m = re.findall('\d', 'ab12c3')
m

['1', '2', '3']

'\D’非数字,等价于[^0-9]

m = re.findall('\D', 'ab你好12c3')
m

['a', 'b', '你', '好', 'c']

'\s’空白字符(打印出来为空白的字符),等价于[\f\n\r\t\v]

m = re.findall('\s', 'ab \t12c3')
m

[' ', '\t']

'\S’非空白字符,等价于[^\f\n\r\t\v]

m = re.findall('\S', 'ab \t12c3')
m

['a', 'b', '1', '2', 'c', '3']

'\w’数字,字母和下划线（）,等价于[A-Za-z0-9]

m = re.findall('\w', 'ab12c3')
m

['a', 'b', '1', '2', 'c', '3']

'\W’非数字,字母,下划线（）,等价于[^A-Za-z0-9]

m = re.findall('\W', 'ab##$12c3')
m

['#', '#', '$']

'[\u4e00-\u9fa5]'匹配汉字

m = re.findall('[\u4e00-\u9fa5]', 'a你b好c')
m

['你', '好']

'\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b\uff01’匹配中文标点符号

m = re.findall(
    '[\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b\uff01]',
    '。；，：“”（）、？《》！')
m

['。', '；', '，', '：', '“', '”', '（', '）', '、', '？', '《', '》', '！']

正则表达式修饰符（flag参数）

're.I’不区分大小写

m = re.findall('abc', 'abcaBc', re.I)
m

['abc', 'aBc']

‘re.S’使’.'匹配包括换行(\n)在内的所有字符

s = '<div>hello\nworld</div>'
m = re.findall(r'<div>(.*)</div>', s, re.S)
m

['hello\nworld']

're.M’匹配多行,影响匹配开头（^）和匹配结尾（$）

m = re.findall('^abc', 'abc\nabc')  #没加“re.M”就只匹配一行
print(m)
m = re.findall('^abc', 'abc\nabc', re.M)
print(m)

['abc']
['abc', 'abc']

同时使用多个修饰符，通过逻辑或（|）来连接多个修饰符

#匹配换行并且不区分大小写
s = '<diV>hello\nworld</DIV>'
m = re.findall(r'<div>(.*)</div>', s, re.S | re.I)
m

['hello\nworld']

贪婪模式与非贪婪模式

贪婪模式：正则表达式会尽可能的匹配最大长度的字符串
非贪婪模式：正则表达式匹配到一个符合要求的字符串就停止，不往下继续匹配了
默认是贪婪模式，在匹配的量词后面加一个 ? 就可以变为非贪婪模式

#贪婪模式
m = re.findall('a.*c', 'abcbbbc')
m

['abcbbbc']

#非贪婪模式
m = re.findall('a.*?c', 'abcbbbc')
m

['abc']