re模块的基本使用

目录

• re模块
  • 常用元字符
  • 特殊构造
  • 贪婪模式
  • 非贪婪模式
  • re的常用函数
  • re模块补充
  • 关于re模块必须知道的知识点

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', 'l', 'j', 'k']

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

s = 'skld_2你3 42ljk'
res = re.findall('\w', s)
print(res)

# ['s', 'k', 'l', 'd', '_', '2', '你', '3', '4', '2', 'l', 'j', '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', s)
print(res)

# ['s', 'k', 'l', 'd', '_', '2', '3', '4', '2', 'l', 'j', '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', 'abcd', '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}', s))

# ['abcc', '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)', s))
# ['a', 'a', 'a', 'a', '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('\w+@\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', 'l', 'lk', 'j', 'kl', 'kl', 'k', 'j', 'kl', 'j', '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))
# ['abc\nabc', '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名称，值就是匹配到的内容（只对正则函数返回对象时有用）