注意:本篇所讲的文件操作,都是对后缀为.txt、.json文件进行的操作。
1、json其实就是一个文件的格式,像.txt一样,json也是一个纯文本文件。与.txt不同的是,json常用来存放有键值对的数据,写法上像python中的字典一样,但与字典不同的是,字典是一个数据类型,且字典在定义的时候,字典里面的字符串用单引号或者双引号都可以。而json是文件的一种格式。 文件的后缀为:.json 。json文件在编写时候,里面的字符串只能用双引号,否则报错。
2、所谓json字符串,定义的时候,就是在json文件的内容外面加上一对单引号。用print输出它的时候,字符串用的是双引号。
3、json字符串与python中的字典这个数据类型之间的转化:
(1)loads() :将json字符串转换成字典格式。
(2)dumps(): 将字典格式转换成json字符串格式。
技巧:要区分是json字符串还是字典,看print结果中,键值对里的字符串的引号就知道了,如果是双引号,那就是json字符串,如果是单引号那就是字典。
4、with open和open的区别:总的来说,with open就比open少写了一个文件关闭的代码,其它都一样。
with open是open的一种简化的写法,使用with open,不需要写close关闭文件,系统自动就会关文件。而open不行,操作完文件,最后一步一定要写close,否则,代码不会报错,但这个文件会一直占用资源。
#法1
file = open(r"D:\测试\文件读写练习\a.txt", "r")
txt = file.read()
print(txt)
file.close() # 关闭文件,这步一定要写,不写会占用资源
结果:
111
222
333
444
# 法2
with open(r"D:\测试\文件读写练习\a.txt", "r") as f:
txt = f.read()
print(txt)
结果:
111
222
333
444
1、所谓文件就是用来保存数据的,这样数据就可以长期的保存下来,等到以后需要的时候再去用。
2、文件的种类:文本文件和二进制文件。
(1)文本文件:就是可以使用文本编辑软件打开的文件(也可以叫查看),这样的文件就是文本文件。
例如:python的源代码、txt文本文件、json文本文件。这些都能用文本编辑软件打开,比如:用记事本打开。
注意:doc、excel这些不属于文本文件。
这里讲解的文本文件都说的是:以.txt、.py、.json后缀结尾的文本文件。
(2)二进制文件
比如:图片、视频、音频。
这种文件不能用文本编辑软件打开。
第一步:打开文件。——open
第二步:操作文件,比如:读、写、追加写。 ——read、write
读:将文件的内容读入内存。
写:把内容写入文件。
第三步:关闭文件。 ——close
一共一个函数、三个方法。分别是:open函数、read方法、write方法、close方法。
负责打开文件,并返回文件对象。而read、write、close都是通过文件对象来调用。
open打开文件的几种方式:
(1)不加b只打开文本文件
r——只读
w——只写
a——追加写
(2)加b打开二进制文件。
rb——用二进制方式打开,只读
wb——用二进制方式打开,只写
ab——用二进制方式打开,追加写
如果文件存在,正常读取,如果不存在报错。
(1)read()—— 一次性读取文件所有内容。返回的是一个字符串,也就是说,read是把整个文件内容读成一个字符串。然后加载到内存。弊端:如果文件太大,会特别占用内存。因此可以按行读取。
(2)readline()——按行读取文件内容、一次读一行,如果多次调用,就会依次一行一行往下读。每调用一次readline(),内部的文件指针就会向下一行移动,这样,就能实现按行读取了。readline()读到文件末尾,也就是把文件所有内容读完了,就会返回"",里面啥都没有。所以,想看readline()把文件读完没有,可以用if判断readline()返回的内容是不是"",如果是则说明读完了。
(3)readlines()——也是一次性读取文件所有内容、一次性读取文件的所有行,但返回的是一个列表。也就是说,列表中的每一个成员就是文件中的每一行。文件有多少行,列表就有多少成员。当遍历列表时,效果跟用readline 一样。
例如:D盘下,有文件【文件操作练习.txt】内容为:你好Python。现在把它全部读出来。
# 1、打开文件
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8") # r、R把\的转义字符,变成普通字符
# 2、读取文件内容
txt = file.read()
print(txt) # 把读到的内容显示出来、显示文件内容
# 3、关闭文件
file.close()
结果:
你好Python。
注意:无论是读文件还是写文件,只要有汉字,都要加 encoding="utf8",否则显示乱码、报错。
安全起见最好的办法就是无论是什么操作,都加上。
例如:把【hello你好】写到上面那个文件里。
注意:写文件时,如果文件不存在,那就创建,如果存在,w就是覆盖文件内容,a就是追加写,两种方式分别进行演示。
第一种:w覆盖写,写完之后会把原来的内容覆盖掉。
file = open(r"D:\文件操作练习.txt", "w", encoding="utf8") # w覆盖写
file.write("hello你好")
file.close()
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8") # 验证是不是已经写进去了
txt = file.read() # 或者直接把文件打开看
print(txt)
file.close()
结果:
hello你好
第二种:a追加写,在原来内容的后面写。
# 如果文件不存在就创建,如果文件存在就追加,每执行一次就追加一次
file = open(r"D:\文件操作练习.txt", "a", encoding='utf8')
file.write("今天星期一")
file.close()
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8") # 读文件
txt = file.read()
print(txt)
file.close()
结果:
你好Python。今天星期一
如果前面、后面想加换行,就加\n。
例如,在【你好python】后面空一行再写【今天星期一】。
file = open(r"D:\文件操作练习.txt", "a", encoding='utf8')
file.write("\n\n今天星期一") # 两个\n表示空两行再写。
file.close()
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
print(txt)
file.close()
结果:
你好Python。
今天星期一
file.write("\n\n今天星期一") # 两个\n表示空两行再写。就是说,你要写的话是紧跟之前内容后面写,现在,加一个换行,说明敲一个回车,也就是另起一行写,再敲一个回车,那就再另起一行。
例如:另起一行写【今天星期一】。
file = open(r"D:\文件操作练习.txt", "a", encoding='utf8')
file.write("\n今天星期一") # 前面加\n,说明在新的一行写
file.close()
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
print(txt)
file.close()
结果:
你好Python。
今天星期一
思路:先用r方式把【文件操作练习.txt】的内容读出来,因为read读出来是字符串,所以可以用字符串的replace方法进行替换,并将替换后的结果保存到一个变量里,关闭文件,用w方式再次打开那个文件,把变量写进去即可。
例如:把【Python】改为【word】。法1,不加判断。
file = open(R"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
a = txt.replace("Python", "word") # read默认内容读出来是字符串格式
file.close() # 这一步必须关闭
file = open(r"D:\文件操作练习.txt", "w", encoding='utf8')
file.write(a) # 把修改后的a写入文件
file.close()
# 看下改好了没有
file = open(R"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
print(txt)
file.close()
结果:
你好word。
法2 加判断
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
file.close()
if "Python" in txt: # 先判断下有没有,有的话再改
s = txt.replace("Python", "word")
file = open(r"D:\文件操作练习.txt", "w", encoding="utf8")
file.write(s)
file.close()
# 看下改好了没有
file = open(R"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
print(txt)
file.close()
结果:
你好word。
例如:把文件a.txt复制为b.txt。
思路:把a.txt打开,读取里面所有内容,然后用w方式把b.txt打开,把内容写入。
把【文件操作练习.txt】复制到其它位置。比如,这里是把文件复制到同目录下的【文件操作练习1.txt】。如果想复制到其它位置,改路径即可,文件名也可以不用改。
例如,把上一步操作的【你好word。】复制到同目录下的【文件操作练习1.txt】里。
file = open(r"D:\文件操作练习.txt", "r", encoding="utf8")
txt = file.read()
file.close()
file = open(r"D:\文件操作练习1.txt", "w", encoding='utf8')
file.write(txt)
file.close()
# 验证看下复制进去没有
file = open(r"D:\文件操作练习1.txt", "r", encoding="utf8")
txt = file.read()
print(txt)
file.close()
结果:
你好word。
例如,把文件a.txt和b.txt合并为c.txt。
思路:把a.txt内容读出来,存到变量a,把b.txt内容读出来,存到变量b,然后把a+b的结果写入c.txt。
例如:a.txt、b.txt内容分别是:
# a.txt 内容
111
222
333
444
# b.txt 内容
你好
合并到c.txt
file = open(r"D:\测试\文件读写练习\a.txt", "r", encoding="utf8")
a = file.read() # 将a.txt读出来的内容存到变量a
file.close()
file = open(r"D:\测试\文件读写练习\b.txt", "r", encoding="utf8")
b = file.read() # 将b.txt读出来的内容存到变量b
file.close()
file = open(r"D:\测试\文件读写练习\c.txt", "a", encoding='utf8') # 注意a或者w
file.write(a + b) # 因为都是字符串所有可以使用+拼接
file.close()
# 验证写进去没有
file = open(r"D:\测试\文件读写练习\c.txt", "r", encoding="utf8")
txt = file.read()
print(txt)
file.close()
结果:
111
222
333
444你好
注意:如果不是字符串可以分别写入。
file.write(a)
file.write(b)
例如: 通过readline(),来读取a.txt文件的所有内容。
file = open(r"D:\测试\文件读写练习\a.txt", "r", encoding="utf8")
while True: # 因为不知道文件有多少行,所以可以写个人造死循环
txt = file.readline()
if txt == "": # 如果readline已经读取到文件最后,就会读不出来内容了,所以返回的就会是""
break # 使用break来退出这个人造死循环
print(txt, end="")
file.close()
结果:
111
222
333
444
进程已结束,退出代码 0
例如:只显示偶数行的内容。
思路:只读方式打开文件,做一个循环来读取所有行,然后在循环开始的时候做一个计数器,用来判断行数是奇数还是偶数,如果是偶数就输出,如果是奇数就不输出,每执行一次循环,计数器就+1。
file = open(r"D:\测试\文件读写练习\a.txt", "r", encoding="utf8")
index = 1 # 对行数进行计数
while True: # 做一个循环用来读取所有行
txt = file.readline() # 按行读取
if txt == "":
break
if index % 2 == 0:
print(txt, end="")
index += 1
file.close()
结果:
222
444
进程已结束,退出代码 0
例如:读取a.txt。
# a.txt的内容为:
111
222
333
444
file = open(r"D:\测试\文件读写练习\a.txt", "r")
list1 = file.readlines()
print(list1)
file.close()
结果:
['111\n', '222\n', '333\n', '444']
进程已结束,退出代码 0
当然,既然是列表那就可以遍历。那么这样就跟用readline效果一样了。
file = open(r"D:\测试\文件读写练习\a.txt", "r")
list1 = file.readlines()
for i in list1:
print(i, end="")
file.close()
结果:
111
222
333
444
进程已结束,退出代码 0
当一个文件的每一行内容都是整数时候,可以求这个文件的最大值、最小值、最大与最小的差值。
例如:文件a.txt内容如下:求该文件中的最值之间的差值。
111
222
333
444
# 法1,用readline
# 思路:先定义一个空列表,然后循环的一行行读取内容,
# 把每行的内容都转化为int型,添加到空列表里,然后再对这个列表求最值。
file = open(r"D:\测试\文件读写练习\a.txt", "r")
list1 = []
while True:
txt = file.readline() # 按行读取
if txt == "":
break
list1.append(int(txt)) # 把每个成员都转化为整型后添加到空列表里
file.close()
print(max(list1)-min(list1))
结果:
333
# 法2,用readlines————不推荐
# 思路:直接就把所有内容读完,返回列表,再对列表求最值,然后再转化为int
file = open(r"D:\测试\文件读写练习\a.txt", "r")
list1 = file.readlines() # 读取所有内容,返回一个列表,列表的成员是文本文件的每一行内容
print(int(max(list1)) - int(min(list1)))
file.close()
结果:
333
使用法2需要注意的问题:对字符串求最值时候,要注意,这种方法只适用于,字符串的所有成员每个数字都不一样。如果一样,结果就不对了。例如:
d.txt文件内容如下:
1
11
2
23
223
现在要给它求最值。
file = open(r"D:\测试\文件读写练习\d.txt", "r")
list1 = file.readlines()
print(max(list1), end="")
print(type(max(list1)))
print(min(list1), end="")
print(int(max(list1)) - int(min(list1)))
结果:
23
1
22
显然,这个结果不对,因为,从d.txt中可以看到,最大值应该是223,最小值是1,差值是223-1=222,但是这里却给出了23,原因是,首先读取文件之后,列表中的每个成员是字符串类型,而字符串中的数字又有相同的地方。例如23和223,它们在比较大小的时候,是先比较第一个字符,如果相同,就比较第二个字符,哪个字符的ascii码大哪个字符就大,所以这里在比较到第二个字符时,3>2,就会返回23 。
所以不推荐法2 。安全的做法就是像法1一样,先把每个成员转为整型,再求最值。
file = open(r"D:\测试\文件读写练习\d.txt", "r")
list1 = []
while True:
txt = file.readline() # 按行读取
if txt == "":
break
list1.append(int(txt)) # 把每个成员都转化为整型后添加到空列表里
file.close()
print(max(list1) - min(list1))
结果:
222
再比如,更简单的解释。
list1 = [2, 10, 3] # 列表的每个成员是int型
list2 = ["2", "10", "3"] # 列表的每个成员是str型
print(max(list1), min(list1))
print(max(list2), min(list2))
结果:
10 2
3 10
小结:如果长得像数字的字符串进行比较大小的话,比较的原理就是,先比较字符串中的每一个字符,谁的ascii值大谁就大。
解析:
file = open(r"D:\测试\文件读写练习\a.txt", "r")
list1 = file.readlines() # 读取所有内容,返回一个列表,列表的成员是文本文件的每一行内容
print(list1) # ['111\n', '222\n', '333\n', '444']
print(type(list1[0])) # 查看列表第一个成员的数据类型
file.close()
结果:
['111\n', '222\n', '333\n', '444']
# 也就是说,列表中的每个成员都是字符串类型,字符串求最值是根据ascii码。
# 而这里,,我们想求的是整数的最值,所以需要把字符串类型转化为int型。
首先,json其实就是一个文件的格式,像.txt一样,json也是一个纯文本文件。与.txt不同的是,json常用来存放有键值对的数据,写法上像python中的字典一样,但与字典不同的是,字典是一个数据类型,而json是文件的一种格式。 文件的后缀为:.json,除此之外,字典中,字符串可以用单引号或者双引号括起来,而json文件中,字符串只能用双引号。
json全称:JavaScript Object Notation。
json的特点:
(1)它是纯文本文件,常用来定义数据。
(2)具有清晰的层级结构,方便阅读
(1)大括号保存对象,中括号保存数组。(python中叫列表,java里叫数组)。
(2)对象、数组可以相互嵌套。
(3)数据采用键值对表示,多个数据之间用逗号分隔,最后一个数据后面不写逗号。
键值对的值可以是:
(1)数字(int、float)——不用引号。
(2)字符串。——要用双引号引起来,必须是双引号
(3)布尔值true、false,注意必须是小写。
(4)值为空值时,写null——注意是小写。
(5)数组或对象,数组的话写在中括号里,对象的话写在大括号里。
小结:所有数据用大括号括起来,大括号里面写键值对,字符串用双引号,对象用大括号,列表用中括号,数字直接写,对象数组可以相互嵌套。此外,小写的null、小写的true、false。
例如:下面这张图片就是一个json文件。
在Pycharm中,新建—》文件,然后起个文件名.json,回车即可。
第一步:导入json模块。
第二步:打开json文件。
第三步:调用json模块的load方法,进行读取。
第四步:关闭文件。
例如:读取上面的a.json文件。这个案例中的a.json文件跟下面代码的python文件在同一级。
注意:如果俩不在同一级,a.json需要写上绝对或者相对路径,否则找不到这个a.json文件。
import json
file = open("a.json", "r", encoding="utf8") # json中有中文,要指定字符集为utf8
data = json.load(file) # 调用json模块中的load方法,读取文件内容
file.close()
print(data) # 输出内容
print(type(data)) # 查看内容是什么格式
结果:
{'name': '张三', 'age': 30, 'sex': '男', 'isMan': True, 'school': None, 'address': {'city': '上海', 'street': '上海外滩'}, 'luckNumbers': [6, 8], 'call': [{'blog': 'www.xxxx'}, {'tel': '1234'}]}
当然也可以使用with open打开文件,结果也是一样的,只是不用再写关闭文件的那行代码。
import json
with open("a.json", "r", encoding="utf8") as f:
data = json.load(f)
print(data)
结果:
{'name': '张三', 'age': 30, 'sex': '男', 'isMan': True, 'school': None, 'address': {'city': '上海', 'street': '上海外滩'}, 'luckNumbers': [6, 8], 'call': [{'blog': 'www.xxxx'}, {'tel': '1234'}]}
既然读取出来的内容是字典,那么就能对字典进行遍历。
import json
with open("a.json", "r", encoding="utf8") as f:
data = json.load(f)
# print(data)
# print(type(data))
for i in data:
print(i, data[i]) # 遍历键值对,字典可以通过【字典名[键]】的方式来取值。
结果:
name 张三
age 30
sex 男
isMan True
school None
address {'city': '上海', 'street': '上海外滩'}
luckNumbers [6, 8]
call [{'blog': 'www.xxxx'}, {'tel': '1234'}]
第一步:导入json模块。
第二步:用只写的方式打开json文件,注意编码方式是utf8。
第三步:用dump方法把字典写入到json文件里。注意:如果有中文要加ensure_ascii=False表示中文不转义。
第四步:关闭文件。
注意:写的时候只能是w模式,不能是a模式。
例如:
import json
dict1 = {"name": "张三", "age": 18, "sex": "男"}
file = open("data.json", "w", encoding="utf8") # 如果没有data.json将会自动创建,如果有则覆盖(因为是w模式)
json.dump(dict1, file, ensure_ascii=False) # ensure_ascii=False表示中文不转义
file.close()
结果:
进程已结束,退出代码 0
# 法2 用with open
import json
dict1 = {"name": "张三", "age": 18, "sex": "男"}
with open("data.json", "w", encoding="utf8") as f:
json.dump(dict1, f, ensure_ascii=False)
结果同上。
然后看这个同级目录下data.json中有没有写入。结果如下,说明成功写入。
# data.json中的内容
{"name": "张三", "age": 18, "sex": "男"}
注意:json中不能追加写,会报错。
例如:将上面data.json中的年龄改为30岁。
思路:先把内容读出来,读出来的结果是一个字典,然后通过【字典名[键]=值】的方式修改为30,最后再把字典写回到data.json里。
import json
file = open("data.json", "r", encoding="utf8")
txt = json.load(file)
txt["age"] = 30 # 修改字典中键的值
print(txt) # 查看修改后的字典
file.close()
file = open("data.json", "w", encoding="utf8") # w 覆盖写,json中写只能用w
json.dump(txt, file, ensure_ascii=False) # dump语法:dump(字典,写入哪个文件,中文不转义)
file.close()
结果:
{'name': '张三', 'age': 30, 'sex': '男'}
# 用with open写
import json
with open(r"data.json", "r", encoding="utf8") as f:
txt = json.load(f)
txt["age"] = 30
print(txt)
with open(r"data.json", "w", encoding="utf8") as f:
json.dump(txt, f, ensure_ascii=False)
结果同上。
(1)json文件的后缀一定是.json。
(2)json文件中,最后一个键值对后面不加逗号。
(3)如果项目中有json文件,那么新建的python文件起名字时候,一定不能叫json.py。
(1)loads() :将json字符串转换成字典格式。
所谓json字符串,就是在json文件的内容外面加上一对单引号。
(2)dumps(): 将字典格式转换成json字符串格式。
这个就是将python中字典这个数据类型,转化成json字符串。
例如:loads()举例。将json字符串转为字典。
import json
str1 = '{"name":"张三","age":20,"sex":"男"}' # 这是一个json字符串
# str1 = "{'name':'张三','age':20,'sex':'男'}" # 这是一个错误写法!json中的字符串必须用双引号
print(str1)
print(type(str1)) # 查看str1的数据类型
print(json.loads(str1)) # loads将字符串转为字典
print(type(json.loads(str1))) # 查看转化后的数据类型
结果:
{"name":"张三","age":20,"sex":"男"}
{'name': '张三', 'age': 20, 'sex': '男'}
# 注意:json文件中字符串只能用双引号,否则报错。
str1 = "{'name':'张三','age':20,'sex':'男'}" # 这是一个错误写法!json中的字符串必须用双引号
print(str1)
print(type(str1)) # 查看str1的数据类型
print(json.loads(str1)) # loads将字符串转为字典
print(type(json.loads(str1))) # 查看转化后的数据类型
结果:报错!!
{'name':'张三','age':20,'sex':'男'}
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
注意:json中的数据如果是字符串只能用双引号引起来,这是json文件编写的规则,而字符串本身就是要用单引号或者双引号引起来,所有,这里的json字符串只能写成:外面单引号,里面字符串是双引号。
例如:dumps举例。将字典转为json字符串。
import json
# dict1 = {'name': '张三', 'age': 20, 'sex': '男'} # 这是一个字典
# 或写成
dict1 = {"name": "张三", "age": 20, "sex": "男"} # 这也是一个字典
print(dict1)
print(type(dict1))
print(json.dumps(dict1, ensure_ascii=False)) # dumps:将字典转为json字符串
print(type(json.dumps(dict1)))
# 注意:使用dums时,有汉字时,要加ensure_ascii=False,防止汉字被转义
结果:
{'name': '张三', 'age': 20, 'sex': '男'}
{"name": "张三", "age": 20, "sex": "男"}
# 定义一个字典,字典里面的字符串用单引号双引号都可以。
小结:从print结果中可以得出这样一个结论:要区分是json字符串还是字典,看print结果中,键值对中字符串的引号就知道了,如果是双引号,那就是json字符串,如果是单引号那就是字典。
定义的时候:字典里面的字符串用单引号、双引号都可以。
print输出的时候:里面的字符串用的是单引号。(或者说,键值对中的字符串用的是单引号。)
例如:定义一个字典,字典中的字符串,分别用双引号、单引号来进行演示。
法1:字典中的字符串用双引号。
dict1 = {"name": "张三", "age": 20, "性别": "男"} # 定义一个字典
print(type(dict1)) # 查看dict1是什么数据类型
print(dict1) # 输出dict1
结果:
{'name': '张三', 'age': 20, '性别': '男'}
# 定义时候的双引号变成了单引号
法2:字典中的字符串用单引号。
dict1 = {'name': '张三', 'age': 20, '性别': '男'} # 定义一个字典
print(type(dict1))
print(dict1)
结果:
{'name': '张三', 'age': 20, '性别': '男'}
# 定义时候的单引号还是单引号
小结:只要输出来的字符串用的是单引号那就一定是字典。
(1)字符串:就是外面要打单引号或者双引号的东西,就叫字符串。或者说,用引号引起来的就叫字符串。
(2)json文件编写规范:如果数据是字符串类型,那么就要打双引号。
(2)json字符串:既要满足字符串的要求又要满足json文件规范,两者结合的结果就是:
定义的时候:外面用单引号,里面用双引号。
例如:str1 = '{"name": "张三", "age": 20, "性别": "男"}'
print输出的时候:里面的字符串是双引号。(或者说,键值对中的字符串用的是双引号。)
例如:
str1 = '{"name": "张三", "age": 20, "性别": "男"}' # 外面单引号,里面双引号
print(type(str1)) # 字符串都用了双引号,这个才符合json编写规则
print(str1)
结果:
{"name": "张三", "age": 20, "性别": "男"} # 字符串输出是双引号
# 对这个str1转为 字典
import json
str1 = '{"name": "张三", "age": 20, "性别": "男"}'
print(json.loads(str1)) # loads:将json字符串转为字典
print(type(json.loads(str1))) # 查看转化后的数据类型
结果:
{'name': '张三', 'age': 20, '性别': '男'} # 单引号,说明是字典
例如:错误的写法,导致最终结果报错。
str1 = "{'name': '张三', 'age': 20, '性别': '男'}" # 外面双引号,里面单引号
print(type(str1)) # 说明这就不是json文件
print(str1) # 因为json文件在写的时候,要求字符串要用双引号
结果:
{'name': '张三', 'age': 20, '性别': '男'}
# 假如现在要对这个str1转为字典
import json
str1 = "{'name': '张三', 'age': 20, '性别': '男'}"
print(json.loads(str1)) # loads:将字符串转为字典
print(type(json.loads(str1))) # 查看转化后的数据类型
结果:报错!
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
# 因为它都不是json文件,所以也就用不了loads这个方法了。