正则表达式
1. 就其本质而言, 正则表达式 (regular expression) 是一种小型的高度专业化的编程语言,(在 python 中)它内嵌在 python 中, 并通过 re 模块实现正则表达式模式被编译成一系列的字节码, 然后由用 c 编写的匹配引擎执行
作用: 用来模糊匹配字符串
2. 字符匹配(普通字符, 元字符)
普通字符: 大多数字符和字母都会和自身匹配
Print(re.findall(jiaxin,haszjhnjiaxinisxjhmbj))
元字符: . ^ $ * + {} [] | () \
字符串方法回顾
- # -*-coding:utf-8 -*-
- __author__ = xiaojiaxin
__file_name__ = 正则表达式
- s="hello world"
- # Python find() 方法检测字符串中是否包含子字符串 str , 如果指定 beg(开始) 和 end(结束) 范围, 则检查是否包含在指定范围内, 如果包含子字符串返回开始的索引值, 否则返回 - 1
- print(s.find("llo"))
- # 2
- # print(s.index("23")) #找不到会报错
- print(s.replace("ll","ss"))
- # hesso world
- print(s.split("o"))
- # [hell, w, rld]
- # 正则表达式模块(Regular Expression 正则表达式)
正则表达式
- import re
- ret=re.findall("w\w{2}l","hello world")
- print(ret)
- # [worl]
- # 完全匹配 "jiaxin", 没找到
- ret1=re.findall("jiaxin","sdkjfnxkgjfkdsgfgusydxtnia")
- print(ret1)
- # []
- ret2=re.findall("jiaxin","sdkjfnxkgjfkdsjiaxindxtnia")
- print(ret2)
- # [jiaxin]
元字符.
- # 元字符
- #. 通配符, 代指单个任意字符, 也可以匹配空格和换行符等
- ret3=re.findall("j.a","sdkjfnxkgjfkdsjiaxindxtnia")
- print(ret3)
- # [jia]
- ret4=re.findall("w.r","hello w\trld!")
- print(ret4)
- # [w\tr]
元字符 ^
- #^ 只从头开始匹配
- ret5=re.findall("^h...o","dhsfjkhello")
- print(ret5)
- # []
- ret5=re.findall("^h...o","hhsfokhello")
- print(ret5)
- # [hhsfo]
元字符 $
- #$ 只从结尾匹配
- ret6=re.findall("j.a$","jiaaskdhfx js")
- print(ret6)
- # []
- ret7=re.findall("j.a$","jiaaskdhfx jda")
- print(ret7)
- # [jda]
** 元字符 ***
- #* 表示重复匹配[0,+oo] .* 表示 0 到多次任意字符
- ret8=re.findall("jia.*xin","sdjfhdxjjjiaajshjkshkxinhsfjkg")
- print(ret8)
- # [jiaajshjkshkxin]
- ret9=re.findall("jia*","sdjfhdxjjjiaajshjkshkxinhsfjkg")
- print(ret9)
- # [jiaa]
元字符 +
- #+ 也表示重复匹配[1,+oo],b 至少有一个
- ret10=re.findall("ab+","ghfxhsgabjhf")
- print(ret10)
- # [ab]
元字符?
- #? [0,1]要么 0, 要么 1, 要么只有一个 b, 要么没有 b
- ret11=re.findall("ab?","ghfxhsgabjhf")
- print(ret11)
- # [ab]
元字符{}
- #{}规定 {} 前面的 a 重复的次数
- ret12=re.findall("a{4}b?","kdfkaaaabhkfd")
- print(ret12)
- # [aaaab]
- #{m,n}可以匹配 n,n+1,n+2m 次, 默认贪婪匹配, 多个匹配按照最多的去匹配
- ret13=re.findall("a{1,5}b?","kdfkaaabhkfd")
- print(ret13)
- # [aaab]
- #[1.+oo)表示方法
- ret14=re.findall("a{1,}b?","kdfkaaabhkfd")
- print(ret14)
- # [aaab]
惰性匹配
- # 惰性匹配
- print(re.findall("abc*?","abcccccc"))
- # [ab]
- # 结论: * [0,+oo)
- # + [1,+oo)
- # ? 0 或 1
- # {m,n} 从 m 或者 m+1,m+2 再或者 n 次重复都可以
元字符[ ]
- # []叫字符集, c 或者 d 或者 e, 但是不能是 cde,cd,ce,de, 只能是三选一
- ret15=re.findall("a[c,d,e]x","acx")
- print(ret15)
- # [acx]
- ret16=re.findall("[a-z]","acxsfw34uriyjkdhk54")
- print(ret16)
- # [a, c, x, s, f, w, u, r, i, y, j, k, d, h, k]
- #[]字符集: 取消元字符的特殊功能, 有例外(\ ^ -)
- ret17=re.findall("[a-z*]","acxsfw3*5uriyjkdhk54")
- print(ret17)
- # [a, c, x, s, f, w, *, u, r, i, y, j, k, d, h, k]
- ret18=re.findall("[a-z0-9A-Z]","acxsfw35uriyjkdhk54")
- print(ret18)
- # [a, c, x, s, f, w, 3, 5, u, r, i, y, j, k, d, h, k, 5, 4]
- #^ 放在 [] 里, 表示取反
- ret19=re.findall("[^a]","acxsfw35uriyjkdhk54")
- print(ret19)
- # [c, x, s, f, w, 3, 5, u, r, i, y, j, k, d, h, k, 5, 4]
- #a 和 c 都要去掉
- ret20=re.findall("[^a,c]","acxsfbw35uriyjkdhk54")
- print(ret20)
- # [x, s, f, w, 3, 5, u, r, i, y, j, k, d, h, k, 5, 4]
元字符 \
- # \ 最重要的符号, 功能有两个: 1. 反斜杠后边跟元字符去除特殊功能
- # 2. 反斜杠后边跟普通字符实现特殊功能
- # \ 序号
- #
- # 1. 引用序号对应的子组所匹配的字符串, 子组的序号从 1 开始计算
- # 2. 如果序号是以 0 开头, 或者 3 个数字的长度那么不会被用于引用对应的子组, 而是用于匹配八进制数字所表示的 ASCII 码值对应的字符
- # 举个栗子:.+) \1 会匹配 "FishC FishC" 或 "55 55", 但不会匹配 "FishCFishC"(注意, 因为子组后边还有一个空格)
- #
- # \A
- #
- # 匹配输入字符串的开始位置
- #
- # \Z
- #
- # 匹配输入字符串的结束位置
- #
- # \b
- #
- # 零宽断言, 匹配一个单词边界, 单词被定义为 Unidcode 的字母数字或下横线字符
- # 举个栗子:\bFishC\b 会匹配字符串 "love FishC"FishC."或"(FishC)"
- #
- # \B
- #
- # 零宽断言, 匹配非单词边界, 其实就是与 \b 相反
- # 举个栗子: py\B 会匹配字符串 "python""py3"或"py2", 但不会匹配"py ""py." 或 "py!"
- #
- # \d
- #
- # 1. 对于 Unicode(str 类型)模式: 匹配任何一个数字, 包括 [0-9] 和其他数字字符; 如果开启了 re.ASCII 标志, 就只匹配 [0-9]
- # 2. 对于 8 位 (bytes 类型) 模式: 匹配 [0-9] 中任何一个数字
- #
- # \D
- #
- # 匹配任何非 Unicode 的数字, 其实就是与 \d 相反; 如果开启了 re.ASCII 标志, 则相当于匹配 [^0-9]
- #
- # \s
- #
- # 1. 对于 Unicode(str 类型)模式: 匹配 Unicode 中的空白字符(包括 [ \t\n\r\f\v] 以及其他空白字符); 如果开启了 re.ASCII 标志, 就只匹配 [ \t\n\r\f\v]
- # 2. 对于 8 位 (bytes 类型) 模式: 匹配 ASCII 中定义的空白字符, 即 [ \t\n\r\f\v]
- #
- # \S
- #
- # 匹配任何非 Unicode 中的空白字符, 其实就是与 \s 相反; 如果开启了 re.ASCII 标志, 则相当于匹配 [^ \t\n\r\f\v]
- #
- # \w
- #
- # 1. 对于 Unicode(str 类型)模式: 匹配任何 Unicode 的单词字符, 基本上所有语言的字符都可以匹配, 当然也包括数字和下横线; 如果开启了 re.ASCII 标志, 就只匹配 [a-zA-Z0-9_]
- # 2. 对于 8 位 (bytes 类型) 模式: 匹配 ASCII 中定义的字母数字, 即 [a-zA-Z0-9_]
- #
- # \W
- #
- # 匹配任何非 Unicode 的单词字符, 其实就是与 \w 相反; 如果开启了 re.ASCII 标志, 则相当于 [^a-zA-Z0-9_]
- #
- # 转义符号
- #
- # 正则表达式还支持大部分 Python 字符串的转义符号:\a,\b,\f,\n,\r,\t,\u,\U,\v,\x,\# 注 1:\b 通常用于匹配一个单词边界, 只有在字符类中才表示退格
- # 注 2:\u 和 \U 只有在 Unicode 模式下才会被识别
- # 注 3: 八进制转义 (\ 数字) 是有限制的, 如果第一个数字是 0, 或者如果有 3 个八进制数字, 那么就被认为是八进制数; 其他情况则被认为是子组引用; 至于字符串, 八进制转义总是最多只能是 3 个数字的长度
- print(re.findall("\d{11}","hdfkhdgk34980657000jhdcfbhbg0426383032"))
- # [34980657000]
- print(re.findall("\sabc","123 abc uirye"))
- # [ abc]
- print(re.findall("\wabc","123 yabc uirye"))
- # [yabc]
- print(re.findall("\w","123 yabc uirye"))
- # [1, 2, 3, y, a, b, c, u, i, r, y, e]
- print(re.findall(r"i\b","hello,i li$ke it !"))
- # [i, i]
元字符 |
- # | 管道符: 或
- #####################################
正则表达式常用方法:
- #search 只找第一个匹配的, 找到就不找了
- #group()用来提出分组截获的字符串
- print(re.search("ok","hdfhnkjshokjhfdkj"))
- # <_sre.SRE_Match object; span=(9, 11), match=ok>
- print(re.search("ok","hdfhnkjshokjhfdkj").group())
- # ok
- ret21=re.search("a.","agj").group()
- print(ret21)
- ret22=re.search("a\+","a+gj")
- print(ret22.group())
- # a+
- ret23=re.findall(r"\\p","fha\p")
- print(ret23)
- # [\\p]
- ret24=re.findall("\\\p","fha\p")
- print(ret24)
- # [\\p]
正则表达式的方法:
findall(): 所有结果都返回在一个列表里
search() : 返回匹配到的第一个对象 (object), 对象可以调用 group() 返回结果
match() : 只在字符串开始匹配时匹配, 也返回匹配到的第一个对象 (object), 对象可以调用 group() 返回结果
split() :
sub() : 替换
compile():
split 方法
- #***********
- # 首先根据 l 分, 再根据 o 分, 再打印出来
- ret30=re.split("[l,o]",hello world)
- print(ret30)
- # [he, , , w, r, d]
- # 注意 "" 的来源
- ret31=re.split("[l,h]",hello world)
- print(ret31)
- # [, e, , o wor, d]
- ret32=re.split("[l,h]",hello world)
- print(ret32)
sub 方法
- # 替换符
- ret33=re.sub("j.a","j*j","hfjhjia")
- print(ret33)
- # hfjhj*j
compile 方法
- # 一次编写规则, 多次使用
- rule=re.compile("\.com")
- rule.findall("sdjfg.comsjdfk")
- print(rule)
- # re.compile(\\.com)
来源: http://www.bubuko.com/infodetail-2545291.html