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

时间  2019-11-30
标签 常见 模块 正则 栏目 正则表达式 繁體版
原文   原文链接

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我s\t+=_#$dfa\nsdfas')
print(dian)

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

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

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

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

## 取消 字符串 转义  r   例： r'read\b'
## 取消  正则 转义  \   例： \.

# \.  # 表示匹配点号自己
dian  = re.findall(r'\.','asdf.asd')


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

S = re.findall('\S','abc\nbb\tsadf sdf' )
print(S)

b = re.search(r'read\B','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：app

 
 
#eg1
re.search('a','abc')
#eg2
re.search('.','ab.cd.ce')ide
 
 
 
 
#正则元字符
# . ^ $ * + ? {} [] \ | ()spa
 
 
 
 
#eg3
re.search('\bs\b','abcd s w')
re.search(r'\bs\b','abcd s w')code
 
 
 
 
#eg4
re.search(r'.','hc')
re.search(r'.','\nhc')对象
 
 
 
 
'''
\d 匹配0~9的数字 
\s 匹配任意的空白符，包括空格，制表符(Tab)，换行符等
\w 匹配字母或数字或下划线或汉字等 
\b 表示单词的边界 
\. 表示匹配点号自己
\D、\S、\W、\B是与小写的相反的做用
\D除啦数字之外的字符blog
 
 
 
 
^ 脱字符，匹配输入字符串的开始的位置
$ 匹配输入字符串的结束位置
'''继承
 
 
 
 
#eg.
re.search(r'\d','ab12')
re.search(r'\s','ab 12')
re.search(r'\w','ab 12')
re.search(r'\w','\ab 12')
re.search(r'\w',r'\ab 12')
re.search(r'\bc\b','abcc c 12')
re.search(r'\b#\b',r'abcc # 12')字符串
 
 
 
 
re.search(r'\D','abc123')
re.search(r'\.','abc.123')string
 
 
 
 
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,3}','12ab233')
re.findall(r'\d{1,3}','12ab234567')
re.findall(r'\d{1,3}','12ab234567890')
 
 
 
 
re.findall(r'\d{1,}','12ab234567890')
re.findall(r'\d{0,}','12ab234567890abc')
re.findall(r'\d{0,3}','12ab234567890abc1')
re.findall(r'\d{,3}','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*?','12ab234567890abc')
re.findall(r'\d{0,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','o',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',s,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 



        

            

        	





    

		

            
相关文章

            

                

                

                    

                

            


            
相关标签/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公众号
    

    

           欢迎关注本站公众号,获取更多信息

        
    




    

    




	


	







    

        联系我们
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程