㈠ 在python中如何匹配一个存在多个相同的正则表达式模式的字符串中的所有正则表达式模式
你的正则表达式使用了贪婪模式的匹配(.*),应该用非贪婪模式,正则表达式应该为<a href="/(.*?)-desktop-wallpapers.html
完整的python语言程序如下
#!/usr/bin/python3 import re a = '<html><body><p>[<a href="/aero-desktop-wallpapers.html" title="Aero HD Wallpapers">Aero</a>, <a href="/animals-desktop-wallpapers.html" title="Animals HD Wallpapers">Animals</a>, <a href="/architecture-desktop-wallpapers.html" title="Architecture HD Wallpapers">Architecture</a>,Wallpapers">Artistic</a>, ........(省略)......... <a href="/vintage-desktop-wallpapers.html" title="Vintage HD Wallpapers">Vintage</a>]</p></body></html>'titles = re.findall('<a href="/(.*?)-desktop-wallpapers.html',str(a))print (titles) 运行结果['aero', 'animals', 'architecture', 'vintage']
㈡ python 正则表达式 断言解释
>>>re.findall(r'(?<=ab).*?(?=d)',s)#非贪婪模式，先找左边有ab，再开始0个字符，
#查看是否右边有d，不满足再向后获取一个字符，直到满足右边有字符d；
#剩余字符串dddd再开始查找ab，搜索到字符串结尾，未找到，退出
['c']
>>>re.findall(r'(?<=ab).*(?=d)',s)#贪婪模式，先找到ab，
#再匹配后面所有字符，查看后面有没有d，如果不满足再抛出右面一个字符
#倒退查找后面有没有d，直到找到；剩余字符串d中继续查找ab，不能找到，退出
['cddd']
>>>re.findall(r'(?<=ab).*?',s)#左边有ab，非贪婪模式【先找到ab，后面0个字符，
#满足整个匹配；从剩余的dddd中再次查找，没找到ab，退出】
['']
>>>re.findall(r'(?<=ab).*',s)##左边有ab，贪婪模式【找到ab，匹配后面整个
#字符串，满足条件；没有剩余字符串，退出】
['cdddd']
>>>re.findall(r'.*(?=d)',s)#先是贪婪模式匹配所有字符，依次倒退找右边是d的
#下次查找位置在本次位置的后面开始，即剩余一个d字符串中找，能够匹配，但匹配的是空串
['aabcddd','']
>>>re.findall(r'.*?(?=d)',s)#从0个字符串开始，判断后面有没有d，如果没有向右
#取得一个字符继续判断，直到找到d{故第一次aabc}；下一次从剩余的dddd找，仍然是从0个字符
#判断，后面有d，返回空串；下次从剩余的ddd中……故四个空串
['aabc','','','','']
>>>re.findall(r'(d)',s)#单个字符的捕获，有几个d返回共多少个元素的列表
['d','d','d','d']
㈢ python正则表达式指定开始匹配的敌方
一. 简介
正则表达式又叫规则表达式，是处理字符串的强大工具。在python中通过调用re模块，可以实现正则匹配，正则表达式模式被编译成一系列的字节码，然后由C编写的匹配引擎执行
二. python常用字符含义(匹配模式)
1186367-20180604115644788-1913251705.png
三. re模块
1. re.match(pattern, string, flags=0) | match(string, [pos, endpos]) (这个用于编译后返回的正则表达式对象Pattern.match())
1)作用：尝试从字符串的起始位置匹配一个模式，如果起始位置匹配成功，返回一个match对象，否则返回None
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等
2) 正则表达式可以包含一些可选标志修饰符来控制匹配模式。修饰符被指定为一个可选的标志，多个修饰符可以通过 | 来指定，如re.I | re.M表示对大小写不敏感和多行匹配物卜空
1186367-20180604123302464-360465156.png
3) 实例
importreprint(re.match('www', 'www.runoob.com').span()) #在起始位置匹配
print(re.match('com', 'www.runoob.com')) #不在起始位置匹配
运行结果为：
(0, 3)
None
为什么第一个起始位置匹配要加span()?
span()的作用是：返回一个元组包含匹配 (开始,结束) 的位置，如果不加span(),我们获得的只是一个match obj，只有加了span()，我们才能获得匹配罩瞎对象的位置。不信请看：
#在命令行输出
print(re.match('www', 'www.runoob.com'))<_sre.SRE_Match object; span=(0, 3), match='www'>
print(re.match('com', 'www.runoob.com'))
None
为什么第二个非起始位置匹配不加span()?
不在起始位置匹配，默认返回的None，而None对象是没有span()方法的，这时候就会报错：
importreprint(re.match('com', 'www.runoob.com').span())
Traceback (most recent call last):
File"", line 1, in
print(re.match('com', 'www.runoob.com').span())
AttributeError: 'NoneType' object has no attribute 'span'
2. re.search(pattern, string, flags=0) | search(string, [pos, endpos])(这个用于编译后返回的正则表达式对象Pattern.search())
1) 作用：在字符串内查找匹配模式，只要找到第一个匹配则返回一个match对象，如果没有找到，则返回None
importre#不加span()返回一个match对象
print(re.search('www', 'www.runoob.com'))<_sre.SRE_Match object; span=(0, 3), match='www'>
print(re.search('www', 'www.runoob.com').span())
(0,3)print(re.search('com', 'www.runoob.com').span())
(11, 14)
3. re.match和re.search一旦匹配成功，就会返回一个match object对象，而match object对象有以下方法：
group(num) num代表组号，表示匹配第num组的字符串，不写时默认是0，表示匹配整个表达式的字符串。group()也可以一次输入多弊悄个组号，如group(1, 2, 3)，这种情况下它将返回一个包含那些组所对应的元组
groups() 返回一个包含所有小组字符串的元组，从1到所含的小组号
span() 返回一个元组包含匹配(开始、结束)的位置
start() 返回匹配开始的位置
end() 返回匹配结束的位置
1) 实例
importre
line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*?) .*', line, re.M|re.I)print(searchObj.group())
Cats are smarter than dogsprint(searchObj.group(0))
Cats are smarter than dogsprint(searchObj.group(1))
Catsprint(searchObj.group(2))
smarterprint(searchObj.group(1, 2))
('Cats', 'smarter')
print(searchObj.groups())
('Cats', 'smarter')
为什么第二组匹配是 (.*?) 而不是 (.*)
我们做个试验，尝试一下 (.*)
importre
line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*) .*', line, re.M|re.I)print(searchObj.group())
Cats are smarter than dogsprint(searchObj.group(1))
Catsprint(searchObj.group(2))
smarter thanprint(searchObj.group(1, 2))
('Cats', 'smarter than')
注意到group(2)的数据是不同的，这个是为什么呢？这就涉及到贪婪匹配和非贪婪匹配
贪婪匹配： 在整个表达式匹配成功的情况下，尽可能多的匹配。比如上面的 .*
.表示除换行之外的所有字符， *表示匹配前面的字符0次或无数次
非贪婪匹配：在整个表达式匹配成功的情况下，尽可能少的匹配。比图上面的 .*?
?表示匹配前面字符0次或1次
注意前面 are () .* 中，()前后是两个空格，而are之后两个空格之间有两种情况，1. "smarter than"， 2. "smarter"，具体选择哪种是由匹配模式决定的，当()里是贪婪匹配时，.*可以匹配smarter，可以匹配空格，可以匹配than，当()里是非贪婪模式时， .*?只会匹配smarter，因为它最多匹配一次
为什么要用前缀 r 呢？
我们知道在python中, \ 表示转义字符，如果需要匹配一个 \ 本身呢？我们就要用\\， 而分别对每个 \ 进行转义，就需要用 \\\\
注意：如果字符串中有字符*需要匹配，可以使用\*或字符集[*]
4. re.compile(pattern, [flags])
1) 作用：用于编译正则表达式，生成一个正则表达式对象(Pattern，这个Pattern不能直接实例化，必须由re.compile()进行构造)，供match()和search()这两个函数使用
pattern：一个字符串形式的正则表达式
flags：编译标志位，用于控制正则表达式的匹配方式，如：是否区分大小写、多行匹配等
2) 实例1
importre#用于匹配至少一个数字
pattern = re.compile(r'\d+')#从开始位置匹配
m = pattern.match('one12twothree34four')#没有匹配，返回None
print(m)
None#从"1"的位置开始匹配
m = pattern.match('one12twothree34four', 3, 10)#正好匹配返回一个match对象
print(m)<_sre.SRE_Match object; span=(3, 5), match='12'>
print(m.group())12
print(m.start())3
print(m.end())5
print(m.span())
(3, 5)
实例2
importre#re.I表示忽略大小写
pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)
m= pattern.match('Hello World Wide Web')#匹配成功返回一个match对象
print(m)<_sre.SRE_Match object; span=(0, 11), match='Hello World'>
#返回匹配成功的整个子串
print(m.group(0))
Hello World#返回匹配成功的整个子串的索引
print(m.span(0))
(0,11)#返回第一个分组匹配成功的子串
print(m.group(1))
Hello#返回第一个分组匹配成功的子串的索引
print(m.span(1))
(0,5)#返回第二个分组匹配成功的子串
print(m.group(2))
World#返回第二个分组匹配成功的子串的索引
print(m.span(2))
(6, 11)#等价于(m.group(1), m.group(2), ...)
print(m.groups())
('Hello', 'World')#不存在第三个分组
print(m.group(3))
Traceback (most recent call last):
File"", line 1, in
print(m.group(3))
IndexError: no such group
5. re.findall(pattern, string, flags=0) | findall(string, [pos, endpos])
1) 作用：遍历匹配，以列表形式返回所有能匹配的子串，如果没找到匹配的，则返回空列表
string：待匹配的字符串
pos：可选参数，指定字符串的起始位置，默认为0
endpos：可选参数，指定字符串的结束位置，默认为字符串的长度
2) 实例
importre#查找数字
pattern = re.compile(r'\d+')
result1= pattern.findall('runoob 123 google 456')print(result1)
['123', '456']
result2= pattern.findall('run88oob123google456', 0, 10)print(result2)
['88', '12']
6. re.finditer(pattern, string, flags=0) | finditer(string, [pos, endpos])
1) 作用：搜索string，返回一个顺序访问每一个匹配结果(match对象)的迭代器。找到匹配的所有子串，并把它们作为一个迭代器返回。
2) 实例
importre
pattern= re.compile(r'\d+')print(pattern.finditer('one1two2three3four4'))
for m in pattern.finditer('one1two2three3four4'):print(m)print(m.group())<_sre.SRE_Match object; span=(3, 4), match='1'>
1
<_sre.SRE_Match object; span=(7, 8), match='2'>
2
<_sre.SRE_Match object; span=(13, 14), match='3'>
3
<_sre.SRE_Match object; span=(18, 19), match='4'>
4
7. re.split(pattern, string, [maxsplit=0, flags=0]) | split(string, [maxsplit])
1) 作用：按照能够匹配的子串将字符串分割后返回列表
pattern：匹配的正则表达式
string：要匹配的字符串
maxsplit：分割次数，maxsplit=1 分割一次，默认为0，不限制次数
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写、多行匹配等
2) 实例1
importre
pattern= re.compile(r'\d+')print(pattern.split('one1two2three3four4'))
['one', 'two', 'three', 'four', ''] #注意后面没有内容，是一个''字符
实例2
importre#匹配\W+表示非单词字符一次或无数次
pattern = re.compile(r'\W+')#用非单词字符分割
print(pattern.split('hello, world'))
['hello', 'world']
使用带括号的正则表达式则可以将正则表达式匹配的内容也添加到列表内
importre#带括号的正则表达式则可以将正则表达式匹配的内容也添加到列表内
pattern = re.compile(r'(\W+)')print(pattern.split('hello, world'))
['hello', ', ', 'world']
㈣ python 正则表达式 （.*）
groups()返回所有捕获组构成的tuple。你的正则表达式中有唯一一个捕获组(.*?)，而?在此处表示非贪婪匹配，即在整个正则表达式成立的前提下匹配尽可能少的字符，此处最少的情况是什么也不匹配，整个正则表达式匹配Python中的Py，而捕获组自然为空字符串。
㈤ python里面什么是贪婪
Python里面的贪婪算法（又称贪心算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，/不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪心算法不是搏孙对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
基本思路
贪心算法的基本思路是从问题的某一个初始解出发一步一步地进行，根据某个优化测度，每一步都要确保能获得局部最优解。每一步只考虑一个数据，他的选取应该满足局部优化的条件。若下一个数据和部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，直到把所有数据枚举完，或者不能再添加算法停止 。贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
基本思路
贪心算法的基本思路是从问题的某一个初始解出发一步一步地进行，根据某个优化测度，每一步都要确保能获得局部最优解。每一步只考虑一个数据，他的选取应该满足局部优化的条件。若下一个数据和部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，直到把所有数据枚举完，或者不能再添加算法停止 。贪心算法弯银镇（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
基本思路
贪心算法的基本思路埋粗是从问题的某一个初始解出发一步一步地进行，根据某个优化测度，每一步都要确保能获得局部最优解。每一步只考虑一个数据，他的选取应该满足局部优化的条件。若下一个数据和部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，直到把所有数据枚举完，或者不能再添加算法停止 。
㈥ python 正则表达式.* 是什么意思 详细解释
分开来说：
1、. 匹配任意除换行符“\n”外的字符；
2、*表示匹配前一个字符0次或无限次；
3、+或*后跟？表示非贪婪匹配，即尽可能少的匹配，如*？重复任意次，但尽可能少重复；
4、 .*? 表示匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。
如：a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab和ab。
㈦ Python 正则表达式（完整版）
注意点：
以上量词都是贪婪模式，会尽可能多的匹配，如果要改为非贪婪模式，通过在量词后面跟随一个 ? 来实现
断言不会匹配任何文本，只是对断言所在的文本施加某些约束
前瞻 ： exp1(?=exp2) exp1 后面的内容要匹配exp2
负前瞻 : exp1(?!exp2) exp1 后面的内容不能匹配exp2
后顾: (?<=exp2)exp1 exp1 前面的内容要匹配exp2
负后顾 : (?<!exp2)exp1 exp1 前面的内容不能匹配exp2
例如：我们要查找hello，但是hello后面必须是world，正则表达式可以这样写： "(hello)s+(?=world)" ,用来匹配 "hello wangxing" 和 "hello world" 只能匹配到后者的hello
(?(id)yes_exp|no_exp) ：对应id的子表达式如果匹配到内容，则这里匹配yes_exp，否则匹配no_exp
㈧ Python中正则表达式的匹配规则总结
其他关于Python的总结文章请访问： https://www.jianshu.com/nb/47435944
正则表达式用来匹配字符串，在python中可以使用 re 模块来完成，本篇做一个对正则表达式的匹配规则的总结
在上述的精确匹配后可以跟上一些符号来进行模糊的匹配：
可以使用中括号的形式进行范围匹配，中括号表达式后边可以跟上上述模糊匹配的符号来表示数量
多个条件可以 紧跟着写在同一个中括号中 ，比如：
[a-zA-Z] ：匹配一个大、小写字母