三、python-json、正则

一、json

　  1、导入模块

import json

　　2、常用方法

　　　　dumps：序列化，把一个Python对象转化成json字符串

　　　　loads：反序列化，把json字符串转化成python

　　　　dump：序列化，把一个Python对象转化成json字符串（针对文件使用）

　　　　load：反序列化，把json字符串转化成python（针对文件使用））

　　3、代码

 import json
 user_dict = {
     'name' :'xiaoming',
     'age' : 18,
     'f' : 1.2,
     'language':('python','java'),
     'li':[1,2,3,4 ],
     'kong': None,
     't' : True,
     'f' : False
 }

 # dumps ---- 序列化 ----python字典对象转换为json格式的字符串
 json_str = json.dumps(user_dict,indent=2,sort_keys=True )
 print('json_str的值是:',json_str)
 print('json_str的类型是:',type(json_str)) # json 格式的字符串

 # loads ---- 反序列化 ---- json 格式的字符串转换为python字典对象
 python_dict = json.loads(json_str)
 print('python_dict的值是:',python_dict)
 print('python_dict的类型是:',type(python_dict)) # 字典类型

 # dump ---- 序列化 ----python字典对象转换为json格式的字符串并存入文件（针对文件用）
 with open('temp.json','w+' ) as f:
     '''
     indent:默认为None，单行存储;设置值时,将多行存储
     sort_keys:默认为False，不排序;设置为True是将根据键名排序
     ensure_ascii：默认为True，中文将以Unicode形式存储;设置为False时，中文将以中文的形式存储
     '''
     json.dump(obj=user_dict,fp=f,indent=2,sort_keys=True,ensure_ascii=False)

 # load ---- 反序列化- 读取文件内容并转换为python字典对象（针对文件用）
 with open('temp.json','r+' ) as f:
     data = json.load(f) 

　　4、python对象与json对象对应关系

python对象	json对象
dict	object
list, tuple	array
str	string
int, float	number
None	null
True/False	true/fase

二、re 正则表达式

　　1、导入模块

import re

　　2、常用方法

search()	在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
findall()	搜索字符串，以列表类型返回全部能匹配的子串
finditer()	搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
sub()	替换类似于字符串中 replace() 方法
compile()	编译正则表达式为模式对象
re.split()	将一个字符串按照正则表达式匹配结果进行分割，返回列表类型

获取 match对象 中的信息

group()	返回匹配到的字符串
start()	返回匹配的开始位置
end()	返回匹配的结束位置
span()	返回一个元组表示匹配位置（开始，结束）

　　3、基本知识介绍

　　a.元字符

　　 大多数字母和字符会匹配它们自身，有少数特殊字符我们称为元字符，它们不能匹配自身

　　b.子组匹配和模式重复次数

　　    .   ^   $   *   +   ?   {}  []   \   |   ()

.	匹配除换行符之外的所有的字符
\	用于转义
\d	匹配0~9的数字
\s	匹配任意的空白符，包括空格，制表符(Tab)，换行符等
\w	匹配字母或数字或下划线或汉字等
\b	表示单词的边界
\.	表示匹配点号本身
\D、\S、\W、\B	是与小写的相反的作用
^	脱字符，匹配输入字符串的开始的位置
$	匹配输入字符串的结束位置

      c.匹配次数

{M,N}	M和N 为非负整数，其中M<=N 表示前面的匹配M~N次
{M，}	表示需要匹配M次 以上
{，N}	等价于{0~N}
{N}	表示需要匹配N次
*	匹配前面的子表达式零次或多次，等价于{0，}
+	匹配前面的子表达式一次或多次，等价于{1，}
?	匹配前面的子表达式零次或一次，等价于{0,1}

注：*？、+？、{n,m}? 贪婪与懒惰

 　　d.子组匹配

　　　 [ ]  : 字符类，将要匹配的一类字符集放在[]里面

[ . ? * ( ) {} ]	匹配里面的这些符号
[0-9]	匹配0到9的数字相当于\d
[^\d]	匹配除数字以外的字符，相当于\D
[a-z]	匹配所有的小写字母
[^a-z]	匹配非小写字母
|	相当于或（or）分支条件,如A | B 匹配字母A或者B 与[AB]是一样的

　　 e.分组

　　   ()  : 分组，将要匹配的一类字符集放在()组成一个小组

 　　4、代码

 import re

 s= 'gjianengasfasdfjianeng12335748'

 # 搜索字符串，以列表类型返回全部能匹配的子串，结果：['jianeng', 'jianeng']
 a = re.findall('jianeng',s )

 # 在一个字符串中搜索，匹配正则表达式的第一个位置，返回match对象，结果：<_sre.SRE_Match object; span=(1, 8), match='jianeng'>
 a = re.search('jianeng',s)

 # 匹配数字，匹配3次，结果:['123', '357']
 a = re.findall('\d{3}',s)

 # . 匹配除换行符之外的所有的字符，结果:['a', '我', 's', '\t', '+', '=', '_', '#', '$', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's']
 dian = re.findall('.','a我s\t+=_#$dfa\nsdfas')

 # \d    # 匹配0~9的数字，结果：['1', '2', '3']
 d = re.findall('\d','abc123')

 # \s    # 匹配任意的空白符，包括空格，制表符(Tab)，换行符等，结果;['\n', '\t', ' ']
 s = re.findall('\s','abc\nbb\tsadf sdf' )

 # \w    # 匹配字母或数字或下划线或汉字等,结果:['a', 's', 'd', '_', '4', '5', '6', '我', 'i']
 w = re.findall('\w','asd_456我i')

 # \b    # 表示单词的边界,结果:['read']
 b = re.findall(r'read\b','read readapple')

 # \.    # 表示匹配点号本身,结果:['.', '.']
 dian  = re.findall(r'\.','asdf.as.d')

 #\D、\S、\W、\B    # 是与小写的相反的作用,结果:['a', 'p', 'p', 'l', 'e']
 D= re.findall(r'\D','a123pple')
 # 结果:['a', 'b', 'c', 'b', 'b', 's', 'a', 'd', 'f', 's', 'd', 'f']
 S = re.findall('\S','abc\nbb\tsadf sdf' )
 # 结果:<_sre.SRE_Match object; span=(5, 9), match='read'>
 b = re.search(r'read\B','read readapple')

 # ^     # 脱字符，匹配输入字符串的开始的位置,结果:<_sre.SRE_Match object; span=(0, 7), match='jianeng'>
 t = re.search('^jianeng','jianengsadfsjianeng')

 # $     # 匹配输入字符串的结束位置,结果:<_sre.SRE_Match object; span=(12, 19), match='jianeng'>
 t = re.search('jianeng$','jianengsadfsjianeng')

 # {N}   # 匹配次数,结果:['123', '345', '345']
 c = re.findall('\d{3}','89ahs123gvbsd34534566')

 # {M,N} #其中M<=N 表示前面的匹配M~N次,结果:['89', '123', '34534', '566']
 c = re.findall('\d{2,5}','89ahs123gvbsd34534566')

 #{ M，}  # 表示需要匹配M次以上,结果:['89', '123', '34534566']
 c = re.findall('\d{2,}','89ahs123gvbsd34534566')

 # {，N}  # 等价于{0~N},结果:['89', '', '', '', '1', '', '']
 c = re.findall('\d{,2}','89ahs1s')

 #  *    # 匹配前面的子表达式零次或多次，等价于{0，},结果:['', '', '', '1525', '', '', '', '', '455', '']
 x = re.findall( '\d*','fds1525sdfg455' )

 #  +    # 匹配前面的子表达式一次或多次，等价于{1，},结果:['1525', '4554585444444545165854444444']
 x = re.findall( '\d+','fds1525sdfg4554585444444545165854444444' )

 #  ?    # 匹配前面的子表达式零次或一次，等价于{0,1},结果:['amount at about']['', '', '', '1', '5', '2', '5', '', '', '', '', '4', '5', '5', '']
 x = re.findall( '\d?','fds1525sdfg455' )

 # 注：*？、+？、{n,m}?  贪婪与懒惰
 # 贪婪  满足要求，选最大的,结果:['amount at about']
 tan = re.findall('a.*t','amount at about')

 # 懒惰  满足要求，就结束,结果:['amount', 'at', 'about']
 lan = re.findall('a.*?t','amount at about')

 #  子组匹配
 #  [ ]  # 字符类，将要匹配的一类字符集放在[]里面
 #  结果:['f', 's', 'a', 'd', 'f', '4', '4', '5', '6', '5', '5', '4', '3', '5']
 zi = re.findall('[a-z0-9]','fsadf44565_5435')
 #   a | b| c ,结果:['a', 'b', 'c']
 zi = re.findall('[abc]','fsadf44565_543b5c')

 # [ . ? * ( ) {} ]    # 匹配里面的这些符号,结果:['.', '?', '*', '(', ')', '{', '}']
 zi = re.findall( '[.?*(){}]','.?*(){}')

 # [^\d]    # 取反的意思,结果:['a', 'b', 'c']
 zi = re.findall( '[^\d]','123456abc')

 # |        # 相当于或（or）分支条件,结果:['abc', 'jianeng']
 h = re.findall('abc|jianeng','abcsdfsajianeng')

 # ()       # 分组，将要匹配的一类字符集放在()组成一个小组,结果:<_sre.SRE_Match object; span=(9, 20), match='xxjianengxx'>
 zu = re.search('xx(jianeng)xx','jianengfsxxjianengxxdgffgfxxjianengxxfgf')

 # 要jianeng ，xx(jianeng)xx,结果:['jianeng', 'jianeng']
 zu = re.findall('xx(jianeng)xx','jianengfsxxjianengxxdgffgfxxjianengxxfgf')

 #  re 模块常用方法
 #finditer()   # 搜索字符串，返回一个匹配结果的迭代类型，
               # 每个迭代元素是match对象

 s = 'sjianengsdfasjianeng15sadfjianeng666'
 # 结果:<callable_iterator object at 0x000001D9BC488470>
 finditer = re.finditer('jianeng',s)
 '''
 结果:
 <_sre.SRE_Match object; span=(1, 8), match='jianeng'>
 jianeng
 1
 8
 (1, 8)
 <_sre.SRE_Match object; span=(13, 20), match='jianeng'>
 jianeng
 13
 20
 (13, 20)
 <_sre.SRE_Match object; span=(26, 33), match='jianeng'>
 jianeng
 26
 33
 (26, 33)
 '''
 for i in finditer:
     print(i)
     print(i.group())
     print(i.start())
     print(i.end())
     print(i.span())

 # sub()       # 替换 类似于字符串中 replace() 方法,结果:s666sdfas66615sadfjianeng666
 s2 = re.sub('jianeng','',s,count=2)

 # compile()   # 编译正则表达式为模式对象
 a = re.compile('jianeng')   # a 要匹配jianeng
 dd='fsadfasfjkjianeng'
 b = a.findall(dd) # 结果['jianeng']

 #re.split()   # 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型,结果:['s', 'sdfas', '15sadfjianeng666']
 c = re.split('jianeng',s,maxsplit=2)