re模块

re模块,即正则表达式,本身是一种小型的、高度专业化的编程语言，它并不是Python的一部分

re模块的作用就是: 从大的字符串中挑选出 具有某种形状特点的字符串

常用元字符

^ : 以..开头

s = 'abcdabc' 
res = re.findall('^ab',s)
print(res)  

# ['ab']

$ : 以..结尾

s = 'abcdabc'
res = re.findall('bc$',s)
print(res)  

# ['bc']

. : 任意字符

s = 'abc红abc'
res = re.findall('abc.',s)
print(res)  

# ['abc红']

d : 数字

s = 'skld2342ljk'
res = re.findall('d',s)
print(res)  

# ['2','3','4','2']

D : 非数字

s = 'skld2342ljk'
res = re.findall('D',s)
print(res)

# ['s','k','l','d','j','k']

w : 非空字符，即数字字母下划线

s = 'skld_2你3 42ljk'
res = re.findall('w','_','2','你','k']

W : 空字符，包括空格 换行

s = 'skld_23 42ljk'
res = re.findall('W',s)
print(res)

# [' ']

s : 空字符，包括空格 换行

s = 'skld_23 42ljk'
res = re.findall('s',s)
print(res)

# [' ']

S : 非空字符，即数字字母下划线

s = 'skld_23 42ljk'
res = re.findall('S','k']

+ : 前面的一个字符至少1个 [1,正无穷)

s = 'abcddabdabcdd abcd abc'
print(re.findall('abcd+',s))

# ['abcdd','abcdd','abcd']

？：前面的一个字符0-1个 前一个字符[0,1] 最大只有一个

s = 'abcddddd abcd abc ab'
print(re.findall('abcd?',s))

# ['abcd','abcd','abc']

*** ：前面的一个字符至少0个 前一个字符[0,正无穷)**

s = 'abcddddd abcd abc ab'
print(re.findall('abcd*',s))

# ['abcddddd','abc']

[] : 中括号内的都可以,但是只占一个位置

s = 'abc bbc cbc dbc abcd '
print(re.findall('[abc]bc',s))

# ['abc','bbc','cbc','abc']

[^] : 中括号的都不可以

s = 'abc bbc cbc dbc'
print(re.findall('[^abc]bc',s))

# ['dbc']

|：或 满足就打印,一个或者两个三个

s = 'abc bbd dbc'
print(re.findall('abc|bbc',s))

# ['abc']

{2}:前面的字符重复2个

s = 'abccabc abccc'
print(re.findall('abc{2}',s))

# ['abcc','abcc']

{1,2}:前面的字符重复1-2个 区间是[1,2]

s = 'abccabc abccc'
print(re.findall('abc{1,2}','abc','abcc']

特殊构造

a(?=d) ：a后面是数字，但是不要数字，不消耗字符串内容

s = 'a123 aaaa a234 abc'
#    a1   aa
#          aa
#           aa 
#               a2  ab

print(re.findall('a(?=d)',s))
# ['a','a']

print(re.findall('a(?=w)','a','a']

贪婪模式

Python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符,一定要找到最后 才停止

**.（任意字符）*（0-无穷个）**

s = 'abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'
print(re.findall('a.*g',s))

# ['abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg']

非贪婪模式

非贪婪的则相反，总是尝试匹配尽可能少的字符,找到一个就停止并返回

**.（任意字符）*（0-无穷个）？（让他进入非贪婪模式）**

s = 'abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'
print(re.findall('a.*?g',s))

# ['abcdefg']

re的常用函数

findall：最常用 推荐使用 直接在函数内部书写匹配规则

import re
a = re.findall("匹配规则","这个字符串是否有匹配规则的字符")
print(a)

compile：写一个特定的规则模板

# 定义邮箱、手机号匹配规则，直接调用
email_pattern = re.compile('[email?protected]w+.com')
phone_patter = re.compile('d{13}')
print(re.findall(email_pattern,s))

match: 从字符串开头找一个，找得到就不找了 ；找不到报错

s = 'ab abcddd abc'
res = re.match('abcd*',s)
print(res.group())

search： 搜索,从整个内容中匹配,只找一个，找不到报错

s = 'ab abcddd abc'
res = re.search('abcd*',s)
print(res.group())

split 切割,相当于字符串的split

s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.split('d+',s))

# ['ab','abcddd','abcasdfjlasjdk','lk','kl','lkj']

sub 替换,相当于字符串的replace

s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.sub('d+',' ',s))

# ab abcddd abcasdfjlasjdk l lk j kl kl k j kl j lkj

subn 替换,会返回替换的次数

s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.subn('d+',s))

# ('ab abcddd abcasdfjlasjdk l lk j kl kl k j kl j lkj',12)

re模块补充

re.S 会让.匹配换行符

a = '''asdfhellopass:
    worldaf
    '''
b = re.findall('hello(.*?)world',a)
c = re.findall('hello(.*?)world',a,re.S)
print(b)
# []

print(c)
# ['pass:n    ']

. 不匹配换行

s = '''abc
abcabc*abc
'''
print(re.findall('abc.abc',s))  
# ['abc*abc']

print(re.findall('abc.abc',s,re.S))  
# ['abcnabc','abc*abc']

分组 --> 只要括号里的（...）

s = 'abc abcd abcdd'
print(re.findall('a(.)c(d)',s))

# [('b','d'),('b','d')]

有名分组

s = 'abc abcd abcdd'
print(re.search('a(?P<name>.)c(?P<name2>d)',s).groupdict())

# {'name': 'b','name2': 'd'}

关于re模块必须知道的知识点

1. .*? ：

非贪婪匹配

1. 贪婪和非贪婪：

   贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

   非贪婪匹配（？）：在满足匹配时，找到一个就停止，返回结果

2. findall：

   findall(pattern,string,flags=0) 浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表

3. re.S：

   表示 “.” 的作用扩展到整个字符串，包括“n”。看如下代码：

4. match和sarch的区别：

   match()函数只在string的开始位置匹配，找不到就报错
   search()会扫描整个string查找匹配,会扫描整个字符串并返回第一个成功的匹配结果

5. 分组：

   ()表示分组，可以与 | 合用，(ab|cd)表示匹配字符 ab 或 字符 cd

6. 有名分组：

   ?P<name> # ?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容（只对正则函数返回对象时有用）