(1)re.match() 能够匹配出以xxx开头的字符串
import re
result = re.match('taobao','taobao.com')
print(result.group())
'taobao'
(2) python常用字符
几个简单测试:
全都可以匹配出来
import re
ret = re.match(".","a")
ret.group()
ret = re.match(".","b")
ret.group()
ret = re.match(".","M")
ret.group()
只能匹配一个:
import re
ret = re.match('.','abc')
print(ret.group())
不能匹配出来:
import re
ret = re.match('.','\nabc')
print(ret.group())
(3)匹配中文字符
匹配中文字符的正则表达式: [\u4e00-\u9fa5]
ret = re.match('[\u4e00-\u9fa5]+','为什么出不来')
print(ret.group())
(4)大小写区分
# 如果hello的首字符小写,那么正则表达式需要小写的h
ret = re.match("h","hello Python")
ret.group()
# 如果hello的首字符大写,那么正则表达式需要大写的H
ret = re.match("H","Hello Python")
ret.group()
# 大小写h都可以的情况
ret = re.match("[hH]","hello Python")
ret.group()
ret = re.match("[hH]","Hello Python")
ret.group()
(5)匹配0到9
# 匹配0到9第一种写法
ret = re.match("[0123456789]","7Hello Python")
ret.group()
# 匹配0到9第二种写法
ret = re.match("[0-9]","7Hello Python")
ret.group()
(6)原始字符
Python中字符串前面加上 r 表示原生字符串
(7)表示数量
(8)需求:匹配出,变量名是否有效
import re
ret = re.match("[a-zA-Z_]+[\w_]*","name1")
ret.group()
ret = re.match("[a-zA-Z_]+[\w_]*","_name")
ret.group()
ret = re.match("[a-zA-Z_]+[\w_]*","2_name")
ret.group()
(9)匹配出,0到99之间的数字
import re
ret = re.match("[1-9]?[0-9]","7")
ret.group()
ret = re.match("[1-9]?[0-9]","33")
ret.group()
ret = re.match("[1-9]?[0-9]","09")
ret.group()
(10) 表示边境
(11)匹配分组
(12)匹配出163、126、qq邮箱之间的数字
ret = re.match("\w{4,20}@163\.com", "[email protected]")
print(ret.group())
(13) 匹配HTML
ret = re.match("<[a-zA-Z]*>\w*</[a-zA-Z]*>", "<html>hh</html>")
print(ret.group())
(14)匹配出<html><h1>www.taobao.com</h1></html>
# 第一个可以
ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", "<html><h1>www.taobao.com</h1></html>")
print(ret.group())
# 第二个不可以
ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", "<html><h1>www.taobao.com</h2></html>")
print(ret.group())
re的高级用法
一 ,compile函数
compile 函数用于编译正则表达式,生成一个 Pattern 对象
import re
# 将正则表达式编译成 Pattern 对象
pattern = re.compile(r'\d+')
Pattern 对象的一些常用方法主要有:
- match 方法:从起始位置开始查找,一次匹配
- search 方法:从任何位置开始查找,一次匹配
- findall 方法:全部匹配,返回列表
- finditer 方法:全部匹配,返回迭代器
- split 方法:分割字符串,返回列表
- sub 方法:替换
二,match 函数
match 方法用于查找字符串的头部(也可以指定起始位置),它是一次匹配,只要找到了一个匹配的结果就返回,而不是查找所有匹配的结果。它的一般使用形式如下:
match(string[, pos[, endpos]])
其中,string 是待匹配的字符串,pos 和 endpos 是可选参数,指定字符串的起始和终点位置,默认值分别是 0 和 len (字符串长度)。因此,当你不指定 pos 和 endpos 时,match 方法默认匹配字符串的头部。
当匹配成功时,返回一个 Match 对象,如果没有匹配上,则返回 None。
group([group1, …]) 方法用于获得一个或多个分组匹配的字符串,当要获得整个匹配的子串时,可直接使用 group() 或 group(0);
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引),参数默认值为 0;
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引+1),参数默认值为 0;
span([group]) 方法返回 (start(group), end(group))。
三,sarch
search 方法用于查找字符串的任何位置,它也是一次匹配,只要找到了一个匹配的结果就返回,而不是查找所有匹配的结果,它的一般使用形式如下:
search(string[, pos[, endpos]])
其中,string 是待匹配的字符串,pos 和 endpos 是可选参数,指定字符串的起始和终点位置,默认值分别是 0 和 len (字符串长度)。
当匹配成功时,返回一个 Match 对象,如果没有匹配上,则返回 None。
示例:
pattern = re.compile('\d+')
m = pattern.search('one12twothree34four')
print(m)
# 这里如果使用 match 方法则不匹配
四, findall
上面的 match 和 search 方法都是一次匹配,只要找到了一个匹配的结果就返回。然而,在大多数时候,我们需要搜索整个字符串,获得所有匹配的结果。
findall 方法的使用形式如下:
findall(string[, pos[, endpos]])
其中,string 是待匹配的字符串,pos 和 endpos 是可选参数,指定字符串的起始和终点位置,默认值分别是 0 和 len (字符串长度)。
findall 以列表形式返回全部能匹配的子串,如果没有匹配,则返回一个空列表。
示例:
import re
pattern = re.compile(r'\d+') # 查找数字
result1 = pattern.findall('hello 123456 789')
result2 = pattern.findall('one1two2three3four4', 0, 10)
print(result1)
print(result2)
import re
#re模块提供一个方法叫compile模块,提供我们输入一个匹配的规则
#然后返回一个pattern实例,我们根据这个规则去匹配字符串
pattern = re.compile(r'\d+\.\d*')
#通过partten.findall()方法就能够全部匹配到我们得到的字符串
result = pattern.findall("123.141593, 'bigcat', 232312, 3.15")
#findall 以 列表形式 返回全部能匹配的子串给result
for item in result:
print(item)
import re
ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)
'['9999', '7890', '12345']'
五, finditer
inditer 方法的行为跟 findall 的行为类似,也是搜索整个字符串,获得所有匹配的结果。但它返回一个顺序访问每一个匹配结果(Match 对象)的迭代器。
示例:
import re
pattern = re.compile(r'\d+')
result_iter1 = pattern.finditer('hello 123456 789')
result_iter2 = pattern.finditer('one1two2three3four4', 0, 10)
print(type(result_iter1))
print(type(result_iter2))
print('result1...')
for m1 in result_iter1: # m1 是 Match 对象
print('matching string: {}, position: {}'.format(m1.group(), m1.span()))
print('result2...')
for m2 in result_iter2:
print('matching string: {}, position: {}'.format(m2.group(), m2.span()))
结果如下:
<class 'callable_iterator'>
<class 'callable_iterator'>
result1...
matching string: 123456, position: (6, 12)
matching string: 789, position: (13, 16)
result2...
matching string: 1, position: (3, 4)
matching string: 2, position: (7, 8)
六:sub (替换后面爬虫比较常用)
sub 方法用于替换。它的使用形式如下:
sub(repl, string[, count])
其中,repl 可以是字符串也可以是一个函数:
- 如果 repl 是字符串,则会使用 repl 去替换字符串每一个匹配的子串,并返回替换后的字符串,另外,repl 还可以使用 id 的形式来引用分组,但不能使用编号 0;
- 如果 repl 是函数,这个方法应当只接受一个参数(Match 对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。
- count 用于指定最多替换次数,不指定时全部替换。
示例:
import re
p = re.compile(r'(\w+) (\w+)') # \w = [A-Za-z0-9]
s = 'hello 123, hello 456'
print(p.sub('hello world', s))
print(p.sub(r'\2 \1', s))
def func(m):
return 'hi' + ' ' + m.group(2)
print(p.sub(func, s))
print(p.sub(func, s, 1))
第二个示例:
# # 需求:将匹配到的阅读次数加1
# # 方法1:
import re
ret = re.sub(r"\d+", '998', "python = 997")
print(ret)
# 方法2:
import re
def add(temp):
strNum = temp.group()
num = int(strNum) + 1
return str(num)
ret = re.sub(r"\d+", add, "python = 997 java=100")
print(ret)
ret = re.sub(r"\d+", add, "python = 99")
print(ret)
七 split
split 方法按照能够匹配的子串将字符串分割后返回列表,它的使用形式如下:
split(string[, maxsplit])
其中,maxsplit 用于指定最大分割次数,不指定将全部分割。
示例:
import re
p = re.compile(r'[\s\,\;]+')
print(p.split('a,b;; c d'))
八 贪婪和非贪婪
Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;
非贪婪则相反,总是尝试匹配尽可能少的字符。
在"*","?","+","{m,n}"后面加上?,使贪婪变成非贪婪。
>>> s="This is a number 234-235-22-423"
>>> re.match(".+(\d+-\d+-\d+-\d+)",s)
>>> re.match(".+?(\d+-\d+-\d+-\d+?)",s)
正则表达式模式中使用到通配字,那它在从左到右的顺序求值时,会尽量“抓取”满足匹配最长字符串,在我们上面的例子里面,“.+”会从字符串的启始处抓取满足模式的最长字符,其中包括我们想得到的第一个整型字段的中的大部分,“\d+”只需一位字符就可以匹配,所以它匹配了数字“4”,而“.+”则匹配了从字符串起始到这个第一位数字4之前的所有字符。
解决方式:非贪婪操作符“?”,这个操作符可以用在"*","+","?"的后面,要求正则匹配的越少越好。