我们平时上网的时候，经常需要在一些网站上注册帐号，而注册帐号的时候对帐号信息会有一些要求。
比如：
上面的图片中，输入的邮件地址、密码、手机号 符合要求才可以注册成功。
我们是我们自己写的网站，那么我们需要判断用户输入是否合法。
那么如何判断用户输入的内容是否合法呢？ 自己写函数来依次判断？
python给我们提供了更方便的工具——re模块，也就是正则表达式模块。
在使用re模块的时候，我们需要了解一些正则表达式的基础知识。
什么是正则表达式？
正则表达式（Regular expressions） 其实就是描述字符串规则的代码。比如说我们的手机号码的规则是 由1开头的11位数字组成。最简单的正则表达式就是普通字符串，可以匹配其自身。比如，正则表达式 ‘hello’ 可以匹配字符串 ‘hello’。
注意：正则表达式并不是一个程序， 也不是python的一部分，它只是是用于处理字符串的一种模式，它有自己的一套语法规则，且十分强大。在提供正则表达式的编程语言里，正则表达式的语法都是一样的，区别在于不同的编程语言支持的语法数量不同，不过不用担心，
下面我们来学习一下正则表达式的基础知识。
学完了正则表达式，我们来学习re模块的使用。
re模块为我们提供了一些函数和常量。
匹配模式：
正则表达式提供了一些可用的匹配模式，比如说不区分大小写，多行匹配等等：
re.U (re.UNICODE) 使用Unicode模式匹配字符串，该模式为默认，\w, \W, \b, \B, \d, \D, \s, \S会受到影响。
re.A(re.ASCII)：使 \w \W \b \B \s \S 只匹配 ASCII 字符，而不是 Unicode 字符。
re.I(re.IGNORECASE): 忽略大小写
re.L(re.LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
re.M(re.MULTILINE): 多行模式，改变'^'和'$'的行为，指定了以后，'^'会增加匹配每行的开始（也就是换行符后的位置）；'$'会增加匹配每行的结束（也就是换行符前的位置）。
re.S(re.DOTALL): 点任意匹配模式，改变'.'的行为, 让'.'可以匹配包括'\n'在内的任意字符。
re.X(re.VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的：
a = re.compile(r"""\d + # the integral part
\. # the decimal point
\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
学完了正则表达式，我们来看一下如何使用 re 模块。
re模块为我们提供了很多方法，我们来看常用的几个：
re.search(pattern, string, flags=0)
对整个字符串进行搜索，并返回第一个匹配的字符串的match对象。
pattern : 使用的正则表达式
string : 要匹配的字符串
flags : 用来控制正则表达式的匹配规则。比如是否区分大小写
示例：
>>> str1 = "Hello world"
>>> print(re.search(r"e", str1))
<_sre.SRE_Match object; span=(1, 2), match='e'>
re.match(pattern, string, flags)
从字符串“开头”去匹配，并返回匹配的字符串的match对象。匹配不到时，返回None
示例：
>>> str1 = "Hello world"
>>> print(re.match(r"e", str1))
None
>>> print(re.match(r"He", str1))
<_sre.SRE_Match object; span=(0, 2), match='He'>
re.fullmatch(pattern, string, flags=0)
如果正则表达式匹配整个字符串，则返回匹配到的match对象， 否则返回None。 注意这里不同于0长度的匹配。
>>> str1 = "Hello world"
>>> print(re.fullmatch(r"[a-z ]", str1, re.I))
None
>>> print(re.fullmatch(r"[a-z ]+", str1, re.I))
<_sre.SRE_Match object; span=(0, 11), match='Hello world'>
re.split(pattern, string, maxsplit=0, flags=0)
使用匹配到的内容分割字符串，返回一个列表，如果maxsplit非0,则根据指定的次数进行分割，剩余的内容作为列表的最后一个元素。
>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['', '', '']
## 如果在进行分割的时候有分组，且匹配的内容的在字符串的起始位置，则结果的第一元素是一个空字符串，
>>> re.split('(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
## 注意这里的 x* 匹配的0个x 会被忽略
>>> re.split('x*', 'axbc')
['a', 'bc']
## 只能匹配空字符串的pattern 一般不会分割字符串 。因为这不是一个预期的行为，在python3.5中会报告 ValueError 错误
>>> re.split("^$", "foo\n\nbar\n", flags=re.M)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
...
ValueError: split() requires a non-empty pattern match.
re.findall(pattern, string, flags=0)
返回一个所有匹配的字符串的字符串列表
示例：
>>> str1 = "Hello world"
>>> print(re.findall(r"e", str1))
['e']
>>> print(re.findall(r"z", str1))
[]
re.finditer(pattern, string, flags=0)
返回匹配对象组成的一个迭代器
示例：
>>> str1 = "Hello python, hello python."
>>> ite = re.finditer(r"[a-z]+", str1 , re.I )
>>> print(ite)
<callable_iterator object at 0x7f79690b92e8>
>>> for i in ite:print(i)
...
<_sre.SRE_Match object; span=(0, 5), match='Hello'>
<_sre.SRE_Match object; span=(6, 12), match='python'>
<_sre.SRE_Match object; span=(14, 19), match='hello'>
<_sre.SRE_Match object; span=(20, 26), match='python'>
re.sub(pattern, repl, string, count=0, flags=0)
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。
>>> str1 = "hello 123, hello 456."
>>> re.sub(r"\d+", "world",str1)
'hello world, hello world.'
>>> def func(matchObj):
... if matchObj:return "--"
... else: return "++"
...
>>> re.sub(r"\d+", func,str1)
'hello --, hello --.'
re.subn(pattern, repl, string, count=0, flags=0)
效果和 sub() 一样,但是结果会返回一个元组 (new_string, number_of_subs_made)
>>> str1 = "hello 123, hello 456."
>>> re.subn(r"\d+", "world",str1)
('hello world, hello world.', 2)
re.escape(string)
转义pattern中 除了ASCII字母、数字、‘_’ 之外的所有字符。其实就是帮在特殊字符前面加 \ 。
>>> re.escape('www.python.org')
'www\\.python\\.org'
re.purge()
清楚正则表达式缓存
re.compile(pattern, flags=0)
将正则表达式编译为一个正则表达式对象， 可以把经常使用的正则表达式编译成正则表达式对象来提高效率
>>> regex = re.compile(r"\d+")
>>> match = regex.search("hello 123")
>>> if match: print(match.group())
...
123
正则表达式对象
通过 re.compile() 我们可以得到一个编译的正则表达式对象，他支持以下方法和属性
regex.search(string[, pos[, endpos]])
>>> pattern = re.compile("d")
>>> pattern.search("dog") # Match at index 0
<_sre.SRE_Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1) # No match; search doesn't include the "d"
regex.match(string[, pos[, endpos]])
>>> pattern = re.compile("o")
>>> pattern.match("dog") # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1) # Match as "o" is the 2nd character of "dog".
<_sre.SRE_Match object; span=(1, 2), match='o'>
regex.fullmatch(string[, pos[, endpos]])
>>> 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.
<_sre.SRE_Match object; span=(1, 3), match='og'>
regex.split(string, maxsplit=0)
regex.findall(string[, pos[, endpos]])
regex.finditer(string[, pos[, endpos]])
regex.sub(repl, string, count=0)
regex.subn(repl, string, count=0)
regex.flags
regex匹配的flags，
regex.groups
返回pattern中分组的数量
>>> aa = re.compile(r'(\d{3})(\d{3})(\d{3})(\d{3})(\d{3})' )
>>> aa.groups
5
regex.groupindex
返回定义了名字的分组 组成的一个字典映射
>>> aa = re.compile(r'(?P<id01>\d{3})(?P<id02>\d{3})' )
>>> aa.groupindex
mappingproxy({'id01': 1, 'id02': 2})
regex.pattern
返回被编译的 pattern 字符串
>>> aa = re.compile(r'(?P<id01>\d{3})(?P<id02>\d{3})' )
>>> aa.pattern
'(?P<id01>\\d{3})(?P<id02>\\d{3})'
我们得到匹配后的文本后 会得到 匹配对象——Match对象
Match对象默认是一个为True 的布尔值。由于 match() and search() 在没有匹配到内容的时候会返回None值， 此时你可以用if语句测试是否有Match对象。
match = re.search(pattern, string)
if match:
process(match)
Match对象支持以下方法和属性：
match.expand(template)
将匹配到的分组代入template中然后返回。template中可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。\id与\g<id>是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符'0'，只能使用\g<1>0。
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.expand(r"\2 \1 \2 \1")
'Newton Isaac Newton Isaac'
match.group([group1, ...])
获得匹配后的分组字符串，参数为编号或者别名；group(0)代表整个字符串，group(1)代表第一个分组匹配到的字符串，依次类推；如果编号大于pattern中的分组数或者小于0，则返回IndexError。另外，如果匹配不成功的话，返回None；如果在多行模式下有多个匹配的话，返回最后一个成功的匹配。
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group()
'Isaac Newton'
>>> m.group(0)
'Isaac Newton'
>>> m.group(1)
'Isaac'
>>> m.group(2)
'Newton'
>>> m.group(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: no such group
match.groups(default=None)
返回一个tuple，包含所有的分组匹配结果；如果default设为None的话，如果有分组没有匹配成功，则返回"None"；若设为0，则返回"0"。
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.groups()
('Isaac', 'Newton')
match.groupdict(default=None)
和上一个相似，不过返回的是dictionary，包含所有命名的分组和其匹配的值，如果有分组没有匹配成功，返回默认值"None"。
>>> m = re.match(r"(?P<id>\w+) (\w+)", "Isaac Newton, physicist")
>>> m.groupdict()
{'id': 'Isaac'}
match.start([group]) / match.end([group])
返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）/ 结束索引（子串最后一个字符的索引+1），group默认值为0。如果[group]存在但是没有匹配成功，返回-1。
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'
match.span([group])
返回一个分组[group]成功匹配时的信息，2-tuple，(m.start([group]), m.end([group]))；如果分组没有成功匹配，返回(-1,-1)。
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> m.span()
(7, 18)
match.pos
在string中匹配时，开始匹配的下标。
match.endpos
在 string中匹配时，结束匹配的下标。
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> len(email)
25
>>> m.pos
0
>>> m.endpos
25
match.lastindex
最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
>>> m = re.match(r"(?P<id>\w+) (\w+)", "Isaac Newton, physicist")
>>> m.lastindex
2
match.lastgroup
返回分组匹配最后成功的分组别名；如果没有一个分组匹配成功，或者最后一个成功匹配的分组没有别名，返回None。
>>> m = re.match(r"(?P<id>\w+) (\w+)", "Isaac Newton, physicist")
>>> m.lastgroup
>>> m = re.match(r"(?P<id>\w+) (?P<word>\w+)", "Isaac Newton, physicist")
>>> m.lastgroup
'word'
match.re
执行该match对象的正则表达式对象。
>>> m = re.match(r"(?P<id>\w+) (\w+)", "Isaac Newton, physicist")
>>> m.re
re.compile('(?P<id>\\w+) (\\w+)')
match.string
传递到match()或search()函数中的字符串。
>>> m = re.match(r"(?P<id>\w+) (\w+)", "Isaac Newton, physicist")
>>> m.string
'Isaac Newton, physicist'