re模块

re模块主要用于提供类似于Perl中的正则表达式操作，包括好几个函数和一个异常函数

匹配函数

flag函数

re.compile() ***

re.compile(patthern, flag=0)
创建一个pattern对象，可以结合其他函数来进行相应操作，比如一个匹配对象需要进行多次不同的操作时，就可以先使用
re.compile()来创建一个对象，然后使用标识符来代入不同函数进行操作。

p = re.compile(pattern) #定义一个匹配对象
print(p.match(string)) #返回一个对象
#等价于print(re.match(pattern, string))
#等价于print(re.match(p, string))
<re.Match object; span=(0, 3), match='abc'>

re.search()

re.search(pattern, string)
pattern.search(string[, pos[, endpos]]) #直接生成对象
扫描字符串，并且返回第一个匹配到的对象，没有匹配到则返回None

p = re.compile('abc')
print(re.search(p, 'deuibewabcd398hufe'))
<re.Match object; span=(7, 10), match='abc'>

p1 = re.compile('a')
print(1,p1.search('abc')) 
print(2,p1.search('abc', 1))#从索引1开始匹配，因此返回None
1 <re.Match object; span=(0, 1), match='a'>
2 None

re.match()

re.match(string, flags=0) 
pattern.match(string[, pos[, endpos]])
从指定索引处开始匹配，返回匹配到的对象，若未匹配到则返回None，默认从开头匹配

p = re.compile('abc')
print(3,re.match(p, 'abcd398hufe')) #若abc不在字符串开头，则返回None
3 <re.Match object; span=(0, 3), match='abc'>

p2 = re.compile('o')
print(1, p2.match('wow')) #索引为匹配到
print(2, p2.match('wow', 1))
1 None
2 <re.Match object; span=(1, 2), match='o'>

re.fullmatch()

re.fullmatch(pattern, flag=0)
pattern.fullmatch(string[, pos[, endpos]]) #指定索引
与match()类似，返回对象，但是string需要完全匹配pattern，不然就返回None

p = re.compile('abc')
print(4,re.fullmatch(p, 'abc'))
#print(4,re.fullmatch(p, 'abcabc')) 返回None
4 <re.Match object; span=(0, 3), match='abc'>

pattern = re.compile("o[gh]")
pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
pattern.fullmatch("ogre")     # No match as not the full string matches.
pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
<re.Match object; span=(1, 3), match='og'>

re.split() ***

re.split(pattern, string, maxsplit=0, flag=0) #maxsplit默认不为0
pattern.split(string, maxsplit=0) 
1.根据匹配的字符串对string进行分割，返回列表。如果maxsplit不为0，那么在分割后，剩下的部分也为返回
2.如果pattern部分加了括号，那么所有的部分都会返回，包括特殊字符

print(5,re.split(r'\W','Wo1rds,words,words.'))
5 ['Wo1rds', 'words', 'words', '']

print(5,re.split(r'(\W)','Wo1rds,words,words.'))
5 ['Wo1rds', ',', 'words', ',', 'words', '.', ''] #加括号返回所有的部分

re.findall() ***

re.findall(pattern, string, flag=0)
pattern.findall(string[, pos[, endpos]]) 
返回一个列表，包含所有的匹配部分，贪婪匹配模式

p = re.compile(r'[bc]')
print(6, re.findall(p, 'abcdusidbabcd3abcabacabcabc'))
6 ['abc', 'abc', 'abc', 'abc', 'abc']
print(7, re.findall(r'[abc]*', 'abcdusidbabcd3abcabacabcabc'))
7['abc', '', '', '', '', '', 'babc', '', '', 'abcabacabcabc', '']

re.finditer()

re.finditer(pattern, string, flag=0)
pattern.finditer(string[, pos[, endpos]]) 
返回迭代对象

result = re.finditer(r'abc', 'ab3cdusidbabcd3abcabacabcabc')
print(next(result))
print(next(result))
<re.Match object; span=(10, 13), match='abc'>
<re.Match object; span=(15, 18), match='abc'>

re.sub()

re.sub(pattern, repl, string, count=0, flag=0)
pattern.sub(repl, string, count=0) 
替换匹配到的部分，贪婪匹配，返回替换后的新字符串

print(7, re.sub('abc', 'xyz', 'abcdshjksdabc23u21983abc'))
7 xyzdshjksdxyz23u21983xyz

re.subn()

re.subn(pattern, repl, string, count=0, flags=0) 
pattern.subn(repl, string, count=0) 
同sub(),返回的是元组，（新字符串，替换次数）

print(8, re.subn('abc', 'xyz', 'abcdshjksdabc23u21983abc'))
8 ('xyzdshjksdxyz23u21983xyz', 3)

re.escape()

re.escape(pattern) 
将字符串中的特殊字符进行转义，有些字符不转义，如下示例：

legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\-\.\^_`\|\~:]+ #加了反斜线的说明被转义

re.purge()

Clear the regular expression cache.
清除缓存

示例

"""
读取给定文本文件，统计单词，计算TOP 10
有一个文件sample.txt，对其进行单词统计，不区分大小写，并显示单词重复最多的10个单词。
思路：
    1.单词统计：以空格为分隔符，以每行为一个记录，特殊字符需要转换成空格便于区分，
    不区分大小写也需要转换
    2.根据重复次数排序，因此字典要倒装
"""
import time
import datetime
import re

word_dict = {}
filename = './sample.txt'

with open(filename, 'r', encoding='utf-8') as f:
    for line in f: #按行操作
        pattern = re.compile(r'[a-z]*', re.I) #定义匹配单词的表达式，忽略大小写
        word_list = list(pattern.findall(line)) #匹配到的单词全部加入到列表
        for word in word_list:
            if word == '': #忽略空字符
                continue
            elif word not in word_dict:
                word_dict[word] = 1
            else :
                word_dict[word] += 1
    sort_dict = sorted(word_dict.items(), key=lambda x:x[1], reverse=True) #lambda函数排序
    print(sort_dict[:10]) #取索引0-9这个10个单词