python基础-- 正则表达式

正则表达式是对字符串操作的一种逻辑公式，

正则表达式是用来匹配字符串非常强大的工具，

    正则表达式的大致匹配过程是：
    1.依次拿出表达式和文本中的字符比较，
    2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。
    3.如果表达式中有量词或边界，这个过程会稍微有一些不同。

 

正则表达式符号含义：

　　　　re代表正则表达式：

^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
re{ n,}	匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
w	匹配字母数字及下划线
W	匹配非字母数字及下划线
s	匹配任意空白字符，等价于 [ f].
S	匹配任意非空字符
d	匹配任意数字，等价于 [0-9].
D	匹配任意非数字
A	匹配字符串开始
	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
z	匹配字符串结束
G	匹配最后匹配完成的位置。
	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
B	匹配非单词边界。'erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
, , 等.	匹配一个换行符。匹配一个制表符。等
1...9	匹配第n个分组的内容。
10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

实例：

　　正则在python的的调用方法有两种，

　　一种是使用re.compile(r, f)方法生成正则表达式对象，然后调用正则表达式对象的相应方法。这种做法的好处是生成正则对象之后可以多次使用。

　　另一种是直接用类方法调用；

　　

1 2 3 4 5 6 7 8 9 10

#返回pattern对象 re.compile(string[,flag]) #以下为匹配所用函数 re.match(pattern, string[, flags]) re.search(pattern, string[, flags]) re.split(pattern, string[, maxsplit]) re.findall(pattern, string[, flags]) re.finditer(pattern, string[, flags]) re.sub(pattern, repl, string[, count]) re.subn(pattern, repl, string[, count])

　　

正则有的主要的四大功能：　　　　

　　　　1. 匹配 查看一个字符串是否符合正则表达式的语法，一般返回true或者false
　　　　2. 获取 正则表达式来提取字符串中符合要求的文本
　　　　3. 替换 查找字符串中符合正则表达式的文本，并用相应的字符串替换
　　　　4. 分割 使用正则表达式对字符串进行分割。

1.re.findall(s,start, end):搜索string，以列表形式返回全部能匹配的子串。

pattern = re.compile(r'd+')
print re.findall(pattern,'one1two2three3four4')
  
### 输出 ###
# ['1', '2', '3', '4']

 

2. re.finditer(s, start, end):

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

import re
  
pattern = re.compile(r'd+')
for m in re.finditer(pattern,'one1two2three3four4'):
  print m.group(),
  
### 输出 ###
# 1 2 3 4

 

3. re.search(s, start, end):

search方法与match方法极其类似，区别在于match()函数只检测re是不是在string的开始位置匹配，search()会扫描整个string查找匹配，match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回None。同样，search方法的返回对象同样match()返回对象的方法和属性。

# 将正则表达式编译成Pattern对象
pattern = re.compile(r'world')
# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None
# 这个例子中使用match()无法成功匹配
match = re.search(pattern,'hello world!')
if match:
  # 使用Match获得分组信息
  print match.group()
### 输出 ###
# world

 

 

4. re.match(s, start, end):这个方法将会从string（我们要匹配的字符串）的开头开始，尝试匹配pattern，一直向后匹配，如果遇到无法匹配的字符，立即返回 None，如果匹配未结束已经到达string的末尾，也会返回None。两个结果均表示匹配失败，否则匹配pattern成功，同时匹配终止，不再对 string向后匹配。

# 匹配如下内容：单词+空格+单词+任意字符
m = re.match(r'(w+) (w+)(?P.*)', 'hello world!')
  
print "m.string:", m.string
print "m.re:", m.re
print "m.pos:", m.pos
print "m.endpos:", m.endpos
print "m.lastindex:", m.lastindex
print "m.lastgroup:", m.lastgroup
print "m.group():", m.group()
print "m.group(1,2):", m.group(1, 2)
print "m.groups():", m.groups()
print "m.groupdict():", m.groupdict()
print "m.start(2):", m.start(2)
print "m.end(2):", m.end(2)
print "m.span(2):", m.span(2)
print r"m.expand(r'g gg'):", m.expand(r'2 13')
  
### output ###
# m.string: hello world!
# m.re:
# m.pos: 0
# m.endpos: 12
# m.lastindex: 3
# m.lastgroup: sign
# m.group(1,2): ('hello', 'world')
# m.groups(): ('hello', 'world', '!')
# m.groupdict(): {'sign': '!'}
# m.start(2): 6
# m.end(2): 11
# m.span(2): (6, 11)
# m.expand(r'2 13'): world hello!

 

5. re.sub(pattern, repl, string[, count])

使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用id或g、g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。

pattern = re.compile(r'(w+) (w+)')
s = 'i say, hello world!'
  
print re.sub(pattern,r'2 1', s)
  
def func(m):
  return m.group(1).title() + ' ' + m.group(2).title()
  
print re.sub(pattern,func, s)
  
### output ###
# say i, world hello!
# I Say, Hello World!

 

6. re.subn(x, s, m):

import re
  
pattern = re.compile(r'(w+) (w+)')
s = 'i say, hello world!'
  
print re.subn(pattern,r'2 1', s)
  
def func(m):
  return m.group(1).title() + ' ' + m.group(2).title()
  
print re.subn(pattern,func, s)
  
### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)

7. re.split(pattern, string[, maxsplit])

按照能够匹配的子串将string分割后返回列表

import re
  
pattern = re.compile(r'd+')
print re.split(pattern,'one1two2three3four4')
  
### 输出 ###
# ['one', 'two', 'three', 'four', '']

 　　匹配结果对象的属性方法：

　　　　01. m.group(g, ...)
　　　　　　返回编号或者组名匹配到的内容，默认或者0表示整个表达式匹配到的内容，如果指定多个，就返回一个元组
　　　　02. m.groupdict(default)
　　　　　　返回一个字典。字典的键是所有命名的组的组名，值为命名组捕获到的内容
　　　　　　如果有default参数，则将其作为那些没有参与匹配的组的默认值。
　　　　03. m.groups(default)
　　　　　　返回一个元组。包含所有捕获到内容的子分组，从1开始，如果指定了default值，则这个值作为那些没有捕获到内容的组的值
　　　　04. m.lastgroup()
　　　　　　匹配到内容的编号最高的捕获组的名称，如果没有或者没有使用名称则返回None(不常用)
　　　　05. m.lastindex()
　　　　　　匹配到内容的编号最高的捕获组的编号，如果没有就返回None。
　　　　06. m.start(g):
　　　　　　当前匹配对象的子分组是从字符串的那个位置开始匹配的,如果当前组没有参与匹配就返回-1
　　　　07. m.end(g)
　　　　　　当前匹配对象的子分组是从字符串的那个位置匹配结束的，如果当前组没有参与匹配就返回-1
　　　　08. m.span()
　　　　　　返回一个二元组，内容分别是m.start(g)和m.end(g)的返回值
　　　　09. m.re()
　　　　　　产生这一匹配对象的正则表达式
　　　　10. m.string()
　　　　　　传递给match或者search用于匹配的字符串
　　　　11. m.pos()
　　　　　　搜索的起始位置。即字符串的开头，或者start指定的位置(不常用)
　　　　12. m.endpos()
　　　　　　搜索的结束位置。即字符串的末尾位置，或者end指定的位置(不常用)

难点：

1 分组 

在re.findall() 方法里面，如果正则表达式里面有（），则返回括号部分的匹配结果

实例

1 不加括号
print(re.findall('a+d+w+','aaaa1111aaaa,aaa222aa,nnn22cc'))
输出  ['aaaa1111aaaa', 'aaa222aa']

2 加括号
print(re.findall('a+(d+)w+','aaaa1111aaaa,aaa222aa,nnn22cc'))
输出   ['1111', '222']

2 断言

https://blog.csdn.net/magictong/article/details/5332423