正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。
一般来说判断一个字符串是否是符合正则表达式的方法是：
- 创建一个的正则表达式；
- 用该正则表达式去匹配用户的输入来判断是否合法。
很多语言都支持正则表达式，但是对 元字符 的支持情况是不同的。我们先来说说元字符：
1. 元字符
比较常用的元字符有下面这几个：
- ^ 开始
- ( ) 域段 其实也可以说是分组啦
- [ ] 包含,默认是一个字符长度
- [^] 不包含,默认是一个字符长度
- {n,m} 匹配长度
- . 任何除了 \n 的单个字符(. 字符点)
- | 或
- \ 转义
- $ 结尾
- [A-Z] 26个大写字母
- [a-z] 26个小写字母
- [0-9] 0至9数字
- [A-Za-z0-9] 26个大写字母、26个小写字母和0至9数字
-
，分割
分割语法：
[A,H,T,W] 包含A或H或T或W字母
[a,h,t,w] 包含a或h或t或w字母
[0,3,6,8] 包含0或3或6或8数字
接下来举一个例子：
比方说我们想要识别正确的电信电话号码，我们知道，电信的电话是 189 开头的 11 位数字，我们可以这样来写表达式：'^189[0-9]{7}$'。表达式中 [0-9] 代表这里是从 0 至 9 的数字，{7} 代表前面的数字有 7 个。^ 与 $ 符号表示从开始和结尾处识别，也就是说这个字符串除了电话不能包含其他的字符。如果我们只写成 '^189[0-9]{7}' 那么是可以匹配 '18912345678aaaa' 的。
我们再来看一个例子，这个例子是正则表达式很经典的例子：Email 地址的识别
我们希望可以验证类似于下面这样的地址：
someone@gmail.com
bill.gates@microsoft.com
观察发现前面是任意的字符，中间有一个 @ 符， 然后又是任意数量的字母，最后是 .com。
我们可以这样写我们的表达式：'^.{1,}@[A-Za-z0-9]{1,}\.com$'
^ 与 $ 含义与上面的例子相同；接下来是一个点，代表可以输入任何除了换行符意外的一个字符；后面的 {1,} 代表数是大于 1 个；最后是转义的点。
上面的例子就是用来练习，实际上的 Email 地址是不能有特殊字符的，最后的域名也有很多，我们来给它升级一下：'[_a-zA-Z0-9]{1,}@[_a-zA-Z0-9]{1,}\.(com|org|net)'。前面我就不解释了，这里面新加了一个 (com|org|net) 它的作用是结尾部分为 com 或 org 或 net，
2. 一些等价的字符
正则表达式难理解因为里面有一个等价的概念，这个概念大大增加了逼格（增加了理解难度），让很多初学者看起来会懵，如果把等价都恢复成原始写法，自己书写正则就超级简单了。
等价是等同于的意思，表示同样的功能，用不同符号来书写。按照这种写法可以简化表达式。
- ? 等价于匹配长度 {0,1}（匹配一个或零个字符）
*等价于匹配长度 {0,}- + 等价于匹配长度 {1,}
- \d 等价于 [0-9]
- \D 等价于 [^0-9]
- \w 等价于 [A-Za-z_0-9]
- \W等价于 [^A-Za-z_0-9]。
所以上面例子中的 '^.{1,}@[A-Za-z0-9]{1,}\.com$' 等价于 ^.+@\w+\.com$；'^189[0-9]{7}$' 等价于 ^189\d{7}$。
其实我们现在就可以利用正则表达式来做一些事情啦，比起使用固定的字符串，使用正则表达式可以使得拆分字符串变得更加灵活。我们先来看一下使用固定字符的情况：（还记得 str.split() 函数吗）
>>> 'a b c'.split(' ')
['a', 'b', '', '', 'c']
我们是没有办法识别连续的空格的，如果用正则表达式试试看呢：
>>> re.split(r'\s+', 'a b c') # \s 可以匹配任何空白字符,包括空格、制表符、换页符等等
['a', 'b', 'c']
>>> re.split(r'[\s\,\;]+', 'a,b;; c d')
['a', 'b', 'c', 'd']
太强大了，，，
正则表达式的基本知识就这么多，我们接下来看看在 python 中正则表达式还有那些强大的使用方法。
3. 标准库模块 re
Python3 中使用 re 模块支持正则表达式（Regular Expression），需要定义一个用于匹配的模式（pattern）字符串，以及一个要匹配的字符串（string）。
由于 Python 的字符串本身也用 \ 转义，因此我们强烈建议使用 Python 的 r 前缀，就不用考虑转义的问题了。
简单的匹配：
In [1]: import re
In [2]: m = re.match(r'My', 'My name is zhangsan')
In [3]: m
Out[3]: <_sre.SRE_Match object; span=(0, 2), match='My'>
In [4]: m.group() # 等价于m.group(0)
Out[4]: 'My'
In [5]: m.start(), m.end()
Out[5]: (0, 2)
In [6]: m.span()
Out[6]: (0, 2)
其中，My是正则表达式模式，最简单的，只匹配字符My本身。而My name is zhangsan是想要检查的字符串，re.match()函数用于查看字符串是不是以正则模式开头。
当我们在Python中使用正则表达式时，re模块内部会干两件事情：
- 编译正则表达式，如果正则表达式的字符串本身不合法，会报错；
- 用编译后的正则表达式去匹配字符串。
如果你仅仅是做一次简单的文本匹配/搜索操作的话，可以直接使用 re 模块级别的函数，比如re.match。如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接下来重复使用时就不需要编译这个步骤了，直接匹配：
>>> import re
# 编译:
>>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
# 使用：
>>> re_telephone.match('010-12345').groups()
('010', '12345')
>>> re_telephone.match('010-8086').groups()
('010', '8086')
编译后生成Regular Expression对象，由于该对象自己包含了正则表达式，所以调用对应的方法时不用给出正则字符串。
4. 使用 match() 从字符串开头开始匹配
可以使用模块级别的 re.match() 或预编译模式的 p.match() ，如果字符串是以正则表达式开头，则表明匹配成功，返回匹配到的对象，比如 <_sre.SRE_Match object; span=(0, 2), match='My'> ，如果匹配失败，返回 None 。
In [1]: import re
In [2]: m1 = re.match(r'zhangsan', 'zhangsan is a handsome boy.') # 模块级的match方法
In [3]: m1 # 匹配成功，返回Match对象
Out[3]: <_sre.SRE_Match object; span=(0, 5), match='zhangsan'>
In [4]: m1.group() # Match对象有group()、start()、end()、span()等方法
Out[4]: 'zhangsan'
In [5]: m2 = re.match(r'mayun', 'zhangsan is a handsome boy.') # 匹配失败
In [6]: type(m2) # 返回None
Out[6]: NoneType
In [7]: p = re.compile(r'zhangsan') # 预编译正则模式也是可以的
In [8]: p.match('zhangsan is a handsome boy.') # 调用预编译正则模式的match方法
Out[8]: <_sre.SRE_Match object; span=(0, 5), match='zhangsan'>
我们使用预编译的方法再写一个上面的邮箱的例子：
import re
p = re.compile(r'[_a-zA-Z0-9]{1,}@[_a-zA-Z0-9]{1,}\.(com|org|net)')
r = p.match('someone@gmail.com')
if r:
print(r.group())
print(r.span())
else:
print('邮箱地址不合法')
r2 = p.match(r'bill.gates@microsoft.com')
if r2:
print(r.group())
print(r.span())
else:
print('邮箱地址不合法')
someone@gmail.com
(0, 17)
邮箱地址不合法
(比尔盖茨你的邮箱地址不合法！妈妈叫你回家改地址)
5. 分组
除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用 ( ) 表示的就是要提取的分组（Group）。比如：
^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：
>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object at 0x1026fb3e8>
>>> m.group(0)
'010-12345'
>>> m.group(1)
'010'
>>> m.group(2)
'12345'
如果你用括号将某一模式包裹起来， 也就是说正则表达式中定义了组，括号中模式匹配得到的结果将归入自己的分组group（无名称）中，包含这些匹配的元组就可以在 Match 对象上用 group()方法提取出子串来。（当使用 match() 或 search() 时会得到 Match 对象）
注意到 group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。
我们也可以使用尖括号为分组指定别名：
In [9]: m2 = re.search(r'(?P<DISH>. dish\b).*(?P<FISH>\bfish)', s)
In [10]: m2.groups()
Out[10]: ('a dish', 'fish')
In [11]: m2.group()
Out[11]: 'a dish of fish'
In [12]: m2.group('DISH')
Out[12]: 'a dish'
In [13]: m2.group('FISH')
Out[13]: 'fish'
In [14]: m2.group(1)
Out[14]: 'a dish'
In [15]: m2.group(2)
Out[15]: 'fish'
提取子串非常有用。在上文中我们就提到了一个正则表达式 ‘或’ 的用法 ：
p = re.compile(r'[_a-zA-Z0-9]{1,}@[_a-zA-Z0-9]{1,}\.(com|org|net)')
再来看一个更加凶残的例子：
>>> t = '19:05:30'
>>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
>>> m.groups()
('19', '05', '30')
这个正则表达式可以直接识别合法的时间。
6. 贪婪匹配与非贪婪匹配
需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的 0 ：
>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')
由于 \d+ 采用贪婪匹配，直接把后面的 0 全部匹配了，结果 0* 只能匹配空字符串了。
必须让 \d+ 采用非贪婪匹配（也就是尽可能少匹配），才能把后面的 0 匹配出来，加个 ? 就可以让 \d+ 采用非贪婪匹配
>>> re.match(r'^(\d+?)(0*)$', '102300').groups()
('1023', '00')
7. 使用 search( ) 寻找首次匹配
如果字符串中有多个地方与正则表达式匹配的话，search() 方法返回第一次匹配到的结果：
search(pattern, string, flags=0)
Scan through string looking for a match to the pattern, returning
a match object, or None if no match was found.
(END)
In [1]: import re
In [2]: s = 'I wish I may, I wish I might have a dish of fish tonight.'
In [3]: re.search('wish', s)
Out[3]: <_sre.SRE_Match object; span=(2, 6), match='wish'>
In [4]: re.search('wish', s).span()
Out[4]: (2, 6)
作为对比如果想要找到所有的匹配可以使用 findall( ) 方法。
8.使用 findall( ) 或 finditer( ) 寻找所有匹配
前面两个函数都是查找到一个匹配后就停止，如果要查找字符串中所有的匹配项，可以使用 findall ( )
In [1]: import re
In [2]: text = 'Today is 11/27/2012. PyCon starts 3/13/2013.'
In [3]: p = re.compile('\d+/\d+/\d+')
In [4]: p.findall(text)
Out[4]: ['11/27/2012', '3/13/2013']
findall( ) 方法会搜索文本并以列表形式返回所有的匹配。 如果你想以迭代方式返回匹配，可以使用 finditer( ) 方法来代替，比如：
In [5]: iters = p.finditer(text)
In [6]: iters
Out[6]: <callable_iterator at 0x7f94c1703f98>
In [7]: for m in iters:
...: print(m)
...:
<_sre.SRE_Match object; span=(9, 19), match='11/27/2012'>
<_sre.SRE_Match object; span=(34, 43), match='3/13/2013'>
9. 使用 split ( ) 按匹配切分
字符串的str.split()方法只适应于非常简单的字符串分割情形， 它并不允许有多个分隔符或者是分隔符周围不确定的空格。 当你需要更加灵活的切割字符串的时候，最好使用 re.split() 方法：
In [1]: import re
In [2]: line = 'asdf fjdk; afed, fjek,asdf, foo'
In [3]: re.split(r'[;,\s]\s*', line) # 正则模式表示 ;或,或空白字符且它们的后面再跟0个或多个空白字符
Out[3]: ['asdf', 'fjdk', 'afed', 'fjek', 'asdf', 'foo']
10. 使用 sub( ) 替换匹配
对于简单的字面模式，直接使用字符串的 str.replace( ) 方法即可，比如：
In [1]: text = 'yeah, but no, but yeah, but no, but yeah'
In [2]: text.replace('yeah', 'yep')
Out[2]: 'yep, but no, but yep, but no, but yep'
对于复杂的模式，请使用 re 模块中的 sub( ) ，比如你想将形式为 11/27/2012 的日期字符串改成 2012-11-27 。示例如下：
In [1]: import re
In [2]: text = 'Today is 11/27/2012. PyCon starts 3/13/2013.'
In [3]: re.sub('(\d+)/(\d+)/(\d+)', r'\3-\1-\2', text)
Out[3]: 'Today is 2012-11-27. PyCon starts 2013-3-13.'
sub( ) 函数中的第一个参数是被匹配的模式，第二个参数是替换模式。反斜杠数字比如 \3 指向前面模式的第 3 个捕获组，此时要加 r 指定为原始字符串，否则会被 Python 自动转义为 \x03。
对于更加复杂的替换，可以传递一个替换回调函数来代替。一个替换回调函数的参数是一个 Match 对象，也就是 match( ) 或者 find( ) 返回的对象。使用 group( ) 方法来提取特定的匹配部分。回调函数最后返回替换字符串。比如：
In [1]: import re
In [2]: from calendar import month_abbr
In [3]: def change_date(m):
...: mon_name = month_abbr[int(m.group(1))]
...: return '{} {} {}'.format(m.group(2), mon_name, m.group(3))
...:
...:
In [4]: text = 'Today is 11/27/2012. PyCon starts 3/13/2013.'
In [5]: p = re.compile(r'(\d+)/(\d+)/(\d+)')
In [6]: p.sub(change_date, text)
Out[6]: 'Today is 27 Nov 2012. PyCon starts 13 Mar 2013.'
如果除了替换后的结果外，你还想知道有多少替换发生了，可以使用 re.subn( ) 来代替。比如：
In [7]: newtext, n = p.subn(r'\3-\1-\2', text)
In [8]: newtext
Out[8]: 'Today is 2012-11-27. PyCon starts 2013-3-13.'
In [9]: n
Out[9]: 2
以上就是比较常用的内容。
正则表达式还有一些其他的内容，如果用到了自己去查参考书吧。
最后作为一个小练习我们模拟爬取网易云的音乐榜单，说是模拟其实是因为我们是手动扒下来的网页（手动滑稽）
不想手动？参考这篇文章
我们扒下来的代码类似与这种：
html = '''<dd>
<ol>
<li onmouseover="this.className='z-hvr'" onmouseout="this.className=''">
<span class="no no-top">1</span>
<a href="/song?id=1374483648" class="nm s-fc0 f-thide" title="Beautiful People (feat. Khalid)">Beautiful People (feat. Khalid)</a>
<div class="oper">
<a href="#" class="s-bg s-bg-11" title="播放" hidefocus="true" data-res-type="18" data-res-id="1374483648" data-res-action="play" data-res-from="31" data-res-data="19723756"></a>
<a href="#" class="u-icn u-icn-81" title="添加到播放列表" hidefocus="true" data-res-type="18" data-res-id="1374483648" data-res-action="addto" data-res-from="31" data-res-data="19723756"></a>
<a href="#" class="s-bg s-bg-12" title="收藏" hidefocus="true" data-res-level="0" data-res-fee="8" data-res-type="18" data-res-id="1374483648" data-res-action="subscribe"></a>
</div>
我们先找到与我们的榜单相关的代码，比如这首《你好》：
</li>
<li onmouseover="this.className='z-hvr'" onmouseout="this.className=''" class="">
<span class="no">4</span>
<a href="/song?id=1374304123" class="nm s-fc0 f-thide" title="你好">你好</a>
<div class="oper">
<a href="#" class="s-bg s-bg-11" title="播放" hidefocus="true" data-res-type="18" data-res-id="1374304123" data-res-action="play" data-res-from="31" data-res-data="19723756"></a>
<a href="#" class="u-icn u-icn-81" title="添加到播放列表" hidefocus="true" data-res-type="18" data-res-id="1374304123" data-res-action="addto" data-res-from="31" data-res-data="19723756"></a>
<a href="#" class="s-bg s-bg-12" title="收藏" hidefocus="true" data-res-level="0" data-res-fee="8" data-res-type="18" data-res-id="1374304123" data-res-action="subscribe"></a>
</div>
</li>
我们可以看见首先有一个 <li> 标签 ，然后歌名在 <a> 标签里面，在一个 > 符号的后面。
所以我们可以这样找到它：
reg = '<li.*?<a href.*?>(.*?)</a>'
r = re.findall(reg, html, re.S)
if r:
for song in r:
print(song)
Beautiful People (feat. Khalid)
Heartbeat (BTS WORLD OST)
I Fell In Love With The Devil (Radio Edit)
你好
晚安
平胸女子
憾
Room to Fall
キスだけで
你在哪里
意料之中全是情歌，，，
