python正则表达式用法,Python中的正则表达式？

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

本文目录一览： 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 ="" 。

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的正则表达式

1,正则表达式的一些内容
? ? ? ? 正则表达式主要是用来匹配文本中需要查找的内容,例如在一片文章中找出电话号码,就中国的来说11位纯数字(不说座机),则使用"\d{11}" 意味匹配数字11次,就能准确的查找出文本中的电话号码. 还有就是在编写网络爬虫的时候需要提取很多超链接再次进行爬取,使用正则表达式就很方便.直接匹配http开头就行,当然也可以使用beautifulsoup的select方法.
看下面的程序看看正则表达提取文本中的邮箱:

\w 匹配字母,数字,下划线?
+ 匹配1次或者多次 re是正则表达式的工具包,工具包出错的话在anaconda的命令行输入"pip install re"安装,其他的工具包也是如此.
re.compile()中的r示意\不是转义字符,也就是保持后面字符串原样,findall返回一个列表.下面还有一个版本的程序略有不同.

compile的另一个参数re.IGONORECASE(忽略大小写),还可以是re.DORALL,多行模式,具体功能也是模糊不清,不过在使用通配符 . 匹配的时候加上re.DOTALL参数能够匹配换行.如果希望忽略大小写和多行模式都开启可以使用re.compile(r'....',re.IGNORECASE|re.DOTALL) .
表达式使用( ),对匹配到的内容分为3组 也就是(\w+)出现字母,数字,下划线一次或多次,这个分组就是下面使用match对象的grou()方法的时候的参数.不给参数和参数0都是得到整个匹配到的内容,? 参数1得到第一个括号匹配到的内容,以此类推参数2和3,如果没有括号分组的话使用参数会出现错误. search( )查找和正则式匹配的内容,只匹一次后面的那个找不到.返回一个match对象

\w 匹配字母,数字,下划线
\W 匹配字母,数字.下划线之外的所有字符
\d 匹配数字
\D 匹配非数字
\s 匹配空格,制表符,换行符
\S匹配除空格制表符,换行符之外的其他字符
[ .... ]定义自己的匹配,如[aeiouAEIOU ]匹配所有的元音字母,注意不是匹配单词.
{最少次数,最多次数},例如{3,9} 匹配3-9次,{ ,10}匹配0-10次. 默认为匹配最多次数(贪心匹配),非贪心模式在后面加上问号?

?? 可选 0次或者1次吧 ?
+匹配1次或多次
*匹配0次或者多次
^ 判断开头 ^\d 如果待匹配串是数字开头则返回第一个数字
$判断结尾? \d$? 如果待匹配串是数字结尾则返回最后一个数字
. ? 通配符,匹配除换行之外的所有字符
? ?\d{11}? 匹配数字11次
????. *?匹配所有字符除 换行
[a-zA-Z0-9._%+-] ?小写和大写字母、数字、句点、下划线、百分号、加号或短横
[a-zA-Z]{2,4} 匹配字母 2 - 4次

python中提供了哪几种通过正则表达式匹配字符串的方法有哪

python中提供了3种通过正则表达式匹配字符串的方法。种通过正则表达式匹配字符串的方法有以下三种。1、贪婪匹配与非贪婪匹配：在定义用于匹配的模式串时，使用.*，则为贪婪匹配。使用.*，则为非贪婪匹配。2、indall与search的选取问题：自己定义的模式串只能匹配到一个结果，使用search方法结合group方法可以直接得到这个字符串。自己定义的模式串能匹配到多个结果，则使用findall方法可以得到存储多个结果字符串的列表。3、匹配时"()"和[]的用法：目标字符串‘abcde’[…]会匹配在[]内的任意一个字符，而不会匹配整个字符串。(…)会匹配在()内的整个字符串。使用search方法时则正常匹配（相当于没有()），使用findall方法时则只会匹配(…)的内容。）[]同时出现，考虑(…)式的字符串与[…]式内的字符和顺序，使用findall方法时结果会舍弃[…]内容，使用search方法时则正常匹配（相当于没有()和[]）。

Python正则表达式之re.match()

我们在面对生物数据，比如序列信息（比如碱基序列、氨基酸序列等）的时候， 会时常要问，这其中是否包含着且含有多少某种已知的模式，一段DNA中是否包含转录起始特征TATA box、一段RNA中是否包含某种lncRNA、一段肽链中是否包含锌指结构等等；另一方面，我们在操作数据时，会时常遇到诸如把某个字符（对象）换成另一种字符（对象）的替换操作，而其本质还是如何搜索符合某种（替换）模式的对象。
在这些几乎天天都可以碰到的 模式匹配/搜索问题中，正则表达式就是一把解决问题的利剑！ 在Python的re模块中，常用的有四个方法(match、search、findall、finditer)都可以用于匹配字符串，今天我们先来了解一下re.match()。
re.match()必须从字符串开头匹配！ match方法尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。主要参数如下：
举个栗子来理解一下它的用法：
运行结果：
从例子中我们可以看出，re.match()方法返回一个匹配的对象，而不是匹配的内容。通过调用span()可以获得匹配结果的位置。而如果从起始位置开始没有匹配成功，即便其他部分包含需要匹配的内容，re.match()也会返回None。
一般一个小括号括起来就是一个捕获组。我们可以使用group()来提取每组匹配到的字符串。 group()会返回一个包含所有小组字符串的元组，从 0 到 所含的小组号。
直接调用groups()则直接返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 再举一个栗子：
运行结果：

一文秒懂python正则表达式常用函数

01 Re概览
Re模块是python的内置模块，提供了正则表达式在python中的所有用法，默认安装位置在python根目录下的Lib文件夹（如 ..\Python\Python37\Lib）。主要提供了3大类字符串操作方法：

字符查找/匹配

字符替换

字符分割

由于是面向字符串类型的模块，就不得不提到字符串编码类型。re模块中，模式串和搜索串既可以是 Unicode 字符串 (常用str类型) ，也可以是8位字节串 (bytes，2位16进制数字，例如\xe5) ， 但要求二者必须是同类型字符串。
02 字符串查找/匹配
预编译：compile
在介绍查找和匹配函数前，首先需要知道re的compile函数，该函数可以将一个模式串编译成正则表达式类型，以便后续快速匹配和复用
import?re pattern?=?re.compile(r'[a-z]{2,5}') type(pattern)?#re.Pattern
此例创建了一个正则表达式式对象 (re.pattern) ，命名为pattern，用于匹配2-5位小写字母的模式串。后续在使用其他正则表达式函数时，即可使用pattern进行方法调用。
匹配：match
match函数用于从文本串的起始位置开始匹配，若匹配成功，则返回相应的匹配对象，此时可调用group()方法返回匹配结果，也可用span()方法返回匹配起止下标区间；否则返回None
import?re pattern?=?re.compile(r'[a-z]{2,5}') text1?=?'this?is?a?re?test' res?=?pattern.match(text1) print(res)?# if?res: ?print(res.group())?#this ?print(res.span())?#(0,?4) text2?=?'是的,?this?is?a?re?test' print(pattern.match(text2))#None
match函数还有一个变形函数fullmatch，当且仅当模式串与文本串刚好全部匹配时，返回一个匹配对象，否则返回None
搜索：search
match只提供了从文本串起始位置匹配的结果，如果想从任意位置匹配，则可调用search方法，与match方法类似，当任意位置匹配成功，则立即返回一个匹配对象，也可调用span()方法获取起止区间、调用group方法获得匹配文本串
import?re pattern?=?re.compile(r'\s[a-z]{2}') text1?=?'this?is?a?re?test' res?=?pattern.search(text1) print(res)?# if?res: ?print(res.group())?#is ?print(res.span())?#(4,?7) pattern2?=?re.compile(r'\s[a-z]{5}') text2?=?'是的,this?is?a?re?test' print(pattern2.search(text2))#None
match和search均用于匹配单个结果，唯一区别在于前者是从起始位置开始匹配，而后者从任意位置匹配，匹配成功则返回一个match对象。

全搜索：findall/finditer
几乎是最常用的正则表达式函数，用于寻找所有匹配的结果，例如在爬虫信息提取中，可非常方便地提取所有匹配字段
import?re pattern?=?re.compile(r'\s[a-z]{2,5}') text1?=?'this?is?a?re?test' res?=?pattern.findall(text1) print(res)?#['?is',?'?re',?'?test']
findall返回的是一个列表对象类型，当无匹配对象时，返回一个空列表。为了避免因同时返回大量匹配结果占用过多内存，可以调用finditer函数返回一个迭代器类型，其中每个迭代元素是一个match对象，可继续调用group和span方法获取相应结果
import?re pattern?=?re.compile(r'\s[a-z]{2,5}') text1?=?'this?is?a?re?test' res?=?pattern.finditer(text1) for?r?in?res: ?print(r.group()) """ ?is ?re ?test """
当匹配模式串较为简单或者仅需单词调用时，上述所有方法也可直接调用re类函数，而无需事先编译。此时各方法的第一个参数为模式串。
import?re pattern?=?re.compile(r'\d{2,5}') text?=?'this?is?re?test' re.findall('[a-z]+',?text)?#['this',?'is',?'re',?'test'] 03 字符串替换/分割
替换:sub/subn
当需要对文本串进行条件替换时，可调用re.sub实现 (当然也可先编译后再用调用实例方法) ，相应参数分别为模式串、替换格式、文本串，还可以通过增加缺省参数限定替换次数和匹配模式。通过在模式串进行分组，可实现字符串的格式化替换（类似字符串的format方法），以实现特定任务。
import?re text?=?'today?is?2020-03-05' print(re.sub('-',?'',?text))?#'today?is?20200305' print(re.sub('-',?'',?text,?1))?#'today?is?202003-05' print(re.sub('(\d{4})-(\d{2})-(\d{2})',?r'\2/\3/\1',?text))?#'today?is?03/05/2020'
re.sub的一个变形方法是re.subn，区别是返回一个2元素的元组，其中第一个元素为替换结果，第二个为替换次数
import?re text?=?'today?is?2020-03-05' print(re.subn('-',?'',?text))?#('today?is?20200305',?2)
分割：split
还可以调用正则表达式实现字符串的特定分割，相当于.split()方法的一个加强版，实现特定模式的分割，返回一个切割后的结果列表
import?re text?=?'today?is?a?re?test,?what?do?you?mind?' print(re.split(',',?text))?#['today?is?a?re?test',?'?what?do?you?mind?'] 04 总结
python中的re模块提供了正则表达式的常用方法，每种方法都包括类方法调用(如re.match)或模式串的实例调用(pattern.match)2种形式

常用的匹配函数：match/fullmatch

常用的搜索函数：search/findall/finditer

常用的替换函数：sub/subn

常用的切割函数：split

还有其他很多方法，但不是很常用，具体可参考官方文档

另外，python还有第三方正则表达式库regex可供选择

到此这篇关于一文秒懂python正则表达式常用函数的文章就介绍到这了，希望大家以后多多支持！

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 正则表达式，怎样匹配以某个字符串开头，以某个字符串结尾的情况？

匹配以abc开头，以qwe结尾
if str.startswith("abc") and str.endswith("qwe"):
print str
截取中间这段的字符串
print re.sub(r"abc", '', re.sub("qwe", '', str))
String regex = "^A*C*B$"; Pattern p = Pattern.compile(regex); java.util.regex.Matcher m = p.matcher("这里是你要匹配的字符串"); while (m.find()) { System.out.println(m.group()); }
^abc 表示 abc开头
qwe$ 表示qwe结尾
中间可以用.+?
匹配以某个字符串开头，以某个字符串结尾的情况的正则表达式:^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()

python怎么样使用正则表达式匹配用户输入的为文件路径？？ 就譬如像： E：index.ph

你好：
正则表达式语法：
## 总结## ^ 匹配字符串的开始。## $ 匹配字符串的结尾。## \b 匹配一个单词的边界。## \d 匹配任意数字。## \D 匹配任意非数字字符。## x? 匹配一个可选的 x 字符 (换言之，它匹配 1 次或者 0 次 x 字符)。## x* 匹配0次或者多次 x 字符。## x+ 匹配1次或者多次 x 字符。## x{n,m} 匹配 x 字符，至少 n 次，至多 m 次。## (a|b|c) 要么匹配 a，要么匹配 b，要么匹配 c。## (x) 一般情况下表示一个记忆组 (remembered group)。你可以利用 re.search 函数返回对## 象的 groups() 函数获取它的值。##正则表达式中的点号通常意味着 “匹配任意单字符”

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')
如图所示：