正则表达式

• 正则表达式就是描述字符串排列的一套规则。利用正则表达式能够作不少事情，主要用于字符串的匹配
• 在实际项目中，咱们常常须要找到某一类符合某种格式的信息，此时，咱们能够观察这些数据的规律，而后将这些数据的格式规律用正则表达式形式描述出来，而后利用正则表达式函数进行相应的处理便可。
  本节主要为你们介绍正则表达式怎么去写，将从原子、原子符、模式修正符、贪婪模式与懒惰模式等方面介绍

1.原子

原子是正则表达式中最基本的组成单位，每一个正则表达式中至少要包含一个原子
常见的原子有这几类：普通字符做为原子、非打印字符做为原子、通用字符做为原子和原子表php

(1) 普通字符做为原子

• 咱们可使用一些普通的字符，好比数字，大小写字母，下划线等均可做为原子使用，以下程序中，‘yue’做为原子使用，这里有三个原子，分别是y,u,e

#普通字符做为原子
import re
pattern = "yue"#yue做为原子使用，有三个原子，分别是y,u,e
string = "http://yum.iqianyue.com"
resultl = re.search(pattern,string)#在string中匹配正确的正则表达式，若匹配成功，将匹配结果返回给变量result
print(resultl)

<_sre.SRE_Match object; span=(16, 19), match='yue'>

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

• 指的是一些在字符串中用于格式控制的符号，好比换行符等（经常使用的非打印字符为 ‘\n’ :用于匹配一个换行符， ‘\t’ ：用于匹配一个制表符）

##非打印字符做为原子
import re
pattern = "\n"
string = '''http://yum.iqianyue.com
http://baidu.com'''  #字符串变量string中包含一个多行的数据，因此这个数据里面包含了对应的换行符，因此，此时进行换行符匹配
resultl = re.search(pattern,string)
print(resultl)

<_sre.SRE_Match object; span=(23, 24), match='\n'>

import re
pattern = "\n"
string = '''http://yum.iqianyue.comhttp://baidu.com'''#在字符串中不包含换行，因此没法成功匹配，故最后输出None
resultl = re.search(pattern,string)
print(resultl)

None

(3) 通用字符做为原子（即一个原子能够匹配一类字符）

• 通用字符，即一个原子能够匹配一类字符
• 常见的通用字符及其含义：

#通用字符做为原子示例
import re 
pattern = "\w\dpython\w"#'\w'匹配任意一个字母、数字、下划线;'\d'匹配任意一个十进制数；
string = "abcdfphp345pythony_py"
result1 = re.search(pattern,string)
print(result1)

<_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等。

#原子表示例
import re 
pattern1 = "\w\dpython[xyz]\w"
pattern2 = "\w\python[^xyz]\w"
pattern3 ="\w\dpython[xyz]\W"
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
print(result1)
print(result2)
print(result3)

<_sre.SRE_Match object; span=(9, 19), match='45pythony_'>
None
None

2 原子符

• 原子符就是正则表达式中具备一些特殊含义的字符，好比重复N次前面的字符等。
  常见的元子符:

(1) 任意匹配原子符

首先看任意匹配符‘.’，能够用‘.’匹配一个除换行符之外的任意字符。
好比，用正则表达式“.python...”匹配一个“python”字符前面有1位，后面有3位格式的字符，这前面的1位和后面的3位能够是除了换行符意外的任意字符。如如下程序：python

import re
pattern=".python..."
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1,string)
print(result1)

<_sre.SRE_Match object; span=(9, 19), match='45pythony_'>

(2) 边界限制原子符

可使用“^”匹配字符串的开始，使用“$”匹配字符串的结束，以下例：正则表达式

import re 
pattern1 = "^abd"#限制以abd开始
pattern2 = "^abc"#限制以abc开始
pattern3 ="py$"#限制以py结束
pattern4 = "ay$"#限制以ay结束
string = "abcdfphp345pythony_py"#源字符串
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

None
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(19, 21), match='py'>
None

(3) 限定符

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

• 看如下例子

import re 
pattern1 = "py.*n"
pattern2 = "cd{2}"
pattern3 ="cd{3}"
pattern4 = "cd{2, }"
string = "abcdddfphp345pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

<_sre.SRE_Match object; span=(13, 19), match='python'>
<_sre.SRE_Match object; span=(2, 5), match='cdd'>
<_sre.SRE_Match object; span=(2, 6), match='cddd'>
None

(4) 模式选择符

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

#模式匹配符示例
import re 
pattern = "python|php"
string ="abcdfphp345pythony_py" 
result = re.search(pattern,string)
print(result)
#能够看出，从源字符串中匹配到告终果“php”

<_sre.SRE_Match object; span=(5, 8), match='php'>

3 模式修正

• 模式修正符，就是能够在不改变正则表达式的状况下，经过模式修正符改变正则表达式的含义，从而实现一些匹配结果的调整等功能。
  经常使用的模式修正符：

import re 
pattern1 = "python"
pattern2 = "python"
string = "abcdfphp345Pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string,re.I)#忽略大小写
print(result1)
print(result2)

None
<_sre.SRE_Match object; span=(11, 17), match='Python'>

import re
pattern = "\t"
string = '''http://yum.iqianyue.com
http://baidu.com'''
resultl = re.search(pattern,string)
print(resultl)

None

4 贪婪模式与懒惰模式

总的来讲，贪婪模式就是的核心就是尽量多的匹配，而懒惰模式就是尽量少的匹配。
可看下面的示例：code

import re 
pattern1 = "p.*y"#贪婪模式
pattern2 = "p.*? y"#懒惰模式
string = "abcdfphp345pythony_py"
result1= re.search(pattern1,string)
result2=re.search(pattern2,string)
print(result1)#找到结尾字符y才中止，即找到最后一个y字符才中止
print(result2)#一旦找到了字符y就中止

<_sre.SRE_Match object; span=(5, 21), match='php345pythony_py'>
None

5 正则表达式常见函数

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

(1) re.match()函数

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

import re
pattern = ".python"
string = "apythonhellomypythonhispythonourpythononend"
result1=re.match(pattern,string)
result2 = re.match(pattern,string).span()#经过.span()能够过滤掉一些信息，只留下匹配成功的结果在源字符串中的位置
print(result1)
print(result2)

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

(2) re.search()函数

用该函数进行匹配，会扫描整个源字符串并进行对应的匹配。
与re.match()函数的不一样之处，该函数在全文中进行检索匹配，而re.match()函数是从源字符串的开头进行匹配。编译

import re
pattern = ".python"
string = "hellomypythonhispythonourpythononend"
result1=re.match(pattern,string)
result2 = re.search(pattern,string)
print(result1)
print(result2)

None
<_sre.SRE_Match object; span=(6, 13), match='ypython'>

(3) 全局匹配函数

• 就是将符合模式的内容所有都匹配出来.思路：
• 1.使用re.compile()对正则表达式进行编译
• 2.编译后，使用indall()根据正则表达式从源字符中将匹配的结果所有找出

import re
string = "hellomypythonhispythonourpythonend"
pattern =re.compile(".python.")#预编译
result =pattern.findall(string)#找出全部符合模式的结果
print(result)

['ypythonh', 'spythono', 'rpythone']

#对上式的整合
import re
string = "hellomypythonhispythonourpythonend"
pattern = ".python."
result =re.compile(pattern).findall(string)
print(result)

['ypythonh', 'spythono', 'rpythone']

(4) re.sub()函数

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

import re
string = "hellomypythonhispythonourpythonend"
pattern = "python."
result = re.sub(pattern,"php",string)
result2=re.sub(pattern,"php",string,)
print(result1)
print(result2)

<_sre.SRE_Match object; span=(5, 19), match='php345pytho_py'>
hellomyphpisphpurphpnd