常用模块一(os模块序列化模块(json,pickle))

Posted li-li

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了常用模块一(os模块序列化模块(json,pickle))相关的知识,希望对你有一定的参考价值。

一、os模块

       os模块是与操作系统交互的一个接口。

  import os
  # 和文件和文件夹的操作有关
    os.makedirs(dirname1/dirname2)    # 可生成多层递归目录
  os.removedirs(dirname1)    # 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
  os.mkdir(dirname)    # 生成单级目录;相当于shell中mkdir dirname
  os.rmdir(dirname)    # 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
  os.listdir(dirname)    # 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
  os.remove(path)  # 删除一个文件,(不能删除文件夹)
  os.rename("oldname","newname")  # 重命名文件/目录
  os.stat(path/filename)  # 获取文件/目录信息


  # 和执行操作系统命令有关
   os.system("bash command")  # 运行shell命令,直接显示(即使用python语言
  直接执行操作系统命令,更适用于有运维功底的python开发人员)
  os.popen("bash command").read() # 运行shell命令,获取执行结果(即使用python语言
  直接执行操作系统命令,更适用于有运维功底的python开发人员)
  os.getcwd() # 获取当前工作目录,即当前python脚本工作的目录路径(并不是当前文件所在
  目录,而是当前文件是在哪个目录下执行的,而且这个是可以改变的)
  os.chdir("dirname") # 改变当前脚本工作目录;相当于shell下cd   注意:os.system和os.popen是执行字符串数据类型的命令行代码。 # 和路径有关   os.path.abspath(path) # 返回path规范化的绝对路径   os.path.split(path) # 将path分割成目录和文件名按元组返回   os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path)的第一个元素   os.path.basename(path) # 返回path最后的文件名。如果path以/或结尾,那么就会返回空值。即os.path.split(path)的第二个元素   os.path.exists(path) # 如果path存在,返回True;如果path不存在,返回False   os.path.isabs(path) # 如果path是绝对路径,返回True   os.path.isfile(path) # 如果path是一个存在的文件,返回True。否则返回False   os.path.isdir(path) # 如果path是一个存在的目录,则返回True。否则返回False   os.path.join(path1[, path2[, ...]]) # 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略,用法示例如下:   print(os.path.join("E:pythonDemowork", "aaa","bbb","ccc"))   # 结果为:E:pythonDemoworkaaabbccc   os.path.getatime(path) # 返回path所指向的文件或者目录的最后访问时间   os.path.getmtime(path) # 返回path所指向的文件或者目录的最后修改时间   os.path.getsize(path) # 返回path的大小
技术分享图片
    print(os.stat("test16.py"))
    # 结果为:os.stat_result(st_mode=33206,     st_ino=36873221949109263, st_dev=3128153233, st_nlink=1,     st_uid=0, st_gid=0, st_size=758, st_atime=1534846129,     st_mtime=1534846129, st_ctime=1534380128)
    注意:os.stat(path/filename) 获取文件/目录信息  的结构说明,如下示例:
    stat 结构:
    st_mode: inode 保护模式。
    st_ino: inode 节点号。
    st_dev: inode 驻留的设备。
    st_nlink: inode 的链接数。
    st_uid: 所有者的用户ID。
    st_gid: 所有者的组ID。
    st_size: 普通文件以字节为单位的大小;包含等待某些特殊文件的数据。
    st_atime: 上次访问的时间。
    st_mtime: 最后一次修改的时间。
    st_ctime: 由操作系统报告的"ctime"。在某些系统上(如Unix)是最新的元数据更改的时间,在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。
stat 结构
技术分享图片
    os模块的属性:
    os.sep    输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
    os.linesep    输出当前平台使用的行终止符,win下为"	
",Linux下为"
"
    os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
    os.name    输出字符串指示当前使用平台。win->nt,Linux->posix
os模块的属性

os.popen/os.system相关解释:

os模块所做的事情:

  定制了很多方法 间接的帮助你去调用操作系统的命令,获得结果,然后帮助你分析整理成我们需要的数据类型的形态;

我们也可以用os.popen/os.system直接取调用操作系统的命令,获得结果,但是,分析和整理的工作需要我们自己做;

所以,用os模块的方法本身能够完成的功能我们就用定制好的方法就够了,如果有一天,我们发现os模块定制好的功能解决不了我们的问题了,而刚好操作系统的命令能够很好地帮助我们解决问题,这个时候就用os.popen/os.system。

技术分享图片
    注意:os.path.getsize()的参数是一个文件夹的情况
    ret = os.path.getsize(r"E:pythonDemo1-basis")
    ret3 = os.path.getsize(r"E:pythonDemowork")
    print(ret, ret3)  # 结果为:4096 4096
    所有的文件夹,都至少是4096个字节,因为每当创建一个文件夹,就在操作系统上创建一个文件,里边存的是这个文件夹的信息,记录文件名、文件大小、创建时间等等,当一个文件刚刚创建出来的时候,只要放了文件就给分配4096个字节的空间,当用完了4096个字节空间后再存数据时则double即扩大一倍,以此类推,而这个大小不会算在这个文件夹中所有文件总大小中,即不会对这个文件夹中所有文件总大小造成影响。
os.path.getsize()的参数是一个文件夹的情况
  练习题:使用python代码统计一个文件夹中所有文件的总大小
  # 递归
  def func(path):
      size_sum = 0
      name_lst = os.listdir(path)
      for name in name_lst:
          path_abs = os.path.join(path,name)
          if os.path.isdir(path_abs):
              size = func(path_abs)
              size_sum += size
          else:
              size_sum += os.path.getsize(path_abs)
      return size_sum

  ret = func(rE:pythonDemo )
      print(ret)

  # 循环(堆栈思想-列表 满足一个顺序 先进来的后出去)
  lst = [r E:pythonDemo ]  # 列表的第一个目录就是我要统计的目录
  size_sum = 0
  while lst: 
      path = lst.pop()
      path_list = os.listdir(path) 
      for name in path_list: 
          abs_path = os.path.join(path,name)
          if os.path.isdir(abs_path): 
              lst.append(abs_path) 
          else:
              size_sum += os.path.getsize(abs_path)
  print(size_sum)

二、序列化模块

       什么叫序列化—--将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。

       为什么要有序列化模块?

    比如,我们在python代码中计算的一个数据需要给另外一段程序使用,那我们怎么给?现在我们能想到的方法就是存在文件里,然后另一个python程序再从文件里读出来。但是我们都知道,对于文件来说是没有字典这个概念的,所以我们只能将数据转换成字典放到文件中。你一定会问,将字典转换成一个字符串很简单,就是str(dic)就可以办到了,为什么我们还要学习序列化模块呢?没错,序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic),将一个名为dic的字典转换成一个字符串,但是你要怎么把一个字符串转换成字典呢?聪明的你肯定想到了eval(),如果我们将一个字符串类型的字典str_dic传给eval,就会得到一个返回的字典类型了。eval()函数十分强大,但是eval是做什么的?e官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。BUT!强大的函数有代价。安全性是其最大的缺点。想象一下,如果我们从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。而使用eval就要担这个风险。所以,我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)。

  为什么要把其他数据类型转换成字符串?(使用序列化的场景)

    1)能够在网络上传输的只能是bytes,

    2)能够存储在文件里的只有bytes和str

       序列化的目的:

              1)以某种存储形式使自定义对象持久化;

              2)将对象从一个地方传递到另一个地方;

              3)使程序更具维护性;

技术分享图片

1、json模块

         json模块提供了四个功能:序列化(dumps和dump)、反序列化(loads和load)。如下示例:

  import json
  dic = {key : value,key2 : value2}
  ret = json.dumps(dic)  # 序列化
  print(dic,type(dic))   # {‘key‘: ‘value‘, ‘key2‘: ‘value2‘} <class ‘dict‘>
  print(ret,type(ret))   # {"key": "value", "key2": "value2"} <class ‘str‘>

  res = json.loads(ret) # 反序列化
  print(res,type(res))   # {‘key‘: ‘value‘, ‘key2‘: ‘value2‘} <class ‘dict‘>
  # json能够序列化的数据有什么特点,请看下面几个示例,并分析结果:
  # 问题1:字典的key是整型,经过序列化和反序列化变成字符串类型
  # 问题2:字典的value是元组,经过序列化和反序列化变成了列表类型
  dic = {1 : [1,2,3], 2 : (4,5,aa)}
  ret = json.dumps(dic)  # 序列化
  print(dic,type(dic))  # {1: [1, 2, 3], 2: (4, 5, ‘aa‘)} <class ‘dict‘>
  print(ret,type(ret))  # {"1": [1, 2, 3], "2": [4, 5, "aa"]} <class ‘str‘>

  res = json.loads(ret) # 反序列化
  print(res,type(res))  # {‘1‘: [1, 2, 3], ‘2‘: [4, 5, ‘aa‘]} <class ‘dict‘>

  # 问题3:set集合类型不能被json序列化
  # 问题4:字典的键必须是字符串才能被json序列化
  s = {1,2,aaa}
  json.dumps(s)  # 报错:TypeError: Object of type ‘set‘ is not JSON serializable
  json.dumps({(1,2,3):123})   # 报错:TypeError: keys must be a string

  总结:json在所有的语言之间都通用:即json序列化的数据,在python上序列化了,那在java中也可以反序列化,所以json能够处理的数据类型是非常有限的,只有字符串,列表,字典,数字这几种类型,而且字典中的key只能是字符串。

  # 向文件中记录字典
  import json
  dic = {key : value,key2 : value2}
  ret = json.dumps(dic) # 序列化(将序列化结果写入内存,下面从内存中读取写入文件)
  with open(json_file,a) as f:
   f.write(ret)  # 向文件json_file中写入字典{"key": "value", "key2": "value2"}

  # 从文件中读取字典
  with open(json_file,r) as f:
   str_dic = f.read() # 文件中读取后写入内存
  dic = json.loads(str_dic)  # 将内存中的字符串反序列化
  print(dic)  # 将反序列化的结果打印{‘key‘: ‘value‘, ‘key2‘: ‘value2‘}
  # dump和load是直接操作文件的,如下示例:
  dic = {key1 : value1,key2 : value2}
  with open(json_file,a) as f:
      json.dump(dic,f)  # 向文件json_file中写入:{"key1": "value1", "key2": "value2"}

  with open(json_file,r) as f:
      dic = json.load(f)
  print(dic)  # {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}

  总结:如果你是处理和文件相关的(往文件里边写或者从文件里边读),那么可以用dump和load;如果是处理网络上传输的数据时,此时数据都是在内存里,这是就要用dumps和loads。

    # 问题5 不支持连续的存 取
  dic = {key1 : value1,key2 : value2}
  with open(json_file,a) as f:
      json.dump(dic,f)
      json.dump(dic,f)
      json.dump(dic,f)

  with open(json_file,r) as f:
      dic = json.load(f)
  print(dic.keys())

  总结:上面程序中虽然成功通过dump多次向文件中存入3个字典,但是load会报错# 也就是说load只能读取存一个字典的文件,嵌套字典也可以,但最外层只能是一个。

那么现在有个需求:就是想要把一个一个的字典放到文件中,再一个一个的取出来,该怎么实现?如下示例:

  dic = {key1 : value1,key2 : value2}
  with open(json_file,a) as f:
      str_dic = json.dumps(dic)
      f.write(str_dic+
)
      str_dic = json.dumps(dic)
      f.write(str_dic + 
)
      str_dic = json.dumps(dic)
      f.write(str_dic + 
)

  with open(json_file,r) as f:
      for line in f:
          dic = json.loads(line.strip())
          print(dic)
  # 结果为:
  # {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}
  # {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}
  # {‘key1‘: ‘value1‘, ‘key2‘: ‘value2‘}

综上:json的dumps、loads-----在内存中做数据转换:

                     umps 序列化 数据类型 转成 字符串;

          loads 反序列化 字符串 转成 数据类型;

       json的dump、load----直接将数据类型写入文件,直接从文件中读出数据类型:

                     dump 序列化 数据类型 写入 文件 反序列化;

                     load 反序列化 文件中 读出 数据类型;

  json是所有语言都通用的一种序列化格式,只支持列表、字典、字符串、数字,且字典的key必须是字符串。

技术分享图片
    # ensure_ascii 关键字参数
    dic = {key:你好}
    print(json.dumps(dic))  # {"key": "u4f60u597d"}
    print(json.dumps(dic,ensure_ascii=False))  # "key": "你好"}
ensure_ascii 关键字参数
技术分享图片
    # json 的格式化输出
    data = {username:[李华,二愣子],sex:male,age:16}
    json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(,,:),ensure_ascii=False)
    print(json_dic2)
    # 结果为:
    # {
    #     "age":16,
    #     "sex":"male",
    #     "username":[
    #         "李华",
    #         "二愣子"
    #     ]
    # }
json 的格式化输出

2、pickle模块

  pickle模块提供了四个功能:序列化,存(dumps、dump)、反序列化,读(loads、load),此外,pickle模块不仅可以序列化字典,列表...它可以把python中任意的数据类型序列化

  import pickle
  dic = {(1,2,3):{a,b},1:abc}
  ret = pickle.dumps(dic)  # dumps序列化的结果只能是字节
  print(ret)  # 结果为:b‘x80x03}qx00(Kx01Kx02Kx03x87qx01cbuiltins
set
qx02]qx03(Xx01x00
  x00x00aqx04Xx01x00x00x00bqx05ex85qx06Rqx07Kx01Xx03x00x00x00abcqx08u.‘
  print(pickle.loads(ret)) # {(1, 2, 3): {‘b‘, ‘a‘}, 1: ‘abc‘}   # pickle模块的dump、load 的和文件操作   with open(pickle_file,wb) as f:   pickle.dump(dic,f)   with open(pickle_file,rb) as f:   ret = pickle.load(f)   print(ret,type(ret))   # pickle可以多次dump和load   dic = {(1,2,3):{a,b},1:abc}   dic1 = {(1,2,3):{a,b},2:abc}   dic2 = {(1,2,3):{a,b},3:abc}   dic3 = {(1,2,3):{a,b},4:abc}   with open(pickle_file,wb) as f:   pickle.dump(dic, f)   pickle.dump(dic1, f)   pickle.dump(dic2, f)   pickle.dump(dic3, f)   with open(pickle_file,rb) as f:   ret = pickle.load(f)   print(ret,type(ret))   ret = pickle.load(f)   print(ret,type(ret))   ret = pickle.load(f)   print(ret, type(ret))   ret = pickle.load(f)   print(ret, type(ret))   # ret = pickle.load(f) # EOFError: Ran out of input   # print(ret, type(ret)) # dump了4个字典,第5次load会报错   # 结果为:   # {(1, 2, 3): {‘b‘, ‘a‘}, 1: ‘abc‘} <class ‘dict‘>   # {(1, 2, 3): {‘b‘, ‘a‘}, 2: ‘abc‘} <class ‘dict‘>   # {(1, 2, 3): {‘b‘, ‘a‘}, 3: ‘abc‘} <class ‘dict‘>   # {(1, 2, 3): {‘b‘, ‘a‘}, 4: ‘abc‘} <class ‘dict‘> # 改进    with open(pickle_file,rb) as f:   while True:   try: ret = pickle.load(f) print(ret,type(ret)) except EOFError: break

总结:1)pickle序列化支持在python中几乎所有数据类型;

          2)dumps序列化的结果只能是字节;

          3)只能在python中使用;

          4)在和文件操作的时候,需要用rb wb的模式打开文件;

          5)可以多次dump和多次load;

 





以上是关于常用模块一(os模块序列化模块(json,pickle))的主要内容,如果未能解决你的问题,请参考以下文章

python常用模块(模块和包的解释,time模块,sys模块,random模块,os模块,json和pickle序列化模块)

Python进阶----os,sys,hashlib模块

Python——常用模块

os模块,sys模块,json / pickle模块,logging模块

常用模块 os模块 序列化模块

23 模块 os sys pickle json