13.常见模块re-正则模块

发布时间：2020-12-14 06:18:07 所属栏目：百科来源：网络整理

导读：1. 正则正则表达式是计算机科学的一个概念，正则表通常被用来检索、替换那些符合某个模式(规则)的文本。也就是说使用正则表达式可以在字符串中匹配出你需要的字符或者字符串，甚至可以替换你不需要的字符或者字符串。元字符 . ^ $ * + ? {} [] | () # 大

1.正则

　　正则表达式是计算机科学的一个概念，正则表通常被用来检索、替换那些符合某个模式(规则)的文本。也就是说使用正则表达式可以在字符串中匹配出你需要的字符或者字符串，甚至可以替换你不需要的字符或者字符串。

元字符

 .   ^   $   *   +   ?   {}  []      |   ()
#大多数字母和字符会匹配它们自身，有少数特殊字符我们称为元字符，它们不能匹配自身

#子组匹配和模式重复次数等
    .   # 匹配除换行符之外的所有的字符
    #  用于转义
    d  # 匹配0~9的数字   
    s  # 匹配任意的空白符，包括空格，制表符(Tab)，换行符等
    w  # 匹配字母或数字或下划线或汉字等 
    b  # 表示单词的边界     
    .  # 表示匹配点号本身 
    D、S、W、B # 是与小写的相反的作用
    ^   # 脱字符，匹配输入字符串的开始的位置
    $   # 匹配输入字符串的结束位置
    
#匹配次数
    {M,N}   # M和N 为非负整数，其中M<=N 表示前面的匹配M~N次
    {M，}   # 表示需要匹配M次 以上
    {，N}   # 等价于{0~N}
    {N}     # 表示需要匹配N次
    *       # 匹配前面的子表达式零次或多次，等价于{0，}
    +       # 匹配前面的子表达式一次或多次，等价于{1，} 
    ?       # 匹配前面的子表达式零次或一次，等价于{0,1}
    #注：*？、+？、{n,m}?  贪婪与懒惰
    
#子组匹配
    [ ]     # 字符类，将要匹配的一类字符集放在[]里面
#例如:
    [ . ? * ( ) {} ]      # 匹配里面的这些符号
    [0-9]                 # 匹配0到9的数字相当于d
    [^d]                 # 匹配除数字以外的字符，相当于D
    [a-z]                 # 匹配所有的小写字母
    [^a-z]                # 匹配非小写字母
    |                     # 相当于或（or）分支条件
        #例如：
        A | B             # 匹配字母A或者B 与[AB]是一样的
    
#分组
    ()      #分组，将要匹配的一类字符集放在()组成一个小组

example：

# 正则： 就是匹配字符串
import re

s= ‘gjianengasfasdfjianeng12335748‘

##### 普通匹配    自己匹配自己
# 你要找的内容     查找的对象
a = re.findall(‘jianeng‘,s )  ## 搜索字符串，以列表类型返回全部能匹配的子串
print(a)
#search()     # 在一个字符串中搜索，匹配正则表达式的第一个位置，返回match对象
a = re.search(‘jianeng‘,s)
print(a)

#### 正则 语法
a = re.findall(‘d{3}‘,s)
print(a)

###   .   ^   $   *   +   ?   {}  []      |   ()

#  .   # 匹配除换行符之外的所有的字符
dian = re.findall(‘.‘,‘a我st+=_#$dfansdfas‘)
print(dian)

#     用于转义
# d   # 匹配0~9的数字
d = re.findall(‘d‘,‘abc123‘)
print(d)

# s  # 匹配任意的空白符，包括空格，制表符(Tab)，换行符等
s = re.findall(‘s‘,‘abcnbbtsadf sdf‘ )
print(s)

#  w  # 匹配字母或数字或下划线或汉字等
w = re.findall(‘w‘,‘asd_456我i‘)
print(w)

# b  # 表示单词的边界
b = re.findall(r‘readb‘,‘read readapple‘)
print(b)      # r‘readb‘,取消 字符串转义

## 取消 字符串 转义  r   例： r‘readb‘
## 取消  正则 转义     例： .

# .  # 表示匹配点号本身
dian  = re.findall(r‘.‘,‘asdf.asd‘)


#D、S、W、B # 是与小写的相反的作用
D= re.findall(r‘D‘,‘a123pple‘)
print( D)

S = re.findall(‘S‘,‘abcnbbtsadf sdf‘ )
print(S)

b = re.search(r‘readB‘,‘read readapple‘)
print( b)


## ^   # 脱字符，匹配输入字符串的开始的位置
t = re.search(‘^jianeng‘,‘jianengsadfsjianeng‘)
print(t)

# $   # 匹配输入字符串的结束位置
t = re.search(‘jianeng$‘,‘jianengsadfsjianeng‘)
print(t)

##匹配次数
c = re.findall(‘d{3}‘,‘89ahs123gvbsd34534566‘)
print( c )

#{M,N}
c = re.findall(‘d{2,5}‘,‘89ahs123gvbsd34534566‘)
print( c )

#{M，}   # 表示需要匹配M次 以上
c = re.findall(‘d{2,}‘,‘89ahs123gvbsd34534566‘)
print( c )

# {，N}  # 等价于{0~N}
c = re.findall(‘d{,2}‘,‘89ahs1s‘)
print( c )

#  *  # 匹配前面的子表达式零次或多次，等价于{0，}
x = re.findall( ‘d*‘,‘fds1525sdfg455‘ )
print(x)

#  + # 匹配前面的子表达式一次或多次，等价于{1，}
x = re.findall( ‘d+‘,‘fds1525sdfg4554585444444545165854444444‘ )
print(x)

#  ?  # 匹配前面的子表达式零次或一次，等价于{0,1}
x = re.findall( ‘d?‘,‘fds1525sdfg455‘ )
print(x)


#注：*？、+？、{n,m}?  贪婪与懒惰
# 贪婪 ， 满足要求，选最大的
tan = re.findall(‘a.*t‘,‘amount at about‘)
print(tan)
# 懒惰,满足要求，就结束
lan = re.findall(‘a.*?t‘,‘amount at about‘)
print(lan)

# #子组匹配
#  [ ]     # 字符类，将要匹配的一类字符集放在[]里面

zi = re.findall(‘[a-z0-9]‘,‘fsadf44565_5435‘)
print(zi)
#   a | b| c
zi = re.findall(‘[abc]‘,‘fsadf44565_543b5c‘)
print(zi)

#  [ . ? * ( ) {} ]      # 匹配里面的这些符号
zi = re.findall( ‘[.?*(){}]‘,‘.?*(){}‘)
print( zi )

##   [^d]    取反的意思

zi = re.findall( ‘[^d]‘,‘123456abc‘)
print(zi)

##|          # 相当于或（or）分支条件
h = re.findall(‘abc|jianeng‘,‘abcsdfsajianeng‘)
print(h)

# ()   #分组，将要匹配的一类字符集放在()组成一个小组
zu = re.search(‘xx(jianeng)xx‘,‘jianengfsxxjianengxxdgffgfxxjianengxxfgf‘)
print(zu )

# 要jianeng    ，xx(jianeng)xx
zu = re.findall(‘xx(jianeng)xx‘,‘jianengfsxxjianengxxdgffgfxxjianengxxfgf‘)
print(zu )

re模块常用方法

#re模块的常用方法 
    search()      # 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象 
    findall()     # 搜索字符串，以列表类型返回全部能匹配的子串
    finditer()    # 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
    sub()         # 替换 类似于字符串中 replace() 方法  
    compile()        # 编译正则表达式为模式对象
    re.split()    # 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
    
    
#获取 match对象  中的信息   
    group()       # 返回匹配到的字符串
    start()        # 返回匹配的开始位置  
    end()         # 返回匹配的结束位置  
    span()        # 返回一个元组表示匹配位置（开始，结束）

example：

#eg1
re.search(‘a‘,‘abc‘)
#eg2
re.search(‘.‘,‘ab.cd.ce‘)

#正则元字符
# . ^ $ * + ? {} [] | ()

#eg3
re.search(‘bsb‘,‘abcd s w‘)
re.search(r‘bsb‘,‘abcd s w‘)

#eg4
re.search(r‘.‘,‘hc‘)
re.search(r‘.‘,‘nhc‘)

‘‘‘
d 匹配0~9的数字
s 匹配任意的空白符，包括空格，制表符(Tab)，换行符等
w 匹配字母或数字或下划线或汉字等
b 表示单词的边界
. 表示匹配点号本身
D、S、W、B是与小写的相反的作用
D除啦数字以外的字符

^ 脱字符，匹配输入字符串的开始的位置
$ 匹配输入字符串的结束位置
‘‘‘

#eg.
re.search(r‘d‘,‘ab12‘)
re.search(r‘s‘,‘ab 12‘)
re.search(r‘w‘,‘ab 12‘)
re.search(r‘w‘,r‘ab 12‘)
re.search(r‘bcb‘,‘abcc c 12‘)
re.search(r‘b#b‘,r‘abcc # 12‘)

re.search(r‘D‘,‘abc123‘)
re.search(r‘.‘,‘abc.123‘)

re.search(r‘^a‘,‘abc.123‘)
re.search(r‘^b‘,‘abc.123‘)
re.search(r‘3$‘,‘abd.123‘)

#{} 次数
re.search(r‘d{1,3}‘,‘12ab23‘)
re.findall(r‘d{1,‘12ab233‘)
re.findall(r‘d{1,‘12ab234567‘)
re.findall(r‘d{1,‘12ab234567890‘)

re.findall(r‘d{1,}‘,‘12ab234567890‘)
re.findall(r‘d{0,‘12ab234567890abc‘)
re.findall(r‘d{0,‘12ab234567890abc1‘)
re.findall(r‘d{,‘12ab234567890abc1‘)
re.findall(r‘d{3}‘,‘12ab234567890abc1‘)

re.findall(r‘d*‘,‘12ab234567890abc1‘) #{0,}
re.findall(r‘d+‘,‘12ab234567890abc‘) #{1,}
re.findall(r‘d?‘,‘12ab234567890abc‘) #{0,1}

re.findall(r‘d*?‘,0}‘,‘12ab234567890abc‘)

re.findall(r‘d+?‘,‘12ab234567890abc‘)
re.findall(r‘d{1,1}‘,‘12ab234567890abc‘)

‘‘‘
* + 被称为贪婪模式
? 被称为懒惰模式
只要加?之后，{n,m}里面就变成{n,n}
‘‘‘

#[]

re.findall(r‘[d]‘,‘12ab23344‘)
re.findall(r‘[ab]‘,‘12ab23344‘)
re.findall(r‘[a|b]‘,‘12ab23344‘)

re.findall(r‘[.?*(){}]‘,‘12ab.?*(){}23344‘)
re.findall(r‘[0-9]‘,‘12ab.?*(){}23344‘)
re.findall(r‘[^d]‘,‘12ab.?*(){}23344‘) # 这里 ^ 是取反的意思脱字符

#()

re.findall(r‘(23)‘,‘12ab.?*(){}23344‘)
re.findall(r‘(2|3)‘,‘12ab.?*(){}23344‘)
re.findall(r‘1(2|3)‘,‘12ab.?*(){}23344‘)
re.findall(r‘(d)‘,‘12ab.?*(){}23344‘)
re.findall(r‘(^d)‘,‘12ab.?*(){}23344‘)

#re模块
a = re.compile(r‘d‘)
a.findall(‘123ab12‘)
re.findall(r‘d‘,‘123ab12‘)

re.sub(‘i‘,‘o‘,‘pythin‘,1)
‘pythin‘.replace(‘i‘,1)

re.split(r‘s‘,‘agg bbw cee‘)
re.split(r‘[s|,]‘,‘agg bbw,cee‘)
re.split(r‘d‘,‘c1e3e‘)

re.match(r‘d‘,‘1223ag‘)
re.match(r‘d‘,‘ab1223ag‘)
re.match(r‘g$‘,‘ab1223ag‘)

c = re.search(r‘[2|3]‘,‘12ab1223ag‘)
c.group()
c.start()
c.end()
c.span()


#finditer()    # 搜索字符串，返回一个匹配结果的迭代类型，
              # 每个迭代元素是match对象

s = ‘sjianengsdfasjianeng15sadfjianeng666‘
finditer = re.finditer(‘jianeng‘,s)
print(finditer )
for i in finditer:
    print(i)
    print(i.group())
    print(i.start() )
    print(i.end() )
    print(i.span() )


#sub()         # 替换 类似于字符串中 replace() 方法
s2 = re.sub(‘jianeng‘,‘666‘,s,count=2)
print(s2)


# compile()        # 编译正则表达式为模式对象
a = re.compile(‘jianeng‘)   # a 要匹配jianeng
dd=‘fsadfasfjkjianeng‘
b = a.findall(dd)
print(b )

#re.split()    # 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
c = re.split(‘jianeng‘,maxsplit=2)
print(c)

2.作业

现在要求大家定义这样的一个类:
1.这个类,必须含有字符串的所有方法
2.同时这个类,包含一个统计方法：
　　统计输入字符串里，英文字母、空格、数字和其他字符分别出现次数，
　　并作为一个字典返回 {‘字母‘：，‘空格‘:,‘数字‘:,‘其他字符:‘ }

import re
class A(str): #  继承str类即可含有字符串所有方法
    def counts(self):
        # print(self)
        num = len(re.findall(r‘d‘,self))
        letter = len(re.findall(r‘[a-zA-Z]‘,self))
        # print(re.findall(r‘[a-zA-Z]‘,self))
        space = len(re.findall(r‘s‘,self))
        other = len(self) - num - letter - space
        count_number = {"num":num,"letter":letter,"space":space,"other": other}
        return count_number
string = A(‘My name is Which,age18‘)
# print(string)
# print(string.upper())
print(string.counts())
# s = ‘hello‘
# s.upper()

View Code

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!