精华内容
下载资源
问答
  • python-正则表达式

    2018-07-17 17:12:00
    正则表达式,又称规则表达式(Regular Expression) 1.正则在任何语言中都占据这相当重要的一块,什么是正则... re.match(正则表达式,需要匹配的字符串) 当然正则表达式规则都是由开发人员进行书写所得。 3.^...

    正则表达式,又称规则表达式(Regular Expression)

    1.正则在任何语言中都占据这相当重要的一块,什么是正则表达式?

      正则表达式即是按照某些规定了的规则来进行寻找或者过滤合适的字符串的一种方式(个人总结)

    2.正则表达式也有相对应的语法,正则表达式的模块为re

      re.match(正则表达式,需要匹配的字符串) 当然正则表达式的规则都是由开发人员进行书写所得。

    3.^和$

      在flask和django框架中使用的颇多,主要用来匹配路由,^是以某某开头,$是以某某结尾,一旦二者同时使用,那么就意味着只单单的匹配^和$中间的那部分

    4. ^在分组括号内部代表的意思是取反,在外部代表的意思是按照某某开头

    5.(?P<name>)分组,将括号中的作为一组,P要绝对的大写

    6.提取区号和号码:ret = re.match("([^-]*)-(\d+)","010-12345678")

    7.前端标签匹配时,前后标签要保持一致,后面的标签可以使用示例方式来进行匹配: 

    re.match(r"<(\w*)><(\w*)>.*</\2></\1>", label)

    8.re模块的高级用法:

      group:re.group() 能够输出正则表达式匹配的内容

      search:匹配出匹配字符串中的数字部分(re.match(r ' \d+ ' , ' 阅读次数为9999 ')

      findall:是search的加强版,能够匹配出符合正则表达式的所有内容 :

    re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")

      sub:按照正则表达式的匹配规则将对应的字符串做出替换:

    re.sub(r"<[^>]*>|&nbsp;|\n", "", test_str)

      split:对待匹配的字符串按照相对应的匹配规则来进行切割,并将切割的值放在一个列表中返回:

    re.split(r":| ","info:xiaoZhang 33 shandong")

    9.贪婪和非贪婪

      首先,需要知道的是,在python中,在匹配时,数量词默认是贪婪的,总是想要匹配更多。

      那么,在某些特定的情况下,我们需要在非贪婪的模式下来进行字符串的匹配,那么就在一些量词的后面加上?来起到限制的作用。比如"*","?","+","{m,n}"等

    10.r的作用

      Python中字符串前面加上 r 表示原生字符串

    11. 附录

    程序方式运行


    \

    将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如,"\\n"匹配\n。

    "\n"匹配换行符。序列"\\"匹配"\"而"\("则匹配"("。即相当于多种编程语言中都有

    的"转义字符"的概念。

    ^

    匹配输入字行首。如果设置了RegExp对象的Multiline属性,^也匹配"\n"或"\r"之后的位置。

    $

    匹配输入行尾。如果设置了RegExp对象的Multiline属性,$也匹配"\n"或"\r"之前的位置。

    *

    匹配前面的子表达式任意次。例如,zo*能匹配"z",也能匹配"zo"以及"zoo"。*等价于{0,}。

    +

    匹配前面的子表达式一次或多次(大于等于1次)。例如,"zo+"能匹配"zo"以及"zoo",

    但不能匹配"z"。+等价于{1,}。

    ?

    匹配前面的子表达式零次或一次。例如,"do(es)?"可以匹配"do"或"does"。?等价于{0,1}。

    {n}

    n是一个非负整数。匹配确定的n次。例如,"o{2}"不能匹配"Bob"中的"o",

    但是能匹配"food"中的两个o。

    {n,}

    n是一个非负整数。至少匹配n次。例如,"o{2,}"不能匹配"Bob"中的"o",

    但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。

    {n,m}

    mn均为非负整数,其中n<=m。最少匹配n次且最多匹配m次。例如,"o{1,3}"

    将匹配"fooooood"中的前三个o为一组,后三个o为一组。"o{0,1}"等价于"o?"。

    请注意在逗号和两个数之间不能有空格。

    ?

    当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,

    匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串,而默认的

    贪婪模式则尽可能多地匹配所搜索的字符串。例如,对于字符串"oooo","o+"

    将尽可能多地匹配"o",得到结果["oooo"],而"o+?"将尽可能少地匹配"o",

    得到结果 ['o', 'o', 'o', 'o']

    .点

    匹配除"\n"和"\r"之外的任何单个字符。要匹配包括"\n"和"\r"在内的任何字符,

    请使用像"[\s\S]"的模式。

    (pattern)

    匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到,

    在VBScript中使用SubMatches集合,在JScript中则使用$0…$9属性。

    要匹配圆括号字符,请使用"\("或"\)"。

    (?:pattern)

    非获取匹配,匹配pattern但不获取匹配结果,不进行存储供以后使用。

    这在使用或字符"(|)"来组合一个模式的各个部分时很有用。

    例如"industr(?:y|ies)"就是一个比"industry|industries"更简略的表达式。

    (?=pattern)

    非获取匹配,正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串,

    该匹配不需要获取供以后使用。例如,"Windows(?=95|98|NT|2000)"

    能匹配"Windows2000"中的"Windows",但不能匹配"Windows3.1"中的"Windows"。

    预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后

    立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。

    (?!pattern)

    非获取匹配,正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串,

    该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)"

    能匹配"Windows3.1"中的"Windows",但不能匹配"Windows2000"中的"Windows"。

    (?<=pattern)

    非获取匹配,反向肯定预查,与正向肯定预查类似,只是方向相反。例如,

    "(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows",但不能

    匹配"3.1Windows"中的"Windows"。"(?<=95|98|NT|2000)Windows"目前

    在python3.6中re模块测试会报错,用"|"连接的字符串长度必须一样,

    这里"95|98|NT"的长度都是2,"2000"的长度是4,会报错。

    (?<!pattern)

    非获取匹配,反向否定预查,与正向否定预查类似,只是方向相反。

    例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows",

    但不能匹配"2000Windows"中的"Windows"。这个地方不正确,有问题

    此处用或任意一项都不能超过2位,如"(?<!95|98|NT|20)Windows正确,

    "(?<!95|980|NT|20)Windows 报错,若是单独使用则无限制,

    如(?<!2000)Windows 正确匹配。同上,这里在python3.6中re模块中

    字符串长度要一致,并不是一定为2,比如"(?<!1995|1998|NTNT|2000)Windows"

    也是可以的。

    x|y

    匹配x或y。例如,"z|food"能匹配"z"或"food"(此处请谨慎)。

    "[zf]ood"则匹配"zood"或"food"。

    [xyz]

    字符集合。匹配所包含的任意一个字符。例如,"[abc]"可以匹配"plain"中的"a"。

    [^xyz]

    负值字符集合。匹配未包含的任意字符。例如,"[^abc]"可以匹配"plain"中的"plin"。

    [a-z]

    字符范围。匹配指定范围内的任意字符。

    例如,"[a-z]"可以匹配"a"到"z"范围内的任意小写字母字符。

    注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围;

    如果出字符组的开头,则只能表示连字符本身.

    [^a-z]

    负值字符范围。匹配任何不在指定范围内的任意字符。

    例如,"[^a-z]"可以匹配任何不在"a"到"z"范围内的任意字符。

    \b

    匹配一个单词边界,也就是指单词和空格间的位置(即正则表达式的"匹配"有两种概念,

    一种是匹配字符,一种是匹配位置,这里的\b就是匹配位置的)。例如,"er\b"可以

    匹配"never"中的"er",但不能匹配"verb"中的"er"。

    \B

    匹配非单词边界。"er\B"能匹配"verb"中的"er",但不能匹配"never"中的"er"。

    \cx

    匹配由x指明的控制字符。例如,\cM匹配一个Control-M或回车符。

    x的值必须为A-Z或a-z之一。否则,将c视为一个原义的"c"字符。

    \d

    匹配一个数字字符。等价于[0-9]。grep 要加上-P,perl正则支持

    \D

    匹配一个非数字字符。等价于[^0-9]。grep要加上-P,perl正则支持

    \f

    匹配一个换页符。等价于\x0c和\cL。

    \n

    匹配一个换行符。等价于\x0a和\cJ。

    \r

    匹配一个回车符。等价于\x0d和\cM。

    \s

    匹配任何不可见字符,包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

    \S

    匹配任何可见字符。等价于[^ \f\n\r\t\v]。

    \t

    匹配一个制表符。等价于\x09和\cI。

    \v

    匹配一个垂直制表符。等价于\x0b和\cK。

    \w

    匹配包括下划线的任何单词字符。类似但不等价于"[A-Za-z0-9_]",

    这里的"单词"字符使用Unicode字符集。

    \W

    匹配任何非单词字符。等价于"[^A-Za-z0-9_]"。

    \xn

    匹配n,其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如,

    "\x41"匹配"A"。"\x041"则等价于"\x04&1"。正则表达式中可以使用ASCII编码。

    \num

    匹配num,其中num是一个正整数。对所获取的匹配的引用。

    例如,"(.)\1"匹配两个连续的相同字符。

    \n

    标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式,

    n为向后引用。否则,如果n为八进制数字(0-7),则n为一个八进制转义值。

    \nm

    标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式,

    nm为向后引用。如果\nm之前至少有n个获取,则n为一个后跟文字m的向后引用。

    如果前面的条件都不满足,若nm均为八进制数字(0-7),则\nm将匹配八进制转义值nm

    \nml

    如果n为八进制数字(0-7),且ml均为八进制数字(0-7),则匹配八进制转义值nml

    \un

    匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。

    例如,\u00A9匹配版权符号(&copy;)。

    \p{P}

    小写 p 是 property 的意思,表示 Unicode 属性,用于 Unicode 正表达式的前缀。

    中括号内的"P"表示Unicode 字符集七个字符属性之一:标点字符。

    其他六个属性:

    L:字母;

    M:标记符号(一般不会单独出现);

    Z:分隔符(比如空格、换行等);

    S:符号(比如数学符号、货币符号等);

    N:数字(比如阿拉伯数字、罗马数字等);

    C:其他字符。

    *注:此语法部分语言不支持,例:javascript。

    \<

    \>

    匹配词(word)的开始(\<)和结束(\>)。例如正则表达式\<the\>能够

    匹配字符串"for the wise"中的"the",但是不能匹配字符串"otherwise"中的"the"。

    注意:这个元字符不是所有的软件都支持的。

    ( )

    将( 和 ) 之间的表达式定义为"组"(group),并且将匹配这个表达式的字符保存到一个

    临时区域(一个正则表达式中最多可以保存9个),它们可以用 \1 到\9 的符号来引用。

    |

    将两个匹配条件进行逻辑"或"(Or)运算。例如正则表达式(him|her)

    匹配"it belongs to him"和"it belongs to her",

    但是不能匹配"it belongs to them."。注意:这个元字符不是所有的软件都支持的。

     2.通过指定配置文件启动

     

    转载于:https://www.cnblogs.com/zxh1297/p/9320829.html

    展开全文
  • Python re正则表达式

    2021-01-15 18:21:28
    re 正则模块 ...下面来介绍匹配规则的写法,规则书写借鉴至:博客园一位优秀博主 下面来使用re模块配合上面的规则来匹配字符 正则匹配规则 字符匹配规则 import re res=re.findall('el','hello 123_*&am

    re 正则模块


    正则指的是一种规则(或是一种表达式):用于匹配字符串

    主要作用就是通过正则表达式来处理字符串,或者从中过滤出我们想要的内容。

    定义好规则以后,它会去字符串中查找符合规则的字符。

    正则表达式和语言无关,几乎所有编程语言都会用到。但re模块是Python独有的

    下面来介绍匹配规则的写法

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    下面来使用re模块配合上面的规则来匹配字符


    正则匹配规则

    字符匹配

    import re
    
    res=re.findall('el','hello 123_*&') # 匹配字符串内的el字符
    print(res) # ['el']
    
    res=re.findall('\w','hello egon 123_*&') # 匹配字符串内的字母数字或下划线
    print(res) # ['h', 'e', 'l', 'l', 'o', '1', '2', '3', '_']
    
    res=re.findall('\W','hello 123_*&') # 匹配字母数字或下划线以外的任意字符
    print(res) # [' ', ' ', '*', '&']
    
    res=re.findall('\s','hello 123_*&\tass\nsd') # 匹配任意空白符,换行或缩进符最终效果也是空白符
    print(res) # [' ', '\t', '\x0c']
    
    res=re.findall('\S','hello 123_*&\tass\nsd') # 匹配除了空白符以外的任意字符
    print(res) # ['h', 'e', 'l', 'l', 'o', '1', '2', '3', '_', '*', '&', 'a', 's', 's', 's', 'd']
    
    res=re.findall('\d','hello 123_*&\tass\nsd') # 匹配数字(常用)
    print(res) # ['1', '2', '3']
    
    res=re.findall('\D','hello 123_*&\tass\nsd') # 匹配除了数字以外的任意字符
    print(res) # ['h', 'e', 'l', 'l', 'o', ' ', '_', '*', '&', '\t', 'a', 's', 's', '\n', 's', 'd']
    
    res=re.findall('\Ahe','hello 123_*&\tass\nsd') # 匹配字符串开头是否为he字符,也可以使用^代替\A
    print(res) # ['he']
    
    res=re.findall('^he','hello 123_*&\tass\nsd') # 和上面效果一致,常用
    print(res) # ['he']
    
    res=re.findall('sd\Z','hello 123_*&\tass\nsd') # 匹配字符串结尾是否为sd字符,写法特殊一些,也可以使用$代替
    print(res) # ['sd']
    
    res=re.findall('sd$','hello 123_*&\tass\nsd') # 和上面效果一致,常用
    print(res) # ['sd']
    

    带特殊符号的正则使用

    # 匹配字符串内是否有a或者23字符
    res = re.findall('a|23','jjskaiek23ks')
    print(res) # ['a', '23']
    
    # 匹配开头结尾都为xx,且中间只有一个ab字符,最终显示出来的是括号里面匹配到的结果
    res = re.findall('xx(ab)xx','xxabxx')
    print(res) # ['ab']
    
    # .匹配除换行符以外的任意字符,这里匹配a到b中间存在一个字符的内容
    res = re.findall('a.b','acb') 
    print(res) # ['acb']
    
    # 如果a-b中间是换行符,则不匹配
    res = re.findall('a.b','a\nb')
    print(res) # []
    
    # 增加这个修饰符可以让.包含所有字符
    res = re.findall('a.b','a\nb',re.S)
    print(res) # ['a\nb']
    
    # 匹配a后面0个或任意个b字符,贪婪模式(尽量拿更多)
    res = re.findall('ab*','abbbcc') 
    print(res) # ['abbb']
    print(re.findall('ab*','cccc')) # ['a']
    
    # 11后面的a出现一次或者或者更多次都可以匹配上,贪婪模式
    res = re.findall('11a+','11a basdfb 11aa ssdfsadf 11aaa') 
    print(res) # ['11a', '11aa', '11aaa']
    
    # 如果11后面没有a,则返回一个空值
    res = re.findall('11a+','11 basdfb 11 ssdfsadf 11')
    print(res) # []
    
    # b前面是否存在0或1个a,如果不存在则只拿到b,如果匹配则一起拿到,这种写法,如果有b则拿到b,贪婪模式
    res = re.findall('a?b','aabbb') 
    print(res) # ['ab', 'b','b']
    
    # a后面是否存在0或1个b,如果不存在则只拿a,如果匹配到了则一起拿到,这种写法,如果有a则拿到a,非贪婪模式,能少拿就少拿
    res = re.findall('ab?','aabbb') 
    print(res) # ['a','ab']
    
    # 由于.是我们想匹配到的内容,且.在正则里有特殊含义,所以需要加上\进行转义
    res = re.findall('a\.?','a.2020a20') 
    print(res) # ['a.', 'a']
    
    # {}里面定义的数字,决定{}前面字符必须要出现的次数,这里{}前面也就是a,然后就是11后面必须存在2个a才能匹配上
    res = re.findall('11a{2}','11a basdfb 11a ssdfsadf 11aa') 
    print(res) # ['11aa']
    
    # 11后面的a出现2-3次之内就可以匹配上。
    res = re.findall('11a{2,3}','11a basdfb 11aa ssdfsadf 11aa') 
    print(res) # ['11aa', '11aa']
    
    # 11后面的a出现在2次以上就可以匹配上。
    res = re.findall('11a{2,}','11aaaa basdfb 11aa ssdfsadf 11aa') 
    print(res) # ['11aa', '11aa']
    
    # 11后面的a后面出现两个任意字符就可以匹配上
    res = re.findall('11a.{2}','11a09 basdfb 11abd ssdfsadf 11aa')
    print(res) # ['11aa', '11aa']
    

    字符组

    # a后面只要是0-9之间的数字就能匹配上
    res = re.findall('a[0-9]','a0dddda2ddddda3dddda1')
    print(res) # ['a0', 'a2', 'a3', 'a1']
    
    res = re.findall('a[0123456789]','a0dddda2ddddda3dddda1') # 和上面效果一至
    print(res) # ['a0', 'a2', 'a3', 'a1']
    
    # 123后面只要存在a-z之间的字母就能匹配上
    res = re.findall('123[a-z]','123bllllll123dllllll123w')
    print(res) #['123b', '123d', '123w']
    
    # 123后面只要存在A-Z之间的字母就能匹配上
    res = re.findall('123[A-Z]','123Allllll123Dlllll123')
    print(res) #['123A', '123D']
    
    # 123后面只要存在一个数字,或者一个a-f之间的小写字母,或者一个A-Z之间的字母就能匹配上
    res = re.findall('123[0-9a-fA-Z]','123O llll 123b llll 123 123Z')
    print(res) #['123O', '123b', '1232', '123Z']
    

    贪婪模式

    在满足匹配时,匹配尽可能长的字符串。

    res = re.findall('xx(.*)xx','xxIxxjshdxxlovexxsffaxxpythonxx')
    print(res)
    # ['Ixxjshdxxlovexxsffaxxpython']
    
    # 只是去掉了头的xx 与 尾部的xx,然后获取了全部内容
    

    非贪婪模式

    在满足匹配时,匹配尽可能更少的字符串,更精准。

    # 只匹配以xx开头以xx结尾的内容,在一大串里面,准确的拿到我们想要的内容
    res = re.findall('xx(.*?)xx','xxIxxjshdxxlovexxsffaxxpythonxx')
    print(res)
    # ['I', 'love', 'python']
    

    通过正则获取常见的链接

    href=  '<a href="https://fanyi.baidu.com/?aldtype=16047#auto/zh"></a>'
    
    # 表示获取以href="开始 最后以"结尾,中间的所有内容,()表示只获取()里匹配到的内容
    res = re.findall('href="(.*?)"',href)
    print(res) # ['https://fanyi.baidu.com/?aldtype=16047#auto/zh']
    

    判断邮箱是否合格

    # 解析:开头必须是数字,且数字长度为5-10位,数字后面必须有@号
    # @后面必须有字母或者数字,长度为1-3位,且后面必须有.
    # 结尾必须是cn或者com。
    res = re.findall('^\d{5,10}@[a-z0-9]{1,3}\.(?:cn|com)$','1234567890@163.com')
    if res:
        print(f'Email:{res[0]}')
    else:
        print('该邮箱输入不合格!')
    

    执行结果

    'Email:1234567890@163.com'
    

    常用方法


    上面一直使用的是findall这个方法匹配,且这个方法也是最为常用的,那么我们再来了解其它几个正则匹配的方法

    re.compile 产生匹配对象

    产生一个正则对象,我们此后匹配规则都可以使用这个对象匹配即可,需要注意的是:定义好一个规则对象以后就固定了。

    import re
    
    # 该规则可以匹配出两个同时出现的数字
    prog = re.compile('\d{2}')
    
    
    print(prog.findall('123ab456')) # ['12', '45']
    

    re.search 一次性匹配

    获取匹配到的内容后就会停止,不会继续向后获取。如果未匹配到使用group()则报错

    import re
    prog = re.compile('\d{2}')
    
    print(prog.search('ab123ll456').group()) # 需要使用group()拿到匹配结果
    # 12
    
    print(prog.search('ab').group()# 报错,因为没匹配到内容则不能group()
    

    re.match 字符串开头匹配

    search基本类似,只会获取内容就停止,但是不同点是:match是从字符串的开头获取内容。

    import re
    
    prog = re.compile('\d{2}')
    
    
    print(prog.match('123ab456').group()) # 需要使用group()拿到匹配结果
    # 12
    
    print(pro.match('ab456').group()) # 报错,因为在开头没有匹配成功
    

    re.fullmatch 匹配全部

    匹配全部字符串是否符合规则,如果符合则可以拿到结果

    # \w+匹配更多的字母数字下划线
    print(re.fullmatch('\w+','123ab456').group())
    # 123ab456
    
    print(re.fullmatch('123ab456','123ab456').group())
    # 123ab456
    
    print(re.fullmatch('123','123ab456').group()) # 报错,字符串不匹配规则
    

    re.split 匹配分隔

    只要规则匹配,就对字符串进行分隔

    # 只要匹配到不是字母数字或者下划线,就进行分隔,这里逗号和点就符合规则了,所以从它开始分隔
    print(re.split('\W', 'Words,words,words.'))
    # ['Words', 'words', 'words', '']
    
    # 只要匹配到字母就进行分隔
    print(re.split('[a-z]','123as456b789'))
    # '123', '', '456', '789']
    

    re.finditer 返回匹配结果为迭代器

    将匹配到的结果存入迭代器内

    # 将匹配到的所有数字放入迭代器内
    res = re.finditer('\d','a1b2c3d4e5f6g7h8i9')
    print(next(res).group()) # 1
    for i in res:
        print(i.group()) # 打印出2-9
    

    re.sub 字符串替换

    符合规则的字符串全部替换成指定的内容,我们也可以指定替换数量

    # 将匹配到的数字全部替换成了:'Num'
    res = re.sub('\d','Num','aa1bb2cc3')
    print(res)
    # aaNumbbNumccNum
    
    print(re.sub('\d','Num','aa1bb2cc3',1))
    # aaNumbb2cc3
    

    re.subn 字符串替换

    sub相同,不同的是返回的是一个元组,内容有:已替换的字符串,替换的数量,如果不指定则匹配到几个,替换的数量就为几个

    res = re.subn('\d','Num','aa1bb2cc3')
    print(res)
    # ('aaNumbbNumccNum', 3)
    
    print(re.subn('\d','Num','aa1bb2cc3',1))
    # ('aaNumbb2cc3', 1)
    

    参考:https://www.cnblogs.com/shenjianping/p/11647473.html

    各位读者大大,see you next time~


    技术小白记录学习过程,有错误或不解的地方请指出,如果这篇文章对你有所帮助请点赞 收藏+关注 子夜期待您的关注,谢谢支持!

    展开全文
  • python书写简单,功能强大, 迅速发展成为 AI ,深度学习的主要语言。介绍Python中的lambda表达式,注意到,它只是一个表达式,不是语句啊。 lambda的语法规则: 一个或多个参数以冒号终止输入参数,这些参数可以...

    01.lambda表达式

    python书写简单,功能强大, 迅速发展成为 AI ,深度学习的主要语言。介绍Python中的lambda表达式,注意到,它只是一个表达式,不是语句啊。

    lambda的语法规则: 一个或多个参数以冒号终止输入参数,这些参数可以理解为有名函数原型的输入参数,以后是一个表达式,相当于有名函数的函数体部分。lambda的函数体部分,是作为返回值输出部分。

    02.场景1:map 和 reduce

    Python 中的 map 和 reduce,再结合 lambda表达式的话,使用起来会更加高效,如下所示:

    def sum(mylist):
    
        return reduce(lambda x, y: 2*x + 1*y, mylist)
    

    可以看到两个输入参数 x, y , 返回为 2*x + y,通过这样对 mylist 的元素完成化简操作。

    03.场景2: lambda 和 list 结合使用

    这个场景在面试中经常被问到,如下所示:

    li = [lambda :x for x in range(10)]
    

    得到一个 lambda 的list,打印li[0]()会得到什么,注意这种调用方法,因为是数组,先拿第一个元素,li[0],后面的括号表示调用lambda表达式。打印的结果为 0 吗?

    NO!是 9

    lambda表达式不会形成对函数体内变量的记忆,只记录最后一个状态。

    那么如果lambda的入参中带有x, 会得到我们想要的结果0 吗?

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    li = [lambda x :x for x in range(10)]
    
    res = li[0](0)
    
    print(res)
    
    输出:0
    

    因此,需要注意区分这两种写法的不同,记得这个区别,在一次面试中,曾经被问到,希望对大家有用。

    展开全文
  • python中利用正则表达式匹配ip地址 ip地址的范围为0.0.0.0-255.255.255....# 匹配 0-255的表达式书写方法 pattern = re.compile(r'([01]?\d?\d|2[0-4]\d|25[0-5])') 以下作具体解释: 0-199:[01]?\d?\d 问号(?)表示匹

    python中利用正则表达式判断ipv4地址是否合法

    ip地址的范围为0.0.0.0-255.255.255.255,分成四段,则每段的范围都是0-255,因此,以一段进行分析:
    在进行书写匹配规则时,可以将每段的取值分为4个区间。即0-99、100-199、200-249、250-255。
    其正则匹配的表达式应为:

    # 匹配 0-255的表达式书写方法
    pattern = re.compile(r'([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])')
    

    以下作具体解释:

    • 0-99:[1-9]?\d

      问号(?)表示匹配0或1次,此表达式可以匹配0-99内任意是数值。

    • 100-199:1\d\d

      第一位为1,第二位和第三位为0-9之间的任意数值。

    • 200-249:2[0-4]\d

      200-249范围内,第一位固定为2,第二位取值范围为[0-4],第三位为0-9之间任意数字,使用’\d’进行匹配。

    • 250-255:25[0-5]

      250-255范围内,前两位固定为25,最后一位取值为[0-5]。

    使用 | 符号,将四部分连接起来,即是一条完整的匹配0-255范围的表达式:([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])
    此时应该已经能够理解,如何进行一段ip地址的匹配,再讲解如何匹配完整的ip地址。
    简单理解就是(0-255).(0-255).(0-255).(0-255)。使用四段相同的表达式,并在四段表达式之间增加3个点(.)。
    可将前三段ip值和三个点看作三部分,即每部分为(0-255).。
    (0-255).的匹配表达式可书写为(([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.),此表达式需要使用三次,因此可以写成 (([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.){3}
    最终,匹配0.0.0.0-255.255.255.255的表达式如下所示:

    # 匹配 0.0.0.0-255.255.255.255的表达式书写方法
    pattern = re.compile(r'(([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.){3}([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])')
    

    下面作几个测试用例(使用fullmatch)

    In [1]: pattern.fullmatch('0.123.12.23')
    Out[1]: <re.Match object; span=(0, 11), match='0.123.12.23'>
    
    In [2]: pattern.fullmatch('192.168.0.1')
    Out[2]: <re.Match object; span=(0, 11), match='192.168.0.1'>
    
    In [3]: pattern.fullmatch('255.255.255.255')
    Out[3]: <re.Match object; span=(0, 15), match='255.255.255.255'>
    # 以上三个ip都属于正常ip,因此能够正确匹配
    # -----------------------------------------------
    # 以下两个示例不是正确的ip,所以匹配不到,无输出结果
    In [4]: pattern.fullmatch('255.255.255.256')
    In [5]: pattern.fullmatch('1255.255.255.255')
    
    

    再使用search、match方法对以上两个错误ip进行匹配测试。

    In [11]: pattern.search('255.255.255.256')
    Out[11]: <re.Match object; span=(0, 14), match='255.255.255.25'>
    # 匹配结果为 255.255.255.25
    
    In [12]: pattern.search('1255.255.255.255')
    Out[12]: <re.Match object; span=(1, 15), match='255.255.255.25'>
    # 匹配结果为 255.255.255.25
    
    In [13]: pattern.match('255.255.255.256')
    Out[13]: <re.Match object; span=(0, 14), match='255.255.255.25'>
    # 匹配结果为 255.255.255.25
    
    In [14]: pattern.match('1255.255.255.255')
    # 无输出结果
    
    # -----------------------------------
    # 请注意观察以下示例的匹配结果
    In [15]: pattern.search('257.127.0.0.1')
    Out[15]: <re.Match object; span=(1, 11), match='57.127.0.0'>
    In [16]: pattern.search('255.255.255.122.256')
    Out[16]: <re.Match object; span=(0, 15), match='255.255.255.122'>
    

    为何会出现上述结果?首先对于search、match、fullmatch进行一个对比:

    方法 解释
    search 只匹配一次,查找整个字符串
    match 只匹配一次,从开头开始匹配
    fullmatch 对字符串进行完整匹配

       由于search匹配时,会查找整个字符串,然后返回满足表达式的结果。所以使用search方法进行匹配时,对于ip的第一个字段和最后一个字段出错的情况下,会自动进行ip址的截取,尽量使结果满足表达式的要求,但是这种结果并不是我们想要的。
       match是从头开始匹配,当ip地址的前三段都正确,而最后一个字段出错时,也无法得出预期的结果。
       fullmatch是完全匹配,因此字符串要完全满足ip地址规则时,才会返回正确结果,ip地址有误时,无输出(输出为None)。


    当然,非要使用search和match进行匹配也是可以的,首先了解一下“零宽断言”。

    零宽断言:用于查找特定内容之前或之后的内容,但并不包括特定内容本身(零宽)。类似于^、 $、 \b一样的作用,指定某一位置需要满足某些条件(断言)。

    表达式 说明
    (?=exp) 匹配exp前面的位置 (此位置后面是exp)
    (?<=exp) 匹配exp后面的位置(此位置前面是exp)
    (?!exp) 此位置后面不能是exp
    (?<!exp) 此位置前面不能是exp

    匹配ip地址时,不允许对不合法的地址进行截取 以得到符合规则的ip地址,即是要求:匹配结果在原字符串中的位置之前和之后不能有被截取的点(.)和数字。
    在这里插入图片描述
    根据以上分析 修改原有正则表达式,在原表达式的前面添加(?<![\.\d]),最后面添加(?![\.\d]),即修改之后完整的表达式为:

    pattern = re.compile(r'(?<![\.\d])(([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.){3}([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])(?![\.\d])')
    

    通过上面这条正则表达式,对之前错误的ip地址重新进行匹配验证,结果如下,

    In [1]: import re
    
    In [2]: pattern = re.compile(r'(?<![\.\d])(([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.){3}([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])(?![\.\d])')
    
    
    # 以下各语句执行后都无输出结果,说明正则匹配不成功,ip地址不合法
    In [11]: pattern.search('255.255.255.256')
    
    In [12]: pattern.search('1255.255.255.255')
    
    In [13]: pattern.match('255.255.255.256')
    
    In [14]: pattern.match('1255.255.255.255')
    
    In [15]: pattern.search('257.127.0.0.1')
    
    In [16]: pattern.search('255.255.255.122.256')
    

    以上就是在python中如何利用re模块判断ip地址是否合法的介绍。

    展开全文
  • 表达式是我们书写Python语句的基础,在Python中,单个常量或变量可以看作最简单的表达式,使用除赋值运算符之外的其他任意运算符和函数调用连接的式子也属于表达式。 运算符优先级遵循的规则为:算术运算符优先级最高,...
  • Python的基本语法 1.缩进 2.控制语句 3.表达式 4.函数 5.对象的方法 6.类型 7.数学运算 Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常...Python开发者有意让违反了缩进规则的程...
  • 前言 正则表达式是处理字符串的强大工具,它...其实,这里就是使用的正则表达式匹配,也就是用一定的规则将特定的文本提取出来。 对于电子邮件来说可以使用 [\w!#%&'+/=?^_`~-]+)@(?:\w?.)+\w? 将它匹配出来。
  • 熟悉Python程序的运行环境与运行方式。掌握 Python 的基本数据类型。掌握 Python 的算术运算规则表达式书写方法。
  • 今天重点说下webpy的路由规则。...#url匹配规则是用正则表达式书写的 #可以声明多条路由规则,每一条都是由url匹配规则和处理类组成 urls=( '/','index', '/user','user', '/topic','topic' )  既然ur...
  • python程序设计.rar

    2019-07-06 12:36:53
    实验一、Python 语言基础 一、实验目的 1、熟练 Python 程序的运行环境与运行方式。 2、掌握 python 的基本数据类型。 3、掌握 python 的算术运算规则表达式书写方法。
  • Python实验1-Python基础

    2020-11-02 09:46:55
    掌握Python的算术运算规则表达式书写方法 实验内容 分别启动命令行形式和图形界面形式的Python解释器,在命令和程序两种方式下执行下列语句 a=2 b="1234" c=a+int(b)%10 print(a,'\t',b,'\t',c) 导入math...
  • python书写简单,功能强大, 迅速发展成为 AI ,机器学习,深度学习的主要语言。 今天花三分钟,介绍Python中的lambda表达式,注意到,它只是一个表达式,不是语句啊。 lambda的语法规则: 一个或多个参数以冒号终止...
  • Python Exception处理

    千次阅读 2017-11-26 15:29:22
    语法错误一般是指由于python语句、表达式、函数等存在书写格式活语法规则上的错误抛出的异常,如python常见的缩进控制,若同层次的执行语句存在缩进不同,会报语法错误(SyntaxError),一般在ide中会有明显的提示,其...
  • 实验1 Python语言基础

    2020-11-30 10:23:47
    3.掌握Python的算术运算规则表达式书写方法。 二、实验内容 1.分别启动命令行形式和图形用户界面形式的Python解释器,在命令和程序两种方式下执行下列语句。 a=2 b=”1234” c=a+int(b)%10 print(a,’\t’,b, ’...
  • 3、掌握 Python 的算术运算规则表达式书写方法。 二、实验内容 1、分别启动命令行的形式和图形用户界面形式的 Python 解释器,在命令和程序 两种方式下执行下列的语句: a=2 b=”1234” c=a+int(b)%10 print...
  • python语言基础上机报告

    千次阅读 2019-09-01 17:49:32
    3.掌握python的算术运算规则表达式书写方法 二、实验内容 1、启动解释器,执行语句; 2、导入math模块,查看该模块帮助消息 3、输入以下语句: >>>x=12 >>>y=x >>>id(x),id(y) 语句...
  • 判断条件的书写规则: 每个if语句的核心都是判断条件的编写 判断条件必须是返回True(成立)或者False(不成立)的表达式 我们通常称返回布尔类型的表达式为“布尔表达式” 等值判断: 判断条件中...
  • Python学习20问--3

    2020-08-02 11:37:50
    Python学习20问--31 短路逻辑2 int()函数3 语句书写4 assert5 python中的内存机制6 魔法方法7 在python中,所有的多对象的、逗号分隔的、没有明确用符号定义的这些集合默认的类型都是元组。8 列表推导式,字典推导式...
  • 一、流程控制语句 Python流程控制语句主要分为三种 顺序语句 分支语句 循环语句 二、分支语句 ...2.判断条件的书写规则 每个if语句的核心都是判断条件的编写 判断条件必须是布尔表达式 我们通常称返回...
  • Python基础进阶:从函数到高级魔法方法学习内容概括学习地址具体学习内容函数函数的作用函数名的命名规则函数的定义基本格式带有参数的格式带有默认值的参数的格式使用关键字参数格式函数的返回值函数文档查看函数...
  • 由于目前还没有利用BeautifulSoup库,因此关于爬虫的难点还是正则表达式书写。但是,当写几个正则表达式之后,发现还是有一定的规则可循的,只要我们的目的明确,想得到网页的什么,我们就直接在该网页上,找到...
  • 具体学习内容函数函数的作用函数名的命名规则函数的定义基本格式带有参数的格式带有默认值的参数的格式使用...表达式基本格式带分支格式调用函数格式类与对象类的组成类的书写规则共有和私有继承魔法方法常用魔术方法...
  • 从字面上解释来说就是为一个文法(具有特定语法的形式的语句或表达式)构造解释器,这个解释器用来解释这个文法,使得这种具有某种书写规则的文法能够表示特定的功能,这种特定书写规则也就是通常所说的语法,如C/...
  • lambda

    2018-10-15 09:49:43
    介绍 lambda在完成简单函数的定义时很有作用,如编写微型函数来对各种表达式简单求值,或者需要用户提供回调函数的时候。...当然我们会在其优势时使用,缺点时使用Python逻辑就好,不是么。 规则 书写 func = lamb...
  • noritersand.github.io-源码

    2021-04-07 23:20:53
    写作规则 \t标签未使用。 缩进由空格代替 文件名,类别和标签必须用小写字母书写。 这是因为文件名和类别会影响文件系统,并且如果大小写混合在一起,则标签是相同的标签,但是会被双重化。 标签应尽可能以单数形式...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

python表达式书写规则

python 订阅