zoukankan      html  css  js  c++  java
  • day32 Pyhton 模块02复习 序列化

    一. 什么是序列化

    在我们存储数据或者网络传输数据的时候. 需要对我们的对象进行处理. 把对象处理成方便存储和传输的数据格式. 这个过程叫序列化

    不同的序列化, 结果也不同. 但是目的是一样的. 都是为了存储和传输.

      三种序列化的方案:

        1. pickle. 可以将我们python中的任意数据类型转化成bytes并写入到文件中. 同样也可以把文件中写好的bytes转换回我们python的数据. 这个过程被称为反序列化

        2.shelve 简单另类的一种序列化的方案. 有点儿类似后面我们学到的redis. 可以作为一种小型的数据库来使用

        3. json 将python中常见的字典, 列表转化成字符串. 是目前前后端数据交互使用频率最高的一种数据格式.

      二.pickle(重点)

        pickle把python对象写入到文件中的一种解决方法,写入的文件是bytes

    import pickle
    class Cat:
    def __init__(self, name, age):
    self.name = name
    self.age = age
    def catchMouse(self):
    print(self.name, "抓⽼老老⿏鼠")
    c = Cat("jerry", 18)
    bs = pickle.dumps(c) # 序列列化⼀一个对象.
    print(bs) # ⼀一堆⼆二进制. 看不不懂
    cc = pickle.loads(bs) # 把⼆二进制反序列列化成我们的对象
    cc.catchMouse() # 猫依然是猫. 还可以抓⽼老老⿏鼠

        pickle中的dumps可以序列化一个对象,loads可以反序列化一个对象,我们使用dump还可以直接把一个对象写入到文件中

    # f = open("cat", mode="wb")
    # pickle.dump(c, f) # 写⼊入到⽂文件中
    # f.close()
    f = open("cat", mode="rb")
    cc = pickle.load(f) # 从⽂文件中读取对象
    cc.catchMouse()

        pickle还支持多个对象的写出.

    lst = [Cat("jerry", 19), Cat("tommy", 20), Cat("alpha", 21)]
    f = open("cat", mode="wb")
    pickle.dump(lst, f)
    f = open("cat", mode="rb")
    ll = pickle.load(f)
    for el in ll:
    el.catchMouse()

    三.shelve
        shelve提供python的持久化操作. 什什么叫持久化操作呢? 说⽩白话,就是把数据写到硬盘上.在操作shelve的时候非常的像操作一个字典

    import shelve
    shelf = shelve.open("sylar")
    # shelf["jay"] = "周杰伦"
    print(shelf['jay'])
    shelf.close()
    
    s = shelve.open("sylar")
    # s["jay"] = {"name":"周杰伦", "age":18, "hobby":"哄⼩小孩"}
    print(s['jay'])
    s.close()
    s = shelve.open("sylar", writeback=True)
    s['jay']['name'] = "胡辣汤" # 尝试改变字典中的数据
    s.close()
    s = shelve.open("sylar")
    print(s['jay']) # 改变了了.
    s.close()

    writeback=True可以动态的把我们修改的信息写入到文件中. 而且这个鬼东西还可以删除数据. 就像字典一样. 上一波操作

    s = shelve.open("sylar", writeback=True)
    del s['jay']
    s.close()
    s = shelve.open("sylar")
    print(s['jay']) # 报错了了, 没有了了
    s.close()
    s = shelve.open("sylar", writeback=True)
    s['jay'] = "周杰伦"
    s['wlj'] = "王⼒力力宏"
    s.close()
    s = shelve.open("sylar")
    for k in s: # 像字典⼀一样遍历
      print(k)
    print(s.keys()) # 拿到所有key的集合
    for k in s.keys():
      print(k)
    for k, v in s.items(): # 像字典⼀一样操作
      print(k, v)
    s.close()

    四 json(重点)
      json是我们前后端交互的枢纽. 相当于编程界的普通话. 大家沟通都用json. 为什么这样呢? 因为json的语法格式可以完美的表示出⼀一个对象. 那什么是json: json全称javascript object notation. 翻译过来叫js对象简谱.

    wf = {
        "name":"汪峰",
        "age":18,
        "hobby":"上头条",
        "wife":{
            "name":'⼦子怡',
            "age":19,
            "hobby":["唱歌", "跳舞", "演戏"]
        }
    }
    这个不是字典么? 对的. 在python⾥里里这玩意叫字典. 但是在javascript⾥里里这东⻄西叫json. ⼀模⼀样的. 我们发现用这样的数据结构可以完美的表示出任
    何对象. 并且可以完整的把对象表示出来. 只要代码格式比较好. 那可读性也是很强的. 所以大家公认⽤用这样一种数据结构作为数据交互的格式.

    程序产生的字典转化成json格式的json串(字符串). 然后网络传输.

    import json
    dic = {"a": "⼥女女王", "b": "萝莉", "c": "⼩小清新"}
    s = json.dumps(dic) # 把字典转化成json字符串串
    print(s) # {"a": "u5973u738b", "b": "u841du8389", "c":
    "u5c0fu6e05u65b0"}
    import json
    dic = {"a": "女王", "b": "萝莉", "c": "小清新"}
    s = json.dumps(dic, ensure_ascii=False) # 把字典转化成json字符串串
    print(s) # {"a": "女王", "b": "萝莉", "c": "小清新"}

    json也可以像pickle一样把序列化的结果写入到文件中.

    dic = {"a": "⼥女女王", "b": "萝莉", "c": "⼩小清新"}
    f = open("test.json", mode="w", encoding="utf-8")
    json.dump(dic, f, ensure_ascii=False) # 把对象打散成json写⼊入到⽂文件中
    f.close()

    同样也可以从文件中读取一个json

    f = open("test.json", mode="r", encoding="utf-8")
    dic = json.load(f)
    f.close()
    print(dic)

    注意. 我们可以向同一个文件中写入多个json串. 但是读不行

    import json
    lst = [{"a": 1}, {"b": 2}, {"c": 3}]
    f = open("test.json", mode="w", encoding="utf-8")
    for el in lst:
        json.dump(el, f)
    f.close()

    注意, 此时文件中的内容是⼀行内容. {"a": 1}{"b": 2}{"c": 3}

    这在读取的时候是无法正常读取的. 那如何解决呢?

    用dumps和loads. 对每一⾏分别进行处理

    import json
    lst = [{"a": 1}, {"b": 2}, {"c": 3}]
    # 写入
    f = open("test.json", mode="w", encoding="utf-8")
    for el in lst:
        s = json.dumps(el, ensure_ascii=True) + "
    "
        f.write(s)
    f.close()
    # 读取
    f = open("test.json", mode="r", encoding="utf-8")
    for line in f:
        dic = json.loads(line.strip())
        print(dic)
    f.close()

    五.configparser模块
      该模块适用于配置文件的格式与windows ini⽂件类似,可以包含一个或多个节(section)每个节可以有多个参数(键=值)

      首先, 我们先看一个xxx服务器的配置文件

    [DEFAULT]
    ServerAliveInterval = 45
    Compression = yes
    CompressionLevel = 9
    ForwardX11 = yes
    
    [bitbucket.org] User
    = hg
    [topsecret.server.com]
    Port
    = 50022 ForwardX11 = no

    我们用configparser就可以对这样的文件进⾏处理.首先, 是初始化

    import configparser
    config = configparser.ConfigParser()
    config['DEFAULT'] = {
        "sleep": 1000,
        "session-time-out": 30,
        "user-alive": 999999
    }
    config['TEST-DB'] = {
        "db_ip": "192.168.17.189",
        "port": "3306",
        "u_name": "root",
        "u_pwd": "123456"
    }
    config['168-DB'] = {
        "db_ip": "152.163.18.168",
        "port": "3306",
        "u_name": "root",
        "u_pwd": "123456"
    }
    config['173-DB'] = {
        "db_ip": "152.163.18.173",
        "port": "3306",
        "u_name": "root",
        "u_pwd": "123456"
    }
    f = open("db.ini", mode="w")
    config.write(f) # 写⼊入⽂文件
    f.flush()
    f.close()

    读取文件信息:

    config = configparser.ConfigParser()
    config.read("db.ini") # 读取⽂文件
    print(config.sections()) # 获取到section. 章节...DEFAULT是给每个章节都配备的信息
    print(config.get("DEFAULT", "SESSION-TIME-OUT")) # 从xxx章节中读取到xxx信息
    # 也可以像字典⼀一样操作
    print(config["TEST-DB"]['DB_IP'])
    print(config["173-DB"]["db_ip"])
    for k in config['168-DB']:
        print(k)
    for k, v in config["168-DB"].items():
        print(k, v)
    print(config.options('168-DB')) # 同for循环,找到'168-DB'下所有键
    print(config.items('168-DB')) #找到'168-DB'下所有键值对
    print(config.get('168-DB','db_ip')) # 152.163.18.168 get⽅方法Section下的
    key对应的value

    增删改操作:

    # 先读取. 然后修改. 最后写回⽂文件
    config = configparser.ConfigParser()
    config.read("db.ini") # 读取⽂文件
    # 添加⼀一个章节
    # config.add_section("189-DB")
    # config["189-DB"] = {
        # "db_ip": "167.76.22.189",
        # "port": "3306",
        # "u_name": "root",
        # "u_pwd": "123456"
    # }
    # 修改信息
    config.set("168-DB", "db_ip", "10.10.10.168")
    # 删除章节
    config.remove_section("173-DB")
    # 删除元素信息
    config.remove_option("168-DB", "u_name")
    # 写回⽂文件
    config.write(open("db.ini", mode="w"))
  • 相关阅读:
    转:套接字
    转:Socket原理与编程基础
    转:rabbitmq——用户管理
    转:rabbitMQ 安装与管理
    转:window与linux互相拷贝文件
    转:Xming + PuTTY 在Windows下远程Linux主机使用图形界面的程序
    Rabbitmq集群
    VS2010 win7 64位安装后新建项目生成时错误:LINK : fatal error LNK1123: 转换到 COFF 期间失败: 文件无效或损坏
    java连接sqlserver2008
    Java单体应用
  • 原文地址:https://www.cnblogs.com/pythonz/p/10032252.html
Copyright © 2011-2022 走看看