Python_正则表达式

2018-09-18 06:43:00来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

正则表达式: 匹配字符串

  re.compile():用于编译正则表达式,生成一个正则表达式对象,供 match() 和 search() 两个函数使用,一般建议使用这种编译方式

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 l = re.compile(r'(.+)[0-2](.*)')                # 对要匹配的格式先进行编译,并且整个过程中只编译一次
4 m = re.search(l, str)
5 m1 = re.search(r'(.+)[0-2](.*)',str)             
6 # 这是对上面两行的简写,这种写法每次匹配的时候都要进行一次匹配公式的编译,如何行数太多,就会使代码运行很慢
7 print(m.group())
8 print(m1.group())

注: 由于反斜杠在Python和正则表达式中的影响,所以添加了 r 来使 字符串表示原生字符串,如果不使用 r   ,那么匹配时需要4个反斜杠,稍后有对反斜杠的解释

结果:

abc1def2ghi3jkl4mn
abc1def2ghi3jkl4mn

 

正则表达式的几种方法:  

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

从头开始匹配,如果在开始位置匹配不成功则返回None

(flags:标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等)

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

 匹配整个字符串,返回第一个成功匹配的,和match()的区别在于:开始位置匹配不成功也可继续匹配

 

re.split(pattern, string[, maxsplit=0, flags=0)

将能够匹配到的字符串当做分割点对字符串进行分割成列表

( maxsplit:分割次数,maxsplit= 1,表示分割一次,默认为0 ,表示比限制次数)

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

找到所有匹配的字符子串 并以列表格式返回

(pos:指定字符串的起始位置,默认为0,endpos:指定字符串结束位置,默认为字符长度)

re.finditer(pattern, string, flags=0 )

在字符串中找到所匹配到的子串,并作为一个迭代器返回

 

re.sub(pattern ,repl , string, count=0 , flag=0 )

替换匹配到的字符,以字符串的形式返回

(repl:替换的字符串,也可为一个函数)

(count:模式匹配后替换的最大次数,默认0 表示替换所有的匹配)

re.subn(pattern,repl,string)

替换匹配到的字符,并返回一个替换了多少次的总数,以元组的形式返回

 

代码实现:

re.match():

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.match('[0-9]', str)
4 m1 = re.match('abc',str)
5 print(m,m1.group())

结果:

None abc

re.search():

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.search('[0-9]', str)
4 print(m)
5 print(m.group())

结果:

<_sre.SRE_Match object; span=(3, 4), match='1'>
1

re.split():

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.split('[0-9]', str,)
4 print(m)

结果:

['abc', 'def', 'ghi', 'jkl', 'mn']

re.findall():

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.findall('[0-9]', str)
4 print(m)

结果:

['1', '2', '3', '4']

re.finditer

1 import re 
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.finditer('abc|ef', str)
4 print(m.__next__())
5 print(m.__next__().group())

结果:

<_sre.SRE_Match object; span=(0, 3), match='abc'>
ef

re.sub():

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.sub('[0-9]', '*',  str, count=3)
4 print(m)

结果:

abc*def*ghi*jkl4mn

re.subn():

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.subn('[0-9]', '*', str)
4 print(m)

结果:

('abc*def*ghi*jkl*mn', 4)

 

正则表达式的基本语法规则:

一般字符 匹配自身相对应的字符
  .

匹配出换行符(\n)以外的任意字符

 ^ 匹配字符串起始部分
 $

匹配字符串终止部分

* 匹配0次或多次前面出现的正则表达式
+ 匹配1 次或多次前面出现的正则表达式
匹配字符重复0次到1次前面出现的正则表达式
{N} 匹配N次前面出现的正则表达式
{N,} 匹配至少N次前面出现的正则表达式
{M,N} 匹配M~N次前面出现的正则表达式
[...] 匹配来自字符集的任意单一字符,如:[amk]匹配'a','m'或'k'
[^...] 不匹配此字符集出现的任何一个字符
[ x - y ] 匹配x~y范围中的任意单一字符
a | b 匹配 a 或 b
(...) 匹配括号内的表达式,将被括起来的表达式作为一个分组,可以使用索引单独取出
 扩展表示法  
 (?....) 分组的不捕获模式,计算索引时会跳过这个分组(表示一个匹配不用保存的分组)
(? ilmsux) 分组中可以设置模式,ilmsux之中的每个字符代表一个模式
 (?imx) 正则表达式包含三种可选标志:i,m,或x,值影响括号中的区域
(?-imx)  正则表达式关闭i,m,或x可选标志,只影响括号中的区域 
(?:     )  类似(...),但不表示一个组
( ?-imx :    )  在括号中不使用i, m,或x 可选标志 
(?imx :      )  在括号中使用i, m,或x 可选标志 
(?#...) 注释 
(?=...) 顺序肯定环视,表示所在位置右侧能够匹配括号内正则
(?!...)  顺序否定环视,表示所在位置右侧不能匹配括号内正则
(?<=...)  逆序肯定环视,表示所在位置左侧能够匹配括号内正则 
(?<!...)  逆序否定环视,表示所在位置左侧不能匹配括号内正则
(?P=name) 引用该分组中的内容
(?P<name>...)   为该分组起一个名字,可以用索引或名字去除该组名字
(?(id/name)Y|N)  如果分组提供的id或name(名称)存在,就返回正则表达式的条件匹配Y,如果不存在就返回N,N为可选项 
 特殊符号  
\A 匹配字符串开始
\b 匹配一个单词的边界,一般是指单词和空格间的位置,例:'er\b'可以匹配‘never’中的'er',但不能匹配‘verb’中的‘er’
\B 匹配非单词边界
\w 匹配字母数字
\W 匹配非字母数字
\s 匹配任意空白字符,等价于[\t\n\r\f]
\S 匹配任意非空字符
\d 匹配任意数字,等价与[0-9]
\D 匹配任意非数字
\z 匹配字符串结束
\Z 匹配字符串结束,如果存在换行,只匹配到换行前的结束字符串
\G 匹配最后匹配完成的位置
\n,\t 匹配一个换行符,匹配一个制表符,等
\1...\9 匹配第n个分组的子表达式
\10 匹配第n个分组的子表达式,否则指的是八进制字符码的表达式

          由于正则表达式使用反斜杠来转义字符,虽然Python正则表达式模块的转义是独立的,但是Python自身处理字符串时,反斜杠也是用于转义字符,就产生了双重转换。

例:匹配一个反斜杠字符需要将参数写成'\\\\':

  '\\\\'将被转义为'\\'

Python中的转义:

  • 在python中使用正则表达式时要切记反斜线\具有两层转义功能,如果你要匹配一个反斜线本身时要注意它必须被转义两次。(除非你使用原始字符串,就是字符串前面加r)
  • Python遇到无法识别字符串中的\[,不会报错,而是将它原样"转交"给字符串: 字符串的表现层: \[ \\[, 字符串的概念层: \[ \[, 正则表达式的表现层: \[ \[, 正则表达式的概念层 :[(非元字符) [(非元字符)  

部分基本语法的代码实现:

 1 import re
 2 s = '65432ab1cdefg'
 3 m0 = re.findall('.', s)
 4 m1 = re.findall('.*', s)      # 匹配任意字符 * 表示匹配0个到多个表达式
 5 m2 = re.findall('.+', s)       # 匹配任意字符 + 表示匹配1个到多个表达式
 6 m8 = re.findall('[^\d].*', s)   # [^...]匹配除...以外的字符
 7 print(m0)
 8 print(m1)
 9 print(m2)
10 print(m8)
11 
12 s1 = '6789_45   6a~bc@$deF'
13 m3 = re.findall('\S', s1)           # \S 匹配非空的任意字符
14 m4 = re.findall('[a-zA-Z]+', s1)     # 匹配大小写字符
15 m5 = re.search('\d+', s1)              # \d 匹配任意数字
16 m6 = re.search('^\d+$', '123455890')  # 如果这个字符串里有字母,那这行代码就会报错,因为\d+ 表示连续数字匹配
17 m7 = re.search('^.+$', '12345f5890')   # . 表示匹配任意字符,所以这里的 ^ $可以从开头匹配到结尾
18 
19 print(m3)
20 print(m4)
21 print(m5.group())
22 print(m6.group())
function

结果:

result

 

flags模式:可选标志位的具体参数:(可以通过or(|)指定多个标志位)

re.I       忽略大小写( 大小写不敏感模式 )
re.L  影响\w ,  \W ,  \b ,  \B ,  \s , \S ,  取决于 本地系统的语言设置(如:要处理法文文本,并用\w来处理文本,那必须是系统配置适当且 把本地化语言改为法文)
re.M 影响 ^,$, (此时,^,$ 不会被解释 )"^" 依然匹配字符串的开始和字符串中每行的开始。同样的, $ 元字符匹配字符串结尾和字符串中每行的结尾
re.S  相当于 .  并且包括换行符在内的任意字符  ( . 是不包括换行符的   )
 re.U  表示特殊字符\w ,  \W ,  \b ,  \B ,  \d ,  \D ,  \s ,  \S  依赖于Unicode字符属性数据库
re.X 空白符被忽略,除非该空白符在字符类中或在反斜杠之后;并且允许你将注释写入 RE,这些注释会被引擎忽略;注释用 "#"号 来标识,不过该符号不能在字符串或反斜杠之后

实例实现:

1 import re
2 str = 'abc\ndef\nghi'
3 m = re.search('^a.*i$', str, flags=re.S)          # re.S 匹配包括换行的任意字符
4 print(m.group())
5 m = re.search('^a.*$', str, flags=re.M)       # ^ $ 受 re.M影响,匹配行的开始和结尾
6 print(m.group())
s

结果:

abc
def
ghi
abc
result

 

几种匹配对象的方法:

x.group(m,...) 返回匹配字符串,默认m=0,可以获得第一个或者第m个括号的分组,多参数时将以元组的形式返回
x.groups() 返回一个包含所有小组字符串的元组
x.start(m) 默认m=0,返回第m个括号的字符串的开始索引
x.end(m) 默认m=0,返回第m个括号字符串的结束索引
x.span(m) 默认m=0,返回第m个括号字符串的开始索引和结束索引

 实例:

1 import re
2 str = 'abc1def2ghi3jkl4mn'
3 m = re.search(r'(.+)[0-2](.*)', str)
4 print(m.group())
5 print(m.group(2))     
6 print(m.start())
7 print(m.end())
8 print(m.span())
example

 

结果:

abc1def2ghi3jkl4mn
ghi3jkl4mn
0
18
(0, 18)
result

 

什么是贪婪匹配,什么是懒惰匹配

贪婪匹配:Python正则表达式默认的匹配,在匹配成功的前提下,正则表达式趋向于最大长度的匹配方式

非贪婪匹配(懒惰匹配):在整个表达式匹配成功的前提下,尽可能少的匹配

贪婪词 惰性词 对贪婪的描述
?? 匹配前一个字符重复0次到1次
* *? 匹配0次或多次
+ +? 匹配1次或多次
{n} {n}? 匹配n次
{n , m} {n , m}? 匹配n~m次,但至多不能超过m次
{n, } {n, }? 匹配至少出现n次

实现:

 1 import re
 2 str = 'aaaaabbbbb'
 3 m = re.findall('.a*', str)        # . 代表匹配除换行符的所有字符
 4 m1 = re.findall('.a*?', str)
 5 m2 = re.findall('.b{2,}', str)
 6 m3 = re.findall('.b{2,}?', str)
 7 print(m)
 8 print(m1)
 9 print(m2)
10 print(m3)
import

结果:

['aaaaa', 'b', 'b', 'b', 'b', 'b']                     #一次就匹配完了a
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b']
['abbbbb']
['abb', 'bbb']
result

正则表达式的简单匹配例子:

例1,匹配电话号码:

1 import re
2 phone_str = 'my phone number is 18380364920'
3 m = re.search('(1)([34578]\d{9})', phone_str)   # (1)表示第一个分组,[34578]表示第二个数字能匹配的数字 ,\d相当于[0-9]
4 
5 if m:
6     print(m.group())
phone

结果:

18380364920
result

例2,简单匹配email:

1 import re
2 email = '2536vera.yin@qq.com'
3 m = re.search(r'[0-9.a-z]{1,26}@[0-9.a-z]{0,20}.[0-9a-z]', email)
4 print(m.group())
email

结果:

 

2536vera.yin@qq.com
View Code

 

例3,简单匹配IP V4

 1 import re
 2 def ai():
 3     str = input('ipv4地址:')
 4     m = re.findall('^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$', str)
 5     if m:
 6         print('ip 有效:', m)
 7     else:
 8         print('ip 无效:', m)
 9     ai()
10 
11 ai()
IPv4

结果:

ipv4地址:192.168.3.22
ip 有效: ['192.168.3.22']
ipv4地址:223.432.44.3
ip 无效: []
ipv4地址:
result

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:基于MNIST手写数字数据集的数字识别小程序

下一篇:数据分析三剑客之一numpy