正则表达式浅谈

正则表达式的概念

正则表达式：用于实现查找符合某些复杂规则的字符串的需要（即：记录文本规则的代码）
eg:windows/dos下用于文件查找的通配符 *

 查找某个目录下所有的word文档：  *.doc

此处*被解释为任意的字符串

一.正则表达式入门

1. 需求： 在一篇英文文章中查找hi:
在很多单词中会包含hi这两个字母eg history 所以可以使用\bhi\b；

#通常正则表达式会忽略大小写的选项，即所匹配出的可能为：HI Hi hI hi其中之一

\b （元字符）代表单词的开头或结尾，\b并不匹配分割字符，仅匹配一个位置

2. 需求：查找hi后不远处跟着单词Lucky:
可以使用 . 元字符 . 匹配除了换行符外任意字符。
*元字符：代表的不是字符也不是位置，而是数量

代表*前的内容可以连续重复使用任意次数，使得整个表达式得到匹配
.*连在一起即为任意数量的不包含换行符的字符。

解决需求：\bhi\b.*\bLucky\b
即为hi 之后任意非换行符字符再加Lucky

3. 0\d\d-\d\d\d\d\d\d\d\d
\d 匹配一位数字（0或1或2.。。。。。。），-:连字符，仅匹配自身，连字符在文本中匹配出连字符本身出来。
可以使用0\d{2}-\d{8}来减少繁琐，{2}{8}的含义为\d必须连续重复2次（8次）

4. 起始与终止：

^ 匹配字符串起始部分
$ 匹配字符串终止部分

5. 方块符匹配：
方块符可以用于创建字符集，按需求匹配

b[aeiu]t :  匹配b +a,e,i,u 中任意一个 + t
[cr][23][dp][o2]:一个包含四个字符的字符串，第一个字符是“c”或“r”，然后是“2”或“3”，后面
是“d”或“p”，最后要么是“o”要么是“2”。例如，c2do、r3p2、r2d2、c3po 等

6. 子组匹配：
子组常用（）来界限
子组在一个更复杂的返回列表中搜索结果，而且这样做是有意义的，因为子组是允许从
单个正则表达式中抽取特定模式的一种机制，例如匹配一个完整电话号码中的一部分（例如
区号），或者完整电子邮件地址的一部分（例如登录名称）。

（\w\w\w）-(\d\d\d)  表示正则匹配中存在两个子组
 m = re.match('(\w\w\w)-(\d\d\d)', 'abc-123')
 m.group()
 >>>'abc'-'123'
 m.group(1)
 >>>'abc'
 m.group(2)
 >>>'123'
 m.groups()
 >>>('abc','123')

group()通常用于以普通方式显示所有的匹配部分，但也能用于获
取各个匹配的子组。可以使用 groups()方法来获取一个包含所有匹配子字符串的元组。

如下为一个简单的示例，该示例展示了不同的分组排列，这将使整个事情变得更加清晰。
>>> m = re.match('ab', 'ab') # 没有子组
>>> m.group() # 完整匹配
'ab'
>>> m.groups() # 所有子组
()
>>>
>>> m = re.match('(ab)', 'ab') # 一个子组
>>> m.group() # 完整匹配
'ab'
>>> m.group(1) # 子组 1 
'ab'
>>> m.groups() # 全部子组
('ab',)
>>>
>>> m = re.match('(a)(b)', 'ab') # 两个子组
>>> m.group() # 完整匹配
'ab'
>>> m.group(1) # 子组 1 
'a'
>>> m.group(2) # 子组 2 
'b'
>>> m.groups() # 所有子组
20 第 1 部分 通用应用主题
('a', 'b')
>>>
>>> m = re.match('(a(b))', 'ab') # 两个子组
>>> m.group() # 完整匹配
'ab'
>>> m.group(1) # 子组 1 
'ab'
>>> m.group(2) # 子组 2 
'b'
>>> m.groups() # 所有子组
('ab', 'b')

懒惰与贪婪

贪婪匹配
正则表达式默认匹配尽可能多的字符

1 a.*b：将匹配最长以a起始，以b结束的字符串
 若目标匹配应用于aabab中，则返回aabab而不是ab

这种匹配机制被称为贪婪匹配
有时会更需要懒惰匹配
懒惰匹配：
匹配尽可能少的字符，前面所给出的限定符都可以使用懒惰匹配，只需要在其后加上？

例如：.*?:匹配任意数量的重复，在能匹配成功的前提下使用最少的重复

*？   重复任意次，但尽可能少重复
+？ 重复一次或多次，尽可能少重复
？？ 重复0或1次，尽可能。。。。。
{n,m}？ 重复n 到m次 尽可能。。。
{n}? 重复n次，尽可能。。。

re模块基础函数

1：findall()函数：
findall()查询字符串中某个正则表达式模式全部的非重复出现情况。这与 search()在执行
字符串搜索时类似，但与 match()和 search()的不同之处在于，findall()总是返回一个列表。如
果 findall()没有找到匹配的部分，就返回一个空列表，但如果匹配成功，列表将包含所有成
功的匹配部分（从左向右按出现顺序排列）。

>>> re.findall('car', 'car')
['car']
>>> re.findall('car', 'scary')
['car']
>>> re.findall('car', 'carry the barcardi to the car')
['car', 'car', 'car']

2： sub()/subn()函数
用于实现搜索和替换功能：sub()和 subn()。两者几乎一样，都是将某字
符串中所有匹配正则表达式的部分进行某种形式的替换。用来替换的部分通常是一个字符串，
但它也可能是一个函数，该函数返回一个用来替换的字符串。subn()和 sub()一样，但 subn()
还返回一个表示替换的总数，替换后的字符串和表示替换总数的数字一起作为一个拥有两个元素的元组返回

>>> re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n')
'attn: Mr. Smith\012\012Dear Mr. Smith,\012'
>>>
>>> re.subn('X', 'Mr. Smith', 'attn: X\n\nDear X,\n')
('attn: Mr. Smith\012\012Dear Mr. Smith,\012', 2)
>>>
>>> print re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n')
attn: Mr. Smith
Dear Mr. Smith,
>>> re.sub('[ae]', 'X', 'abcdef')
'XbcdXf'
>>> re.subn('[ae]', 'X', 'abcdef')
('XbcdXf', 2)

3：对who命令结果进行正则匹配
$ who
wesley console Jun 20 20:33
wesley pts/9 Jun 22 01:38 (192.168.0.6)
wesley pts/1 Jun 20 20:33 (:0.0)
wesley pts/2 Jun 20 20:33 (:0.0)
wesley pts/4 Jun 20 20:33 (:0.0)
wesley pts/3 Jun 20 20:33 (:0.0)
wesley pts/5 Jun 20 20:33 (:0.0)
wesley pts/6 Jun 20 20:33 (:0.0)
wesley pts/7 Jun 20 20:33 (:0.0)
wesley pts/8 Jun 20 20:33 (:0.0)

import re
f = open('whodata.txt', 'r')
for eachLine in f:
 print re.split(r'\s\s+', eachLine)
f.close()

上述代码执行后，会将空格符进行筛选过滤，以空格为界限。
但是不能筛出制表符及换行符（\011:制表符\012:换行符）

代码运行结果：
$ who > whodata.txt
$ rewho.py
[‘wesley’, ‘console’, ‘Jun 20 20:33\012’]
[‘wesley’, ‘pts/9’, ‘Jun 22 01:38\011(192.168.0.6)\012’]
[‘wesley’, ‘pts/1’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/2’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/4’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/3’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/5’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/6’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/7’, ‘Jun 20 20:33\011(:0.0)\012’]
[‘wesley’, ‘pts/8’, ‘Jun 20 20:33\011(:0.0)\012’]
改进之后：引入strip()过滤换行符，改造正则匹配语句为： \s\s+|\t

import re
import os


def huanhangstrip():
    with os.open('who.txt','r') as f:
        for eachline in f:
            print(re.split(r'\s\s+|\t',eachline.strip()))

代码执行结果：
$ rewho.py
[‘wesley’, ‘console’, ‘Feb 22 14:12’]
[‘wesley’, ‘ttys000’, ‘Feb 22 14:18’]
[‘wesley’, ‘ttys001’, ‘Feb 22 14:49’]
[‘wesley’, ‘ttys002’, ‘Feb 25 00:13’, ‘(192.168.0.20)’]
[‘wesley’, ‘ttys003’, ‘Feb 24 23:49’, ‘(192.168.0.20)’]