json、正则

json

json存在的价值
json文件可以在任何语言之间都能解析，让数据在不同的编程语言之间都可以传输，所以json，用于不同编程语言之间的数据交流。我们在写文件保存数据时，可以先转换成json数据，方便以后的数据的回收利用。比如说我们虽然会有语言差异的限制，但是数据却是通用的。

json 数据格式要求：

有且只有一个数据；唯一的数据必须json支持的数据类型对应的数据。

json 支持的数据类型有：

• 数字 ：10、12.3、3e3
• 字符串 ： “abc”、“\tabc\n123”
• 布尔 ： true、false
• 空值 ： null
• 数组 ： [数据1， 数据2，…]
• 字典 ：{键1：值1， 键2：值2，…}

Python	JSON
dict	Object
list	Array
tuple	Array
str	String
int	Number
float	Number
True	true
False	false
None	null

注意布尔、空值的区别
转换：

• json数据转Python 数据

import json
json.loads(json格式字符串)

• python 数据转 json

import json
json.dumps(python格式字符串)

正则表达式

正则表达式是一种可以让复杂的字符串问题变得简单的工具。

导入

import re

语法

函数用法

函数	说明
re.match	将正则表达式模式匹配到字符串的开头
fullmatch	将正则表达式模式匹配到所有字符串
search	在字符串中搜索是否存在模式
sub	替换在字符串中找到的模式的出现
subn	与 sub 相同，但也返回进行的替换次数
split	根据出现的模式拆分字符串
findall	查找字符串中所有出现的模式
finditer	返回一个迭代器，为每个匹配项生成一个 Match 对象
compile	将一个模式编译成一个 Pattern 对象
purge	清除正则表达式缓存
escape	反斜杠字符串中的所有非字母数字

特殊字符：

字符	功能
“.”	匹配除换行符以外的任何字符
“^”	匹配字符串的开头
“$”	匹配字符串的结尾或字符串结尾的换行符之前
“*”	匹配前面 RE 的 0 个或多个（贪婪）重复。贪婪意味着它将匹配尽可能多的重复
“+”	匹配前面 RE 的 1 个或多个（贪婪）重复
“？”	匹配前面 RE 的 0 或 1（贪心）。 *?,+?,??前三个特殊字符的非贪婪版本
{m,n}	匹配前面 RE 的 m 到 n 次重复
{m,n}？	上述的非贪婪版本
“\”	转义特殊字符或表示特殊序列
[]	表示一组字符。作为第一个字符的“^”表示补集
(…)	匹配括号内的 RE。稍后可以在字符串中检索或匹配内容
(?aiLmsux)	这些字母设置了下面定义的相应标志
(?:…)	正则括号的非分组版本
(?P…)	组匹配的子字符串可以通过名称访问
(?P=name)	匹配名为 name 的组之前匹配的文本
（？＃…）	一条评论;忽略
(?=…)	匹配 if … 匹配下一个，但不使用字符串
(?!..)	如果 … 下一个不匹配则匹配
(?<=…)	如果前面有 … 则匹配（必须是固定长度）
(?<!..)	如果前面没有 … 则匹配（必须是固定长度）
(?(id/name)yes/no)	如果匹配 id/name 的组匹配 yes 模式，否则匹配（可选）no 模式。

特殊序列
由“\”和下表中的一个字符组成。如果普通字符不在列表中，则生成的 RE 将匹配第二个字符

字符	功能
\number	匹配相同编号的组的内容
\A	仅匹配字符串的开头
\Z	仅匹配字符串的末尾
\b	匹配空字符串，但只匹配单词的开头或结尾
\B	匹配空字符串，但不匹配单词的开头或结尾
\d	匹配任何十进制数字； [0-9]
\D	匹配任何非数字字符；相当于 [^\d]
\s	匹配任何空白字符； 相当于[ \t\n\r\f\v]
\S	匹配任何非空白字符；相当于 [^\s]。
\w	匹配任何字母数字字符；相当于 [a-z A-Z 0-9 _ ]
\W	匹配 \w 的补码。
\\	匹配文字反斜杠。

常用正则表达式大全

匹配：
	匹配中文字符： [\u4e00-\u9fa5]   
	匹配双字节字符(包括汉字在内)：[^x00-xff] 
	匹配空白行：ns*r 
	匹配HTML标记：< (S*?)[^>]*>.*?|<.*? /> 
	匹配首尾空白字符：^s*|s*$ 
	匹配Email地址：w+([-+.]w+)*@w+([-.]w+)*.w+ ([-.]w+)* 
	匹配网址URL：[a-zA-z]+://[^s]* 
	匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
	匹配国内电话号码：d{3}-d{8}|d{4}-d{7} 
	匹配腾讯QQ号：[1-9][0-9]{4,} 
	匹配中国邮政编码：[1-9]d{5} (?!d) 
	匹配身份证：d{15}|d{18} 
	匹配ip地址：d+.d+.d+.d+
	 
数字： 
　　 ^[1-9]d*$　 　 								 	 //匹配正整数 
　　 ^-[1-9]d*$ 　								     //匹配负整数 
　 　^-?[1-9]d*$　　									 //匹配整数 
　 　^[1-9]d*|0$　 									 //匹配非负整数（正整数 + 0） 
　 　^-[1-9]d*|0$　　				 				 //匹配非正整数（负整数 + 0） 
　 　^[1-9]d*.d*|0.d*[1-9]d*$　　 					 //匹配正浮点数 
　　 ^-([1-9]d*.d*|0.d*[1-9]d*)$　 				   	 //匹配负浮点数 
　　 ^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$　			 //匹配浮点数 
　　 ^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$　			  　 //匹配非负浮点数（正浮点数 + 0） 
　　 ^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$　　        //匹配非正浮点数（负浮点数 + 0） 
　　
字符串： 
　　^[A-Za-z]+$　　		//匹配由26个英文字母组成的字符串 
　 　^[A-Z]+$　　		//匹配由26个英文字母的大写组成的字符串 
　　^[a-z]+$　　			//匹配由26个英文字母的小写组成的字符串 
　 　^[A-Za-z0-9]+$　　  //匹配由数字和26个英文字母组成的字符串 
　　^w+$　　				//匹配由数字、26个英文字母或者下划线组 成的字符串 
　　
验证: 
　　验证用户密码:“^[a-zA-Z]w{5,17}$”
　　#正确格式为：以字母开头，长度 在6-18之间，只能包含字符、数字和下划线。 
　　验证是否含有^%&'',;=?$"等字符：“[^%& '',;=?$x22]+” 
　　验证Email地址：“^w+ [-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$” 
　　验证InternetURL：“^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$” 
　　验证电话号码：“^((d{3,4})|d{3,4}-)?d{7,8}$” 
　　#正确格式为：“XXXX-XXXXXXX”，“XXXX- XXXXXXXX”，“XXX-XXXXXXX”， “XXX-XXXXXXXX”，“XXXXXXX”，“XXXXXXXX”。 
	验证身份证号（15位或18位数字）：“^d{15}|d{}18$” 
	验证一年的12个月：“^(0?[1-9]|1[0-2])$”
	验证一个月的31天：“^((0?[1-9])|((1|2) [0-9])|30|31)$” 

限制：
	只能输入数字：“^[0-9]*$” 
　　只能输入n位的数字：“^d{n}$” 
　　只能输入至少n位数字：“^d{n,}$” 
　  只能输入m-n位的数字：“^d{m,n}$” 
　　只能输入零和非零开头的数字：“^(0|[1-9][0-9]*)$” 
　　只能 输入有两位小数的正实数：“^[0-9]+(.[0-9]{2})?$” 
　　只能输入有1-3位小数的正实数：“^[0-9]+(.[0-9] {1,3})?$” 
　　只能输入非零的正整数：“^+?[1-9][0-9]*$” 
　　只能输入非零的负整数：“^-[1-9] [0-9]*$” 
　　只能输入汉字：“^[u4e00-u9fa5],{0,}$” 
　　只能输入长度为3的字符：“^.{3}$” 
　　只能输入由26个英文字母组成的字符串：“^[A-Za- z]+$” 
　　只能输入由26个大写英文字母组成的字符串：“^[A-Z]+$” 
　　只能输入由26个小写英文字母组成的字符串：“^[a-z]+$” 
　　只能输入由数字和26个英文字母组成的字符串：“^[A-Za-z0-9]+$” 
　　只能输入由数字、 26个英文字母或者下划线组成的字符串：“^w+$” 

# 基本用法
result = re.fullmatch(r'a[MN\d]b', 'aNb')
# <re.Match object; span=(0, 3), match='aNb'>
result1 = re.fullmatch(r'a[^MN\d]b', 'aBb')
# <re.Match object; span=(0, 3), match='aBb'>
result2 = re.fullmatch(r'[1-9]\d{4,11}', '1234567')
# <re.Match object; span=(0, 7), match='1234567'>

# 分组
result3 = re.fullmatch(r'([A-Z]{3}\d{2})[\u4e00-\u9fa5][A-Z]{3}', 'WIN94和AWM')
result4 = re.fullmatch(r'(\d{2})([a-z])[\u4e00-\u9fa5]{2}\1\2', '98k就叫98k')
print(result4.match())
# AttributeError: 're.Match' object has no attribute 'match'
# 属性错误:'re.Match'对象没有属性'match'
result5 = re.fullmatch(r'([a-z])(\d{3})[\u4e00-\u9fa5]{2}\2', 'm416也叫416')
print(result5.span())
# (0, 9)

# 重复
message = '我今年18岁，月薪50088元，身高188，体重70公斤，8块腹肌。每年交308元的腾讯会员费。房贷每月3000元，车贷每月2288元。'
result6 = re.findall(r'\d+元', message)
# ['50088元', '308元', '3000元', '2288元']

# 捕获
result7 = re.findall(r'(\d+)元', message)
# ['50088', '308', '3000', '2288']

# 分支
mess = '我爱你，胜过我讨厌你'
result8 = re.findall(r'我([\u4e00-\u9fa5]|[\u4e00-\u9fa5]{2})你', mess)
# ['爱', '讨厌']

# 转义
result9 = re.findall(r'\\d+\.\d+', '\d.879')    # ['\\d.879']
message1 = '1:萝卜：单价2元，起售份数5 2:西红柿：单价3元，起售份数5 '
result10 = re.findall(r'\d+', message1)         # ['1', '2', '5', '2', '3', '5']
result11 = re.findall(r'\d+\b', message1)       # ['1', '5', '2', '5']
result12 = re.findall(r'\b\d+', message1)       # ['1', '2']
result13 = re.findall(r'\B\d+\B', message1)     # ['2', '3']

# match()
result14 = re.match(r'\d{4}', '2022.08.09 hello, world.')
print(result14.group())  # 2022

# search()
result15 = re.search(r'\d{4}', '2022.08.09 hello, world.')
print(result15.span())  # (0, 4)

# finditer()
result16 = re.finditer(r'\d{4}', '2022.08.09 hello, world.')
print(next(result16))
# <re.Match object; span=(0, 4), match='2022'>

# split()
result17 = re.split(r'\.| |,', '2022.08.09 hello,world')
# ['2022', '08', '09', 'hello', 'world']

# sub()
result18 = re.sub(r'\d', '*', '2022.08.09 hello, world.')
# '****.**.** hello, world.'

# group()
message2 = 'CHN:98, JPN:78, USA:86'
result19 = re.search(r'([A-Z]{3}):(\d{2})', message2)
print(result19.group(1))    # CHN

# (?!)
result20 = re.fullmatch(r'(?i)abc', 'ABc')
# <re.Match object; span=(0, 3), match='ABc'>

# (?s)
result21 = re.fullmatch(r'(?s)hello.world', 'hello\nworld')
# <re.Match object; span=(0, 11), match='hello\nworld'>