day28 re(正则)模块

目录

• re模块有什么用？
  • re模块的基础使用
    • 元字符
  • 终极
    • 贪婪模式
    • 非贪婪模式
  • re模块高级
    • comple
    • match和search
    • 分组函数
  • re.split()
    • sub和subn
  • 分组
• typing

re模块有什么用？

• 在文本或者字符串内获取你所需要的东西

s = '孙悟空找猪八戒找媳妇高翠兰,然后吃西瓜'

import re

res = re.findall('媳妇(.{3})', s)
print(res)

['高翠兰']

re模块的基础使用

import re

s = '孙悟空找猪八戒找媳妇高翠兰,然后吃西瓜,再吃西瓜'

res = re.findall('西瓜', s)
print(res)

['西瓜', '西瓜']

元字符

• 元字符会有特殊的意义
• 常用的元字符

    1. ^  从开头进行匹配
    2. $  从结尾进行匹配
    3. |  相当于or，或者的意思
    4. [] 找到[]内的任意一个元素的所有元素，^放在里面就是反取
    5. .  任意一个字符
    6. {3}大括号前面的字符匹配3次，{m,n}匹配前一个字符m至n次，{m,}则匹配m至无限次
    7. *  前面的字符匹配0-无穷个
    8. +  前面的字符匹配1-无穷个
    9. ?  前面的字符匹配0-1个
    10. \d 匹配数字[0-9]
    11. \s 空白字符（包括\t\r\n\f\v）
    12. \w 匹配字符,字母，数字，下划线
    13. 上面三个如果是大写，就是反取，[]内使用^也是反取
    14. .*? 用了你会爱上它

• ^ $ |

s = '孙悟空找猪八戒找媳妇西高翠兰,然后吃西瓜,再吃西瓜'

# ^ 匹配开头的
res = re.findall('^孙悟空', s)
print(res)

# $ 匹配结尾的
res = re.findall('$猪八戒', s)
print(res)

# | 相当于or
res = re.findall('猪八戒|孙悟空', s)
print(res)

['孙悟空']
[]
['孙悟空', '猪八戒']

• [] .

# [] 找到[]内任意一个元素的所有元素
s = 'abcdefgabckdjfkljsadalasjkdlfjklbkljklfjc'
res = re.findall('[a, b, c]', s)
print(res)

# [^a-z]反取
#匹配出除字母外的字符，^元字符如果写到字符集里就是反取
a = re.findall("[^a-z]", "匹配s这s个字符串是否s匹配f规则re则")  # 反取，匹配出除字母外的字符
print(a)

# .  任意一个字符
s = '孙悟空找猪八戒找媳妇高翠兰,然后吃西瓜,再吃西瓜'
res= re.findall('媳妇...', s)
print(res)

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'a', 'a', 'b', 'c']
['匹', '配', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则']
['媳妇高翠兰']

• {} * + ?

# {3} 大括号前面的字符匹配三次
s = '孙悟空找猪八戒找媳妇妇妇妇高翠兰,然后吃西瓜,再吃西瓜'
res = re.findall('媳妇{3}', s)
print(res)

# * 前面的字符匹配 0-无穷个
s = '孙悟空找猪八戒找媳高翠兰,然后吃西瓜,再吃西瓜'
res = re.findall('媳妇*',s)
print(res)

# + 前面的字符匹配 1-无穷个
res = re.findall('媳妇+', s)
print(res)

# ? 前面的字符匹配0-1个
s = '孙悟空找猪八戒找媳妇妇妇高翠兰,然后吃西瓜,再吃西瓜'
res = re.findall('媳妇?', s)
print(res)

['媳妇妇妇']
['媳']
[]
['媳妇']

• \d \s \w

# \d 数字
# 符号可以连在一起使用
s = '孙悟空找猪八戒找媳妇妇妇高翠兰,然后asdfasdf吃西234234瓜,再吃   西瓜'
res = re.findall('\d+', s)
print(res)

# \D
res = re.findall('\D*', s)
print(res)

['234234']
['孙悟空找猪八戒找媳妇妇妇高翠兰,然后asdfasdf吃西', '', '', '', '', '', '', '瓜,再吃   西瓜', '']

# \s 空
s = '孙悟空找猪八戒找媳妇妇妇高翠兰,,再吃   西瓜'
res = re.findall('\s+', s)
print(res)

# \S 费控
res = re.findall('\S*', s)
print(res)

['   ']
['孙悟空找猪八戒找媳妇妇妇高翠兰,,再吃', '', '', '', '西瓜', '']

# \w 字符，字母，数字，下划线
s = '孙悟空找猪八戒找媳妇高$$$$$@@@@翠兰,然____后asddf吃西234234瓜'
res = re.findall('\w+', s)
print(res)

# \W 非字符，字母，数字，下划线
res = re.findall('\W+', s)
print(res)

['孙悟空找猪八戒找媳妇高', '翠兰', '然____后asddf吃西234234瓜']
['$$$$$@@@@', ',']

终极

贪婪模式

• 一直找
• .* 代表所有的

s = '孙悟空找猪八戒找媳妇妇妇高$$$$$@@@@翠兰,然____后asdfasdf吃西234234瓜,再吃   西瓜妇'
# 从第一个猪找到最后一个妇去了
res = re.findall('猪.*妇', s)
print(res)

['猪八戒找媳妇妇妇高$$$$$@@@@翠兰,然____后asdfasdf吃西234234瓜,再吃   西瓜妇']

非贪婪模式

• ?就是停止符，找到一个就停止

s = '孙悟空找猪八戒找媳妇妇妇高$$$$$@@@@翠兰,然____后asdfasdf吃西234234瓜,再吃   西瓜妇'
res = re.findall('猪.*?妇', s)
print(res)

['猪八戒找媳妇']

睡眠革命

re模块高级

comple

• 写一个通用的规则模版

import re
s = '孙悟空找猪八戒找媳妇妇妇高$$$$$@@@@翠兰,然____后asdfasdf吃西234234瓜,再吃   西瓜妇'
res1 = re.compile('\d+')
res2 = re.compile('\w+')
res3 = re.compile('\s+')

result1 = res1.findall(s)
result2 = res2.findall(s)
result3 = res3.findall(s)
print(result1)
print(result2)
print(result3)

phone_compile = re.compile('1\d{10}')
email_compile = re.compile('\w+@\w+.\w+')

test_s = '12345678900  nickchen121@163.com  22812373393@qq.com'
res_phone = phone_compile.findall(test_s)
print(res_phone)

res_email = email_compile.findall(test_s)
print(res_email)

['234234']
['孙悟空找猪八戒找媳妇妇妇高', '翠兰', '然____后asdfasdf吃西234234瓜', '再吃', '西瓜妇']
['   ']
['12345678900']
['nickchen121@163.com', '22812373393@qq.com']

match和search

• match和search的区别，match从开头开始匹配找一个，search搜索所有找第一个

s = '猪八戒找媳妇猪八戒'
# s = '孙悟空找媳妇猪八戒'    # match会报错，除非不用group
match_res = re.match('猪八戒', s)   # 从开头匹配，取一个
print(match_res.group())

search_res = re.search('猪八戒',s)  # 搜索一个
print(search_res.group())

猪八戒
猪八戒

分组函数

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

取出匹配对象方法

只对正则函数返回对象的有用

• group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如2
• groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
• groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果

origin = "hello world"
# 有两个分组定义了key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
# ?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
r = re.match("(?P<n1>h)(?P<n2>\w+)", origin)
print(r.group())  # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())  # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict())  # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果

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

re.split()

• 就是字符串的split方法，区别是可以使用正则表达式去替换

import re

s = '猪八戒的媳妇是1高翠兰，孙悟空的媳妇是2白骨精，唐僧的媳妇是3女儿国王，沙悟净没有媳妇（py9的学生们）'

print(s.split('，'))
print('-'*50)
res = re.split('\d+',s)
print(res)

s = '猪八戒的媳妇是a高翠兰，孙悟空的媳A妇是b白骨精，唐僧的B媳妇是z女儿国王，沙悟净没有媳妇（py9的学生们）'
print('-'*50)
print(s.split('，'))
print('-'*50)

res = re.split('[a-zA-Z]',s)  # a,b,c,
print(res)

['猪八戒的媳妇是1高翠兰', '孙悟空的媳妇是2白骨精', '唐僧的媳妇是3女儿国王', '沙悟净没有媳妇（py9的学生们）']
--------------------------------------------------
['猪八戒的媳妇是', '高翠兰，孙悟空的媳妇是', '白骨精，唐僧的媳妇是', '女儿国王，沙悟净没有媳妇（py', '的学生们）']
--------------------------------------------------
['猪八戒的媳妇是a高翠兰', '孙悟空的媳A妇是b白骨精', '唐僧的B媳妇是z女儿国王', '沙悟净没有媳妇（py9的学生们）']
--------------------------------------------------
['猪八戒的媳妇是', '高翠兰，孙悟空的媳', '妇是', '白骨精，唐僧的', '媳妇是', '女儿国王，沙悟净没有媳妇（', '', '9的学生们）']

sub和subn

• 都是用来替换内容，但是subn会计算替换的次数，类似于字符串的replace方法

s = '猪八戒的媳妇是1高翠兰，孙悟空的媳妇是2白骨精，唐僧的媳妇是3女儿国王，沙悟净6没有媳妇（py9的学生们）'

res = re.sub('\d', '', s)
print(res)

print('-'*50)

res = re.subn('\d', '', s)
print(res)

猪八戒的媳妇是高翠兰，孙悟空的媳妇是白骨精，唐僧的媳妇是女儿国王，沙悟净没有媳妇（py的学生们）
--------------------------------------------------
('猪八戒的媳妇是高翠兰，孙悟空的媳妇是白骨精，唐僧的媳妇是女儿国王，沙悟净没有媳妇（py的学生们）', 5)

分组

• 需要的东西加括号就行了，括号外的东西不打印

import re

s = '猪八戒的媳妇是高翠兰，孙悟空的媳妇是白骨精，唐僧的媳妇是女儿国王，沙悟净没有媳妇（py9的学生们）'

res = re.findall('(.*?)的媳妇是(.*?)(，)',s)
print(res)

[('猪八戒', '高翠兰', '，'), ('孙悟空', '白骨精', '，'), ('唐僧', '女儿国王', '，')]

typing