精华内容
下载资源
问答
  • Pyrere正则表达式库简介、入门、使用方法之详细攻略 目录 re正则表达式库简介 1、正则表达式元字符表集合——正则表达式pattern 2、pattern常见应用 re正则表达式库入门 0、re.compile 函数...

    Py之re:re正则表达式库的简介、常用函数、经典案例之详细攻略

     

     

    目录

    re正则表达式库的简介

    1、正则表达式元字符表集合——正则表达式的pattern

    re正则表达式库的常用函数

    1、re.compile 函数

    2、re.match和re.search

    2.1、re.match

    2.2、re.search

    3、检索和替换

    3.1、re.sub方法

    3.2、sub函数去掉代码中的注释

    3.3、sub函数将中文标点符号采用空格替换

    3.4、sub函数去掉字符串中的所有括号及括号内容

    4、re.findall

    5、split函数返回list

    5.1、split函数去掉字符串内的所有标点符号,但是不包含特殊符号|

    re正则表达式库的使用方法

    1、基础语法


     

     

    re正则表达式库的简介

          正则表达式在很多语言里都支持,python也不例外,re模块就是正则表达式的应用  正则表达式对字符串的逻辑操作,主要是对字符串的一种过滤,用“元字符” 与“普通字符”组成一个字符串规则对已知的字符串或文本过滤出自己想要的字符串。

     

    1、正则表达式元字符表集合——正则表达式的pattern

    正则表达式模式语法中的特殊元素,描述其在正则表达式上下文中的行为。
    注:要使用元字符本身的普通字符,必须使用转义字符转义一下,如 :"\(" 在正则表达式中代表普通给"("字符,其它的雷同

    字符 一、6种特殊标记字符
    \

    将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如,'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。

    ^
    $

    匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性,^ 也匹配 '\n' 或 '\r' 之后的位置。
    匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性,$ 也匹配 '\n' 或 '\r' 之前的位置。

    *
    ?
    +

    匹配前面的子表达式零次或多次。例如,zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
    (1)、*是一个限定符,用来修饰前一个字符或分组,限定匹配重复的数量为任意数量。*与+不同,+要求重复数量至少为1,*则可以为0,所以字符串为空也是可以匹配的。
    匹配前面的子表达式零次或一次。例如,"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。
    匹配前面的子表达式一次或多次。例如,'zo+' 能匹配 "zo" 以及 "zoo",但不能匹配 "z"。+ 等价于 {1,}。

    .

    匹配除换行符(\n、\r)之外的任何单个字符。要匹配包括 '\n' 在内的任何字符,请使用像"(.|\n)"的模式。

      二、3种大括号重复字符
    {n}
    {n,}
    {n,m}

    重复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次,m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。例如,"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。

      其他字符01
    ?

    当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串。
    (1)、而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串 "oooo",'o+?' 将匹配单个 "o",而 'o+' 将匹配所有 'o'。

    (pattern)

    匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到,在VBScript 中使用 SubMatches 集合,在JScript 中则使用 $0…$9 属性。要匹配圆括号字符,请使用 '\(' 或 '\)'。

    (?:pattern)

    匹配 pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如, 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。

    (?=pattern)

    正向肯定预查(look ahead positive assert),在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows",但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。

    (?!pattern)

    正向否定预查(negative assert),在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows",但不能匹配"Windows2000"中的"Windows"。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。

    (?<=pattern) 反向(look behind)肯定预查,与正向肯定预查类似,只是方向相反。例如,"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows",但不能匹配"3.1Windows"中的"Windows"。
    (?<!pattern) 反向否定预查,与正向否定预查类似,只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows",但不能匹配"2000Windows"中的"Windows"。

    (1)、大写与小写正好相反!

      三、4种中括号范围字符
    x|y

    匹配 x 或 y。例如,'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。

    [xyz]

    字符集合。匹配所包含的任意一个字符。例如, '[abc]' 可以匹配 "plain" 中的 'a'。
    (1)、[Pp]ython,匹配 "Python" 或 "python"
    (2)、rub[ye],匹配 "ruby" 或 "rube"

    [0-9],匹配任何数字。类似于 [0123456789]

     

    [^xyz]

    负值字符集合。匹配未包含的任意字符。例如, '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。
    (1)、[^aeiou],除了aeiou字母以外的所有字符

    [a-z]

    字符范围。匹配指定范围内的任意字符。例如,'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
    (1)、[a-z],匹配任何小写字母。  [A-Z],匹配任何大写字母。
    (2)、[a-zA-Z0-9],匹配任何字母及数字

    [^a-z]

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

      四、4种大小写字母字符
    \b

    匹配一个单词边界,也就是指单词和空格间的位置。例如, 'er\b' 可以匹配"never" 中的 'er',但不能匹配 "verb" 中的 'er'。

    \B

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

    \d

    匹配一个数字字符。等价于 [0-9]。
    (1)、\d+ :匹配多个数字,即删除非数字的字符串 

    \D

    匹配一个非数字字符。等价于 [^0-9]。
    (1)、pure_phone= re.sub(r'\D', "", '2-959-5')      # 删除非数字的字符串,比如删除号码中的-得到29595

    \s

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

    \S

    匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

    \w

    匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
    匹配字母、数字、下划线
    (1)、\W+:匹配多个文本,如数字、字母、下划线和加号本身字符

    \W

    匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
    匹配非字母、数字、下划线。

      五、3种即换页、换行、回车符
    \cx

    匹配由 x 指明的控制字符。例如, \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则,将 c 视为一个原义的 'c' 字符。

    \f

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

    \n

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

    \r

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

    \t

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

    \v

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

      其他字符02
    \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 的向后引用。如果前面的条件都不满足,若 n 和 m 均为八进制数字 (0-7),则 \nm 将匹配八进制转义值 nm。

    \nml

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

    \un

    匹配 n,其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如, \u00A9 匹配版权符号 (?)。

     

     

     

    re正则表达式库的常用函数

    1、re.compile 函数

    compile 函数用于编译正则表达式,生成一个正则表达式( Pattern )对象,供 match() 和 search() 这两个函数使用。
    语法:re.compile(pattern[, flags])
    参数

    • pattern : 一个字符串形式的正则表达式
    • flags : 可选,表示匹配模式,比如忽略大小写,多行模式等,具体参数为:
    正则表达式的修饰符flags 描述
    re.I 忽略大小写。使匹配对大小写不敏感
    re.L 本地化识别(locale-aware)匹配,表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境。
    re.M 多行匹配,影响 ^ 和 $,多行模式
    re.S 使 . 匹配包括换行在内的所有字符。即为 . 并且包括换行符在内的任意字符(. 不包括换行符)。
    re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B。表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库。
    re.X 为了增加可读性,忽略空格和 # 后面的注释。该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

     

    2、re.match和re.search

    2.1、re.match

    re.match:只匹配字符串的开始。尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。
    语法:re.match(pattern, string, flags=0)
    参数说明

    • pattern    匹配的正则表达式
    • string    要匹配的字符串。
    • flags    标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

    (1)、根据匹配对象函数来获取匹配表达式

    匹配对象方法 描述
    group(num=0) 匹配的整个表达式的字符串,group() 可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。
    groups() 返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
    group([group1, …]) 方法用于获得一个或多个分组匹配的字符串,尤其group() #获得整个匹配的子串
    start()
    span()
    start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始、终止位置
    span([group]) 方法返回 (start(group), end(group))

    (2)、group()、group(1)的应用

    import re
    line = "Catsss are smarter than dogs"
    matchObj = re.match( r'(.*) are smarter (.*?) .*', line, re.M|re.I)
    '''
    前面的一个 r 表示字符串为非转义的原始字符串,让编译器忽略反斜杠,也就是忽略转义字符。但是这个字符串里没有反斜杠,所以这个 r 可有可无。
    (.*):第一个匹配分组,.* 代表匹配除换行符之外的所有字符。
    (.*?):第二个匹配分组,.*? 后面多个问号,代表非贪婪模式,也就是说只匹配符合条件的最少字符
     .*:最后一个,没有括号包围,所以不是分组,匹配效果和第一个一样,但是不计入匹配结果中。
     
    '''
    
    if matchObj:
        print ("matchObj.group(): ", matchObj.group())      # 得到全部匹配结果,得到完整文本字符
        print ("matchObj.group(1): ", matchObj.group(1))    # 得到第一组匹配结果
        print ("matchObj.group(2): ", matchObj.group(2))    # 没有第二个匹配组
    else:
        print ("No match!!")
    
    matchObj.group():  Catsss are smarter than dogs
    matchObj.group(1):  Catsss
    matchObj.group(2):  than

     

     

    2.2、re.search

    re.search:匹配整个字符串。扫描整个字符串,并返回第一个成功的匹配。
    语法:re.search(pattern, string, flags=0)
    参数说明

    • pattern    匹配的正则表达式
    • string    要匹配的字符串。
    • flags    标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

     

     

     

    3、检索和替换

    3.1、re.sub方法

    Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
    语法:re.sub(pattern, repl, string, count=0, flags=0)
    参数

    • pattern : 正则中的模式字符串。
    • repl : 替换的字符串,也可为一个函数
    • string : 要被查找替换的原始字符串。
    • count : 模式匹配后替换的最大次数,默认 0 表示替换所有的匹配。

    (1)、将匹配的数字乘以 2:A23G4HFD567→A46G8HFD1134

    import re
     
    # 将匹配的数字乘以 2
    def double(matched):
        value = int(matched.group('value'))
        return str(value * 2)
     
    s = 'A23G4HFD567'
    print(re.sub('(?P<value>\d+)', double, s))

     

     

    3.2、sub函数去掉代码中的注释

    #sub函数去掉代码中的注释
    phone = "2-959-5     # 这是一个国外电话号码?,<)(12~"
    res = re.sub(r'#.*$', "", phone)
    print(res)
    

    2-959-5    

     

     

    3.3、sub函数将中文标点符号采用空格替换

    #sub函数将中文标点符号采用空格替换
    str='ABC。你好,123!@#%'
    
    import re
    from zhon.hanzi import punctuation
    res01=re.sub(r"[%s]+" %punctuation, " ",str)
    print(res01)

    ABC 你好 123 @#%

     

    3.4、sub函数去掉字符串中的所有括号及括号内容

    #去掉字符串中的所有括号及括号内容
    import re  
    str="今天(1)天气{1}非常好啊,[1]是的。"
    str_sub = re.sub(u"\\(.*?\\)|\\{.*?}|\\[.*?]", "", str)
    print(str_sub)   
    '今天天气非常好啊,是的。'

     

     

     

    4、re.findall

    findall函数:在字符串中找到正则表达式所匹配的所有子串,并返回一个列表。
    (1)、match 和 search 是匹配一次,findall 匹配所有
    语法:findall(string[, pos[, endpos]])
    参数说明

    • string : 待匹配的字符串。
    • pos : 可选参数,指定字符串的起始位置,默认为 0。
    • endpos : 可选参数,指定字符串的结束位置,默认为字符串的长度

     


    5、split函数返回list

    5.1、split函数去掉字符串内的所有标点符号,但是不包含特殊符号|

    #split函数去掉字符串内的所有标点符号,但是不包含特殊符号|
    str='ABC。你好,123!@#%|/'
    
    # coding: utf8
    import re
    pattern = r',|\.|/|;|\'|`|\[|\]|<|>|\?|:|"|\{|\}|\~|!|@|#|\$|%|\^|&|\(|\)|-|=|\_|\+|,|。|、|;|‘|’|【|】|·|!| |…|(|)'
    res = re.split(pattern, str)
    print(res)

    ['ABC', '你好', '123', '', '', '', '|', '']

     

     

     

    re正则表达式库的使用方法

    1、基础语法

    '''
    a-z是所有小写字母
    “+”表示匹配前面的子表达式一次或多次(大于等于1次)。
        例如,“zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。+等价于{1,}
    '''
    import re
    pattern = re.compile(r'([a-z]+) ([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写
    m = pattern.match('Hello World Wide Web')
    print( m.group(0) )              # 返回匹配成功的整个子串
    print( m.span(2) )               # 返回第二个分组匹配成功的子串的索引
    print( m.group(3) )          
    print( m.span(4) )               #不存在第四个匹配,所以错误

     

     

     

     

    展开全文
  • Python2.7支持正则表达式模块,提供正则表达式来处理html以及其他网络符号
  • python的re.py分析

    2019-06-12 17:49:23
    re.py是用来做什么,在文件内实现了什么小功能,这些小功能怎样被引用,而构建这个文件用了什么写法,做到知其然而知所以然,我觉得很重要。 第一点先搞清楚,我来自哪里 import enum import sre_compile ...

    个人想法:分析一个文件的功能,来源于需求

    re.py是用来做什么的,在文件内实现了什么小功能,这些小功能怎样被引用,而构建这个文件用了什么写法,做到知其然而知所以然,我觉得很重要。

    第一点先搞清楚,我来自哪里

    import enum
    import sre_compile
    import sre_parse
    import functools
    try:
        import _locale
    except ImportError:
        _locale = None

    引入了enum(枚举),sre_compile(编译),sre_parse(分析),functools(函数工具),或_locale(本地)

    第二点,我要实现什么功能

    # public symbols
    __all__ = [
        "match", "fullmatch", "search", "sub", "subn", "split",
        "findall", "finditer", "compile", "purge", "template", "escape",
        "error", "Pattern", "Match", "A", "I", "L", "M", "S", "X", "U",
        "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
        "UNICODE",
    ]

    第三点,我要实现的功能缺乏些那些元素,我要添加

    __version__ = "2.2.1"
    
    class RegexFlag(enum.IntFlag):
        ASCII = sre_compile.SRE_FLAG_ASCII # assume ascii "locale"
        IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
        LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
        UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode "locale"
        MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
        DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
        VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
        A = ASCII
        I = IGNORECASE
        L = LOCALE
        U = UNICODE
        M = MULTILINE
        S = DOTALL
        X = VERBOSE
        # sre extensions (experimental, don't rely on these)
        TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
        T = TEMPLATE
        DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation
    globals().update(RegexFlag.__members__)
    

    第四点 接口

    # public interface
    
    def match(pattern, string, flags=0):
        """Try to apply the pattern at the start of the string, returning
        a Match object, or None if no match was found."""
        return _compile(pattern, flags).match(string)
    
    def fullmatch(pattern, string, flags=0):
        """Try to apply the pattern to all of the string, returning
        a Match object, or None if no match was found."""
        return _compile(pattern, flags).fullmatch(string)
    
    def search(pattern, string, flags=0):
        """Scan through string looking for a match to the pattern, returning
        a Match object, or None if no match was found."""
        return _compile(pattern, flags).search(string)
    
    def sub(pattern, repl, string, count=0, flags=0):
        """Return the string obtained by replacing the leftmost
        non-overlapping occurrences of the pattern in string by the
        replacement repl.  repl can be either a string or a callable;
        if a string, backslash escapes in it are processed.  If it is
        a callable, it's passed the Match object and must return
        a replacement string to be used."""
        return _compile(pattern, flags).sub(repl, string, count)
    
    def subn(pattern, repl, string, count=0, flags=0):
        """Return a 2-tuple containing (new_string, number).
        new_string is the string obtained by replacing the leftmost
        non-overlapping occurrences of the pattern in the source
        string by the replacement repl.  number is the number of
        substitutions that were made. repl can be either a string or a
        callable; if a string, backslash escapes in it are processed.
        If it is a callable, it's passed the Match object and must
        return a replacement string to be used."""
        return _compile(pattern, flags).subn(repl, string, count)
    
    def split(pattern, string, maxsplit=0, flags=0):
        """Split the source string by the occurrences of the pattern,
        returning a list containing the resulting substrings.  If
        capturing parentheses are used in pattern, then the text of all
        groups in the pattern are also returned as part of the resulting
        list.  If maxsplit is nonzero, at most maxsplit splits occur,
        and the remainder of the string is returned as the final element
        of the list."""
        return _compile(pattern, flags).split(string, maxsplit)
    
    def findall(pattern, string, flags=0):
        """Return a list of all non-overlapping matches in the string.
    
        If one or more capturing groups are present in the pattern, return
        a list of groups; this will be a list of tuples if the pattern
        has more than one group.
    
        Empty matches are included in the result."""
        return _compile(pattern, flags).findall(string)
    
    def finditer(pattern, string, flags=0):
        """Return an iterator over all non-overlapping matches in the
        string.  For each match, the iterator returns a Match object.
    
        Empty matches are included in the result."""
        return _compile(pattern, flags).finditer(string)
    
    def compile(pattern, flags=0):
        "Compile a regular expression pattern, returning a Pattern object."
        return _compile(pattern, flags)
    
    def purge():
        "Clear the regular expression caches"
        _cache.clear()
        _compile_repl.cache_clear()
    
    def template(pattern, flags=0):
        "Compile a template pattern, returning a Pattern object"
        return _compile(pattern, flags|T)
    
    # SPECIAL_CHARS
    # closing ')', '}' and ']'
    # '-' (a range in character set)
    # '&', '~', (extended character set operations)
    # '#' (comment) and WHITESPACE (ignored) in verbose mode
    _special_chars_map = {i: '\\' + chr(i) for i in b'()[]{}?*+-|^$\\.&~# \t\n\r\v\f'}
    
    def escape(pattern):
        """
        Escape special characters in a string.
        """
        if isinstance(pattern, str):
            return pattern.translate(_special_chars_map)
        else:
            pattern = str(pattern, 'latin1')
            return pattern.translate(_special_chars_map).encode('latin1')
    
    Pattern = type(sre_compile.compile('', 0))
    Match = type(sre_compile.compile('', 0).match(''))

    第五点 网络转换

    # internals
    
    _cache = {}  # ordered!
    
    _MAXCACHE = 512
    def _compile(pattern, flags):
        # internal: compile pattern
        if isinstance(flags, RegexFlag):
            flags = flags.value
        try:
            return _cache[type(pattern), pattern, flags]
        except KeyError:
            pass
        if isinstance(pattern, Pattern):
            if flags:
                raise ValueError(
                    "cannot process flags argument with a compiled pattern")
            return pattern
        if not sre_compile.isstring(pattern):
            raise TypeError("first argument must be string or compiled pattern")
        p = sre_compile.compile(pattern, flags)
        if not (flags & DEBUG):
            if len(_cache) >= _MAXCACHE:
                # Drop the oldest item
                try:
                    del _cache[next(iter(_cache))]
                except (StopIteration, RuntimeError, KeyError):
                    pass
            _cache[type(pattern), pattern, flags] = p
        return p
    
    @functools.lru_cache(_MAXCACHE)
    def _compile_repl(repl, pattern):
        # internal: compile replacement pattern
        return sre_parse.parse_template(repl, pattern)
    
    def _expand(pattern, match, template):
        # internal: Match.expand implementation hook
        template = sre_parse.parse_template(template, pattern)
        return sre_parse.expand_template(template, match)
    
    def _subx(pattern, template):
        # internal: Pattern.sub/subn implementation helper
        template = _compile_repl(template, pattern)
        if not template[0] and len(template[1]) == 1:
            # literal replacement
            return template[1][0]
        def filter(match, template=template):
            return sre_parse.expand_template(template, match)
        return filter
    
    # register myself for pickling
    
    import copyreg
    
    def _pickle(p):
        return _compile, (p.pattern, p.flags)
    
    copyreg.pickle(Pattern, _pickle, _compile)

     第六点 语法扫描器

    # experimental stuff (see python-dev discussions for details)
    
    class Scanner:
        def __init__(self, lexicon, flags=0):
            from sre_constants import BRANCH, SUBPATTERN
            if isinstance(flags, RegexFlag):
                flags = flags.value
            self.lexicon = lexicon
            # combine phrases into a compound pattern
            p = []
            s = sre_parse.Pattern()
            s.flags = flags
            for phrase, action in lexicon:
                gid = s.opengroup()
                p.append(sre_parse.SubPattern(s, [
                    (SUBPATTERN, (gid, 0, 0, sre_parse.parse(phrase, flags))),
                    ]))
                s.closegroup(gid, p[-1])
            p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
            self.scanner = sre_compile.compile(p)
        def scan(self, string):
            result = []
            append = result.append
            match = self.scanner.scanner(string).match
            i = 0
            while True:
                m = match()
                if not m:
                    break
                j = m.end()
                if i == j:
                    break
                action = self.lexicon[m.lastindex-1][1]
                if callable(action):
                    self.match = m
                    action = action(self, m.group())
                if action is not None:
                    append(action)
                i = j
            return result, string[i:]

     

    展开全文
  • rePy2exe针对py2exe应用程序一个逆向工程工具
  • 转自:https://www.crifan.com/python_re_sub_detailed_introduction/ //这个网址讲不错。 ...re.sub是个正则表达式方面函数,用来实现通过正则表达式,实现比普通字符串replace更加强大...

    转自:https://www.crifan.com/python_re_sub_detailed_introduction/

    //这个网址讲的不错。

    1.re.sub的功能

    re是regular expression的缩写,表示正则表达式

    sub是substitute的缩写,表示替换;

    re.sub是个正则表达式方面的函数,用来实现通过正则表达式,实现比普通字符串的replace更加强大的替换功能;

    inputStr = "hello 111 world 111"
    replacedStr = inputStr.replace("111", "222")
    //这样可以进行替换

     

    inputStr = "hello 123 world 456"
    replacedStr = re.sub("\d+", "222", inputStr)
    //这样可以把数字都换为222

     

     对于输入的一个字符串,利用正则表达式(的强大的字符串处理功能),去实现(相对复杂的)字符串替换处理,然后返回被替换后的字符串.

    2.re.sub的各个参数的详细解释

    re.sub共有五个参数。

    其中三个必选参数:patternreplstring

    两个可选参数:countflags

     

    转载于:https://www.cnblogs.com/BlueBlueSea/p/10648404.html

    展开全文
  • 介绍: Django是一个开放源代码...由于我在urls.py使用re_path正则匹配数字方式,后台search.py不能接受到变量值! 匹配变量: 字符串:(?P<prm>\w+) 数字:(?P<int>\d+) 类型、个数匹配:(?P&...

    介绍:

    Django是一个开放源代码的Web应用框架,由Python写成。采用了MVT的框架模式,即模型M,视图V和模版T。

    错误截图:

    错误原因: 

    由于我在urls.py使用re_path正则匹配数字的方式,后台search.py不能接受到变量值!

    匹配变量:

    • 字符串:(?P<prm>\w+)
    • 数字:(?P<int>\d+)
    • 类型、个数匹配:(?P<p>[0-9]{4}) //4个0-9的数字

    urls.py

    search.py(错误的写法)

    问题解决:

     search.py(正确的写法)

    总结: 

    由于使用了正则匹配数字在URL上,所以后台对应函数必须接收参数,而**kwargs可以当作容纳多个key和value的dictionary,类似接收数据的参数还有*args。

    那么*args和**kwargs区别?

    print '======================================'
    def func(*args,**kwargs):
        print 'args=',args
        print 'kwargs=',kwargs
        print '======================================'
     
    func(1,2,3)
    func(a=1,b=2,c=3)
    func(1,2,3,a=1,b=2,c=3)
    func(1,'b','c',a=1,b='b',c='c')
    

     

     

     

    展开全文
  • py转义和re.escape

    2019-08-29 18:36:34
    re.escape就是让一个正则表达式里面*?+\等等都失去特殊含义,而使用其字面 比如上面\d和在正则表达式里表示数字和"任意个",如果想使它们失去特殊含义,则可以对\和用\转义,使其变成字面意思 也就是说pattern应该...
  • view函数:一个可选用对象,通常为一个是为一个视图函数或者在include函数中的urls.py的元祖或者列表 参数:可选的要传递给视图函数的默认参数(关键字参数:字典形式) 别名:一个可选的name参数,即为命名空间 ...
  • re_name.py

    2020-05-06 18:58:55
    重命名文件名,批量修改文件名字,可以修改文件夹里格式和后缀,python代码,从0开始修改文件名字
  • import cookielib,re #临时存储学生cookie stuCookie='' #声明一个CookieJar对象实例来保存cookie cookie = cookielib.CookieJar() #利用urllib2库HTTPCookieProcessor对象来创建cookie处理器 ...
  • 使用一次性客户端应用程序从Raspberry Pi将植物土壤水分读数上传到Blot're。 客户创建 基本客户创建 后创建新客户端应用程序。 import blotre blotre . Blotre ({ 'client_id' : "Client id from Blot're" , ...
  • 该项目是使用版本1.6.1生成。 开发服务器 为开发服务器运行ng serve 。 导航到http://localhost:4200/ 。 如果您更改任何源文件,该应用程序将自动重新加载。 代码脚手架 运行ng generate component component-...
  • Re库是python拥有全部正则表达式功能,同时,re模块也提供了与这些方法功能完全一致函数,这些函数使用一个模式字符串作为它们第一个参数。 如果想要查看更多关于正则表达式用法,请查看:正则表达式...
  • Python正则表达式指南 ...得益于这一点,在提供了正则表达式语言里,正则表达式语法都是一样,区别只在于不同编程语言实现支持语法数量不同;但不用担心,不被支持语法通常是不常用...
  • 南邮CTF-RE-Py交易

    2018-11-20 22:33:00
    pyc反编译工具是uncompyle6 root@kali:~/Desktop# uncompyle6 Py.pyc &...得到反编译后的py文件 # uncompyle6 version 3.2.3 # Python bytecode 2.7 (62211) # Decompiled from: Python 2.7.13 (defau...
  • 在Django官方文档中,介绍了urls里面使用path和re_path一些写法。 网址:https://docs.djangoproject.com/en/3.0/topics/http/urls/ 以下是path第一个例子: from django.urls import path from . import...
  • CG repy交易小白详解

    2019-12-02 22:25:13
    发现,是一个Py.pyc文件,然后看这个话应该是和Python有关;下载之后,对这个一点也不知道,所以我就直接双击运行,发现一闪而过,那就要想其他方法了,用了ida,od(有点傻),都不行 所以就在网上查了一下,...
  • Django 一文看懂urls.py与views.py的联系

    万次阅读 2020-07-09 18:42:07
    创建settings.py中通过ROOT_URLCONF变量指定全局路由文件名称,一般路由名称与工程名称相同。 Django使用urlpatterns变量名来添加路由,改变量是列表类型,一般有path和re_path组成。 2 DjangoURL路由流程 ...
  • 下载迅雷文件名不顺眼,批量修改下文件名,写了个很简单重命名python脚本re_name.py,很方便。 修改前: 修改后: #!\usr\bin\envpython#-*-coding:utf-8-*-#Filename:re_name.pyimportospath=os....
  • </script>''',re.I|re.M|re.S) s = r.sub ('',content) r = re.compile(r'''*?</style>''',re.I|re.M|re.S) s = r.sub ('', s) r = re.compile(r'''<!--.*?-->''', re.I|re.M|re.S) s = r.sub('',s) r = re....
  • https://cgctf.nuptsast.com/challenges#Re 下载下来是个pyc文件 然后使用在线工具将其反编译 它将输入flag每一位与32异或,然后再加上16,最后用base64加密得到correct 所以代码应该为 先将correct解密,然后...
  • py3+urllib+bs4+反爬,20+行代码教你爬取豆瓣妹子图:http://www.cnblogs.com/UncleYong/p/6892688.htmlpy3+requests+json+xlwt,爬取拉勾招聘信息:http://www.cnblogs.com/UncleYong/p/6960044.htmlpy3+urllib+re,...
  • 里面jiami()函数是这样 整个加密逻辑就在那一个函数里,,写逆脚本,,,爆破也可 #include <stdio.h> #include <string.h> int bh(char x) { if (x > 96 && x <= 122) return x -...
  • py3+urllib+bs4+反爬,20+行代码教你爬取豆瓣妹子图:http://www.cnblogs.com/UncleYong/p/6892688.htmlpy3+requests+json+xlwt,爬取拉勾招聘信息:http://www.cnblogs.com/UncleYong/p/6960044.htmlpy3+urllib+re,...
  • 1. Hello,RE! 直接拖进IDA,根据提示找奇怪字符串并转换 直接切近main函数,然后转成伪C代码,发现了输出flag结构,直接吧看到数字进行转换就好 2. ReadAsm2 硬考汇编阅读能力,读呗……给出是func...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,238
精华内容 895
关键字:

py的re