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

分类：正则表达式作者：编程之家用户

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：

 
 
#eg1
re.search(‘a‘,‘abc‘)
#eg2
re.search(‘.‘,‘ab.cd.ce‘)
 
 
 
 
#正则元字符
# . ^ $ * + ? {} [] \ | ()
 
 
 
 
#eg3
re.search(‘\bs\b‘,‘abcd s w‘)
re.search(r‘\bs\b‘,‘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‘\bc\b‘,‘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 


        

            

        	




版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

                            

                    

                

                

                    

                        

                            
相关推荐

                            



                                
jquery.validate使用攻略（表单校验）

                                
jquery.validate使用攻略（表单校验） 目录 jquery.validate使用攻略1 第一章&#160;jquery.validate使用攻略1 第二章&#160;jQuery.validate.js API7 Custom selectors7 Utilities8 Validato

                            

                                
清空字符串的空格（正则表达式）

                                
/\s+/g和/\s/g的区别 正则表达式/\s+/g和/\s/g，目的均是找出目标字符串中的所有空白字符，但两者到底有什么区别呢？ 我们先来看下面一个例子： let name = &#39;ye wen jun&#39;;let ans = name.replace(/\s/g, &#39;&#3

                            

                                
自整理几个jquery.Validate验证正则

                                
自整理几个jquery.Validate验证正则： 1. 只能输入数字和字母 /^[0-9a-zA-Z]*$/g jQuery.validator.addMethod(&quot;letters&quot;, function (value, element) { return this.optio

                            

                                
this.optional(element)的用法

                                
this.optional(element)的用法 this.optional(element)是jquery.validator.js表单验证框架中的一个函数，用于表单控件的值不为空时才触发验证。 简单来说，就是当表单控件值为空的时候不会进行表单校验，此函数会返回true，表示校验通过，当表单控件

                            

                                
jQuery.validate 表单动态验证

                                
jQuery.validate 表单动态验证 实际上jQuery.validate提供了动态校验的方法。而动态拼JSON串的方式是不支持动态校验的。牺牲jQuery.validate的性能优化可以实现(jQuery.validate的性能优化见图1.2 jQuery.validate源码 )。 也可

                            

                                
自定义验证之这能输入数字(包括小数 负数 )

                                
自定义验证之这能输入数字(包括小数 负数 ) &lt;script type=&quot;text/javascript&quot;&gt; function onlyNumber(obj){ //得到第一个字符是否为负号 var t = obj.value.charAt(0); //先把非数字的都

                            

                                
validator.js——引入外部验证规则

                                
// 引入了外部的验证规则 import { validateAccountNumber } from &quot;@/utils/validate&quot;; validator.js /*是否合法IP地址*/ export function validateIP(rule, value,cal

                            

                                
VUE开发--表单验证——正则

                                
VUE开发--表单验证(六十三) 一、常用验证方式 vue 中表单字段验证的写法和方式有多种，常用的验证方式有3种： data 中验证 表单内容： &lt;!-- 表单 --&gt; &lt;el-form ref=&quot;rulesForm&quot; :rules=&quot;formRul

                            

                                
正则表达式—含座机的

                                
正则表达式 座机的： 例子： 座机有效写法: 0316-8418331 (010)-67433539 (010)67433539 010-67433539 (0316)-8418331 (0316)8418331 正则表达式写法 0\d{2,3}-\d{7,8}|\(?0\d{2,3}[)-]?\d

                            

                                
js校验输入0-1之间的小数,最多保留小数点后两位

                                
var reg = /^0\.[1-9]{0,2}$/;var linka = 0.1;console.log (reg.test (linka)); 0到1两位小数正则 ^(0\.(0[1-9]|[1-9]{1,2}|[1-9]0)$)|^1$ 不含0、0.0、0.00 // 验证是否是[1-10

                            

                                
input最大长度限制问题

                                
input最大长度限制问题 &lt;input type=&quot;text&quot; maxlength=&quot;5&quot; /&gt; //可以 &lt;input type=&quot;number&quot; maxlength=&quot;5&quot; /&gt; //没有效

                            

                                
js输入验证是否为空、是否为null、是否都是空格—去掉所有空格

                                
js输入验证是否为空、是否为null、是否都是空格 目录 1.截头去尾 trim 2.截头去尾 会去掉开始和结束的空格，类似于trim 3.会去掉所有的空格，包括开始，结束，中间 1.截头去尾 trim str=str.trim(); // 强烈推荐 最常用、最实用 or $.trim(str);

                            

                                
正则表达式语法大全以及match、search、replace、test的各自作用

                                
正则表达式语法大全 字符串.match(正则)：返回符合的字符串，若不满足返回null 字符串.search(正则)：返回搜索到的位置，若非一个字符，则返回第一个字母的下标，若不匹配则返回-1 字符串.replace(正则,新的字符串)：找到符合正则的内容并替换 正则.test(字符串)：在字符串中

                            

                                
正整数正则表达式

                                
正整数正则表达式正数的正则表达式(包括0，小数保留两位)： ^((0{1}.\d{1,2})|([1-9]\d.{1}\d{1,2})|([1-9]+\d)|0)$正数的正则表达式(不包括0，小数保留两位)： ^((0{1}.\d{1,2})|([1-9]\d.{1}\d{1,2})|([1-9]+

                            

                                
JS 正则验证 test()

                                
JS 正则验证 test() /*用途：检查输入手机号码是否正确输入：s：字符串返回：如果通过验证返回true,否则返回false /function checkMobile(s){var regu =/[1][3][0-9]{9}$/;var re = new RegExp(regu);if (r

                            

                                
常用正则

                                
请输入保留两位小数的销售价的正则： /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$)/ 1.只能输入英文 &lt;input type=&quot;text&quot; onkeyup=&quot;value

                            

                                
判断价格的正则表达式

                                
判断价格的正则表达式 价格的正则表达式 /(^[1-9]\d*(\.\d{1,2})?$)|(^0(\.\d{1,2})?$)/; 1 解析：价格符合两种格式 ^ [1-9]\d*(.\d{1,2})?$ ： 1-9 开头，后跟是 0-9，可以跟小数点，但小数点后要带上 1-2 位小数，类似 2,2

                            

                                
最实用的正则表达式整理

                                
文章浏览阅读106次。这篇文章主要介绍了最实用的正则表达式整理,比如校验邮箱的正则，号码相关，数字相关等等，本文给大家列举的比较多，需要的朋友可以参考下。_/^(?:[1-9]d*)$/ 手机号

                            

                                
正则表达式总结，正则表达式匹配不包含某个字符串

                                
文章浏览阅读1.2k次。4、匹配中的==、an==、== an9、i9 == "9i"和99p==请注意下面这部分的作用，它在匹配中间内容的时候排除了说明：当html字符串如下时，可以匹配到两处，表示匹配的字符串不包含and且不包含空白字符。说明：在上面的正则表达式中，_gvim正则表达式匹配不包含某个字符串

                            

                                
正则表达式匹配a标签的href

                                
文章浏览阅读897次。【代码】正则表达式匹配a标签的href。_auto.js 正则匹配herf

                            

                    



            

            

              
          

            

              




              

            

          

          
          

            

              

                  
    
              

            

          

          

            

              

                  
    
              

            

          

          
          

            

              

                
                
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot