Virtua1's blog

爬虫&正则表达式

字数统计: 2.1k阅读时长: 8 min
2019/05/14 Share

正则表达式语法

正则表达式只能匹配字符串,不能匹配整个数(如12344),所以只能匹配 0-9 这些字符。

  • \b 元字符,匹配单词的开头或结尾

  • . 元字符,匹配除了换行符以外的任意字符

  • *元字符,匹配前面的子表达式零次或多次

  • \d 元字符,匹配数字,即[0-9]

  • - 匹配它本身 – 连字符

  • \w 元字符,匹配字母、数字、下划线或汉字

  • \s 元字符,匹配任意的空白符

    • ^ 元字符,匹配字符串的开始

    • $ 元字符,匹配字符串的结束

    • 字符转义:如果查找元字符本身的话,需要用\转义

    • 重复:

1.* 匹配前面的子表达式零次或多次,等价与{0,}
2.+ 匹配前面的子表达式一次或多次,等价与{1,}
3.? 匹配前面的子表达式零次或一次,等价于{0,1}
4.{n} 匹配前面的子表达式n次
5.{n,} 匹配前面的子表达式n次或更多次
6.{n,m} 匹配前面的子表达式n到m次,其中n <= m

  • (...) 匹配圆括号中的正则表达式,或指定一个子表达式1.(...){n}指定这个子表达式的重复n次
  • 反义:查找除了这些以外的任意字符的情况

1.\W 匹配任意不是字母、数字、下划线、汉子的字符
2.\S 匹配任意不是空白符的字符
3.\D 匹配任意非数字的字符
4.\B 匹配不是单词开头或结束的位置,

  • 后向引用\序号重复搜索前面某个分组匹配的文本
  • 零宽断言:查找在某些内容(但并不包括这些内容)之前后之后的东西,也就是说它们像\b,^,$那样用于指定一个位置

1.(?=exp) 匹配exp前面的位置
2.(?<=exp) 匹配exp后面的位置
3.(?!exp) 匹配后面跟的不是exp的位置
4.(?<!exp) 匹配前面不是exp的位置

  • 注释:小括号的另一种用途是通过语法(?#comment)来包含注释
  • 贪婪与懒惰

1.当正则表达式中能接受重复的限定符时,通常的行为是(在试整个表达式能得到匹配的前提下)匹配尽可能多的字符,这就是贪婪匹配。
2.如果匹配尽可能少的字符,就称为懒惰匹配,即在给出的限定符后面加上一个问号?
3.*? 重复任意次,但尽可能少重复
4.+? 重复1次或更多次,但尽可能少重复
5.?? 重复0次或1次,但尽可能少重复
6.{n,}? 重复n次或以上,但尽可能少重复

re模块基础用法

python的re模块提供了与 Perl 语言类似的正则表达式匹配操作。

在学习re模块的方法之前先说一下pattern的概念,pattern可以理解为一个匹配模式,通过re.compile方法得到这种模式。

re.compile(pattern, flags=0)

在参数中我们传入了原生字符串对象pattern,通过compile方法编译生成一个pattern对象,然后我们利用这个对象来进行进一步的匹配。

另一个参数 flags,参数的含义是:匹配模式,取值可以使用按位或运算符’|’表示同时生效,比如re.I | re.M

注:以下七个方法中的flags同样是代表匹配模式的意思,如果在pattern生成时已经指明了flags,那么在下面的方法中就不需要传入这个参数了

re.match(pattern, string[, flags])

re.match:将会从string(我们要匹配的字符串)的开头开始,尝试匹配pattern,一直向后匹配,如果遇到无法匹配的字符,立即返回None,如果匹配未结束已经到达string的末尾,也会返回None。两个结果均表示匹配失败,否则匹配pattern成功,同时匹配终止,不再对string向后匹配。

例子:

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'virtua1')
6
 
7
result1 = re.match(pattern,'virtua1')
8
result2 = re.match(pattern,'virtua1web dog')
9
result3 = re.match(pattern,'virtuaweb ')
10
result4 = re.match(pattern,'web dog')
11
 
12
if result1:
13
    print result1.group()
14
else:
15
    print '1匹配失败!'
16
 
17
 
18
if result2:
19
    print result2.group()
20
else:
21
    print '2匹配失败!'
22
 
23
24
if result3:
25
    print result3.group()
26
else:
27
    print '3匹配失败!'
28
29
30
if result4:
31
    print result4.group()
32
else:
33
    print '4匹配失败!'
34
    
35
//virtua1
36
//virtua1
37
//3匹配失败!
38
//4匹配失败!

re.search(pattern, string[, flags])

re.search:search方法与match方法极其类似,区别在于match()函数只检测re是不是在string的开始位置匹配,search()会扫描整个string查找匹配,match()只有在0位置匹配成功的话才有返回,如果不是开始位置匹配成功的话,match()就返回None。同样,search方法的返回对象同match()返回对象的方法和属性

例子:

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'virtua1')
6
result1 = re.match(pattern,'web dogvirtua1')
7
result2 = re.search(pattern,'web dogvirtua1')
8
9
 
10
if result1:
11
    print result1.group()
12
else:
13
    print '1匹配失败!'
14
 
15
 
16
if result2:
17
    print result2.group()
18
else:
19
    print '2匹配失败!'
20
    
21
//1匹配失败!
22
//virtua1

re.split(pattern, string[, maxsplit])

按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数,不指定将全部分割

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'\d+')
6
result = re.split(pattern,'web dogvirtua1')
7
8
if result:
9
    print result
10
else:
11
    print '匹配失败!'
12
//['web dogvirtua', '']

re.findall(pattern, string[, flags])

搜索string,以列表形式返回全部能匹配的子串。

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'\d+')
6
result = re.findall(pattern,'web dogvirtua1')
7
8
if result:
9
    print result
10
else:
11
    print '匹配失败!'
12
//['1']

re.finditer(pattern, string[, flags])

搜索string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'\d+')
6
result = re.finditer(pattern,'we3333b do000gv66ir44t0u78a1')
7
8
if result:
9
	for i in result:
10
		print i.group()
11
else:
12
    print '匹配失败!'
13
//3333
14
//000
15
//66
16
//44
17
/0
18
//78
19
/1

re.sub(pattern, repl, string[, count])

使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时,可以使用\id或\g、\g引用分组,但不能使用编号0。
当repl是一个方法时,这个方法应当只接受一个参数(Match对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。
count用于指定最多替换次数,不指定时全部替换。

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'(\w+) (\w+)')
6
s = 'i say, hello world!'
7
8
print re.findall(pattern,s)
9
print re.sub(pattern,r'\2 \1', s)
10
 
11
def func(m):
12
    return m.group(1).title() + ' ' + m.group(2).title()
13
 
14
print re.sub(pattern,func, s)
15
16
//[('i', 'say'), ('hello', 'world')]
17
//say i, world hello!
18
//I Say, Hello World!

re.subn(pattern, repl, string[, count])

返回 (sub(repl, string[, count]), 替换次数)。

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'(\w+) (\w+)')
6
s = 'i say, hello world!'
7
8
print re.subn(pattern,r'\2 \1', s)
9
 
10
def func(m):
11
    return m.group(1).title() + ' ' + m.group(2).title()
12
 
13
print re.subn(pattern,func, s)
14
//('say i, world hello!', 2)
15
//('I Say, Hello World!', 2)

re模块的另一种用法

上面学习了7个常用的方法,例如match,search等等,不过调用方式都是 re.match,re.search的方式,其实还有另外一种调用方式,可以通过pattern.match,pattern.search调用,这样调用便不用将pattern作为第一个参数传入了。

利用pattern.findall()作为例子:

1
#! /usr/bin/evn python
2
#! coding=utf-8
3
import re
4
 
5
pattern = re.compile(r'(\w+) (\w+)')
6
s = 'i say, hello world!'
7
8
txt = pattern.findall(s)
9
print txt
10
//[('i', 'say'), ('hello', 'world')]

正则表达式对象

re.RegexObjectre.compile()

返回 RegexObject 对象。

re.MatchObject

以上在看re.match()re.search()方法的时侯,说到这两种方法都是返回match对象。
group() 返回被 RE 匹配的字符串。匹配成功后返回match对象。

  • group([group1, …]) 方法用于获得一个或多个分组匹配的字符串,当要获得整个匹配的子串时,可直接使用 group() 或 group(0);

  • start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引),参数默认值为 0;

  • end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引+1),参数默认值为 0;

  • span([group]) 方法返回 (start(group), end(group))。

  • start() 返回匹配开始的位置

  • end() 返回匹配结束的位置

  • span() 返回一个元组包含匹配 (开始,结束) 的位置

CATALOG
  1. 1. 正则表达式语法
  2. 2. re模块基础用法
    1. 2.1. re.compile(pattern, flags=0)
    2. 2.2. re.match(pattern, string[, flags])
    3. 2.3. re.search(pattern, string[, flags])
    4. 2.4. re.split(pattern, string[, maxsplit])
    5. 2.5. re.findall(pattern, string[, flags])
    6. 2.6. re.finditer(pattern, string[, flags])
    7. 2.7. re.sub(pattern, repl, string[, count])
    8. 2.8. re.subn(pattern, repl, string[, count])
  3. 3. re模块的另一种用法
  4. 4. 正则表达式对象
    1. 4.1. re.RegexObjectre.compile()
    2. 4.2. re.MatchObject