python 正则表达式用法

做数据清洗时，经常需要用到正则表达式替换等等

首先介绍一下元字符（匹配规则）

.                    匹配任意字符（不包括换行符）
^                    匹配开始位置，多行模式下匹配每一行的开始
$                    匹配结束位置，多行模式下匹配每一行的结束
*                    匹配前一个元字符0到多次
+                    匹配前一个元字符1到多次
?                    匹配前一个元字符0到1次
{m,n}                匹配前一个元字符m到n次
\\                   转义字符，跟在其后的字符将失去作为特殊元字符的含义，例如\\.只能匹配.，不能再匹配任意字符
[]                   字符集，一个字符的集合，可匹配其中任意一个字符
|                    逻辑表达式 或 ，比如 a|b 代表可匹配 a 或者 b
(...)                分组，默认为捕获，即被分组的内容可以被单独取出，默认每个分组有个索引，从 1 开始，按照"("的顺序决定索引值
(?iLmsux)            分组中可以设置模式，iLmsux之中的每个字符代表一个模式,用法参见 模式 I
(?:...)              分组的不捕获模式，计算索引时会跳过这个分组
(?P<name>...)        分组的命名模式，取此分组中的内容时可以使用索引也可以使用name
(?P=name)            分组的引用模式，可在同一个正则表达式用引用前面命名过的正则
(?#...)              注释，不影响正则表达式其它部分,用法参见 模式 I
(?=...)              顺序肯定环视，表示所在位置右侧能够匹配括号内正则
(?!...)              顺序否定环视，表示所在位置右侧不能匹配括号内正则
(?<=...)             逆序肯定环视，表示所在位置左侧能够匹配括号内正则
(?<!...)             逆序否定环视，表示所在位置左侧不能匹配括号内正则
(?(id/name)yes|no)   若前面指定id或name的分区匹配成功则执行yes处的正则，否则执行no处的正则
\number              匹配和前面索引为number的分组捕获到的内容一样的字符串
\A                   匹配字符串开始位置，忽略多行模式
\Z                   匹配字符串结束位置，忽略多行模式
\b                   匹配位于单词开始或结束位置的空字符串
\B                   匹配不位于单词开始或结束位置的空字符串
\d                   匹配一个数字， 相当于 [0-9]
\D                   匹配非数字,相当于 [^0-9]
\s                   匹配任意空白字符， 相当于 [ \t\n\r\f\v]
\S                   匹配非空白字符，相当于 [^ \t\n\r\f\v]
\w                   匹配数字、字母、下划线中任意一个字符， 相当于 [a-zA-Z0-9_]
\W                   匹配非数字、字母、下划线中的任意字符，相当于 [^a-zA-Z0-9_]

补充一下转义字符\，可以转义很多字符：

\n：换行

\t：制表符

\\：表示\

当然也可以使用r' '：默认' '内部的的字符不转义

#输出的字符中也有' 或者"
print('I\'m \"ok\"!')  #将',''转义，  I'm "ok"!

#记住字符要加上''
print('\\\n\\')  
#输出：
\
\

print('\\\t\\')
#输出：
\       \

#r''
print(r'\\\t\\')  #\\\t\\

比如下面的例子

在正则表达式中，如果直接给出字符，就是精确匹配：
'00\d'  可以匹配'007'，但无法匹配'00A'；
'\d\d\d'  可以匹配'010'；
'\w\w\d'  可以匹配'py3'；
'py.'  可以匹配'pyc'、'pyo'、'py!'等等


要匹配变长的字符，在正则表达式中，用*表示任意个字符（包括0个），用+表示至少一个字符，用?表示0个或1个字符，用{n}表示n个字符，用{n,m}表示n-m个字符
如：\d{3}\s+\d{3,8}
1.\d{3}  表示匹配3个数字，例如'010'；
2.\s  可以匹配一个空格（也包括Tab等空白符），所以\s+表示至少有一个空格，例如匹配' '，' '等；
3.\d{3,8}  表示3-8个数字，例如'1234567'
综合起来，上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码
如果要匹配'010-12345'这样的号码呢？由于'-'是特殊字符，在正则表达式中，要用'\'转义，所以，上面的正则是\d{3}\-\d{3,8}

看看进阶版的例子

要做更精确地匹配，可以用[]表示范围：
[0-9a-zA-Z\_]  可以匹配一个数字、字母或者下划线；
[0-9a-zA-Z\_]+  可以匹配至少由一个数字、字母或者下划线组成的字符串，比如'a100'，'0_Z'，'Py3000'等等；
[a-zA-Z\_][0-9a-zA-Z\_]*  可以匹配由字母或下划线开头，后接任意个由一个数字、字母或者下划线组成的字符串，也就是Python合法的变量；
[a-zA-Z\_][0-9a-zA-Z\_]{0, 19}  更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）


A|B  可以匹配A或B，所以(P|p)ython可以匹配'Python'或者'python'。
^表示行的开头，^\d表示必须以数字开头。
$表示行的结束，\d$表示必须以数字结束。
你可能注意到了，py也可以匹配'python'，但是加上^py$就变成了整行匹配，就只能匹配'py'了

 

re模块

re.match(r‘正则表达式’,test)

该方法判断是否匹配成功，如果匹配成功，就返回一个match对象，否则返回None

import re 

re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
#输出：<re.Match object; span=(0, 9), match='010-12345'>

re.match(r'^\d{3}\-\d{3,8}$', '010 12345')  #啥都不输出

#简单的小程序,需要自己替换正则表达式
test = input('用户输入的字符串:')
if re.match(r'正则表达式', test):
    print('ok')
else:
    print('failed')

切分字符串

re.split(r'正则表达式','被切割对象')

#字符串有切割函数split
'a b  c'.split(' ')  #['a', 'b', '', 'c']

#如果想把空格去掉
re.split(r'\s+','a b  c')  #['a', 'b', 'c']

#无论多少个空格都可以正常分割。加入,试试
re.split(r'[\s\,]+', 'a,b, c  d')  #['a', 'b', 'c', 'd']

#再加入;试试
re.split(r'[\s\,\;]+', 'a,b;; c  d')  #['a', 'b', 'c', 'd']

提取子串

SQL的split也有提取子串的功能，split(a,b)[0]或者是split(a,b)[1]

正则表达式用()表现要提取的分组（group），可以在match对象上使用group()方法

group(0)是原始字符串，group(1)，group(2)分别是第1,2个子串，groups()则输出全部子串

#group()
m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
for i in range(3):
    print(m.group(i))

#输出：
010-12345
010
12345

#如果是groups()则输出全部子串
t = '19:05:30'
m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
m.groups()   #('19', '05', '30')

 

贪婪匹配

正则匹配默认的是贪婪匹配，也就是匹配尽可以多的字符

#贪婪匹配
#由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了
re.match(r'^(\d+)(0*)$', '102300').groups()   #('102300', '')

#必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配
re.match(r'^(\d+?)(0*)$', '102300').groups()   #('1023', '00')

 

编译

re.compile()

就是为了避免重复使用时多次输入

#编译：
re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')   
re_telephone.match('010-12345').groups()  #('010', '12345')
re_telephone.match('010-8086').groups()  #('010', '8086')

 

全部代码如下：

# -*- coding: utf-8 -*-
"""
Created on Tue Jul 21 10:52:00 2020

@author: Admin
"""



import pandas as pd
import numpy as np

#输出的字符中也有' 或者"
print('I\'m \"ok\"!')  #将',''转义，  I'm "ok"!

#记住字符要加上''
print('\\\n\\')  
#输出：
\
\

print('\\\t\\')
#输出：
\       \

#r''
print(r'\\\t\\')  #\\\t\\

import re 

re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
#输出：<re.Match object; span=(0, 9), match='010-12345'>

re.match(r'^\d{3}\-\d{3,8}$', '010 12345')  #啥都不输出

#简单的小程序,需要自己替换正则表达式
test = input('用户输入的字符串:')
if re.match(r'正则表达式', test):
    print('ok')
else:
    print('failed')



#字符串有切割函数split
'a b  c'.split(' ')  #['a', 'b', '', 'c']

#如果想把空格去掉
re.split(r'\s+','a b  c')  #['a', 'b', 'c']

#无论多少个空格都可以正常分割。加入,试试
re.split(r'[\s\,]+', 'a,b, c  d')  #['a', 'b', 'c', 'd']

#再加入;试试
re.split(r'[\s\,\;]+', 'a,b;; c  d')  #['a', 'b', 'c', 'd']
 

#group()
m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
for i in range(3):
    print(m.group(i))

#输出：
010-12345
010
12345

#如果是groups()则输出全部子串
t = '19:05:30'
m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
m.groups()   #('19', '05', '30')

#贪婪匹配
#由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了
re.match(r'^(\d+)(0*)$', '102300').groups()   #('102300', '')

#必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配
re.match(r'^(\d+?)(0*)$', '102300').groups()   #('1023', '00')
 


#编译：
re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')   
re_telephone.match('010-12345').groups()  #('010', '12345')
re_telephone.match('010-8086').groups()  #('010', '8086')