爬虫笔记（六）——如何写正则表达式详解

什么是正则表达式？

　　正则表达式(Regular Expression)是一种文本模式，在编写处理字符串的程序或网页时，经常会有查找符合某些规则的字符串的需求。正则表达式就是用于描述这些规则的工具，换句话说，正则表达式就是记录文本规则的代码。我们将分别从原子、元子符、模式修正符、贪婪模式与懒惰模式等方面进行介绍，代码引进re模块。

这篇博客主要讲如何写正则表达式，下篇再介绍关于正则表达式的函数运用。

一、原子

原子是正则表达式中最基本的组成单位，每个正则表达式至少要包含一个原子，常见原子主要有以下几类：

1. 普通子符作为原子
2. 非打印字符作为原子
3. 通用字符作为原子
4. 原子表

普通字符就是利用数字、大小写字母、下滑线等作为原子使用。如“python"，这里有六个原子，分别是python的六个字母。如下面的代码中，用”python"取匹配一段字符，如“wanglongxuepython"，成功匹配到了'python'。

import re

string = "wanglongxuepython"
pattern = "python"
result = re.search(pattern,string)
print (result)

#<_sre.SRE_Match object; span=(11, 17), match='python'>

非打印字符就是指在字符串中起格式控制的符号，常见有换行符\n和制表符\t，其分别用来匹配换行和制表。

import re

string = '''wanglong
xuepython'''
pattern = "\n"
result = re.search(pattern,string)
print (result)

#<_sre.SRE_Match object; span=(8, 9), match='\n'>

如果string没有包含换行，就会返回None。

import re

string = "wanglongxuepython"
pattern = "\n"
result = re.search(pattern,string)
print (result)

#None

通用字符就是可以用一个原子匹配一类字符，常见的通用字符有以下几个：

1. \w           　　可以匹配任意一个大小写字母、数字或下划线的字符
2. \W　　　　　可以匹配任意一个除大小写字母、数字和下划线以外的字符
3. \s　　　　　可以匹配任意一个空白字符
4. \S　　　　　可以匹配任意一个除空白字符以外的字符
5. \d　　　　　可以匹配任意一个十进制数
6. \D　　　　　可以匹配任意一个除十进制数以外的字符　　

比如我们用"\d\dxue\w"去匹配一个string"wanglong1314xuepython"，就可以得到“14xuep"。

import re

string = "wanglong1314xuepython"
pattern = "\d\dxue\w"
result = re.search(pattern,string)
print (result)

#<_sre.SRE_Match object; span=(10, 16), match='14xuep'>

原子表就是定义一组地位平等的原子，然后匹配时会在原子表中取任意一个原子，用[ ]表示，比如[love]。还有一种是匹配时会取除原子表内原子以外任意一个，这种用[ ^]表示，比如[^love]。[a-z]表示是a到z。

import re

string = "wanglong1314xuepython"
pattern = "[love]ong13"
result = re.search(pattern,string)
print (result)

#<_sre.SRE_Match object; span=(4, 10), match='long13'>

二、元字符

所谓的元字符就是在正则表达式中具有特殊含义的字符，比如重复前面N次字符等。具体来说元字符分为任意匹配元字符、边界限制元字符、限定符、模式选择符、模式单元等。

任意匹配元字符用着'.'表示，他可以匹配除换行符以外的任意一个字符。

import re

string = "wanglong1314xuepython"
pattern = "...long...."
result = re.search(pattern,string)
print (result)

#<_sre.SRE_Match object; span=(1, 12), match='anglong1314'>

边界限制元字符，可以使用"^"匹配字符串的开始，使用"$"匹配字符串的结束。

import re

string = "wanglong1314xuepython"
pattern1 = "^wang"
pattern2 = "^long"
pattern3 = "thon$"
pattern4 = "pyth$"
result1 = re.search(pattern1,string)
result2 = re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print (result1)
print (result2)
print (result3)
print (result4)

#<_sre.SRE_Match object; span=(0, 4), match='wang'>
#None
#<_sre.SRE_Match object; span=(17, 21), match='thon'>
#None

限定符也是元字符的一种，常见限定符有下面几个：

1. *               　　匹配0次、1次或多次前面的原子
2. ?　　　　　　匹配0次或1次前面的原子
3. +　　　　　　匹配1次或多次前面的原子　
4. {n}　　　　　　前面的原子恰好出现n次
5. {n,}　　　　　　前面的原子至少出现n次
6. {n,m}　　　　　　前面的原子至少出现n次，至多出现m次

import re

string = "aabbbcde"
pattern1 = "a.*c"
pattern2 = "b?c"
pattern3 = "b+c"
pattern4 = "b{2}c"
pattern5 = "b{2,}c"
result1 = re.search(pattern1,string)
result2 = re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
result5 = re.search(pattern5,string)
print (result1)
print (result2)
print (result3)
print (result4)
print (result5)

#<_sre.SRE_Match object; span=(0, 6), match='aabbbc'>
#<_sre.SRE_Match object; span=(4, 6), match='bc'>
#<_sre.SRE_Match object; span=(2, 6), match='bbbc'>
#<_sre.SRE_Match object; span=(3, 6), match='bbc'>
#<_sre.SRE_Match object; span=(2, 6), match='bbbc'>

模式选择符用着‘｜’表示，比如' A|B '，它可以任意选择一种模式去匹配，即A模式和B模式，哪种模式更快匹配到则取哪种模式。

import re

string = "aabbbcde"
pattern1 = "ac|cd"
pattern2 = "cd|aa"
result1 = re.search(pattern1,string)
result2 = re.search(pattern2,string)
print (result1)
print (result2)

#<_sre.SRE_Match object; span=(5, 7), match='cd'>
#<_sre.SRE_Match object; span=(0, 2), match='aa'>

模式单元符用（）表示，他可以将几个单元符变成一个大单元。

import re

string = "aabbbbcde"
pattern1 = "(bb){2}cd"
pattern2 = "bb{2}cd"
result1 = re.search(pattern1,string)
result2 = re.search(pattern2,string)
print (result1)
print (result2)

#<_sre.SRE_Match object; span=(2, 8), match='bbbbcd'>
#<_sre.SRE_Match object; span=(3, 8), match='bbbcd'>

三、模式修正

所谓的模式修正就是在不改变正则表示式的情况下，通过模式修正改变正则表达式的含义，从而实现一些匹配结果调整等功能。常见的一些模式修正符有以下几点：

1. I             匹配时忽略大小写
2. M　　　多行匹配
3. L　　　做本地识别匹配
4. U　　　根据Unicode字符及解析字符
5. S　　　让.可以匹配换行符，即.可以匹配任意字符

import re

string = "aabbbbcde"
pattern1 = "bbBB"
result1 = re.search(pattern1,string)
result2 = re.search(pattern1,string,re.I)
print (result1)
print (result2)

#None
#<_sre.SRE_Match object; span=(2, 6), match='bbbb'>

四、贪婪模式与懒惰模式

贪婪模式的核心就是尽可能地多的匹配，懒惰模式的核心就是尽可能地少匹配。

import re

string = "wanglongphp223python_py"
pattern1 = "p.*y"  #贪婪模式
pattern2 = "p.*?y"　#懒惰模式
result1 = re.search(pattern1,string)
result2 = re.search(pattern2,string)
print (result1)
print (result2)

#<_sre.SRE_Match object; span=(8, 23), match='php223python_py'>
#<_sre.SRE_Match object; span=(8, 16), match='php223py'>

 

转载于:https://www.cnblogs.com/longwhite/p/10397764.html