一、json
1、导入模块
import json
2、常用方法
dumps:序列化,把一个Python对象转化成json字符串
loads:反序列化,把json字符串转化成python
dump:序列化,把一个Python对象转化成json字符串(针对文件使用)
load:反序列化,把json字符串转化成python(针对文件使用))
3、代码
1 import json
2 user_dict = {
3 'name' :'xiaoming',
4 'age' : 18,
5 'f' : 1.2,
6 'language':('python','java'),
7 'li':[1,2,3,4 ],
8 'kong': None,
9 't' : True,
10 'f' : False
11 }
12
13 # dumps ---- 序列化 ----python字典对象转换为json格式的字符串
14 json_str = json.dumps(user_dict,indent=2,sort_keys=True )
15 print('json_str的值是:',json_str)
16 print('json_str的类型是:',type(json_str)) # json 格式的字符串
17
18 # loads ---- 反序列化 ---- json 格式的字符串转换为python字典对象
19 python_dict = json.loads(json_str)
20 print('python_dict的值是:',python_dict)
21 print('python_dict的类型是:',type(python_dict)) # 字典类型
22
23 # dump ---- 序列化 ----python字典对象转换为json格式的字符串并存入文件(针对文件用)
24 with open('temp.json','w+' ) as f:
25 '''
26 indent:默认为None,单行存储;设置值时,将多行存储
27 sort_keys:默认为False,不排序;设置为True是将根据键名排序
28 ensure_ascii:默认为True,中文将以Unicode形式存储;设置为False时,中文将以中文的形式存储
29 '''
30 json.dump(obj=user_dict,fp=f,indent=2,sort_keys=True,ensure_ascii=False)
31
32 # load ---- 反序列化- 读取文件内容并转换为python字典对象(针对文件用)
33 with open('temp.json','r+' ) as f:
34 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、代码
1 import re
2
3 s= 'gjianengasfasdfjianeng12335748'
4
5 # 搜索字符串,以列表类型返回全部能匹配的子串,结果:['jianeng', 'jianeng']
6 a = re.findall('jianeng',s )
7
8 # 在一个字符串中搜索,匹配正则表达式的第一个位置,返回match对象,结果:<_sre.SRE_Match object; span=(1, 8), match='jianeng'>
9 a = re.search('jianeng',s)
10
11 # 匹配数字,匹配3次,结果:['123', '357']
12 a = re.findall('\d{3}',s)
13
14 # . 匹配除换行符之外的所有的字符,结果:['a', '我', 's', '\t', '+', '=', '_', '#', '$', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's']
15 dian = re.findall('.','a我s\t+=_#$dfa\nsdfas')
16
17 # \d # 匹配0~9的数字,结果:['1', '2', '3']
18 d = re.findall('\d','abc123')
19
20 # \s # 匹配任意的空白符,包括空格,制表符(Tab),换行符等,结果;['\n', '\t', ' ']
21 s = re.findall('\s','abc\nbb\tsadf sdf' )
22
23 # \w # 匹配字母或数字或下划线或汉字等,结果:['a', 's', 'd', '_', '4', '5', '6', '我', 'i']
24 w = re.findall('\w','asd_456我i')
25
26 # \b # 表示单词的边界,结果:['read']
27 b = re.findall(r'read\b','read readapple')
28
29 # \. # 表示匹配点号本身,结果:['.', '.']
30 dian = re.findall(r'\.','asdf.as.d')
31
32 #\D、\S、\W、\B # 是与小写的相反的作用,结果:['a', 'p', 'p', 'l', 'e']
33 D= re.findall(r'\D','a123pple')
34 # 结果:['a', 'b', 'c', 'b', 'b', 's', 'a', 'd', 'f', 's', 'd', 'f']
35 S = re.findall('\S','abc\nbb\tsadf sdf' )
36 # 结果:<_sre.SRE_Match object; span=(5, 9), match='read'>
37 b = re.search(r'read\B','read readapple')
38
39 # ^ # 脱字符,匹配输入字符串的开始的位置,结果:<_sre.SRE_Match object; span=(0, 7), match='jianeng'>
40 t = re.search('^jianeng','jianengsadfsjianeng')
41
42 # $ # 匹配输入字符串的结束位置,结果:<_sre.SRE_Match object; span=(12, 19), match='jianeng'>
43 t = re.search('jianeng$','jianengsadfsjianeng')
44
45 # {N} # 匹配次数,结果:['123', '345', '345']
46 c = re.findall('\d{3}','89ahs123gvbsd34534566')
47
48 # {M,N} #其中M<=N 表示前面的匹配M~N次,结果:['89', '123', '34534', '566']
49 c = re.findall('\d{2,5}','89ahs123gvbsd34534566')
50
51 #{ M,} # 表示需要匹配M次以上,结果:['89', '123', '34534566']
52 c = re.findall('\d{2,}','89ahs123gvbsd34534566')
53
54 # {,N} # 等价于{0~N},结果:['89', '', '', '', '1', '', '']
55 c = re.findall('\d{,2}','89ahs1s')
56
57 # * # 匹配前面的子表达式零次或多次,等价于{0,},结果:['', '', '', '1525', '', '', '', '', '455', '']
58 x = re.findall( '\d*','fds1525sdfg455' )
59
60 # + # 匹配前面的子表达式一次或多次,等价于{1,},结果:['1525', '4554585444444545165854444444']
61 x = re.findall( '\d+','fds1525sdfg4554585444444545165854444444' )
62
63 # ? # 匹配前面的子表达式零次或一次,等价于{0,1},结果:['amount at about']['', '', '', '1', '5', '2', '5', '', '', '', '', '4', '5', '5', '']
64 x = re.findall( '\d?','fds1525sdfg455' )
65
66 # 注:*?、+?、{n,m}? 贪婪与懒惰
67 # 贪婪 满足要求,选最大的,结果:['amount at about']
68 tan = re.findall('a.*t','amount at about')
69
70 # 懒惰 满足要求,就结束,结果:['amount', 'at', 'about']
71 lan = re.findall('a.*?t','amount at about')
72
73 # 子组匹配
74 # [ ] # 字符类,将要匹配的一类字符集放在[]里面
75 # 结果:['f', 's', 'a', 'd', 'f', '4', '4', '5', '6', '5', '5', '4', '3', '5']
76 zi = re.findall('[a-z0-9]','fsadf44565_5435')
77 # a | b| c ,结果:['a', 'b', 'c']
78 zi = re.findall('[abc]','fsadf44565_543b5c')
79
80 # [ . ? * ( ) {} ] # 匹配里面的这些符号,结果:['.', '?', '*', '(', ')', '{', '}']
81 zi = re.findall( '[.?*(){}]','.?*(){}')
82
83 # [^\d] # 取反的意思,结果:['a', 'b', 'c']
84 zi = re.findall( '[^\d]','123456abc')
85
86 # | # 相当于或(or)分支条件,结果:['abc', 'jianeng']
87 h = re.findall('abc|jianeng','abcsdfsajianeng')
88
89 # () # 分组,将要匹配的一类字符集放在()组成一个小组,结果:<_sre.SRE_Match object; span=(9, 20), match='xxjianengxx'>
90 zu = re.search('xx(jianeng)xx','jianengfsxxjianengxxdgffgfxxjianengxxfgf')
91
92 # 要jianeng ,xx(jianeng)xx,结果:['jianeng', 'jianeng']
93 zu = re.findall('xx(jianeng)xx','jianengfsxxjianengxxdgffgfxxjianengxxfgf')
94
95
96 # re 模块常用方法
97 #finditer() # 搜索字符串,返回一个匹配结果的迭代类型,
98 # 每个迭代元素是match对象
99
100 s = 'sjianengsdfasjianeng15sadfjianeng666'
101 # 结果:<callable_iterator object at 0x000001D9BC488470>
102 finditer = re.finditer('jianeng',s)
103 '''
104 结果:
105 <_sre.SRE_Match object; span=(1, 8), match='jianeng'>
106 jianeng
107 1
108 8
109 (1, 8)
110 <_sre.SRE_Match object; span=(13, 20), match='jianeng'>
111 jianeng
112 13
113 20
114 (13, 20)
115 <_sre.SRE_Match object; span=(26, 33), match='jianeng'>
116 jianeng
117 26
118 33
119 (26, 33)
120 '''
121 for i in finditer:
122 print(i)
123 print(i.group())
124 print(i.start())
125 print(i.end())
126 print(i.span())
127
128
129 # sub() # 替换 类似于字符串中 replace() 方法,结果:s666sdfas66615sadfjianeng666
130 s2 = re.sub('jianeng','666',s,count=2)
131
132 # compile() # 编译正则表达式为模式对象
133 a = re.compile('jianeng') # a 要匹配jianeng
134 dd='fsadfasfjkjianeng'
135 b = a.findall(dd) # 结果['jianeng']
136
137 #re.split() # 将一个字符串按照正则表达式匹配结果进行分割,返回列表类型,结果:['s', 'sdfas', '15sadfjianeng666']
138 c = re.split('jianeng',s,maxsplit=2)