正则表达式

  • 正则表达式就是描述字符串排列的一套规则。利用正则表达式可以做很多事情,主要用于字符串的匹配
  • 在实际项目中,我们经常需要找到某一类符合某种格式的信息,此时,我们可以观察这些数据的规律,然后将这些数据的格式规律用正则表达式形式描述出来,然后利用正则表达式函数进行相应的处理即可。

    本节主要为大家介绍正则表达式怎么去写,将从原子、原子符、模式修正符、贪婪模式与懒惰模式等方面介绍

1.原子

原子是正则表达式中最基本的组成单位,每个正则表达式中至少要包含一个原子

常见的原子有这几类:普通字符作为原子、非打印字符作为原子、通用字符作为原子和原子表

(1) 普通字符作为原子

  • 我们可以使用一些普通的字符,比如数字,大小写字母,下划线等都可作为原子使用,如下程序中,‘yue’作为原子使用,这里有三个原子,分别是y,u,e
  1. #普通字符作为原子
  2. import re
  3. pattern = "yue"#yue作为原子使用,有三个原子,分别是y,u,e
  4. string = "http://yum.iqianyue.com"
  5. resultl = re.search(pattern,string)#在string中匹配正确的正则表达式,若匹配成功,将匹配结果返回给变量result
  6. print(resultl)
  1. <_sre.SRE_Match object; span=(16, 19), match='yue'>

(2) 非打印字符作为原子

  • 指的是一些在字符串中用于格式控制的符号,比如换行符等(常用的非打印字符为 ‘\n’ :用于匹配一个换行符, ‘\t’ :用于匹配一个制表符)
  1. ##非打印字符作为原子
  2. import re
  3. pattern = "\n"
  4. string = '''http://yum.iqianyue.com
  5. http://baidu.com''' #字符串变量string中包含一个多行的数据,所以这个数据里面包含了对应的换行符,所以,此时进行换行符匹配
  6. resultl = re.search(pattern,string)
  7. print(resultl)
  1. <_sre.SRE_Match object; span=(23, 24), match='\n'>
  1. import re
  2. pattern = "\n"
  3. string = '''http://yum.iqianyue.comhttp://baidu.com'''#在字符串中不包含换行,所以无法成功匹配,故最后输出None
  4. resultl = re.search(pattern,string)
  5. print(resultl)
  1. None

(3) 通用字符作为原子(即一个原子可以匹配一类字符)

  • 通用字符,即一个原子可以匹配一类字符
  • 常见的通用字符及其含义:
符号 含义
\w 匹配任意一个字母、数字和下划线
\W 匹配除任意一个字母、数字和下划线以外的任意一个字符
\d 匹配任意一个十进制数
\D 匹配除十进制数以外的任意一个其他字符
\s 匹配任意一个空白字符
\S 匹配除空白字符以外的任意一个其他字符
  1. #通用字符作为原子示例
  2. import re
  3. pattern = "\w\dpython\w"#'\w'匹配任意一个字母、数字、下划线;'\d'匹配任意一个十进制数;
  4. string = "abcdfphp345pythony_py"
  5. result1 = re.search(pattern,string)
  6. print(result1)
  1. <_sre.SRE_Match object; span=(9, 18), match='45pythony'>

(4) 原子表

  • 由[]表示,比如[xyz]就是一个原子表,这个原子表中定义了3个原子,这3个原子的地位平等。如我们定义的正则表达式为“[xyz]py”,对应的源字符串为“xpython”,若用 re.search()函数进行匹配,就可以匹配出结果“xpy”,因为此时只要py前一位是x y z字母中的其中一个字母,就可以匹配成功。
  • 类似的,[]代表的是除了中括号里面的原子均可以匹配成功。比如"[xyz]py"能匹配“apy”,但是不能匹配xpy等。
  1. #原子表示例
  2. import re
  3. pattern1 = "\w\dpython[xyz]\w"
  4. pattern2 = "\w\python[^xyz]\w"
  5. pattern3 ="\w\dpython[xyz]\W"
  6. string = "abcdfphp345pythony_py"
  7. result1 = re.search(pattern1,string)
  8. result2= re.search(pattern2,string)
  9. result3 = re.search(pattern3,string)
  10. print(result1)
  11. print(result2)
  12. print(result3)
  1. <_sre.SRE_Match object; span=(9, 19), match='45pythony_'>
  2. None
  3. None

2 原子符

  • 原子符就是正则表达式中具有一些特殊含义的字符,比如重复N次前面的字符等。

    常见的元子符:
符号 含义
. 匹配除换行符以外的任意字符
^ 匹配字符串的开始位置
$ 匹配字符串的终止位置
* 匹配0次、1次或多次前面的原子
? 匹配0次或1次前面的原子
+ 匹配1次或多次前面的原子
{n} 前面的原子正好出现n次
{n,} 前面的原子至少出现n次
{m,n} 前面的原子至少出现n次,至多出现m次

(1) 任意匹配原子符

首先看任意匹配符‘.’,可以用‘.’匹配一个除换行符以外的任意字符。

比如,用正则表达式“.python...”匹配一个“python”字符前面有1位,后面有3位格式的字符,这前面的1位和后面的3位可以是除了换行符意外的任意字符。如以下程序:

  1. import re
  2. pattern=".python..."
  3. string = "abcdfphp345pythony_py"
  4. result1 = re.search(pattern1,string)
  5. print(result1)
  1. <_sre.SRE_Match object; span=(9, 19), match='45pythony_'>

(2) 边界限制原子符

可以使用“^”匹配字符串的开始,使用“$”匹配字符串的结束,如下例:

  1. import re
  2. pattern1 = "^abd"#限制以abd开始
  3. pattern2 = "^abc"#限制以abc开始
  4. pattern3 ="py$"#限制以py结束
  5. pattern4 = "ay$"#限制以ay结束
  6. string = "abcdfphp345pythony_py"#源字符串
  7. result1 = re.search(pattern1,string)
  8. result2= re.search(pattern2,string)
  9. result3 = re.search(pattern3,string)
  10. result4 = re.search(pattern4,string)
  11. print(result1)
  12. print(result2)
  13. print(result3)
  14. print(result4)
  1. None
  2. <_sre.SRE_Match object; span=(0, 3), match='abc'>
  3. <_sre.SRE_Match object; span=(19, 21), match='py'>
  4. None

(3) 限定符

限定符也是元子符中的一种,常见的限定符包括*、?、+、{n}、{n,}、{n,m}

  • 看以下例子
  1. import re
  2. pattern1 = "py.*n"
  3. pattern2 = "cd{2}"
  4. pattern3 ="cd{3}"
  5. pattern4 = "cd{2, }"
  6. string = "abcdddfphp345pythony_py"
  7. result1 = re.search(pattern1,string)
  8. result2= re.search(pattern2,string)
  9. result3 = re.search(pattern3,string)
  10. result4 = re.search(pattern4,string)
  11. print(result1)
  12. print(result2)
  13. print(result3)
  14. print(result4)
  1. <_sre.SRE_Match object; span=(13, 19), match='python'>
  2. <_sre.SRE_Match object; span=(2, 5), match='cdd'>
  3. <_sre.SRE_Match object; span=(2, 6), match='cddd'>
  4. None

(4) 模式选择符

来看模式选择符“|”,使用模式选择符,可以设置多个模式,匹配时可从中选择任意一个模式匹配。比如正则表达式“python|php”中,字符串“python”和“php”均满足匹配条件

  1. #模式匹配符示例
  2. import re
  3. pattern = "python|php"
  4. string ="abcdfphp345pythony_py"
  5. result = re.search(pattern,string)
  6. print(result)
  7. #可以看出,从源字符串中匹配到了结果“php”
  1. <_sre.SRE_Match object; span=(5, 8), match='php'>

3 模式修正

  • 模式修正符,就是可以在不改变正则表达式的情况下,通过模式修正符改变正则表达式的含义,从而实现一些匹配结果的调整等功能。

    常用的模式修正符:
符号 含义
I 匹配时忽略大小写
M 多行匹配
L 做本地化识别匹配
U 根据Unicode字及解析字符
S 让.匹配包括换行符,即用了该模式修正后,“.”匹配就可以匹配任意的字符了
  1. import re
  2. pattern1 = "python"
  3. pattern2 = "python"
  4. string = "abcdfphp345Pythony_py"
  5. result1 = re.search(pattern1,string)
  6. result2= re.search(pattern2,string,re.I)#忽略大小写
  7. print(result1)
  8. print(result2)
  1. None
  2. <_sre.SRE_Match object; span=(11, 17), match='Python'>
  1. import re
  2. pattern = "\t"
  3. string = '''http://yum.iqianyue.com
  4. http://baidu.com'''
  5. resultl = re.search(pattern,string)
  6. print(resultl)
  1. None

4 贪婪模式与懒惰模式

总的来说,贪婪模式就是的核心就是尽可能多的匹配,而懒惰模式就是尽可能少的匹配。

可看下面的示例:

  1. import re
  2. pattern1 = "p.*y"#贪婪模式
  3. pattern2 = "p.*? y"#懒惰模式
  4. string = "abcdfphp345pythony_py"
  5. result1= re.search(pattern1,string)
  6. result2=re.search(pattern2,string)
  7. print(result1)#找到结尾字符y才停止,即找到最后一个y字符才停止
  8. print(result2)#一旦找到了字符y就停止
  1. <_sre.SRE_Match object; span=(5, 21), match='php345pythony_py'>
  2. None

5 正则表达式常见函数

常见的表达式函数有:re.match()函数、re.search()函数、全局匹配函数、re.sub()函数.

(1) re.match()函数

从源字符的起始位置匹配一个模式,就用re.match()函数,其格式为:re.match(pattern,string,flag),第一个参数表示对应的正则表达式,第二个表示源字符,第三个是可选参数,表示对应的标志位,可以放模式修正等信息.

  1. import re
  2. pattern = ".python"
  3. string = "apythonhellomypythonhispythonourpythononend"
  4. result1=re.match(pattern,string)
  5. result2 = re.match(pattern,string).span()#通过.span()可以过滤掉一些信息,只留下匹配成功的结果在源字符串中的位置
  6. print(result1)
  7. print(result2)
  1. <_sre.SRE_Match object; span=(0, 7), match='apython'>
  2. (0, 7)

(2) re.search()函数

用该函数进行匹配,会扫描整个源字符串并进行对应的匹配。

与re.match()函数的不同之处,该函数在全文中进行检索匹配,而re.match()函数是从源字符串的开头进行匹配。

  1. import re
  2. pattern = ".python"
  3. string = "hellomypythonhispythonourpythononend"
  4. result1=re.match(pattern,string)
  5. result2 = re.search(pattern,string)
  6. print(result1)
  7. print(result2)
  1. None
  2. <_sre.SRE_Match object; span=(6, 13), match='ypython'>

(3) 全局匹配函数

  • 就是将符合模式的内容全部都匹配出来.思路:
  • 1.使用re.compile()对正则表达式进行编译
  • 2.编译后,使用indall()根据正则表达式从源字符中将匹配的结果全部找出
  1. import re
  2. string = "hellomypythonhispythonourpythonend"
  3. pattern =re.compile(".python.")#预编译
  4. result =pattern.findall(string)#找出所有符合模式的结果
  5. print(result)
  1. ['ypythonh', 'spythono', 'rpythone']
  1. #对上式的整合
  2. import re
  3. string = "hellomypythonhispythonourpythonend"
  4. pattern = ".python."
  5. result =re.compile(pattern).findall(string)
  6. print(result)
  1. ['ypythonh', 'spythono', 'rpythone']

(4) re.sub()函数

根据正则表达式实现替换某些字符串的功能,可以使用re.sub()函数实现,其格式为:re.sub(pattern,rep,string,max), 第一个参数表示对应的正则表达式,第二个参数表示要替换成的字符串,第三个参数表示为源字符串,第四个表示可选项,代表最多替换的次数,若忽略不写的话,会将符合模式的结果全部替换

  1. import re
  2. string = "hellomypythonhispythonourpythonend"
  3. pattern = "python."
  4. result = re.sub(pattern,"php",string)
  5. result2=re.sub(pattern,"php",string,)
  6. print(result1)
  7. print(result2)
  1. <_sre.SRE_Match object; span=(5, 19), match='php345pytho_py'>
  2. hellomyphpisphpurphpnd

python编程基础—正则表达式的更多相关文章

  1. python 编程基础练习 第一天

    python 编程基础练习 第一天: 需求: 1.计算2的38次方,180*0.7输出(精度显示正常), x的y次方,数字倒序输出即345876输出678543,方法越多越好. 2.字符串处理: 1) ...

  2. 第2章 Python编程基础知识 第2.1节 简单的Python数据类型、变量赋值及输入输出

    第三节 简单的Python数据类型.变量赋值及输入输出 Python是一门解释性语言,它的执行依赖于Python提供的执行环境,前面一章介绍了Python环境安装.WINDOWS系列Python编辑和 ...

  3. Python编程基础[条件语句if 循环语句 for,while](二)

    ython条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块. 可以通过下图来简单了解条件语句的执行过程: if 判断条件: 执行语句……else: 执行语句…… x= ...

  4. Python编程基础(一)

    1.Python中的变量赋值不需要类型声明 2.等号(=)用来给变量赋值 3.字符串拼接用  “+”  号 temp=‘123’ print('temp的值是%s'%temp) #整数和字符创的转换, ...

  5. 【学习笔记】第二章 python安全编程基础---正则表达式

    一.python正则表达式 定义:正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式相匹配: 1.1RE模块:是python语言拥有全部的正则表达式功能的一个正则模块: 常见 ...

  6. 1.Python编程基础

    1. 其实,程序指的就是一系列指令,用来告诉计算机做什么,而编写程序的关键在于,我们需要用计算机可以理解的语言来提供这些指令. 虽然借助 Siri(Apple).Google Now(Android) ...

  7. Python编程基础(一)编程语言是什么?编译型语言和解释型语言的区别|Python是什么?

    编程语言是什么? 其实,程序指的就是一系列指令,用来告诉计算机做什么,而编写程序的关键在于,我们需要用计算机可以理解的语言来提供这些指令. 虽然借助 Siri(Apple).Google Now(An ...

  8. Python编程基础[函数和面向对象](三)

    Python 函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也 ...

  9. python编程基础

    Date: 2019-05-27 Author: Sun 1. 程序 为了完成某种特定功能,以某种程序设计语言编写的有序指令的集合.程序是指挥cpu工作的"工作手册".计算机只能执 ...

随机推荐

  1. lsdslam代码笔记

    0.1. question 0.2. 算法框架 0.3. 代码解析 0.3.1. 数据结构 0.3.1.1. Frame 0.3.1.2. FrameMemory 0.3.1.3. FramePose ...

  2. C#工作笔记

    没想到一个Java后端开发还要负责C#桌面程序,我感觉有点方.不过方归方,活还是要干的.简单记录下学到的一些知识点. 1.引用API函数 namespace Demo { class MyUtil { ...

  3. php七牛批量删除空间内的所有文件方法

    相信大家都在使用七牛的免费云存储服务的同时,有清空七牛云存储镜像文件或者批量删除七牛云空间文件的需求,该怎么做?官方的工具好像并没有提供批量删除的功能,七牛云官方给出的建议是删除空间,再新建一个这样太 ...

  4. Jenkins-FQA

    1.svn url不能设置成文件路径,而应该是"文件夹"路径,也就是说必须是目录. 示例: Checking out https://svn.gw.com.cn:10000/svn ...

  5. IDEA的热部署插件jrebel6.4.3离线安装版配置与破解

    JRebel 介绍 IDEA上原生是不支持热部署的,一般更新了 Java 文件后要手动重启 Tomcat 服务器,才能生效,浪费不少生命啊.目前对于idea热部署最好的解决方案就是安装JRebel插件 ...

  6. Java 操作jar包工具类以及如何快速修改Jar包里的文件内容

    需求背景:写了一个实时读取日志文件以及监控的小程序,打包成了Jar包可执行文件,通过我们的web主系统上传到各个服务器,然后调用ssh命令执行.每次上传前都要通过解压缩软件修改或者替换里面的配置文件, ...

  7. Mac系统下STF的环境搭建和运行

    本文参考以下文章整理:MAC 下 STF 的环境搭建和运行 一. 前言 STF,全称是Smartphone Test Farm,WEB 端批量移动设备管理控制工具,就是可以用浏览器来批量控制你的移动设 ...

  8. oracle分组-神奇的cube和rollup

    先看代码: 表结构如下: emp表 EMPNO                                     NOT NULL NUMBER(4) ENAME                 ...

  9. 设计模式--单例模式(Singleton pattern)及应用

    单例模式 参考文档: 该文仅介绍spring的单例模式:spring 的单例模式 介绍原理:Spring的单例模式底层实现 参考书籍:漫谈设计模式:从面向对象开始-刘济华.pdf 1. 单例模式解析 ...

  10. (转)Maven使用

    MAVEN3--(一)关于MAVEN 博客分类: MAVEN3   1.简介 MAVEN是Apache开源组织中的一个跨平台的项目管理工具. 主要功能有项目构建.依赖管理以及项目信息管理. 2.项目构 ...