python csv、json、pickle数据持久化

1. csv/json/pickle基本概念

csv:CSV（Comma Separated Values）格式是电子表格和数据库最常见的导入和导出格式。用文本文件形式储存的表格数据,可以使用excel打开，易于阅读，

json:数据交换格式。用于提升网络传输效率，可以字符串和python之间的转换，可用于网页上这种数据传输，支持跨语言

pickle:pickle模块实现了用于对Python对象结构进行序列化和反序列化的二进制协议，人类无法识别
 
在pickle协议和JSON（JavaScript对象表示法）之间存在根本区别：
    JSON是一种文本序列化格式（它输出unicode文本，虽然大多数时候它被编码为utf-8），而pickle是一个二进制序列化格式；
    JSON是人类可读的，而pickle不是；
    JSON是可互操作的，并且在Python生态系统之外广泛使用，而pickle是特定于Python的；
    默认情况下，JSON只能表示Python内建类型的一个子集，并且没有自定义类； pickle可以代表极大数量的Python类型
  （其中许多是通过巧妙地使用Python内省功能自动实现的；复杂的情况可以通过实现specific object APIs来解决）。

2 csv/json/pickle基本使用方法

1. csv

1. csv模块API说明

csv模块的reader和writer对象读取和写入序列。程序员还可以使用DictReader和DictWriter类以字典形式读取和写入数据。
csv模块定义以下函数：
1.csv.reader(csvfile, dialect='excel', **fmtparams)
    1.返回一个读取器对象，它将在给定的csvfile中迭代。csvfile可以是任何支持iterator协议的对象，并且每次调用__next__()方法时返回一个字符串 - file objects和列表对象都是合适的。
    2.如果csvfile是文件对象，则应使用newline=''打开它。如果没有使用newline=""，写到文件中会在每行结束加个\t换行符
2.csv.writer(csvfile, dialect='excel', **fmtparams)
    返回一个writer对象，可以使用writerow(data),writerows(datas)
csv模块定义以下类：
1.class csv.DictReader(csvfile, fieldnames=None, restkey=None, restval=None, dialect='excel', *args, **kwds)
    创建一个对象，其操作类似于普通读取器，但将读取的信息映射到一个dict中，其中的键由可选的fieldnames参数给出。
    fieldnames参数是一个sequence，其元素按顺序与输入数据的字段相关联。这些元素成为结果字典的键。
2.class csv.DictWriter(csvfile, fieldnames, restval='', extrasaction='raise', dialect='excel', *args, **kwds)
    创建一个操作类似于常规writer的对象，但将字典映射到输出行。
    fieldnames参数是一个sequence，用于标识传递给writerow()方法的字典中的值被写入csvfile。
    如果传递给writerow()方法的字典包含fieldnames中未找到的键，则可选的extrasaction参数指示要执行的操作。

2.csv具体代码示例

import csv

# 例一
with open('test.csv', 'w', encoding='utf-8',newline="") as f:
    lst = ['活下去的诀窍是', '保持愚蠢', '又不能知道自己有多蠢']
    writer = csv.writer(f)
    writer.writerows(lst)
    or #使用writerow
    for x in lst:
        writer.writerow(x)
#注意open文件应设置encoding和newline参数
#writer() 通过 writerrow() 或 writerrows() 写入一行或多行数据。

# 例二
with open('test.csv', 'w', encoding='utf-8', newline="") as csvfile:
    fieldnames = ['name', 'age', 'sex']
    d = [{'name': '小明','age': 32,'sex': '男'}, 
        {'name': '小强','age': 12,'sex': '男'},
        {'name': '小蓝','age': 22,'sex': '男'}]
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(d)
#DictWriter() 必须指定参数 fieldnames 说明键名，通过 writeheader() 将键名写入，通过 writerrow() 或 writerrows() 写入一行或多行字典数据。

# 读操作
with open('test.csv', newline='',encoding='utf-8') as csvfile:
    t = csv.reader(csvfile, delimiter=' ')
    for row in t:
        print(t)

with open('test.csv') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        print(row['name'], row['age'])
#DictReader() 返回有序字典，使得数据可通过字典的形式访问，键名由参数 fieldnames 指定，默认为读取的第一行。

2. json简单使用介绍

1. json模块API说明

python转换json
json.dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
    1.将obj序列化为fp,json模块总是产生str对象，而不是bytes对象。因此，fp.write()必须支持str输入。
    2.如果 skipkeys 的值为 true (默认为: False), 那么不是基本类型 (str, int, float, bool, None)的字典键将会被跳过, 而不是引发一个 TypeError 异常.
    3.如果indent是非负整数或字符串，缩进
    4.separator = (item_separator， key_separator),默认(',',':')
    5.sort_keys为真（默认值：False），则字典的输出将按键排序。
    6.遇见复杂的python无法转换时使用default参数,覆盖default()方法以序列化其他类型
json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
    同上用法
json转换python
json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
    1.object_hook是一个可选的函数，它将被任何对象字面值解码（dict）的结果调用。
    2.parse_float（如果指定）将使用要解码的每个JSON浮点的字符串进行调用。
json.loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
    同上用法
对于复杂的结构我们可以自定义解码和编码
class json.JSONDecoder(object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)
class json.JSONEncoder(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

2. json具体使用示例

import json
# 简单编码===========================================
print json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
# ["foo", {"bar": ["baz", null, 1.0, 2]}]

obj = ['foo', {'bar': ('baz', None, 1.0, 2)}]
a= json.dumps(obj)
# 反序列化
print json.loads(a)
# [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]

#字典排序
print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
# {"a": 0, "b": 0, "c": 0}

#自定义分隔符
print json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=(',',':'))
# [1,2,3,{"4":5,"6":7}]
print json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=('/','-'))
# [1/2/3/{"4"-5/"6"-7}]

#增加缩进，增强可读性，但缩进空格会使数据变大
print json.dumps({'4': 5, '6': 7}, sort_keys=True,indent=2, separators=(',', ': '))
# {
#   "4": 5,
#   "6": 7
# }


# 另一个比较有用的dumps参数是skipkeys，默认为False。
# dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，会忽略这个key。
data = {'a':1,(1,2):123}
print json.dumps(data,skipkeys=True)
#{"a": 1}

#将对象序列化并保存到文件
obj1 = ['foo1', {'bar': ('baz', None, 1.0, 2)}]
obj2 = ['foo2', {'bar': ('baz', None, 1.0, 2)}]

with open(r"json.txt","w+") as f:
    json.dump(obj1,f)
    json.dump(obj2,f)

with open(r"json.txt","r") as f:
    print json.load(f)
    print(json.load(f))

3.pickle使用

1.pickle模块API说明

pickle模块实现了用于对Python对象结构进行序列化和反序列化的二进制协议
1.pickle.dump(obj, file, protocol=None, *, fix_imports=True)
    将obj的腌制表示写入打开的file object 文件。这相当于Pickler（文件， 协议）.dump（obj）。
2.pickle.dumps(obj, protocol=None, *, fix_imports=True)
    将对象的腌制表示作为bytes对象返回，而不是将其写入文件。
3.pickle.load(file, *, fix_imports=True, encoding="ASCII", errors="strict")
    从打开的文件对象file读取pickled对象表示形式，并返回其中重新构建的对象层次结构。它等同于Unpickler(file).load()。
4.pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict")
    从bytes对象读取腌制对象层次结构，并返回其中指定的重构对象层次结构。

2.pickle具体示例

import pickle

#序列化操作
d = [ 'person1':{'name':'jack','age':33}, 'person2':{'name':'tom','age':133}]
pk = pickle.dumps(d)


#反序列化操作
src_dic = {"date":date.today(),"oth":([1,"a"],None,True,False),}
det_str = pickle.dumps(src_dic)

#写到文件中，注意使用"wb"
with open('pickle.txt', 'wb') as f:
    d = [{'安其拉': 1, '是否': 2}, {'李白': 12, '分': 22}, {'后羿': 13, 'b': 24}]
    pickle.dump(d, f)
    dd = [{'a': 1, '拉克丝': 2}, {'老子': 12, 'b': 22}, {'a': 13, 'b': 24}]
    pickle.dump(dd, f)

#读取文件"rb"
with open('pickle.txt', 'rb') as f:
    while True:
        try:
            row = pickle.load(f)
            print(row)
        except Exception as e:
            print(e)
            break

3.使用场景

1.pickle主要用于存储计算过数据，保存下来下次使用直接获取，特点是他的读写效率高于一般文件，存储大小也更小
2.json主要用于网络直接传递数据,存储一些结构化数据
3.CSV 通常用于在电子表格软件和纯文本之间交互数据。实际上，CSV 都不算是一个真正的结构化数据，CSV 文件内容仅仅是一些用逗号分隔的原始字符串值。

转载于:https://www.cnblogs.com/lonelyhiker/p/8747776.html