正则表达式及re模块

re 模块

match 函数

• 尝试用正则表达式模式从字符串的 开头匹配，如果匹配成功，则返回一个匹配对象；否则返回 None

案例：使用match函数匹配字符串

>>> import re		#导入正则表达式模块
>>> re.match('foo', 'food')		#匹配字符串'food'中是否包含字符'foo'，包含返回一个对象
<re.Match object; span=(0, 3), match='foo'>
>>> re.match('foo', 'food').group() 	#匹配'seafood'中是否包含字符'foo'，不包含返回None
'foo'

search 函数

• 在字符串中查找正则表达式模式的第一次出现，如果匹配成功，则返回一个匹配对象；否则返回 None。

案例

>>> import re		# 导入正则表达式模块
>>> m = re.search('foo', 'food')	# 匹配字符串'food'中是否包含字符'foo'，包含返回一个对象
>>> print(m)					# 打印对象m
<re.Match object; span=(0, 3), match='foo'>
>>> m = re.search('foo', 'seafood')		# 字符串'seafood'中是否包含字符'foo'，包含返回对象
>>> m
>>> m.group()		# 通过group()，取出m对象中的内容

findall 函数

• 在字符串中查找正则表达式模式的所有出现；返回一个匹配对象的列表

案例

>>> import re		# 导入正则表达式模块
>>> re.findall('foo', 'seafood is food')		# 查找所有的'foo'，会返回在一个列表中
['foo', 'foo']

finditer函数

• 查找字符串中所有匹配字符【返回迭代器】

案例

>>> import re		# 导入正则表达式模块
>>> re.finditer('foo', 'seafood is food')		#查找所有的'foo'，返回在一个迭代器对象中
>>> list(re.finditer('foo', 'seafood is food'))		#将迭代器对象转换为列表，验证结果
>>> for m in re.finditer('foo', 'seafood is food'):		#for循环遍历finditer迭代器对象中元素
...     m.group()

import re
# 1. re.match(正则表达式, 字符串)
# \d: 数字      \d\d\d == \d{3}
dc1 = re.match("\d{3}", "456aaabbb")
print(dc1)  # <_sre.SRE_Match object; span=(0, 3), match='456'>
print(dc1.group())  # "456"
# 2. re.search(正则表达式, 字符串)
# 在字符串中查找正则表达式模式的第一次出现，如果匹配成功，则返回一个匹配对象；
# 否则返回 None
dc2 = re.search("\d{3}", "aaa123bbb456ccc789ddd")
print("dc2:", dc2)  # <_sre.SRE_Match object; span=(3, 6), match='123'>
print(dc2.group())  # 123
# 3. re.findall(正则表达式, 字符串)
#    在字符串中查找正则表达式模式的所有出现,返回一个列表
dc3 = re.findall("\d{3}", "aaa123bbb456ccc789ddd")
print("dc3:", dc3)  # ['123', '456', '789']
# 4. re.finditer(正则表达式, 字符串): 查找字符串中所有匹配字符
dc4 = re.finditer("\d{3}", "aaa123bbb456ccc789ddd")
print("dc4:", dc4)  # <callable_iterator object at 0x7f25594d0048>
for item in dc4:
    print(item.group())

split 方法

• 根据正则表达式中的分隔符把字符分割为一个列表，并返回成功匹配的列表
• 字符串也有类似的方法，但是正则表达式更加灵活

案例

# split方法，使用正则切割字符串
>>> s1 = 'hello-world-how-are-you.tar.gz'		#定义一个字符串s1
>>> s1.split('-')								#split()，将字符串s1，用字符'-'进行切割
>>> s1.split('.')				#split()，将字符串s1，用字符'.'进行切割
>>> re.split('-|\.', s1)		#split()，使用正则，将字符串s1，用字符'-' 或'.'行切割，'.'代表任意字符，要用'\'进行转义

sub方法

• 把字符串中所有匹配正则表达式的地方替换成新的字符串

>>> import re		# 导入正则表达式模块
>>> re.sub('X', 'nfx', 'Hi X, Nice to meet you, X')		#将字符串中的'X', 替换成'nfx'

compile函数

• 对正则表达式模式进行编译，返回一个正则表达式对象
• 不是必须要用这种方式，但是在大量匹配的情况下，可以提升效率

案例

>>> patt = re.compile('f..')		#编译正则表达式'f..'【匹配包含f的任意三个字串】
>>> m = patt.search('seafood is food')		#search(), 在字符串中，匹配正则表达式patt【f..】
>>> m			#查看对象m
>>> m.group()		#查看m中的对象

# findall(), 在字符串'seafood is food'中，匹配正则表达式patt【f..】
>>> patt.findall('seafood is food')		#将查找到的所有'foo'，返回在一个列表中

# 5. re.split(正则表达式，字符串): 根据正则表达式中的分隔符把字符分割为一个列表，并返回成功匹配的列表
#    字符串也有类似的方法，但是正则表达式更加灵活
str01 = "hello_tar.gz"
dc5 = re.split("_|\.",str01)
print("dc5:",dc5)

# 6. re.sub(正则表达式，替换字符串，字符串) 把字符串中所有匹配正则表达式的地方替换成新的字符串
dc6 = re.sub("\d{3}","wwy","Hi 123, Nice to meet you, 456~") 
print("dc6:",dc6) # dc6: Hi wwy, Nice to meet you, wwy~

# 7. re.compile(字符串): 对正则表达式模式进行编译，返回一个正则表达式对象
#         不是必须要用这种方式，但是在大量匹配的情况下，可以提升效率
patt = re.compile("\d{3}")  #  # patt: 正则表达式对象
dc7 = patt.search("aaa123bbb456ccc789ddd")
print("dc7:",dc7)   # <_sre.SRE_Match object; span=(3, 6), match='123'>
print(dc7.group())   # 123
dc8 = patt.findall("aaa123bbb456ccc789ddd")
print("dc8:",dc8)   # ['123', '456', '789']

分析 apache 访问日志

需求：编写一个apache 日志分析脚本(count_patt.py)：

• 统计每个客户端访问 apache 服务器的次数
• 将统计信息通过字典的方式显示出来
• 分别统计客户端是 Firefox 和 MSIE 的访问次数
• 分别使用函数式编程和面向对象编程的方式实现

# 需求：编写一个日志分析脚本：
# 统计每个客户端(ip)访问 apache 服务器的次数
# 将统计信息通过字典(dict)的方式显示出来
# {"192.168.1.100":3, "192.168.1.101":2, .....}
# 分别统计客户端是 Firefox 和 MSIE 的访问次数
import re
def count_data(fname, patt_str):  # fname: /opt/apache.log
    patt_jg = {}  # 存储结果数据
    fr = open(fname, mode="r")
    patt_obj = re.compile(patt_str)  # patt_str: "(\d+\.){3}\d+"
    for line in fr.readlines():  # for line in fr:
        dc = patt_obj.search(line)  # SRE_Match object
        ip = dc.group()
        if ip in patt_jg.keys():  # 判断key在不在字典中
            patt_jg[ip] += 1  # 在的话, 出现次数+1
        else:
            patt_jg[ip] = 1   # 不在的话, 出现次数=1
    fr.close()
    return patt_jg
if __name__ == '__main__':
    fname = "/opt/apache.log"
    # \d+\.\d+\.\d+\.\d+  ->  (\d+\.){3}\d+
    patt_ip = "(\d+\.){3}\d+"
    patt_browser = "Firefox|MSIE"
    dc = count_data(fname, patt_ip)
    print(dc)
    dc1 = count_data(fname, patt_browser)
    print(dc1)
# cat /opt/apache.log
# 192.168.1.100  Firefox
# 192.168.1.101  MSIE
# 192.168.1.102  Firefox
# 192.168.1.100  MSIE
# 192.168.1.103  Firefox
# 192.168.1.101  MSIE