python正则表达式开头

⑴ 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正则表达式是什么

python正则表达式是：

'hing'

'wing'

'123456'

'dddddd'

'regex.py'

'.*.py'

正则表达式（简称为 regex）是一些由字符和特殊符号组成的字符串， 描述了模式的重复或者表述多个字符。正则表达式能按照某种模式匹配一系列有相似特征的字符串。换句话说， 它们能够匹配多个字符串。

孤立的一个正则表达式并不能起到匹配字符串的作用，要让其能够匹配目标字符，需要创建一个正则表达式对象。通常向compile()函数传入一个原始字符形式的正则表达式，即 r'.....'。

要让正则表达式不区分大小写，可以向re.compile()传入re.IGNORECASE或re.I，作为第二个参数。通过传入re.DOTALL作为re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。

⑶ 用python正则表达式，截取一段字符串中以“[”开头，以“]”结束的字符串

importre
a="asdf[abc123]我们"
g=re.search("[.*]",a)
ifg:
print(g.group())
else:
print("")

看看这个是不是你想要的效果，最后打印的是[abc123]，如果你[]不想要，可以在匹配完成后手动去掉字符串的第一个和最后一个字符

⑷ 请问python编程中怎么用正则表达式来编写一个程序，从而判断输入的数是否为浮点数。求高手指教。

1.程序如下：

importre

number=str(input("Pleaseinputanumber:"))

pattern=re.compile(r'^[-+]?[0-9]+.[0-9]+$')

match=pattern.match(number)

ifmatch:

print"Numberisafloat."

else:

print"Numberisnotafloat."

2.关于这个正则表达式，解释一下：

^[-+]?[0-9]+.[0-9]+$

^表示以这个字符开头，也就是以[-+]开头，[-+]表示字符-或者+之一，

?表示0个或1个，也就是说符号是可选的。

同理[0-9]表示0到9的一个数字，+表示1个或多个，也就是整数部分。

.表示的是小数点，是转义字符因为.是特殊符号（匹配任意单个除 之外的字符），

所以需要转义。

小数部分同理，$表示字符串以此结尾。

3.关于正则表达式，根据需要有好几种写法：

1.强制符号、整数、小数和指数

^[-+][0-9]+.[0-9]+[eE][-+]?[0-9]+$

2.强制符号、整数、小数，没有指数

^[-+][0-9]+.[0-9]+$

3.可选符号，强制整数、小数，没有指数

^[-+]?[0-9]+.[0-9]+$

4或更多，见下文：

http://blog.csdn.net/guaguastd/article/details/39184407

P.S.：例子中的是第三种写法。

4. 测试结果：

⑸ Python中正则表达式的常用元字符有哪些呢

Python 中常用的正则表达式元字符包括：

1. .：匹配任意一个字符（除了换行符 ）。

2. ^：匹配字符串的开头。

3. $：匹配字符串的结尾。

4. *：匹配前面的字符 0 次或多次。

5. +：匹配前面的字符 1 次或多次。

6. ?：匹配前面的字符 0 次或 1 次。

7. {n}：匹配前面的字符恰好 n 次。

8. {m,n}：匹配前面的字符至少 m 次，至多 n 次。

9. []：匹配方括号内的任意一个字符。

10. ()：标记一个子表达式的开始和结束位置。

11. |：表示或，匹配符号左右两边的任意一个表达式。

12. ：用来转义元字符或者表示特殊字符。

这些耐散元字符在正则表达式晌亩握中经常使用，可以组合成各种复杂的宴庆正则表达式，用于字符串的匹配和替换等操作。

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

python正则匹配以xx开头以xx结尾的单词的步骤：

1、假设需要匹配的字符串为：site sea sue sweet see case sse ssee loses需要匹配的为以s开头以e结尾的单词。正确的正则式为：sS*?e

2、使用python中re.findall函数表示匹配字符串中所有的可能选项，re是python里的正则表达式模块。findall是其中一个方法，用来按照提供的正则表达式，去匹配文本中的所有符合条件的字符串。

3、代码和结果如下：

text ='site sea sue sweet see case sse ssee loses'

re.findall(r'sS*?e',text)

结果为：['site', 'sue', 'see', 'sse', 'ssee']

(6)python正则表达式开头扩展阅读：

python正则匹配,以某某开头某某结尾的最长子串匹配

代码如下：

regVersions = re.search(r'(V|v)[0-9].*[0-9]', filename)

if regVersions:

print regVersions.group()