re(正则表达式)库入门

6.1 正则表达式的概念

正则表达式是用来简洁表达一组字符串的表达式

正则表达式的优势：简洁
能非常简单的表达一组数据的特征，能将一组字符串的特点表达出来

• 通用的字符串表达框架
• 简洁表达一组字符串的表达式
• 针对字符串表达“简洁”和“特征”思想的工具
• 判断某字符串的特征归属

正则表达式在文本处理中十分常用

• 表达文本类型的特征（病毒、入侵等）
• 同时查找或替换一组字符串
• 匹配字符串的全部内容（主要）

正则表达式的使用

• 编译：将符合正则表达式语法的字符串转换成正则表达式的特征
  

我们可以认为编译后的特征与一组字符串 是对应的，而编译前的正则表达式只是一个符合正则表达式语法的一组字符串，但并不是真正意义上的正则表达式

6.2 正则表达式的语法

正则表达式语法由字符和操作符构成

6.3 Re库的基本使用

Re库主要用于字符串匹配

调用方式：

import re

6.3.1正则表达式的表示类型

• raw string类型（原生字符串类型）
  
• string类型，更繁琐。
  
  注： 建议当正则表达式包含转义符时使用raw string

6.3.2Re库主要功能函数

• re.search(pattern,string,flags=0)
• pattern：正则表达式的字符串或原生字符串表示
• string：待匹配字符串
• flags：正则表达式使用时的控制标记

import re
match = re.search(r'[1-9]\d{5}','BIT 100081')
if match:
    print(match.group(0))

#100081

• group和groups
  group()在正则表达式中用于获取分段截获的字符串,解释如下代码（代码来自网络）

import re
pattern = re.compile(r"([a-z]+) ([0-9]+)",re.I)

m = pattern.match("hello 2019 Hello 2018")

print(m.group(0))#hello 2019
print(m.group(1))#hello
print(m.group(2))#2019
#print(m.group(3))
print(m.group())#hello 2019

1. 正则表达式中的三组括号把匹配结果分成三组
   group() 同group（0）就是匹配正则表达式整体结果
   group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。
2. 没有匹配成功的，re.search（）返回None
3. 如果正则表达式中没有括号，group(1)就不对了。
4. 一般，m.group(N) 返回第N组括号匹配的字符
5. m.groups() 返回所有括号匹配的字符，以tuple格式。 m.groups() == (m.group(0), m.group(1), …)

• re.match(pattern,string,flags=0)
  从一个字符串的开始位置期匹配正则表达式，返回match对象

import re
match = re.match(r'[1-9]\d{5}','BIT 100081')
if match:
    match.group(0)
    
print(match.group(0))
#AttributeError: 'NoneType' object has no attribute 'group'

match = re.match(r'[1-9]\d{5}','100081 BIT')
if match:
    print(match.group(0))
    #'100081'

• re.findall(pattern,string,flags=0)
  搜索字符串，以列表类型返回全部能匹配的子串

import re
ls = re.findall(r'[1-9]\d{5}','BIT100081 TSU100084')
print(Is)
#['100081', '100084']

• re.split(pattern,string,maxsplit=0,flags=0)
  将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
• maxsplit：最大分割数，剩余部分作为最后一个元素输出

import re
print(re.split(r'[1-9]\d{5}','BIT100081 TSU100084',maxsplit=1))
#['BIT', ' TSU100084']
print(re.split(r'[1-9]\d{5}','BIT100081 TSU100084',maxsplit=2))
#['BIT', ' TSU', '']
print(re.split(r'[1-9]\d{5}','BIT100081 TSU100084',maxsplit=3))
#['BIT', ' TSU', '']
print(re.split(r'[1-9]\d{5}','BIT100081 TSU100084'))
#['BIT', ' TSU', '']

• re.finditer(pattern,string,flags=0)
  搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素时match对象

import re
for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSU100084'):
    if m:
        print(m.group(0))

        # 100081
        # 100084

• re.sub(pattern,repl,string,count=0,flags=0)
  在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

  简单说就是用一个新的字符串替换正则表达式匹配上的字符串，并与原来的字符串经组合返回一个新的字符串

  • repl：替换匹配字符串的字符串（当pattern匹配上某一个字符串后，替换的那个字符串）
  • count：匹配的最大替换次数

import re
print(re.sub(r'[1-9]\d{5}',':zipcode','BIT100081 TSU100084'))
#'BIT:zipcode TSU:zipcode'

6.3.3Re库的另一种等价用法

这种方法的好处就是经过一次编译当我们需要多次对正则表达式进行使用和匹配时候可以使用这个方式加快程序的运行

• re.compile(pattern,flags=0)
  将正则表达式的字符串形式编译成正则表达式对象
• pattern：正则表达式的字符串或原生字符串表示
• flags：正则表达式使用时的控制标记

regex=re.compile(r'[1-9]\d{5}')

字符串或原生字符串表示并不是正则表达式，他只是一种表示，如果通过compile编译生成了一个对象regex，这个regex才是正则表达式，它代表了一组字符串，所以我们可以通过这样的函数来实现正则表达式、表示之间的对应，而这种对应，使得我们能够更好的理解正则表达式对象的这种使用方式，经过了compile之后的正则表达式，就可以使用它的对象的方法，而这个对象的方法与RE库提供的6个操作方法是一致的

regex.search()
regex.match()
regex.findall()
regex.split()
regex.finditer()
regex.sub()
在这6个函数使用的过程中，需要注意，正是由于前面已经给了regex正则表达式对象，所以在调用这些函数的时候，需要将其中的正则表达式那个参数去掉，因为我们已经不再需要正则表达式的参数，只需要直接给出相关的需要匹配的字符串就可以了

6.4 Re库的match对象

match对象就是一次匹配的结果，它包含了很多匹配的相关信息

import re
match = re.search(r'[1-9]\d{5}','BIT 100081')
if match:
    print(match.group(0))#100081

print(type(match))#<class 're.Match'>

• Match对象的属性

• Match对象的方法

import re
m = re.search(r'[1-9]\d{5}','BIT100081 TSU100084')
#返回待匹配的文本
print(m.string)
#BIT100081 TSU100084

#返回匹配时使用的pattern对象（正则表达式）
print(m.re)
#re.compile('[1-9]\\d{5}')

#返回正则表达式搜索文本的开始位置
print(m.pos)
#0

#返回正则表达式搜索文本的结束位置
print(m.endpos)
#19

#返回获得匹配后的字符串
print(m.group(0))
#10081

#返回匹配字符串在原始字符串的开始位置
print(m.start())
#3

#返回匹配字符串在原始字符串的结束位置
print(m.end())
#9

#返回返回(.start(),.end())
print(m.span())
#(3,9)

6.5 Re库的贪婪匹配和最小匹配

• 贪婪匹配

Re库默认采用贪婪匹配，即输出匹配最长的子串。

import re
match = re.search(r'PY.*N','PYANBNCNDN')
print(match.group())
#PYANBNCNDN

• 如何输出最短的子串呢？

match = re.search(r'PY.*?N','PYANBNCNDN')
print(match.group(0))
#'PYAN'

• 最小匹配操作符

总结