一、正则表达式

1. 简介

正则表达式（regular expression）(regex)(RE)，用来简洁表达一组字符的表达式，由字符和操作符构成。
正则表达式常用于文本处理，表达文本类型的特征，同时查找或替换一组字符串、匹配字符串的全部或部分

2. 正则表达式中的符号

按照符号的功能，可将其分为三类，一般情况下表达式都是由这三种符号组成的。

2.1 正则字符

2.2 限定字符

2.3 定位字符

2.4 经典实例

二、re库

1. 简介

2. 常用方法

2.1 re.search(pattern,string,flags=0)

pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

flags 如：
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性，忽略空格和 # 后面的注释

2.2 re.match(pattern,string,flags=0)

（1）与re.search()的区别在于：
re.match()是从起始位置就匹配成功，否则返回none;
re.search()匹配整个字符串，直到找到一个匹配成功的。注意：一次匹配，如果后面还有匹配的也不会查找了.
（2）提取数据：group

• group()用来提取分组截获的字符串，（）用来分组。
• group() 同group（0）用来表示匹配正则表达式整体结果。
• group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。
• 当嵌套分组时（有两层括号），即r'((expression1)(expression2))'的情况时，最外层的分组被解释成一个整体group(1)，里层的分组解释从group(2)开始
• 没有匹配成功的，re.search()返回None。

(3)常用方法

group(): 用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)
span(): 返回匹配字符串的起始位置
start()：用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
end()：用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0 

2.2 re.findall(string[, pos[, endpos]])

• 其中，string 是待匹配的字符串，pos 和 endpos 是可选参数，指定字符串的起始和终点位置，默认值分别是 0 和 len (字符串长度)。
• findall 以列表形式返回 。

import re
pattern=r'([a-z]+) ([a-z]+)'
text='hello World python'
#Example 1 search
search_list = re.search(pattern, text) 
if search_list:
    print(search_list)
print(search_list.group())
print(search_list.group(1))
print(search_list.group(2))
#结果
<re.Match object; span=(7, 18), match='orld python'>
orld python
orld
python

#Example 2 match
#2.1
match_list = re.match(pattern, text) 
if match_list:
	 print(match_list)
#结果为none 因为match是从头开始匹配

#2.2
#Example 2 match
pattern2=r'([a-z]+) (\w{5})'
text='hello World python'
match_list = re.match(pattern2, text) 
if match_list:
    print(match_list)
print(match_list.group(1))
print(match_list.group(2))
#结果
<re.Match object; span=(0, 11), match='hello World'>
hello
World

#Example 3 findall
findall_list = re.findall(pattern, text) 
if findall_list:
	 print(findall_list)
#结果
['hello', 'orld']

2.3 re.split(string[, maxsplit])

其中，maxsplit 用于指定最大分割次数，不指定将全部分割。跟字符串的分隔类似，但是这个更加灵活。

import re
pattern3=r'[\s\d]+'
text='hello World python'
split_list=re.split(pattern3,text) ## 表示遇到空白字符\s或者数字\d，都会切割。+表示如果有多个空格也可以切割。
print(split_list)
#结果
['hello', 'World', 'python']

#以上也可以写成
split_list=re.split(r'[\s\d]+','hello World python')

2.4 re.sub(repl, string[, count]) ==>re.sub(pattern, repl, string)

repl 可以是字符串也可以是一个函数：

• 如果 repl 是字符串，则会使用 repl 去替换字符串每一个匹配的子串，并返回替换后的字符串，另外，repl 还可以使用 id 的形式来引用分组，但不能使用编号 0；
• 如果 repl 是函数，这个方法应当只接受一个参数（Match 对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
• count用来指定最多替换的次数，默认为全部替换。

#Example 1 将数字进行更改
pattern = '\d+'
repl = 'NUM'
string = """Python是一门面向对象的编程语言，诞生于1991年。\
一般情况下Python是Java的20%，所以说人生苦短，我用Python。"""
re.sub(pattern, repl, string)

#Example 2 对某一个词汇进行同一表达
text = 'Python是一门面向对象的编程语言，诞生于1991年。\
一般情况下Python语言是Java的20%。Python目前使用人数很多。'
pattern = '[(Python语言)+(Python)]+'   #要加+，否则变成[]内任一字符参与替换，从而导致多次替换
repl = 'Python语言'
re.sub(pattern, repl, text)

#Example 3 替换函数用法
def read_num(num):
    num_temp = num.group() 
    num = int(num_temp) + 1
    return str(num)
 
s = "阅读次数为：999,浏览次数为2000"
ret = re.sub(r"\d+",read_num,s)
print(ret)
#print结果：阅读次数为：1000,浏览次数为2001
#sub方法会将匹配到的数据依次传到方法read_num中，\
#所以我们首先要使用group方法获取到每个参数的具体内容，然后将这个字符串转为int类型，再加1，注意return的时候要转为字符串，这个位置的值只能是字符串

3. 贪婪与非贪婪

• 贪婪匹配：Python默认贪婪匹配，即尽可能多的匹配。
• 非贪婪匹配：在 “*” “？” “+” “{m,n}”的后面加上？就可以做到非贪婪，尽可能少的匹配

s=“this is a number: 0312-265-8888”
ret = re.match(r".+(\d+-\d+-\d+)",s)  #因为要匹配数字，所以把号码用括号括起来
ret.group()
#'this is a number:0512-587-4567' #这个结果是这种方式提取到的号码，明显不是我们想要的.
#贪婪方式:前面的.+尽可能的匹配多一些，后面的\d+只要有一个数字就可以满足(造成group(1)前一个只有一个2），所以别的数字都归到了.+里面
ret.group(1)    
#'2-587-4567'

#改成非贪婪模式
ret = re.match(r".+?(\d+-\d+-\d+)",s)
ret.group(1)  
#'0312-265-8888'  此时尽可能多的匹配后面的\d+。