正则表达式与JSON

一、初识正则表达式

# 正则表达式是一个特殊的字符序列，一个字符串是否与我们所设定的这样的字符序列，相匹配
# 快速检索文本、实现一些替换文本的操作
# 1、检查一串数字是否室电话号码
# 2、检测一个字符串是否符合email
# 3、把一个文本里指定的单词替换为另一个单词
import re
a = "C|C++|Java|C#|Python|JavaScript"r = re.findall("Python", a)
print(r)
# 规则
if len(r) > 0:print("字符串中包含Python")
else:print("字符串中不包含Python")

运行结果：

二、元字符与普通字符

元字符：

元字符	描述
\	将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如，“\\n”匹配\n。“\n”匹配换行符。序列“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。
^	匹配输入字行首。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$	匹配输入行尾。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*	匹配前面的子表达式任意次。例如，zo能匹配“z”，也能匹配“zo”以及“zoo”。等价于{0,}。
+	匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o为一组，后三个o为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串，而默认的贪婪模式则尽可能多地匹配所搜索的字符串。例如，对于字符串“oooo”，“o+”将尽可能多地匹配“o”，得到结果[“oooo”]，而“o+?”将尽可能少地匹配“o”，得到结果 ['o', 'o', 'o', 'o']
.点	匹配除“\n”和"\r"之外的任何单个字符。要匹配包括“\n”和"\r"在内的任何字符，请使用像“[\s\S]”的模式。
(pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“$”或“$”。
(?:pattern)	非获取匹配，匹配pattern但不获取匹配结果，不进行存储供以后使用。这在使用或字符“(\|)”来组合一个模式的各个部分时很有用。例如“industr(?:y\|ies)”就是一个比“industry\|industries”更简略的表达式。
(?=pattern)	非获取匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如，“Windows(?=95\|98\|NT\|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	非获取匹配，正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如“Windows(?!95\|98\|NT\|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。
(?<=pattern)	非获取匹配，反向肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95\|98\|NT\|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。 *python的正则表达式没有完全按照正则表达式规范实现，所以一些高级特性建议使用其他语言如java、scala等
(?<!patte_n)	非获取匹配，反向否定预查，与正向否定预查类似，只是方向相反。例如“(?<!95\|98\|NT\|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。 *python的正则表达式没有完全按照正则表达式规范实现，所以一些高级特性建议使用其他语言如java、scala等
x\|y	匹配x或y。例如，“z\|food”能匹配“z”或“food”(此处请谨慎)。“[z\|f]ood”则匹配“zood”或“food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”任一字符。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b	匹配一个单词的边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”；“\b1_”可以匹配“1_23”中的“1_”，但不能匹配“21_3”中的“1_”。
\B	匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d	匹配一个数字字符。等价于[0-9]。grep 要加上-P，perl正则支持
\D	匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何不可见字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。\f(换页符)，\v(垂直制表符)
\S	匹配任何可见字符。等价于[^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”，这里的"单词"字符使用Unicode字符集。
\W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
\xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。
\num	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
\nml	如果n为八进制数字（0-7），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。
\p{P}	小写 p 是 property 的意思，表示 Unicode 属性，用于 Unicode 正表达式的前缀。中括号内的“P”表示Unicode 字符集七个字符属性之一：标点字符。其他六个属性： L：字母； M：标记符号（一般不会单独出现）； Z：分隔符（比如空格、换行等）； S：符号（比如数学符号、货币符号等）； N：数字（比如阿拉伯数字、罗马数字等）； C：其他字符。 *注：此语法部分语言不支持，例：javascript。
\< \>	匹配词（word）的开始（\<）和结束（\>）。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。
( )	将( 和 ) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 \1 到\9 的符号来引用。
\|	将两个匹配条件进行逻辑“或”（or）运算。例如正则表达式(him\|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。
[\u4e00-\u9fa5]	匹配汉字。print("\u4e00")打印汉字"一"；print("\u9fa5")打印汉字"龥"。

import re
a = "C0C++7Java8C#9Python6JavaScript"# "Python" 普通字符  "\d" 元字符
r = re.findall("\d", a)
print(r)运行结果：
['0', '7', '8', '9', '6']

三、字符集

# 字符集
import re
s = "abc, acc, adc, aec, aec, ahc"
r = re.findall("a[c-f]c", s)
print(r)运行结果：
['acc', 'adc', 'aec', 'aec']

四、概括字符

1、\d 数字字符

import re
a = "python 1111\tjava&678__p\nhp"# \d 数字字符
r_d = re.findall("\d", a)
r = re.findall("[0-9]", a)
print(r_d)
print(r)运行结果：
['1', '1', '1', '1', '6', '7', '8']
['1', '1', '1', '1', '6', '7', '8']

2、\D 非数字字符

import re
a = "python 1111\tjava&678__p\nhp"# \D 非数字字符
o_D = re.findall("\D", a)
o = re.findall("[^0-9]", a)
print(o_D)
print(o)运行结果：
['p', 'y', 't', 'h', 'o', 'n', ' ', '\t', 'j', 'a', 'v', 'a', '&', '_', '_', 'p', '\n', 'h', 'p']
['p', 'y', 't', 'h', 'o', 'n', ' ', '\t', 'j', 'a', 'v', 'a', '&', '_', '_', 'p', '\n', 'h', 'p']

3、\w 单词字符

import re
a = "python 1111\tjava&678__p\nhp"# \w 单词字符
p_w = re.findall("\w", a)
p = re.findall("[A-Za-z0-9_]", a)
print(p_w)
print(p)运行结果：
['p', 'y', 't', 'h', 'o', 'n', '1', '1', '1', '1', 'j', 'a', 'v', 'a', '6', '7', '8', '_', '_', 'p', 'h', 'p']
['p', 'y', 't', 'h', 'o', 'n', '1', '1', '1', '1', 'j', 'a', 'v', 'a', '6', '7', '8', '_', '_', 'p', 'h', 'p']

4、\W 非单词字符

import re
a = "python 1111\tjava&678__p\nhp"# \W 非单词字符
q_W = re.findall("\W", a)
q = re.findall("[^A-Za-z0-9_]", a)
print(q_W)
print(q)运行结果：
[' ', '\t', '&', '\n']
[' ', '\t', '&', '\n']

5、\s 空白字符

import re
a = "python 1111\tjava&678__p\nhp"# \s 空白字符
s = re.findall("\s", a)
print(s)运行结果：
[' ', '\t', '\n']

6、\S 非空白字符

import re
a = "python 1111\tjava&678__p\nhp"# \S 非空白字符
S = re.findall("\S", a)
print(S)运行结果：
['p', 'y', 't', 'h', 'o', 'n', '1', '1', '1', '1', 'j', 'a', 'v', 'a', '&', '6', '7', '8', '_', '_', 'p', 'h', 'p']

7、. 匹配除换行符(\n)之外的所有字符

import re
a = "python 1111\tjava&678__p\nhp"# . 匹配除换行符(\n)之外的所有字符
q = re.findall(".", a)
print(q)运行结果：
['p', 'y', 't', 'h', 'o', 'n', ' ', '1', '1', '1', '1', '\t', 'j', 'a', 'v', 'a', '&', '6', '7', '8', '_', '_', 'p', 'h', 'p']

五、数量词

import re
a = "python 1111java678php"r = re.findall("[a-z]{3,6}", a)
print(r)运行结果：
['python', 'java', 'php']

六、贪婪与非贪婪

1、贪婪模式：

import re
a = "python 1111java678php"# 贪婪模式
r = re.findall("[a-z]{3,6}", a)
print(r)运行结果：
['python', 'java', 'php']

2、非贪婪模式：

import re
a = "python 1111java678php"# 非贪婪模式
s = re.findall("[a-z]{3,6}?", a)
print(s)运行结果：
['pyt', 'hon', 'jav', 'php']

七、匹配0次1次或者无限多次

1、* *前面的字符匹配0次或者无限多次

import re
a = "pytho0python1pythonn2"r = re.findall("python*", a)
print(r)运行结果：
['pytho', 'python', 'pythonn']

2、+ +前面的字符匹配1次或者无限多次

import re
a = "pytho0python1pythonn2"o = re.findall("python+", a)
print(o)运行结果：
['python', 'pythonn']

3、? ?前面的字符匹配0次或者1次

import re
a = "pytho0python1pythonn2"p = re.findall("python?", a)
print(p)运行结果：
['pytho', 'python', 'python']

八、边界匹配符

import re
qq = "1282911984"r = re.findall("^\d{7,10}$", qq)
print(r)运行结果：
['1282911984']o = re.findall("^1", qq)
print(o)运行结果：
['1']p = re.findall("8$", qq)
print(p)运行结果：
print(p)

九、组

import re
a = "PythonPythonPythonPython"
r = re.findall("(Python){4}", a)
print(r)运行结果：
['Python']o = re.findall("(Python){3}", a)
print(o)运行结果：
['Python']p = re.findall("(Python){2}", a)
print(p)运行结果：
['Python', 'Python']q = re.findall("(Python){1}", a)
print(q)运行结果：
['Python', 'Python', 'Python', 'Python']s = re.findall("[Python]{4}", a)
print(s)运行结果：
['Pyth', 'onPy', 'thon', 'Pyth', 'onPy', 'thon']t = re.findall("[Python]{3}", a)
print(t)运行结果：
['Pyt', 'hon', 'Pyt', 'hon', 'Pyt', 'hon', 'Pyt', 'hon']u = re.findall("[Python]{2}", a)
print(u)运行结果：
['Py', 'th', 'on', 'Py', 'th', 'on', 'Py', 'th', 'on', 'Py', 'th', 'on']v = re.findall("[Python]{1}", a)
print(v)运行结果：
['P', 'y', 't', 'h', 'o', 'n', 'P', 'y', 't', 'h', 'o', 'n', 'P', 'y', 't', 'h', 'o', 'n', 'P', 'y', 't', 'h', 'o', 'n']

十、匹配模式参数

1、re.I 忽略大小写

import re
lanuage = "PythonC#\nJavaPHP"r = re.findall("c#", lanuage, re.I)
print(r)运行结果：
['C#']

2、re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
3、re.M 多行模式
4、re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）

import re
lanuage = "PythonC#\nJavaPHP"o = re.findall(".{1}", lanuage, re.S)
print(o)运行结果：
['P', 'y', 't', 'h', 'o', 'n', 'C', '#', '\n', 'J', 'a', 'v', 'a', 'P', 'H', 'P']

5、re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
6、re.X 为了增加可读性，忽略空格和 # 后面的注释

7、多个模式匹配用|

import re
lanuage = "PythonC#\nJavaPHP"p = re.findall("c#.{1}", lanuage, re.I | re.S)
print(p)运行结果：
['C#\n']

十一、re.sub正则替换

1、示例一：

import re
lanuage = "PythonC#JavaC#PHPC#"
r = re.sub("C#", "GO", lanuage, 0)print(r)运行结果：
PythonGOJavaGOPHPGO

2、示例二：

import re
lanuage = "PythonC#JavaC#PHPC#"
r = re.sub("C#", "GO", lanuage, 1)print(r)运行结果：
PythonGOJavaC#PHPC#

3、示例三：

import re
lanuage = "PythonC#JavaC#PHPC#"def convert(value):passr = re.sub("C#", convert, lanuage, 1)print(r)运行结果：
PythonJavaC#PHPC#

4、示例四：

import re
lanuage = "PythonC#JavaC#PHPC#"def convert(value):matched = value.group()return "!!" + matched + "!!"r = re.sub("C#", convert, lanuage, 0)print(r)运行结果：
Python!!C#!!Java!!C#!!PHP!!C#!!

十二、把函数作为参数传递

需求：将字符串s中大于等于6的数字替换为9，小于6的数字替换为0。

import re
s = "A8C7D1D8E6"def covert(value):matched = value.group()if int(matched) >= 6:return "9"else:return "0"r = re.sub("\d", covert, s)
print(r)运行结果：
A9C9D0D9E9

十三、search与match函数

1、search将尝试搜索整个字符串，直到找到第一个满足正则表达式的结果，将找到的结果返回回来

import res = "A83C72D1D8E67"# search将尝试搜索整个字符串，直到找到第一个满足正则表达式的结果，将找到的结果返回回来
r1 = re.search("\d", s)
print(r1)运行结果：
<re.Match object; span=(1, 2), match='8'>print(r1.span())运行结果：
(1, 2)print(r1.group())运行结果：
8

2、match：match将尝试从字符串的首字母开始进行匹配，如果match没有找到相应的匹配结果，那么它将返回一个None

import res = "A83C72D1D8E67"# match将尝试从字符串的首字母开始进行匹配，如果match没有找到相应的匹配结果，那么它将返回一个None
r = re.match("\d", s)
print(r)运行结果：
Nonea = "83C72D1D8E67"
o = re.match("\d", a)
print(o)运行结果：
<re.Match object; span=(0, 1), match='8'>print(o.span())运行结果：
(0, 1)print(o.group())运行结果：
8

3、findall：

import res = "A83C72D1D8E67"r2 = re.findall("\d", s)
print(r2)运行结果：
['8', '3', '7', '2', '1', '8', '6', '7']

十四、group分组

1、示例一：

import res = "life is short, i use python"r = re.search("life(.*)python", s)
print(r.group())运行结果：
life is short, i use pythonprint(r.group(0))运行结果：
life is short, i use pythonprint(r.group(1))运行结果：is short, i use

2、示例二：

import rea = "life is short, i use python, i love python"
o = re.search("life(.*)python(.*)python", a)
print(o.group())运行结果：
life is short, i use python, i love pythonprint(o.group(0))运行结果：
life is short, i use python, i love pythonprint(o.group(1))运行结果：is short, i use print(o.group(2))运行结果：
, i love

3、示例三：

import rea = "life is short, i use python, i love python"
o = re.search("life(.*)python(.*)python", a)print(o.groups())运行结果：
(' is short, i use ', ', i love ')

十五、一些关于学习正则的建议

1、校验数字的表达式

(1)、数字：^[0-9]*$

(2) 、n位的数字：^\d{n}$

(3)、至少n位的数字：^\d{n,}$

(4)、m-n位的数字：^\d{m,n}$

(5) 、零和非零开头的数字：^(0|[1-9][0-9]*)$

(6) 、非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$

(7) 、带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$

(8) 、正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$

(9) 、有两位小数的正实数：^[0-9]+(.[0-9]{2})?$

(10) 、有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$

(11) 、非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$

(12) 、非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$

(13) 、非负整数：^\d+$ 或 ^[1-9]\d*|0$

(14) 、非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$

(15) 、非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$

(16) 、非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$

(17)、正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$

(18) 、负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$

(19)、浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$

2、校验字符的表达式

(1)、汉字：^[\u4e00-\u9fa5]{0,}$

(2)、英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$

(3)、长度为3-20的所有字符：^.{3,20}$

(4)、由26个英文字母组成的字符串：^[A-Za-z]+$

(5)、由26个大写英文字母组成的字符串：^[A-Z]+$

(6 、由26个小写英文字母组成的字符串：^[a-z]+$

(7)、由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$

(8)、由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$

(9)、中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$

(10)、中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$

(11)、可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+

(12)、禁止输入含有~的字符：[^~\x22]+

3.特殊需求表达式

(1)、Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

(2)、域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?

(3)、InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$

(4)、手机号码（可根据目前国内收集号扩展前两位开头号码）：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$

(5)、电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$

(6)、国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}

(7)、15位身份证号：^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}$

(8)、18位身份证号：^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$

(9)、帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

(10)、密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$

(11)、强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$

(12)、日期格式：^\d{4}-\d{1,2}-\d{1,2}

(13)、一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$

(14)、一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$

4.、钱的输入格式：

(1)、有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$

(2)、这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$

(3)、一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$

(4)、这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$

(5)、必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$

(6)、这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$

(7)、这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$

(8)、1到3个数字,后面跟着任意个逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$

备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里

5、 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$

6、中文字符的正则表达式：[\u4e00-\u9fa5]

7、双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))

8、空白行的正则表达式：\n\s*\r (可以用来删除空白行)

9、HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)

10、首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)

11、腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)

12、中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)

13、IP地址：\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)

14、IP地址：((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))

十六、理解JSON

1、什么是JSON？

答：(1)、JSON是一种轻量级的数据交换格式；

(2)、字符串是JSON的表现形式；

(3)、符合JSON格式的字符串叫做JSON字符串。

2、JSON的特点：

(1)、易于阅读；

(2)、易于解析(跨语言交换数据)；

(3)、网络传输效率高。

3、JSON数据传输示意图：

十七、反序列化

import jsonjson_str = '[{"name": "小草", "age": 18, "flag": false}, {"name": "小唐", "age": 18, "flag": true}]'# 反序列化
student = json.loads(json_str)
print(type(student))运行结果：
<class 'list'>print(student)运行结果：
[{'name': '小草', 'age': 18, 'flag': False}, {'name': '小唐', 'age': 18, 'flag': True}]

十八、序列化

1、JSON--Python数据类型对比：

JSON Python数据类型对比
JSON	Python
object	dict
array	list
string	str
number	int
number	float
true	True
false	False
null	None

2、示例：

import jsonstudent = [{'name': '小草', 'age': 18, 'flag': False},{'name': '小唐', 'age': 18, 'flag': True}
]json_str = json.dumps(student)
print(type(json_str))运行结果：
<class 'str'>print(json_str)运行结果：
[{"name": "\u5c0f\u8349", "age": 18, "flag": false}, {"name": "\u5c0f\u5510", "age": 18, "flag": true}]

十九、小谈JSON、JSON对象与JSON字符串