Python字符串和转义字符的查找、替换

一、转义字符

转义字符	描述
\ (在行尾时)	续行符
\	反斜杠符号
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行，其中o是字母，不是数字0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出
\s	用于匹配单个空格符，包括tab键和换行符；
\S	用于匹配除单个空格符之外的所有字符；
\d	用于匹配从0到9的数字；
\w	用于匹配字母，数字或下划线字符；
\W	用于匹配所有与\w不匹配的字符；
.	用于匹配除换行符之外的所有字符。
.*?	表示非贪心算法，表示要精确的配对。
.*	表示贪心算法，表示要尽可能多的匹配
()	表示要获取括号之间的信息。

二、re模块

Python中re模块主要功能是通过正则表达式是用来匹配处理字符串的

常用函数

1、compile 函数

compile 函数用于编译正则表达式，生成一个 Pattern 对象，它的一般使用形式如下：

re.compile(pattern,flag=0)
'''
pattern： 正则模型
falgs ： 匹配模式,比如忽略大小写，多行模式等
返回值: Pattern 对象
'''

使用方法：

import re
# 将正则表达式编译成 Pattern 对象 
pattern = re.compile(r'\d+')

Pattern 对象的一些常用方法主要有：match 方法、search 方法、findall 方法、finditer 方法、split 方法、sub 方法、subn 方法。从compile()函数的定义中，可以看出返回的是一个匹配对象，它单独使用就没有任何意义，它单独使用就没有任何意义，需要和findall(), search(), match(）搭配使用。
实际上我们常用的正则表达式方法，都已经自带了compile了！一般情况下不需要先使用re.compile再调用正则表达式方法。

2、match 函数

从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

match(pattern, string, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# falgs ： 匹配模式

import  re
str="hello egon bcd egon lge egon acd 19"
r=re.match("h\w+",str) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None,非字母，汉字，数字及下划线分割
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict())  # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
# hello
# ()
# {}


r2=re.match("h(\w+)",str) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
print(r2.group())
print(r2.groups())
print(r2.groupdict())

# hello
# ('ello',)
# {}

r3=re.match("(?P<n1>h)(?P<n2>\w+)",str)  #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
print(r3.group())
print(r3.groups())
print(r3.groupdict())

# hello
# ('h', 'ello')
# {'n1': 'h', 'n2': 'ello'}

3、search 函数

search,浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回None

search(pattern, string, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# falgs ： 匹配模式

import  re
str="hello egon bcd egon lge egon acd 19"
r=re.search("h\w+",str) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None,非字母，汉字，数字及下划线分割
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict())  # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果

# hello
# ()
# {}


r2=re.search("h(\w+)",str) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
print(r2.group())
print(r2.groups())
print(r2.groupdict())

# hello
# ('ello',)
# {}

r3=re.search("(?P<n1>h)(?P<n2>\w+)",str)  #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
print(r3.group())
print(r3.groups())
print(r3.groupdict())

# hello
# ('h', 'ello')
# {'n1': 'h', 'n2': 'ello'}

match()函数 与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个合规则的字符串

4、findall 函数

浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表

findall(pattern, string, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# falgs ： 匹配模式

'''
注意： 一旦匹配成，再次匹配，是从前一次匹配成功的，后面一位开始的，也可以理解为匹配成功的字符串，不在参与下次匹配
'''
import re
r=re.findall("\d+\w\d+","a2b3c4d5") #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串方到一个列表中
print(r)
# ['2b3', '4d5'] #匹配成功的字符串，不再参与下次匹配，所以3c4也符合规则但是没有匹配到

'''
注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表
'''
import re
r=re.findall("","a2b3c4d5") #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串方到一个列表中
print(r)
# ['', '', '', '', '', '', '', '', ''] #如果没有写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的空字符串列表，如上是8个字符，返回是9个空字符

'''
注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是*就表示组里的内容可以是0个或者多过，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里0内容（即是空白）所以尽量避免用*否则会有可能匹配出空字符串
注意：正则只拿组里最后一位，如果规则里只有一个组，匹配到的字符串里在拿组内容是，拿的是匹配到的内容最后一位
'''
import re
r=re.findall("(ca)*","ca2b3caa4d5") #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串方到一个列表中
print(r)
# ['ca', '', '', '', 'ca', '', '', '', '', '']#用*号会匹配出空字符

'''
无分组：匹配所有合规则的字符串，匹配到的字符串放到一个列表中
'''
import re
r=re.findall("a\w+","ca2b3 caa4d5") #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串方到一个列表中
print(r)
# ['a2b3', 'aa4d5']#匹配所有合规则的字符串，匹配到的字符串放入列表

'''
有分组：只将匹配到的字符串里，组的部分放到列表里返回，相当于groups()方法
'''
import re
r=re.findall("a(\w+)","ca2b3 caa4d5") #有分组：只将匹配到的字符串里，组的部分放到列表里返回
print(r)
# ['2b3', 'a4d5']#返回匹配到组里的内容返回

'''
多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返
相当于在group()结果里再将组的部分，分别，拿出来放入一个元组，最后将所有元组放入一个列表返回
'''
import re
r=re.findall("(a)(\w+)","ca2b3 caa4d5") #有多分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返回
print(r)
# [('a', '2b3'), ('a', 'a4d5')]#返回的是多维数组

'''
分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
'''
import re
r=re.findall("(a)(\w+(b))","ca2b3 caa4b5") #分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
print(r)
# [('a', '2b', 'b'), ('a', 'a4b', 'b')]#返回的是多维数组

'''
?:在有分组的情况下findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
'''
import re
r=re.findall("a(?:\w+)","a2b3 a4b5 edd") #?:在有分组的情况下，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
print(r)
# ['a2b3', 'a4b5']

5、finditer 函数

6、split 函数

根据正则匹配分割字符串，返回分割后的一个列表

split(pattern, string, maxsplit=0, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# maxsplit：指定分割个数
# flags  ： 匹配模式

import  re
r=re.split("a\w","sdfadfdfadsfsfafsff")
print(r)
r2=re.split("a\w","sdfadfdfadsfsfafsff",maxsplit=2)
print(r2)

# ['sdf', 'fdf', 'sfsf', 'sff']
# ['sdf', 'fdf', 'sfsfafsff']

7、sub 函数

替换匹配成功的指定位置字符串

sub(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl   ： 要替换的字符串
# string ： 要匹配的字符串
# count  ： 指定匹配个数
# flags  ： 匹配模式

import  re
r=re.sub("a\w","替换","sdfadfdfadsfsfafsff")
print(r)

# sdf替换fdf替换sfsf替换sff

'''注意：同时替换所有元素时，可以使用 竖线 | 将所有想要替换的元素隔开，表示或的意思。'''
a = '于枫#1立马#1立正#3，全身#1绷直#4！'
b = re.sub('#1|#2|#3|#4','',a)
print(b)   ## 于枫立马立正，全身绷直！

8、subn 函数

替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受

subn(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl   ： 要替换的字符串
# string ： 要匹配的字符串
# count  ： 指定匹配个数
# flags  ： 匹配模式

import  re
a,b=re.subn("a\w","替换","sdfadfdfadsfsfafsff") #替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
print(a) #返回替换后的字符串
print(b) #返回替换次数

# sdf替换fdf替换sfsf替换sff
# 3

三、字符串

常用函数

1、replace函数

替换单个的字符或指定的字符串

s1 = 'abcDEF'
s2 = s1.replace('a','A')
'''想同时替换掉两个或多个字符串呢，直接调用多次就行了'''
s1 = 'abcDEF'
s2 = s1.replace('a','A').replace('b','B')

待补充