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+2……m次，默认贪婪匹配，多个匹配按照最多的去匹配
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‘]正则表达式的方法：
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*jcompile方法
#一次编写规则，多次使用
rule=re.compile("\.com")
rule.findall("sdjfg.comsjdfk")
print(rule)
# re.compile(‘\\.com‘)原文地址：http://blog.51cto.com/10777193/2093365
