python 爬虫括号的用法

首先是文档说明：

>>> import re

>>> help(re.findall)

Help on function findall in module re:

findall(pattern, string, flags=0)

Return a list of all non-overlapping matches in the string.

If one or more capturing groups are present in the pattern, return

a list of groups; this will be a list of tuples if the pattern

has more than one group.

Empty matches are included in the result.

意思很明显，分组匹配下（一对括号内是一个组），findall函数返回元组形式的匹配结果，并且匹配为空也会返回到元组中。
所以一般用法是这样的：

>>> a = "one two three
four five six"

>>> import re

>>> b = re.findall(r"(one) (two) (three) (four) (five) (six)",a)#去掉了"|"号

>>> print(b)

[('one', 'two', 'three', 'four', 'five', 'six')]#按组将匹配结果添加到元组中返回

>>> b = re.findall(r"(one) (two) (three) (four)",a)

#不完全匹配

>>> print(b)

[('one', 'two', 'three', 'four')]

#按组返回匹配成功部分，列表长度为1

>>> b = re.findall(r"one|two|three|four|five|six",a)

#不安组的条件匹配

>>> print(b)

['one', 'two', 'three', 'four', 'five', 'six']#返回长度为6的列表

>>> b = re.findall(r"one two three four five six",a)

>>> print(b)

['one
two three four five six'] #完全匹配，返回长度为1的列表

>>> b = re.findall(r"(one) (two) (three) (four) (five) (six)
(seven)",a)

>>> print(b)

[]#
没法全部匹配，返回空

>>> print (re.findall(r"[abc]","abc"))#[]的效果

['a','b','c']

>>> print (re.findall(r"a|b|c","abc"))#"|"的效果

['a','b','c']

通过以上实验可以得出的结论：
1条件匹配符"|"使得findall按每一种条件匹配一次，且"|"和"[]"效果是相同的，返回形式一样。
2圆括号分组匹配使得findall返回元组，元组中，几对圆括号就有几个元素，保留空匹配。

再看我提问中举的例子，将条件匹配与分组匹配结合在了一起。

>>> a = "one two three
four five six"

>>> b = re.findall("(one)|(two)|(three)|(four)|(five)|(six)",a)#加上了"|"号

>>> print(b)

[('one', '', '', '', '', ''), ('', 'two', '', '', '', ''),

('', '', 'three', '', '', ''),('', '', '', 'four', '', ''),

('', '', '', '', 'five', ''),('', '', '', '', '', 'six')]

于是就理解了：
1这个结果是因为按组匹配所以有元组，每个元组都有六个元素。
2而因为是条件匹配，列了六种匹配条件，于是findall匹配六次，结果列表有六个元素。
3又因为每次匹配只能用一种条件，所以按组匹配结果列表中的每个元组只有一组有值而其他均为空。

这有什么用呢？比如：

>>> x = "3 min 46 sec
300 ms"

#分秒毫秒的提取

>>> print(re.findall(r"(\d{0,}) (min|sec|ms)",x))

[('3', 'min'), ('46', 'sec'), ('300', 'ms')] #会不会很方便？

--------------------------------------------------------------------------------------------------
这个理解其实对下面那个问题（如何匹配某种单词搭配）没什么用，因为还有一个符号没有介绍，那就是"?:"符号，表示取消按分组返回。

#这个正则式子是随意写就的，

#按照人的思维理解。

#这个式子匹配以h或s为开头，ef或cd的（a或b）结尾为结尾的东西。

#一共有2*2*2八种可能性，findall的结果会有八个元素。

>>>
print(re.findall(r"\b((h|s)(ef|(cd|(a|b))))\b","sef scd sa sb
hef hcd ha hb"))

#不添加?:符号时结果如下：

#正则式子中的括号一共有五个，所以返回列表里的每个元组有五个元素

[('sef',
's', 'ef', '', ''), ('scd', 's', 'cd', 'cd', ''),

('sa', 's',
'a', 'a', 'a'), ('sb', 's', 'b', 'b', 'b'),

('hef',
'h', 'ef', '', ''), ('hcd', 'h', 'cd', 'cd', ''),

('ha', 'h',
'a', 'a', 'a'), ('hb', 'h', 'b', 'b', 'b')]

#下面是加上"?:"的结果

>>>print(re.findall(r"\b(?:(?:h|s)(?:ef|(?:cd|(?:a|b))))\b","sef
scd sa sb hef hcd ha hb"))

['sef',
'scd', 'sa', 'sb', 'hef', 'hcd', 'ha', 'hb']

#非常简洁

第一个式子返回的结果其实也算OK，因为已经覆盖到了所有的可能，只不过冗余项比较多，想得到纯粹的结果还要处理一次。
第二个式子加了"?:"后就简洁许多。
作为初学者，可能用不到分组这么复杂的正则式子，也就更不用提取消分组的符号了，所以很多正则的入门教程并不会花太多时间在这两项上。
所以现在就介绍一下如何解决匹配单词搭配的问题。
就比如说找数量结构的词组吧。

我们先进行书面的结构分析
数量结构是一种表示数量关系的短语，比如汉语中的一斤酒一两牛肉，由数词+量词+名词构成，也可以是一下，轻轻一按，用力一踢，由副词/+数词+动词构成。
在英语中数量结构又分为两种。
第一种是 a/an + n1 + of + n2，其中n1、n2是名词。比如 a piece of bread 。这种结构往往用来修饰不可数名词。
第二种是 num. + n 这个简单，就是数词+可数名词的复数形式，穷举所有的数词就行了。

第一种的正则式很简单，是这样的：

r"\ban{0,1}\b
\b\w+\b \bof\b \b\w+\b" #凡是在不定冠词和of之间的必然是名词，在of之外的是名词

第二种就稍微复杂一点，我们要把所有的数词都列出来，寻找其中的规律

差不多能分出这么几组
没有规律的：(?:hundred|thounsand|million|billion|trillion|one|two|three|ten|five|eleven|twelve
twenty|forty)
结尾可加teen也可不加的：(?:(?:four)(?:teen){0,1})
结尾可加teen或ty也可不加的 ：(?:(?:six|seven|eight|nine)|(?:ty|teen))
结尾必须加teen或ty的： (?:(?:fif|thir)(?:ty|teen))
把他们组合起来就是：

r"(?:(?:hundred|thounsand|million|billion|trillion|one|two|three|ten|five|eleven|twelve
|twenty|forty)|(?:(?:four)(?:teen){0,1})|(?:(?:six|seven|eight|nine)|(?:ty|teen))|(?:(?:fif|thir)(?:ty|teen)))\b"

再加上第一种可能就成了：

(?:\ban{0,1}\b
\b\w+\b
\bof\b)|(?:(?:(?:hundred|thounsand|million|billion|trillion|one|two|three|ten|five|eleven|twelve|twenty|forty)|(?:(?:four)(?:teen){0,1})|(?:(?:six|seven|eight|nine)|(?:ty|teen))|(?:(?:fif|thir)(?:ty|teen)))\b)

这还只是选了前部分，后面还要接一个名词，所以：

(?:(?:\ban{0,1}\b \b\w+\b \bof\b)|(?:(?:(?:hundred|thounsand|million|billion|trillion|one|two|three|ten|five|eleven|twelve|twenty|forty)|(?:(?:four)(?:teen){0,1})|(?:(?:six|seven|eight|nine)|(?:ty|teen))|(?:(?:fif|thir)(?:ty|teen)))\b)) (?:\b\w+\b)

于是这就是是完成状态了，我们来检测一下成果吧：

input

import rea = "a
cup of tea million stars forty people "

b = re.compile(r"(?:(?:\ban{0,1}\b
\b\w+\b
\bof\b)|(?:(?:(?:hundred|thounsand|million|billion|trillion|one|two|three|ten|five|eleven|twelve|twenty|forty)|(?:(?:four)(?:teen){0,1})|(?:(?:six|seven|eight|nine)|(?:ty|teen))|(?:(?:fif|thir)(?:ty|teen)))\b))
(?:\b\w+\b)")

print(re.findall(b,a))

output

['a
cup of tea', 'million stars', 'forty people']

这种眼花缭乱的式子，看着很麻烦，也不好解读，还好python提供了松散正则表达式。
只要在re.comile的第二个参数上填上"re.VERBOSE"即可写成如
'''
example
'''
注释的形式，此时空格不再被匹配，必须使用\s表达（下面这个版本已经更新了，这次更新囊括了所有的序数词）:

a = "give me a kiss million stars one piece"

b = re.compile(r"""

#随时可以以#号备注

(?:\b\w+\b\s\b\w+\b\s)?

(?:

(?:\ban?\b\s\b\w+\b\s\bof\b)

|#第一类数量结构

(?:

(?:\b(?:one|two|three|five|first|second|third|fifth|sixth|an?))

|#fifth在这里 没有规律的数词 fifth sixth

(?:(?:hundred|thounsand|million|billion|trillion|ten|eleven|twel(?:f|ve))(?:th)?)

|

(?:(?:twent|fort)(?:y|ieth))

|

(?:(?:four)(?:teen|th)?)

|#加不加teen皆可的数词

(?:(?:six|seven|eight?|nine?)(?:(?:(?:t[yh])(?:eth)?)|(?:teen)(?:th)?)?)

|#加不加teen或ty皆可的数词

(?:(?:fif|thir)(?:(?:t[yi])(?:eth)?|(?:teen)(?:th)?))

#必须加teen或ty的数词 fifteen
thirteen fifty thirty  fiftieth thirtieth
fifteenth thirteenth

)\b#第二类数量结构

)\s

(?:\b\w+\b)#后跟的名词

""",re.VERBOSE)

这个式子到这里还是比较粗糙的，比如对于任何一文章中的“the one you”他都会当作数量结构匹配，所以还要增加一些其他条件来过滤这样的可能，不过我还没学到那个地步，所以我也没法解决这个问题，以后学会再来添加吧！

更新一下：
关键词：零宽断言。
在python正则表达式中使用零宽断言，网上也有很多教程。
简单说，零宽断言要完成的目标是：当字符串符合一定条件，则匹配某些字符。
什么叫断言？
一个断言就是对条件做出判断，相当于if判断结构，满足条件，则做某事，不过else只能是不匹配。
什么叫零宽？
也就是这个东西所占的匹配字符中的宽度是零，也就是不匹配本身。
其他的关键词如零宽度正预测先行断言太复杂了我也不太清楚，就不讲了，会用就行。

使用方法：exp(?=exp)
在括号中使用?=后，这个括号内?=之后的字符就成了零宽断言所要判断的条件，前面括号之外的表达式则是判断满足条件要启用的匹配字符。
举例：
\w+(?=logy)
该表达式匹配任意以logy结尾的单词，但是不匹配logy本身。

如果要把这个判断放在前面，则要用：(?<=exp)exp
举例：
(?<=href=")http
可以匹配href="开头的http，但是不包括href="，这样的操作也省去了爬虫清洗数据时的一部分压力。

需要注意的是，前置的断言在python中不能使用不确定宽度的字符作为判断条件，必须确定字符的个数。所以如果你还想同时匹配(?<=src=")http，你不能写(?<=src="|href=")http，你可以写:
(?:(?<=src=")|(?<=href="))http
这是python实现的一个小缺陷。
不过后置的就可以这么写
http(?=src="|href=")

接着我们还有满足条件不匹配的用法，也就是在?后面加!。前置的就成了
(?!<=exp)
后置的成了(?!=exp)
这时候填写进去的字符，就成了遇到则不匹配的条件。

而我的数词查找就需要这个功能，来实现避免数词出现在省略先行词从句的开头的情况。
当然下面这个表达式是不能运行的，必须放到之前那个大串里。

re.compile(r"""

(?!

(?:

\b

(?:

(?:[Yy]ou|[Tt]hey)(?:'re)?

|

I|to|with|in|[SsHh]h?e|[Ii]t

|

(?:[Tt]h)(?:is|at|e[sr]e|)

|

(?:(?:[Ww]h)(?:o[ms]?e?|ere|at|en|i[cl][he]))

)

\b

)

)

#筛掉的特殊词you I he she it this there that
those with to in which where what when while whose who whom

""",re.VERBOSE)

结合两者就是：

En_value =
re.compile(r"""

#随时可以以#号备注

#尾断言可以有不确定符号数的匹配，首断言不可以。

(?:\b\w+\b\s\b\w+\b\s)?

(?:

(?:\ban?\b\s\b\w+\b\s\bof\b)

|#第一类数量结构

(?:

(?:\b(?:one|two|three|five|first|second|third|fifth|sixth|an?))

|#fifth在这里 没有规律的数词 fifth sixth

(?:(?:hundred|thounsand|million|billion|trillion|ten|eleven|twel(?:f|ve))(?:th)?)

|

(?:(?:twent|fort)(?:y|ieth))

|

(?:(?:four)(?:teen|th)?)

|#加不加teen皆可的数词

(?:(?:six|seven|eight?|nine?)(?:(?:(?:t[yh])(?:eth)?)|(?:teen)(?:th)?)?)

|#加不加teen或ty皆可的数词

(?:(?:fif|thir)(?:(?:t[yi])(?:eth)?|(?:teen)(?:th)?))

#必须加teen或ty的数词 fifteen thirteen fifty thirty 
fiftieth thirtieth fifteenth thirteenth

)\b#第二类数量结构

)\s

(?!

(?:

\b

(?:

(?:[Yy]ou|[Tt]hey)(?:'re)?

|

I|to|with|in|[SsHh]h?e|[Ii]t

|

(?:[Tt]h)(?:is|at|e[sr]e|)

|

(?:(?:[Ww]h)(?:o[ms]?e?|ere|at|en|i[cl][he]))

)

\b

)

)

#筛掉的特殊词(you I he she it this there
that those with to in which where what when while whose who whom

(?:\b\w+\b)#后跟的名词

""",re.VERBOSE)