python 正则findall,Python中的正则表达式？

python 正则findall,Python中的正则表达式？详细介绍

本文目录一览： python中的正则表达式中的

你要的代码：
import re
emailStr = "abc123@163.com xxx 456def@qq.com yyy 789ghi@gmail.com"
allEmailList = re.findall("([a-zA-Z0-9]+@(?:163|qq|gmail)\.com)", emailStr) # ['abc123@163.com', '456def@qq.com', '789ghi@gmail.com']
print(allEmailList)
中间过程的代码：
# allEmailList = re.findall("[a-zA-Z0-9]@(163|qq|gmail)\.com", emailStr) # ['163', 'qq', 'gmail']
# allEmailList = re.findall("([a-zA-Z0-9]+@(163|qq|gmail)\.com)", emailStr) # [('abc123@163.com', '163'), ('456def@qq.com', 'qq'), ('789ghi@gmail.com', 'gmail')]
# allEmailList = re.finditer("([a-zA-Z0-9]+@(163|qq|gmail)\.com)", emailStr) #

附录：

(?:163|qq) 可以这样写，则只匹配而不产生分组

Python中re.findall()函数是要求正则表达式在捕获第0组数据时,要在正则表达式上加小括号才能捕获.

也就是说如果你要获取整个正则表达式匹配的数据(你这里是电子邮箱地址),需要在正则表达式外面加小括号,

然后取第0捕获组的数据(你这里是[x[0] for x in zhengze]),

因为findall函数把每一个匹配的多个捕获组(就是你正则表达式中的小括号中)的数据放到一个元组里,所以要用for循环把第0捕获组的数据取出来.

具体程序改进如下

>>>zhengze=re.findall("([A-Za-z0-9]+@(163|qq|gmail)\.com)",txt)>>>[x[0] for x in zhengze]结果就是你要的邮箱列表了.

python正则表达式findall的匹配问题

python的正则中用（）会进行匹配，所以返回结果是['','']，就是两个（）中的匹配。要想达到原来的匹配效果，就是把4匹配出来，有两种解决方法：
1.最外层加个大括号，变成：m = re.findall('(([0-9])*4([0-9])*)',
'[4]')，返回结果的第一个元素就是匹配结果了。
2.去除（）的匹配结果返回，在括号前面加入?:，变成m =
re.findall('(?:\d)*4(?:\d)*', '[4]')，返回结果就是要匹配的结果了。

Python常用的正则表达式处理函数详解

正则表达式是一个特殊的字符序列，用于简洁表达一组字符串特征，检查一个字符串是否与某种模式匹配，使用起来十分方便。
在Python中，我们通过调用re库来使用re模块：
import re
下面介绍Python常用的正则表达式处理函数。
re.match函数
re.match 函数从字符串的起始位置匹配正则表达式，返回match对象，如果不是起始位置匹配成功的话，match()就返回None。
re.match(pattern, string, flags=0)
pattern：匹配的正则表达式。
string：待匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。具体参数为：
re.I：忽略大小写。
re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境。
re.M：多行模式。
re.S：即 . ，并且包括换行符在内的任意字符（. 不包括换行符）。
re.U：表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库。
re.X：为了增加可读性，忽略空格和 # 后面的注释。
import?re #从起始位置匹配 r1=re.match('abc','abcdefghi') print(r1) #不从起始位置匹配 r2=re.match('def','abcdefghi') print(r2) 运行结果：

其中，span表示匹配成功的整个子串的索引。
使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num)：匹配的整个表达式的字符串，group() 可以一次输入多个组号，这时它将返回一个包含那些组所对应值的元组。
groups()：返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
import?re s='This?is?a?demo' r1=re.match(r'(.*)?is?(.*)',s) r2=re.match(r'(.*)?is?(.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups()) 运行结果：

上述代码中的(.*)和(.*?)表示正则表达式的贪婪匹配与非贪婪匹配。
re.search函数
re.search函数扫描整个字符串并返回第一个成功的匹配，如果匹配成功则返回match对象，否则返回None。
re.search(pattern, string, flags=0)
pattern：匹配的正则表达式。
string：待匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
import?re #从起始位置匹配 r1=re.search('abc','abcdefghi') print(r1) #不从起始位置匹配 r2=re.search('def','abcdefghi') print(r2) 运行结果：

使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num=0)：匹配的整个表达式的字符串，group() 可以一次输入多个组号，这时它将返回一个包含那些组所对应值的元组。
groups()：返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
import?re s='This?is?a?demo' r1=re.search(r'(.*)?is?(.*)',s) r2=re.search(r'(.*)?is?(.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups()) 运行结果：

从上面不难发现re.match与re.search的区别：re.match只匹配字符串的起始位置，只要起始位置不符合正则表达式就匹配失败，而re.search是匹配整个字符串，直到找到一个匹配为止。
re.compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式对象，供 match() 和 search() 这两个函数使用。
re.compile(pattern[, flags])
pattern：一个字符串形式的正则表达式。
flags：可选，表示匹配模式，比如忽略大小写，多行模式等。
import?re #匹配数字 r=re.compile(r'\d+')? r1=r.match('This?is?a?demo') r2=r.match('This?is?111?and?That?is?222',0,27) r3=r.match('This?is?111?and?That?is?222',8,27) ? print(r1) print(r2) print(r3) 运行结果：

findall函数
搜索字符串，以列表形式返回正则表达式匹配的所有子串，如果没有找到匹配的，则返回空列表。
需要注意的是，match 和 search 是匹配一次，而findall 匹配所有。
findall(string[, pos[, endpos]])
string：待匹配的字符串。
pos：可选参数，指定字符串的起始位置，默认为0。
endpos：可选参数，指定字符串的结束位置，默认为字符串的长度。
import?re #匹配数字 r=re.compile(r'\d+')? r1=r.findall('This?is?a?demo') r2=r.findall('This?is?111?and?That?is?222',0,11) r3=r.findall('This?is?111?and?That?is?222',0,27) ? print(r1) print(r2) print(r3) 运行结果：

re.finditer函数
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
pattern：匹配的正则表达式。
string：待匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等。
import?re? r=re.finditer(r'\d+','This?is?111?and?That?is?222') for?i?in?r:? ?print?(i.group()) 运行结果：

re.split函数
将一个字符串按照正则表达式匹配的子串进行分割后，以列表形式返回。
re.split(pattern, string[, maxsplit=0, flags=0])
pattern：匹配的正则表达式。
string：待匹配的字符串。
maxsplit：分割次数，maxsplit=1分割一次，默认为0，不限次数。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等。
import?re? r1=re.split('\W+','This?is?111?and?That?is?222')? r2=re.split('\W+','This?is?111?and?That?is?222',maxsplit=1)? r3=re.split('\d+','This?is?111?and?That?is?222')? r4=re.split('\d+','This?is?111?and?That?is?222',maxsplit=1)? print(r1) print(r2) print(r3) print(r4) 运行结果：

re.sub函数
re.sub函数用于替换字符串中的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)
pattern：正则中的模式字符串。
repl：替换的字符串，也可为一个函数。
string：要被查找替换的原始字符串。
count：模式匹配后替换的最大次数，默认0表示替换所有的匹配。
import?re? r='This?is?111?and?That?is?222' #?删除字符串中的数字 r1=re.sub(r'\d+','',r) print(r1) #?删除非数字的字符串? r2=re.sub(r'\D','',r) print(r2) 运行结果：

到此这篇关于Python常用的正则表达式处理函数详解的文章就介绍到这了，希望大家以后多多支持！

Python中的正则表达式？

因为正则表达式中有两组小括号，即两个分组
findall会以元组形式返回所有分组中的内容，即[('127.0.0.1', '.1')]
其中'127.0.01'表示匹配最外层大括号的内容
'.1'表示匹配'\.[0-9]{1,3}'的内容（最后一次重复时为.1）
由于('\.[0-9]{1,3}')为需要重复三次的分组，该括号不能省略
而使用findall就一定会显示括号分组的内容
若想只显示127.0.0.1而不显示'.1'，可考虑使用match方法
返回从字符串起始位置开始，第一次匹配正则表达式的内容
match返回的结果为re.Match对象，可通过group()显示匹配的字符串，即127.0.0.1
通过groups()显示匹配的所有分组，即('127.0.0.1', '.1')
如图所示：

python正则表达式如何匹配字符串

python正则表达式匹配字符串的方法：1、使用【(.+?)】这个正则表达式来提取单个位置的字符串；2、使用【(?P?)】这个正则表达式【匹配连续多个位置的字符串。相关免费学习推荐：python视频教程python正则表达式匹配字符串的方法：一、单个位置的字符串提取这种情况我们可以使用(.+?)这个正则表达式来提取。 举例，一个字符串"a123b",如果我们想提取ab之间的值123，可以使用findall配合正则表达式，这样会返回一个包含所以符合情况的list。代码如下：import restr = "a123b"print re.findall(r"a(.+?)b",str)#输出['123']1.1贪婪和非贪婪匹配如果我们有一个字符串”a123b456b”，如果我们想匹配a和最后一个b之间的所有值而非a和第一个出现的b之间的值，可以用?来控制正则贪婪和非贪婪匹配的情况。代码如下：import restr = "a123b456b" print re.findall(r"a(.+?)b", str)#输出['123']#?控制只匹配0或1个,所以只会输出和最近的b之间的匹配情况 print re.findall(r"a(.+)b", str)#输出['123b456'] print re.findall(r"a(.*)b", str)#输出['123b456']1.2多行匹配如果你要多行匹配，那么需要加上re.S和re.M标志. 加上re.S后。将会匹配换行符，默认.不会匹配换行符。代码如下：str = "a23ba34b" re.findall(r"a(d+)b.+a(d+)b", str)#输出[]#因为不能处理str中间有换行的情况 re.findall(r"a(d+)b.+a(d+)b", str, re.S)#s输出[('23', '34')]加上re.M后,^$标志将会匹配每一行，默认^和$只会匹配第一行。代码如下：str = "a23ba34b" re.findall(r"^a(d+)b", str)#输出['23'] re.findall(r"^a(d+)b", str, re.M)#输出['23', '34']二、连续多个位置的字符串提取这种情况我们可以使用(?P

?)这个正则表达式来提取。举例，如果我们有一行webserver的access日志:'192.168.0.1 25/Oct/2012:14:46:34 "GET /api HTTP/1.1" 200 44 "http://abc.com/search" "Mozilla/5.0"'，我们想提取这行日志里面所有的内容，可以写多个(?P

expr)来提取,其中name可以更改为你为该位置字符串命名的变量，expr改成提取位置的正则即可。代码如下：import reline ='192.168.0.1 25/Oct/2012:14:46:34 "GET /api HTTP/1.1" 200 44 "http://abc.com/search""Mozilla/5.0"'reg = re.compile('^(?P

[^ ]*) (?P

[^ ]*) "(?P

[^"]*)" (?P

[^ ]*) (?P

[^ ]*) "(?P

[^"]*)" "(?P

[^"]*)"')regMatch = reg.match(line)linebits = regMatch.groupdict()print linebitsfor k, v in linebits.items() : print k+": "+v输出的结果为：status: 200referrer: request: GET /api HTTP/1.1user_agent: Mozilla/5.0date: 25/Oct/2012:14:46:34size: 44remote_ip: 192.168.0.1

python 正则表达式，怎样匹配以某个字符串开头，以某个字符串结尾的情况？

匹配以某个字符串开头，以某个字符串结尾的情况的正则表达式:^abc.*?qwe$
Python正则表达式的几种匹配用法：
1.测试正则表达式是否匹配字符串的全部或部分
regex=ur"" #正则表达式if re.search(regex, subject):do_something()else:do_anotherthing()
2.测试正则表达式是否匹配整个字符串
regex=ur"/Z" #正则表达式末尾以/Z结束if re.match(regex, subject):do_something()else:do_anotherthing()
3.创建一个匹配对象，然后通过该对象获得匹配细节(Create an object with details about how the regex matches (part of) a string)
regex=ur"" #正则表达式match = re.search(regex, subject)if match:# match start: match.start()# match end (exclusive): atch.end()# matched text: match.group()do_something()else:do_anotherthing()
4.获取正则表达式所匹配的子串(Get the part of a string matched by the regex)
regex=ur"" #正则表达式match = re.search(regex, subject)if match:result = match.group()else:result = ""
5. 获取捕获组所匹配的子串(Get the part of a string matched by a capturing group)
regex=ur"" #正则表达式match = re.search(regex, subject)if match:result = match.group(1)else:result = ""
6. 获取有名组所匹配的子串(Get the part of a string matched by a named group)
regex=ur"" #正则表达式match = re.search(regex, subject)if match:result = match.group"groupname")else:result = ""
7. 将字符串中所有匹配的子串放入数组中(Get an array of all regex matches in a string)
result = re.findall(regex, subject)
8.遍历所有匹配的子串(Iterate over all matches in a string)
for match in re.finditer(r"<(.*?)/s*.*?//1>", subject)# match start: match.start()# match end (exclusive): atch.end()# matched text: match.group()
9.通过正则表达式字符串创建一个正则表达式对象(Create an object to use the same regex for many operations)
reobj = re.compile(regex)
10.用法1的正则表达式对象版本（use regex object for if/else branch whether (part of) a string can be matched）
reobj = re.compile(regex)if reobj.search(subject):do_something()else:do_anotherthing()
11.用法2的正则表达式对象版本（use regex object for if/else branch whether a string can be matched entirely）
reobj = re.compile(r"/Z")　＃正则表达式末尾以/Z 结束if reobj.match(subject):do_something()else:do_anotherthing()
12.创建一个正则表达式对象，然后通过该对象获得匹配细节（Create an object with details about how the regex object matches (part of) a string）
reobj = re.compile(regex)match = reobj.search(subject)if match:# match start: match.start()# match end (exclusive): atch.end()# matched text: match.group()do_something()else:do_anotherthing()
13.用正则表达式对象获取匹配子串（Use regex object to get the part of a string matched by the regex）
reobj = re.compile(regex)match = reobj.search(subject)if match:result = match.group()else:result = ""
14.用正则表达式对象获取捕获组所匹配的子串（Use regex object to get the part of a string matched by a capturing group）
reobj = re.compile(regex)match = reobj.search(subject)if match:result = match.group(1)else:result = ""
15.用正则表达式对象获取有名组所匹配的子串（Use regex object to get the part of a string matched by a named group）
reobj = re.compile(regex)match = reobj.search(subject)if match:result = match.group("groupname")else:result = ""
16.用正则表达式对象获取所有匹配子串并放入数组（Use regex object to get an array of all regex matches in a string）
reobj = re.compile(regex)result = reobj.findall(subject)
17.通过正则表达式对象遍历所有匹配子串（Use regex object to iterate over all matches in a string）
reobj = re.compile(regex)for match in reobj.finditer(subject):# match start: match.start()# match end (exclusive): match.end()# matched text: match.group()
码如下： # -*- coding: cp936 -*-import restring = "xxxxxxxxxxxxxxxxxxxxxxxx entry '某某内容' for aaaaaaaaaaaaaaaaaa"result = re.findall(".*entry(.*)for.*",string)for x in result: print x# '某某内容'正则表达式的用法如下：
python正则匹配以xx开头以xx结尾的单词的步骤：
1、假设需要匹配的字符串为：site sea sue sweet see case sse ssee loses 需要匹配的为以s开头以e 结尾的单词。 正确的正则式为：\bs\S*?e\b
2、使用python中re.findall函数表示匹配字符串中所有的可能选项，re是python里的正则表达式模块。findall是其中一个方法，用来按照提供的正则表达式，去匹配文本中的所有符合条件的字符串。
3、代码和结果如下：
text ='site sea sue sweet see case sse ssee loses'
re.findall(r'\bs\S*?e\b',text)
结果为：['site', 'sue', 'see', 'sse', 'ssee']
扩展资料：
python正则匹配,以某某开头某某结尾的最长子串匹配
代码如下：
regVersions = re.search(r'(V|v)[0-9].*[0-9]', filename)
if regVersions:
print regVersions.group()

python的re正则 findall 怎么知道有没有截取到信息？

你可以先用re.search 返回如果是None就是没找到
findall返回一个列表,如果长度不为0就表示有匹配成功。
具体原因需要看你使用的正则式与要匹配的字符串才能确定问题所在。
比如下面这样的区别：
re.findall(r'\S+', 'this is a string')
['this', 'is', 'a', 'string']
re.findall(r'\s+', 'this is a string')
[' ', ' ', ' ']

python正则表达式re.findall(rw+, s)中的r是什么意思？

在Python的string前面加上‘r’，
是为了告诉编译器这个string是个raw
string，不要转意backslash
'\'
。
例如，\n
在raw
string中，是两个字符，\和n，
而不会转意为换行符。由于正则表达式和
\
会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上'r'。
例：r"\n\n\n\n\n\n”
作用：声明后面的字符串是普通字符串
特殊字符串中含有：转义字符
\n
\t
什么什么的
用途：一般用在
正则表达式、文件绝对地址
1，正则表达式：
2、系统路径
这样就不用专门的去处理引号之中的特殊字符了
延伸阅读：python的
内建函数
和
subprocess
。此文是本系列的第三篇文章了，和之前一样，内容出自官方文档，但是会有自己的理解，并非单纯的翻译。所以，如果我理解有误，欢迎指正，谢谢。
本模块提供了和Perl里的正则表达式类似的功能，不关是正则表达式本身还是被搜索的字符串，都可以是Unicode字符，这点不用担心，python会处理地和Ascii字符一样漂亮。
正则表达式使用反斜杆（\）来转义特殊字符，使其可以匹配字符本身，而不是指定其他特殊的含义。这可能会和python字面意义上的字符串转义相冲突，这也许有些令人费解。比如，要匹配一个反斜杆本身，你也许要用'\\\\'来做为正则表达式的字符串，因为正则表达式要是\\，而字符串里，每个反斜杆都要写成\\。
你也可以在字符串前加上
r
这个前缀来避免部分疑惑，因为
r
开头的python字符串是
raw
字符串，所以里面的所有字符都不会被转义，比如r'\n'这个字符串就是一个反斜杆加上一字母n，而'\n'我们知道这是个换行符。因此，上面的'\\\\'你也可以写成r'\\'，这样，应该就好理解很多了。可以看下面这段：
re是python里的正则表达式模块。findall是其中一个方法，用来按照提供的正则表达式，去匹配文本中的所有符合条件的字符串。返回结果是一个包含所有匹配的list。
[1]
就是列表中的[1]啊
Python中字符串前面加上
r
表示原生字符串，
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

用python 中的findall如何提取括号中字符串的内容

re.findall("(?<=[(])[^()]+\.[^()]+(?=[)])",text)
text表示上面的文本
　　这里我们用了一个 Python的正则模块 re.findall来做字符串匹配解决这个问题.
看下正则的流程
首先说下什么是正则表达式, 正则其实就是对字符串特征的抽象!!!
当我们的字符串特性变化了,我们不需要大幅度修改程序,只要修改该特征结构就可以重新匹配我们要的字符.
这里我们用到了以下几种类型 正则表达式
字符
边界
特殊构造
回到题目 我们需要做的是将"("和")"之间的字符串匹配出来.
?<=[(] 代表 "(" 开始,但不一定是串首
?=[)] 代表 ")" 结束,但不一定是串尾
[^()]+\.[^()]+ 代表 中间含 "."的字符串, "\."是"."转义字符 "+"代表里面可以有1个"."或无数个"."
最后代码片断:
import re
re.findall("(?<=[(])[^()]+\.[^()]+(?=[)])",text)

python正则表达式re.findall(rw+, s)中的r是什么意思？

Python中字符串前面加上 r 表示原生字符串，
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
在Python的string前面加上‘r’， 是为了告诉编译器这个string是个raw string，不要转意backslash '\' 。 例如，\n 在raw string中，是两个字符，\和n， 而不会转意为换行符。由于正则表达式和 \ 会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上'r'。
例：r"\n\n\n\n\n\n”
作用：声明后面的字符串是普通字符串
特殊字符串中含有：转义字符 \n \t 什么什么的
用途：一般用在 正则表达式、文件绝对地址
1，正则表达式：
2、系统路径
这样就不用专门的去处理引号之中的特殊字符了