Python语法基础14 pickle与json模块异常处理

最新推荐文章于 2021-07-14 12:07:31 发布

WHFdebook

最新推荐文章于 2021-07-14 12:07:31 发布

阅读量233

点赞数

本文链接：https://blog.csdn.net/qq_45183681/article/details/94472884

版权

将变量从内存变成可存储或者是可传输的这个过程我们称之为序列化。
将变量的内容从序列化的对象中重新读入到内存的过程我们称之为反序列化。

需求：
1.将字典存到demo.txt文件中
2.从demo.txt文件中将字典重新读取

dict1 = {“name”:“韩梅梅”,“age”:19}

print(dict1)

dict1[“age”] = 20

with open(“demo.txt”,“w”,encoding=“utf-8”) as f:

f.write(str(dict1))

with open(“demo.txt”,“r”,encoding=“utf-8”) as f2:
str1 = f2.read()
print(str1)
# print(type(str1))
dict2 = eval(str1)
print(dict2)
print(type(dict2))

class Card:
def init(self, cardnum, password, money, lock=False):
self.cardnum = cardnum
self.password = password
self.money = money
self.lock = lock

def obj2dict(card):
return {“cardnum”:card.cardnum,“password”:card.password,“money”:card.money,“lock”:card.lock}

def dict2obj(d1):
return Card(d1[“cardnum”],d1[“password”],d1[“money”],d1[“lock”])

if name == ‘main’:
card = Card(“101110”,“111”,10000)
# card2 = Card(“101112”,“111”,10000)
# card3 = Card(“101113”,“111”,10000)
# cardlist = [card,card2,card3]
# print(card)
# print(str(card))
‘’’
1.将card对象写入到文件中
2.将对象读取出来，读取出来是Card类型
‘’’
with open(“card.txt”,“w”,encoding=“utf-8”) as f:
# for card in cardlist:
carddict = obj2dict(card)
f.write(str(carddict)+"\n")

with open("card.txt","r",encoding="utf-8") as f2:
    clist = []
    for line in f2.readlines():
        dict1 = eval(line)
        card1 = dict2obj(dict1)
        clist.append(card1)
        # print(card1)
        # print(card1.cardnum)
        # print(card1.money)
print(clist)

import pickle模块

pickle模块可以将任意的对象序列化成二进制的字符串写入到文件中。
还可以从文件中读取并且转为写入时候类型。

pickle.dumps(obj)
功能：将obj进行序列化

pickle.dump(obj,f)
参数一：被序列化的对象
参数二：打开的文件
功能：将obj序列化并且存入到打开的文件中

pickle.loads(bytes)
功能：将二进制的字符串转为对象

pickle.load(f)
功能:将文件中的内容读取并且转为对象

class Card:
def init(self, cardnum, password, money, lock=False):
self.cardnum = cardnum
self.password = password
self.money = money
self.lock = lock

dict1 = {“name”:“韩梅梅”,“age”:19}
card = Card(“101110”, “111”, 10000)
card2 = Card(“101112”, “111”, 10000)
card3 = Card(“101113”, “111”, 10000)
cardlist = [card, card2, card3]

with open(“pickledemo.txt”,“wb”) as f:

# f.write(pickle.dumps(cardlist))

pickle.dump(card2,f)

with open(“pickledemo.txt”,“rb”) as f2:
# obj = pickle.loads(f2.read())
# print(obj)
# print(type(obj))
# print(obj[0].cardnum)
obj = pickle.load(f2)
print(obj)

json模块
json模块提供的方法，可以直接将python基本数据类型序列化为json字符串。
也可以将json字符串转为python的基本数据类型。

json.dumps(obj,default)
obj：被序列化的对象
default：函数，将对象转为字典的函数
功能：将对象序列化为json字符串

json.dump(obj,f,default)
obj：被序列化的对象
f:打开的文件对象
default：函数，将对象转为字典的函数
功能：将对象序列化为json字符串并且写入到打开的文件对象中

json.loads(s,object_hook)
参数一：字符串
参数二：将字典转为对象的函数
功能:将字符串反序列化成对象

json.load(f,object_hook)
参数一：打开的文件对象
参数二：将字典转为对象的函数
功能:将打开的文件对象的内容读取并且反序列化成对象

import json

class Card:
def init(self, cardnum, password, money, lock=False):
self.cardnum = cardnum
self.password = password
self.money = money
self.lock = lock

def obj2dict(card):
return {“cardnum”:card.cardnum,“password”:card.password,“money”:card.money,“lock”:card.lock}

def dict2obj(d1):
return Card(d1[“cardnum”],d1[“password”],d1[“money”],d1[“lock”])

card = Card(“101110”, “111”, 10000)
card2 = Card(“101112”, “111”, 10000)
card3 = Card(“101113”, “111”, 10000)
cardlist = [card, card2, card3]
cardlist2 = {“card1”:card,“card2”:card2,“card3”:card3}
dict1 = {“name”:“韩梅梅”,“age”:19,“sex”:True}

print(json.dumps(dict1))

jstr = json.dumps(card,default=obj2dict)
print(type(jstr))

with open(“jsondemo.txt”,“w”,encoding=“utf-8”) as f:
# jstr = json.dumps(card, default=obj2dict)
# f.write(jstr)
json.dump(cardlist2,f,default=obj2dict)

with open(“jsondemo.txt”,“r”,encoding=“utf-8”) as f2:
# obj = json.loads(f2.read(),object_hook=dict2obj)
# print(obj)
# print(type(obj))
obj = json.load(f2)
print(obj)

csv模块
import csv
from collections import Iterator

def getcsvlist(path,n):
csvlist = []
with open(path,“r”,encoding=“gbk”,errors=“ignore”) as f:
csv_reader = csv.reader(f)
# print(len(list(csv_reader)))
# print(isinstance(csv_reader,Iterator))
for x in range(n):
# print(next(csv_reader))
csvlist.append(next(csv_reader))
return csvlist

# for row in csv_reader:
#     print(row)

‘’’
读取文件中前30条数据
‘’’

if name == ‘main’:
res = getcsvlist(“002.csv”,30)
print(res)

import csv

def writercsv(path1):
with open(path1,“w”,encoding=“gbk”) as f2:
csv_writer = csv.writer(f2)
csv_writer.writerows(getcsvlist(“002.csv”,30))
# for row in reslist:
# csv_writer.writerow(row)

if name == ‘main’:
# d1 = getcsvlist(“002.csv”,30)
writercsv(“003.csv”)

异常处理
语法：
try：
＃有可能发生语句块
except 错误类型1 as e:
#异常处理
except 错误类型2 as e2:
#异常处理2

finally:
#无论代码是否出现异常都会执行此语句块

执行过程：
先执行try下面的语句块，当语句出现异常的时候，会去excpt语句中进行错误匹配，
若匹配上则执行该except下面的语句，若匹配不上的则报错。
无论代码是否出现异常，都会执行finally下面的语句。

在使用异常的捕捉的时候需要注意，它不但可以捕捉该类型的错误，
还可以将其子类一网打尽。

def func(a,b):
try:
res = a/b
except Exception as e:
res = e
return res

if name == ‘main’:
# print(func(1,2))
# print(func(1,0))
print(func(2,0))

# try:
#     print(func(1,"122"))
#     print("hello1")
# except Exception as e:
#     print("e",e)
# finally:
#     print("hello")

# try:
#     print("hello")
# except:
#     pass
#     # with open("user.txt","r",encoding="utf-8") as f:
#     #     print(f.read())
# # except:
# #     print("此文件不存在")
# print("执行下面的内容。。。")

错误调用栈：
若错误没有捕获，则会一直向上抛，直到抛给python解释器，python解释器
打印错误的堆栈信息然后退出。
因此查找错误的时候
第一：先看错误类型
第二：从下往上找［必须是你自己写的模块］

def func1(a,b):
return a/b

def func2(a,b):
return func1(a,b)

def main(a,b):
return func2(a,b)

if name == ‘main’:
print(main(1,2))
print(main(1,0))

记录错误
import logging
import time

def func1(a,b):
return a/b

def func2(a,b):
return func1(a,b)

def main(a,b):
return func2(a,b)

if name == ‘main’:
try:
print(main(1,0))
except Exception as e:
logging.exception(e)
print(“end”)
time.sleep(30)
print(“over”)

异常并不是凭空产生的，捕获的异常其实就是系统定义异常的类的一个实例。
在我们开发的过程中，我们不但可以捕获异常，我们也可自己自定义异常，主动抛出异常
在自定义异常的时候我们需要选好继承关系。
在必要的时候我们才进行自定义错误类型，若python 中存在已有的错误类型，我们
尽量使用python内置的错误类型。

常见的错误类型