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.)c(?Pd)', 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 # ?P<>定义组里匹配内容的key(键),<>里面写key名称,值就是匹配到的内容(只对正则函数返回对象时有用)

转载于:https://www.cnblogs.com/faye12/p/11604571.html

你可能感兴趣的:(python)