正则表达式-CSDN博客

本文链接：https://blog.csdn.net/R3eE9y2OeFcU40/article/details/80518029

欢迎关注天善智能，我们是专注于商业智能BI，人工智能AI，大数据分析与挖掘领域的垂直社区，学习，问答、求职一站式搞定！

对商业智能BI、大数据分析挖掘、机器学习，python，R等数据领域感兴趣的同学加微信：tsaiedu，并注明消息来源，邀请你进入数据爱好者交流群，数据爱好者们都在这儿。

1.正则表达式概述

正则表达式，又称正规表示式、正规表示法、正规表达式、规则表达式、常规表示法（英语：Regular Expression，在代码中常简写为regex、regexp或RE），是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。在很多文本编辑器里，正则表达式通常被用来检索、替换那些匹配某个模式的文本。

Regular Expression的“Regular”一般被译为“正则”、“正规”、“常规”。此处的“Regular”即是“规则”、“规律”的意思，Regular Expression即“描述某种规则的表达式”之意。

Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先使用re.compile()函数，将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。

2.re模块操作

在Python中需要通过正则表达式对字符串进行匹配的时候，可以使用一个模块，名字为re

1.re模块的使用过程

#coding=utf-8

# 导入re模块

import re

# 使用match方法进行匹配操作

result = re.match(正则表达式,要匹配的字符串)

# 如果上一步匹配到数据的话，可以使用group方法来提取数据

result.group()

re.match是用来进行正则匹配检查的方法，若字符串匹配正则表达式，则match方法返回匹配对象（Match Object），否则返回None（注意不是空字符串""）。

匹配对象Macth Object具有group方法，用来返回字符串的匹配部分。

2.re模块示例

#coding=utf-8

import re

result = re.match("taobao","taobao.com")

result.group()

运行结果：

'taobao'

re.match() 能够匹配出以xxx开头的字符串

3.表示字符

**匹配中文字符的正则表达式： ** [\u4e00-\u9fa5]

单字符匹配

匹配分组

表示边界

表示数量

正则表达式中的特殊用法

使用分组的同时，会有一些特殊的使用方式如下：

表达式描述

(?:expression)作为正则表达式的一部分，但是匹配结果丢弃

(?=expression)匹配expression表达式前面的字符，如 "How are you doing" ,正则"(?.+(?=ing))" 这里取ing前所有的字符，并定义了一个捕获分组名字为 "txt" 而"txt"这个组里的值为"How are you do"

(?<=expression)匹配expression表达式后面的字符，如 "How are you doing" 正则"(?(?<=How).+)" 这里取"How"之后所有的字符，并定义了一个捕获分组名字为 "txt" 而"txt"这个组里的值为" are you doing";

(?!expression)匹配字符串后面不是expression表达式字符，如 "123abc" 正则 "d{3}(?!d)"匹配3位数字后非数字的结果

举例：（直接在Python3.5中演示）

表示字符

. 匹配任意1个字符(除了 ) [ ]匹配[ ]中列举的字符匹配数字，即0-9

re.match(".","a")

<_sre.SRE_Match object; span=(0, 1), match='a'>

re.match(".","abc")

<_sre.SRE_Match object; span=(0, 1), match='a'>

re.match("h","hello Python")

<_sre.SRE_Match object; span=(0, 1), match='h'>

re.match("[hH]","Hello Python")

<_sre.SRE_Match object; span=(0, 1), match='H'>

re.match("[0123456789]","7Hello Python")

<_sre.SRE_Match object; span=(0, 1), match='7'>

re.match("[0-9]","7Hello Python")

<_sre.SRE_Match object; span=(0, 1), match='7'>

re.match("嫦娥2号","嫦娥2号发射成功")

<_sre.SRE_Match object; span=(0, 4), match='嫦娥2号'>

re.match("嫦娥d号","嫦娥2号发射成功")

<_sre.SRE_Match object; span=(0, 4), match='嫦娥2号'>

w 匹配单词字符，即a-z、A-Z、0-9、_和各国语言

re.match('w','abc')

<_sre.SRE_Match object; span=(0, 1), match='a'>

re.match('[\u4e00-\u9fa5]','人生苦短，我用python')

<_sre.SRE_Match object; span=(0, 1), match='人'>

re.match('w','人生苦短，我用python')

<_sre.SRE_Match object; span=(0, 1), match='人'>

re.match('w','人生苦短，我用python',re.ASCII)

None

注意： w 如果只是想匹配字母数字下划线，可以加上re.ASCII

re.match(r"c:\a","c:\a\b\c")

<_sre.SRE_Match object; span=(0, 4), match='c:\a'>

ret = re.match(r"c:\a","c:\a\b\c").group()

print(ret)

c:a

说明:

Python中字符串前面加上 r 表示原生字符串，

与大多数编程语言相同，正则表达式里使用""作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠""：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，有了原始字符串，我们也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

表示数量

* 匹配前一个字符出现0次或者无限次，即可有可无

+ 匹配前一个字符出现1次或者无限次，即至少有1次

re.match("[A-Z][a-z]*","Mm")

<_sre.SRE_Match object; span=(0, 2), match='Mm'>

re.match("[A-Z][a-z]*","Aabcdef")

<_sre.SRE_Match object; span=(0, 7), match='Aabcdef'>

re.match("[a-zA-Z_]+[w_]*","name1")

<_sre.SRE_Match object; span=(0, 5), match='name1'>

re.match("[a-zA-Z_]+[w_]*","_name")

<_sre.SRE_Match object; span=(0, 5), match='_name'>

re.match("[a-zA-Z_]+[w_]*","2_name")

None

? 匹配前一个字符出现1次或者0次，即要么有1次，要么没有

{m} 匹配前一个字符出现m次

{m,}匹配前一个字符至少出现m次

{m,n} 匹配前一个字符出现在m-n次范围都可以

re.match("[1-9]?[0-9]","7")

<_sre.SRE_Match object; span=(0, 1), match='7'>

re.match("[1-9]?[0-9]","33")

<_sre.SRE_Match object; span=(0, 2), match='33'>

re.match("[1-9]?[0-9]","09")

<_sre.SRE_Match object; span=(0, 1), match='0'>

re.match("[a-zA-Z0-9_]{6}","12a3g45678")

<_sre.SRE_Match object; span=(0, 6), match='12a3g4'>

re.match("[a-zA-Z0-9_]{6,}","12a3g45678")

<_sre.SRE_Match object; span=(0, 10), match='12a3g45678'>

re.match("[a-zA-Z0-9_]{8,20}","1ad12f23s34455ff66")

<_sre.SRE_Match object; span=(0, 18), match='1ad12f23s34455ff66'>

表示边界

$ 匹配字符串结尾

re.match("[w]{4,20}@163.com", "ererBai@163.com")

<_sre.SRE_Match object; span=(0, 15), match='ererBai@163.com'>

#结尾仍不符合要求，但却没过滤掉

re.match("[w]{4,20}@163.com", "erBai@163.comheihei")

<_sre.SRE_Match object; span=(0, 13), match='erBai@163.com'>

# 通过$来确定末尾

re.match("[w]{4,20}@163.com$", "ererBai@163.comheihei")

None

匹配一个单词的边界

re.match(r".*ver", "ho ver abc")

<_sre.SRE_Match object; span=(0, 6), match='ho ver'>

#报错

re.match(r".*ver", "ho verabc").group()

Traceback (most recent call last):

File "", line 1, in

AttributeError: 'NoneType' object has no attribute 'group'

#报错

re.match(r".*ver", "hover abc").group()

Traceback (most recent call last):

File "", line 1, in

AttributeError: 'NoneType' object has no attribute 'group'

B 匹配非单词边界

re.match(r".*BverB", "hoverabc")

<_sre.SRE_Match object; span=(0, 5), match='hover'>

re.match(r".*BverB", "ho verabc")

None

re.match(r".*BverB", "hover abc")

None

re.match(r".*BverB", "ho ver abc")

None

匹配分组

| 匹配左右任意一个表达式

#匹配出0-100之间的数字

re.match("[1-9]?d","8")

<_sre.SRE_Match object; span=(0, 1), match='8'>

#得到的结果是0，不符合我们的需求

re.match("[1-9]?d","08")

<_sre.SRE_Match object; span=(0, 1), match='0'>

#所以我们应该加$

re.match("[1-9]?d$","08")

None

re.match("[1-9]?d$|100","8")

<_sre.SRE_Match object; span=(0, 1), match='8'>

re.match("[1-9]?d$|100","100")

<_sre.SRE_Match object; span=(0, 3), match='100'>

re.match("[1-9]?d$|100","78")

<_sre.SRE_Match object; span=(0, 2), match='78'>

( ) 将括号中字符作为一个分组

#匹配出163、126、qq邮箱之间的数字

re.match("w{4,20}@163.com", "ererBai@163.com")

<_sre.SRE_Match object; span=(0, 12), match='ererBai@163.com'>

re.match("w{4,20}@(163|126|qq).com", "ererBai@qq.com")

<_sre.SRE_Match object; span=(0, 11), match='ererBai@qq.com'>

re.match("w{4,20}@(163|126|qq).com", "ererBai@126.com")

<_sre.SRE_Match object; span=(0, 12), match='ererBai@126.com'>

e.match("w{4,20}@(163|126|qq).com", "ererBai@gmail.com")

None

um 引用分组num匹配到的字符串

# 能够完成对正确的字符串的匹配

re.match("<[a-zA-Z]*>w*", "hh")

<_sre.SRE_Match object; span=(0, 15), match='hh'>

# 如果遇到非正常的html格式字符串，匹配出错

re.match("<[a-zA-Z]*>w*", "hh")

<_sre.SRE_Match object; span=(0, 23), match='hh'>

# 通过引用分组中匹配到的数据即可，但是要注意是元字符串，即类似 r""这种格式

re.match(r"<([a-zA-Z]*)>w*", "hh")

<_sre.SRE_Match object; span=(0, 15), match='hh'>

# 因为2对<>中的数据不一致，所以没有匹配出来

re.match(r"<([a-zA-Z]*)>w*", "hh")

None

umber 引用分组num匹配到的字符串

#匹配出

taobao.com

re.match(r"<(w*)><(w*)>.*", "

taobao.com

<_sre.SRE_Match object; span=(0, 36), match='

taobao.com

re.match(r"<(w*)><(w*)>.*", "

taobao.com

None

(?P) (?P=name) 引用别名为name分组分配到的字符串

#匹配出

taobao.com

re.match(r"<(?Pw*)><(?Pw*)>.*", "

taobao.com

<_sre.SRE_Match object; span=(0, 32), match='

taobao.com

re.match(r"<(?Pw*)><(?Pw*)>.*", "

taobao.com

None

注意：(?P)和(?P=name)中的字母p大写

附：常用表达式

校验数字的表达式

1 数字：^[0-9]*$

2 n位的数字：^d{n}$

3 至少n位的数字：^d{n,}$

4 m-n位的数字：^d{m,n}$

5 零和非零开头的数字：^(0|[1-9][0-9]*)$

6 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$

7 带1-2位小数的正数或负数：^(-)?d+(.d{1,2})?$

8 正数、负数、和小数：^(-|+)?d+(.d+)?$

9 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$

10 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$

11 非零的正整数：^[1-9]d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^+?[1-9][0-9]*$

12 非零的负整数：^-[1-9][]0-9"*$ 或 ^-[1-9]d*$

13 非负整数：^d+$ 或 ^[1-9]d*|0$

14 非正整数：^-[1-9]d*|0$ 或 ^((-d+)|(0+))$

15 非负浮点数：^d+(.d+)?$ 或 ^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$

16 非正浮点数：^((-d+(.d+)?)|(0+(.0+)?))$ 或 ^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$

17 正浮点数：^[1-9]d*.d*|0.d*[1-9]d*$ 或 ^(([0-9]+.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*.[0-9]+)|([0-9]*[1-9][0-9]*))$

18 负浮点数：^-([1-9]d*.d*|0.d*[1-9]d*)$ 或 ^(-(([0-9]+.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*.[0-9]+)|([0-9]*[1-9][0-9]*)))$

19 浮点数：^(-?d+)(.d+)?$ 或 ^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$

校验字符的表达式

1 汉字：^[\u4e00-\u9fa5]{0,}$

2 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$

3 长度为3-20的所有字符：^.{3,20}$

4 由26个英文字母组成的字符串：^[A-Za-z]+$

5 由26个大写英文字母组成的字符串：^[A-Z]+$

6 由26个小写英文字母组成的字符串：^[a-z]+$

7 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$

8 由数字、26个英文字母或者下划线组成的字符串：^w+$ 或 ^w{3,20}$

9 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$

10 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$

11 可以输入含有^%&',;=?$"等字符：[^%&',;=?$\x22]+

12 禁止输入含有~的字符：[^~\x22]+

特殊需求表达式

1 Email地址：^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$

2 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?

3 InternetURL：[a-zA-z]+://[^s]* 或 ^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$

4 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])d{8}$

5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^((d{3,4}-)|d{3.4}-)?d{7,8}$

6 国内电话号码(0511-4405222、021-87888822)：d{3}-d{8}|d{4}-d{7}

7 身份证号(15位、18位数字)：^d{15}|d{18}$

8 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$

9 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

10 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]w{5,17}$

11 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$

12 日期格式：^d{4}-d{1,2}-d{1,2}

13 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$

14 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$

15 钱的输入格式：

1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$

2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$

3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$

4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$

5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$

6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$

7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$

8.1到3个数字,后面跟着任意个逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$

- 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里

16 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x|X][m|M][l|L]$

17 中文字符的正则表达式：[\u4e00-\u9fa5]

18 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))

19 空白行的正则表达式： s* (可以用来删除空白行)

20 HTML标记的正则表达式：<(S*?)[^>]*>.*?|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)

21 首尾空白字符的正则表达式：^s*|s*$或(^s*)|(s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)

22 腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)

23 中国邮政编码：[1-9]d{5}(?!d) (中国邮政编码为6位数字) 33 IP地址：d+.d+.d+.d+ (提取IP地址时有用) 34 IP地址：((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))

4.re模块的高级用法

1.search

re.search(r"d+", "阅读次数为 9999")

<_sre.SRE_Match object; span=(6, 10), match='9999'>

2.findall

#统计出python、c、c++相应文章阅读的次数

re.findall(r"d+", "python = 9999, c = 7890, c++ = 12345")

['9999', '7890', '12345']

3.sub将匹配到的数据进行替换

#方法一

re.sub(r"d+", '998', "python = 997")

'python = 998'

#方法二

def add(temp):

strNum = temp.group()

num = int(strNum) + 1

return str(num)

re.sub(r"d+", add, "python = 997")

'python = 998'

例子

#从下面的字符串中取出文本

岗位职责：

完成推荐算法、数据统计、接口、后台等服务器端相关工作

必备要求：

良好的自我驱动力和职业素养，工作积极主动、结果导向

技术要求：

1、一年以上 Python 开发经验，掌握面向对象分析和设计，了解设计模式

2、掌握HTTP协议，熟悉MVC、MVVM等概念以及相关WEB开发框架

3、掌握关系数据库开发设计，掌握 SQL，熟练使用 MySQL/PostgreSQL 中的一种

4、掌握NoSQL、MQ，熟练使用对应技术解决方案

5、熟悉 Javascript/CSS/HTML5，JQuery、React、Vue.js

加分项：

大数据，数理统计，机器学习，sklearn，高性能，大并发。

解决方法：

s='''

岗位职责：

完成推荐算法、数据统计、接口、后台等服务器端相关工作

必备要求：

良好的自我驱动力和职业素养，工作积极主动、结果导向

技术要求：

1、一年以上 Python 开发经验，掌握面向对象分析和设计，了解设计模式

2、掌握HTTP协议，熟悉MVC、MVVM等概念以及相关WEB开发框架

3、掌握关系数据库开发设计，掌握 SQL，熟练使用 MySQL/PostgreSQL 中的一种

4、掌握NoSQL、MQ，熟练使用对应技术解决方案

5、熟悉 Javascript/CSS/HTML5，JQuery、React、Vue.js

加分项：

大数据，数理统计，机器学习，sklearn，高性能，大并发。

'''

re.sub(r'| |s','',s)

'岗位职责：完成推荐算法、数据统计、接口、后台等服务器端相关工作必备要求：良好的自我驱动力和职业素养，工作积极主动、结果导向技术要求：1、一年以上Python开发经验，掌握面向对象分析和设计，了解设计模式2、掌握HTTP协议，熟悉MVC、MVVM等概念以及相关WEB开发框架3、掌握关系数据库开发设计，掌握SQL，熟练使用MySQL/PostgreSQL中的一种4、掌握NoSQL、MQ，熟练使用对应技术解决方案5、熟悉Javascript/CSS/HTML5，JQuery、React、Vue.js 加分项：大数据，数理统计，机器学习，sklearn，高性能，大并发。'

4.split

根据匹配进行切割字符串，并返回一个列表

re.split(r":| ","info:xiaoZhang 33 shandong")

['info', 'xiaoZhang', '33', '', '', '', '', '', '', '', '', '', 'shandong']

re.split(r":| *","info:xiaoZhang 33 shandong")

['info', 'xiaoZhang', '33', 'shandong']

5.贪婪和非贪婪

正则表达式匹配的两种模式：贪婪模式、懒惰模式

贪婪模式：从目标字符串的两头开始搜索，一次尽可能多的匹配符合条件的字符串，但是有可能会匹配到不需要的内容，正则表达式中的元字符、量词、范围等都模式是贪婪匹配模式，使用的时候一定要注意分析结果，

懒惰模式：从目标字符串按照顺序从头到位进行检索匹配，尽可能的检索到最小范围的匹配结果，语法结构是在贪婪模式的表达式后面加上一个符号?即可，

Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；

非贪婪则相反，总是尝试匹配尽可能少的字符。

在"*", "?" , "+" , "{m,n}" 后面加上？，使贪婪变成非贪婪。

re.match(r"erbai(d+)","erbai521888").group(1)

'521888'

re.match(r"erbai(d+?)","erbai521888").group(1)

'5'

re.match(r"(d+)(.*)", "5211314erbai").groups()

('5211314', 'erbai')

re.match(r"(d+?)(.*)", "5211314erbai").groups()

('5', '211314erbai')

练习

(一)

有一批网址：

http://www.interoem.com/messageinfo.asp?id=35

http://3995503.com/class/class09/news_show.asp?id=14

http://lib.wzmc.edu.cn/news/onews.asp?id=769

http://www.zy-ls.com/alfx.asp?newsid=377&id=6

http://www.fincm.com/newslist.asp?id=415

需要正则后为：

http://www.interoem.com/

http://3995503.com/

http://lib.wzmc.edu.cn/

http://www.zy-ls.com/

http://www.fincm.com/

表达式：

#单个修改的表达式有以下几种参考方案

re.match(r'http.+.[a-z]{2,3}/',str)

re.match(r'http://.*?/',str)

re.sub(r'(http://.*?/).*',lambda x:x.group(1),str)

#整块都修改

import re

f = open('url.txt','w')

s = '''http://www.interoem.com/messageinfo.asp?id=35

http://3995503.com/class/class09/news_show.asp?id=14

http://lib.wzmc.edu.cn/news/onews.asp?id=769

http://www.zy-ls.com/alfx.asp?newsid=377&id=6

http://www.fincm.com/newslist.asp?id=415'''

f.write(s)

f = open('url.txt','r')

def main():

for line in f:

ret = re.match(r'http://.+.[a-z]{2,3}/', line)

print(ret.group())

f.close()

if __name__ == '__main__':

main()

结果：

http://www.interoem.com/

http://3995503.com/

http://lib.wzmc.edu.cn/

http://www.zy-ls.com/

http://www.fincm.com/

(二)

现在有一句英文如下：

hello world ha ha

需求查找所有的单词

表达式：

#我写了两种，当然方法是多种的

re.split(r' +','hello world ha ha')

['hello', 'world', 'ha', 'ha']

re.findall(r' w+',’ hello world ha ha’)

['hello', 'world', 'ha', 'ha']

2017.8.9回顾

1.正则表达式（Regular Expression）：查询和匹配字符串的规则

2.正则表达式表示数据

普通字符：元数据，可以用于匹配指定的字符

r = “a”：用于在目标字符串中匹配小写字母a元字符

r = “.”：用于匹配任意一个字符

r = “”：转移字符~用于将一个普通的字符，转义成一个有意义的字符

r = “d”：表示一个0~9之间的整数

r = “D”：表示一个非数字字符

r = “w”：表示任意一个0~9或者字母或者下划线的字符

r = “W”：表示任意一个特殊字符

r = “s”：表示匹配一个空白字符

r = “S”：表示匹配一个非空白字符

r = “^”：匹配字符串的开头位置

r = “$”：匹配字符串的结束位置

r = “d*”：表示前面匹配的字符出现了0次或者多次

r = “d?”：表示前面匹配的字符出现了0次或者1次

r =”d+”：表示前面匹配的字符出现了1次或者多次

#范围匹配

分组匹配方式：将多个匹配字符当成一个完整的匹配公式

(abc)：用于在目标字符串中查询abc同时出现的地方

选择匹配方式：将指定的多个字符，选择其中一个进行匹配

[abc]：用于在目标字符串中，查询a或者b或者c出现的地方

[0-9]：用于匹配一个0~9之间的数字->等价于d

[a-z]：用于匹配一个a-z之间的字母

[A-Z]：用于匹配一个A-Z之间的字母

[a-zA-Z]：用于匹配一个字母【大小写均可】

[a-zA-Z0-9_]：用于匹配一个非特殊字符，等价于w

#范围匹配

d{m, n}：匹配到的字符出现了至少m次，最多n次

d{,20}：匹配一个数字最多出现20次

d{8,}：匹配一个数字，最少出现8次

d{8,16}：匹配一个数字，最少出现8次，最多出现16次

#正则表达式在python中的使用

正则表达式，在python中，主要用到了一个re模块

compile()：编译正则表达式

pattern = re.compile(“^d{2,}$”)

pattern = r‘^d{2,}$’

pattern.match(str,begin,end)：从指定的字符串str第一个字符查询匹配的字符

pattern.search(str, begin, end):从指定的字符串中直接进行查询，查询到的第一个结果作为匹配结果

pattern.findall(str)：从指定的字符串中，查询符合匹配规则的字符，将所有符合的字符存放在一个列表中

pattern.finditer(str)：从指定的字符串中，查询符合匹配规则的字符保存在一个可以迭代的对象中

pattern.sub():替换

pattern.split():拆分

文章来源：天善智能社区https://ask.hellobi.com/publish/article/11817

作者：许胜利