各类模块的粗略总结(time,re,os,sys,序列化,pickle,shelve.#!json )

***collections 扩展数据类型***

***re 正则相关操作 正则 匹配字符串***

***time 时间相关 三种格式:时间戳,格式化时间(字符串),时间元组(结构化时间).
***
```python
#时间戳: timestamp 从1970年1月1日00:00开始按秒计算偏移量.
time.time()

#格式化时间: (Format String) 1992-12-10
%Y-%m-%d_%a %H:%M:S
%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6),星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

#时间元组: (结构化时间)Stack_Time 包含九个元素:年 月 日 时 分 秒 今年第几周 今年的第几天 夏令时
```
```
#时间戳-->时间元组(结构化时间)
time.gmtime(#填时间戳) #UTC时间
time.localtime(#填时间戳) #当地时间

#时间元组-->时间戳
time.mktime(#时间元组)

#时间元组-->字符串
time.strftime(‘格式定义‘,‘时间元组‘) #若不传参数,则显示当前时间
time.strftime("%Y-%m-%d",time.localtime(1500000000))
‘2017-07-14‘

import time
#字符串-->时间元组
#time.strptime(‘时间字符串‘,‘字符串格式‘)
l = time.strptime(‘1992-10-10‘,‘%Y-%m-%d‘)
print(l)
#时间元组-->字符串
# time.strftime(‘格式定义‘,‘时间元组‘) #若不传时间元组,就显示当前时间.
l1 = time.strftime(‘%Y-%m-%d‘)
print(l1)

l2 = time.strftime(‘%Y-%m-%d‘,time.localtime(1500000000))
print(l2)

```

***os 和操作系统有关的***

***sys 和 python 解释器交互的***

***序列化模块 将python 中的数据结构转化成 str.
什么叫序列化? 将原本的字典/列表等内容,转化成一个字符串的过程***

***json json 通用的数据结构 在 python 里表现的是字典和列表***

## json :four_leaf_clover:

用于字符串和python数据类型之间进行转换 , 因为json表示出来就是一个字符串

json模块提供了四个方法

| 方法 | 描述 |
| ----- | ----------------------------- |
| dump | 接收一个文件句柄 , 将原数据类型转换成字符串写入文件 |
| load | 接收一个文件句柄 , 将文件中的字符串转换成原数据类型返回 |
| dumps | 接收一个数据类型 , 将其转换成字符串 |
| loads | 接收一个字符串 , 将其转换成原数据类型 |

dump 和 load 实例

```python
# 导入json模块
import json
# 创建一个文件句柄
f = open(‘json_file‘,‘w‘)
# 创建一个字典
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
# 将字典转换成字符串写入文件
json.dump(dic,f)
# 关闭文件
f.close()
# 创建一个文件句柄
f = open(‘json_file‘)
# 将文件中的字符串读出并转换成原数据类型
dic2 = json.load(f)
# 关闭文件句柄
f.close()
# 打印类型和结果
print(type(dic2),dic2)
# <class ‘dict‘> {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}
```

dumps 和 loads 实例

```python
# 导入json模块
import json
# 创建一个新列表
lst = [‘1‘,‘2‘,‘3‘,‘4‘]
# 将列表转换成字符串,用j_d来接收返回值
j_d = json.dumps(lst)
# 将字符串转换成原数据类型,用j_s来接收返回值
j_s = json.loads(j_d)
# 打印j_d的值以及类型
print(j_d,type(j_d))
# ["1", "2", "3", "4"] <class ‘str‘>
# 打印j_s的值以及类型
print(j_s,type(j_s))
# [‘1‘, ‘2‘, ‘3‘, ‘4‘] <class ‘list‘>
```

loads的特殊情况

```python
# 导入json模块
import json
# 创建一个字符串,内部为一个字典
dic_s = "{‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:3}"
# 将字符串转换成字典
json.loads(dic_s)
# 解释器出现报错
# json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
‘‘‘
报错原因,用json的loads功能时,字符串类型的字典中的字符串必须由 "" 表示
即上面的dic_s应该改为 ‘{"k1":"v1","k2":"v2","k3":3}‘

结论:用json的loads功能时,字符串类型的字典中的字符串必须由 "" 表示
‘‘‘
```

PS : json可用于不同语言之间的数据交换

***pickle 在 python 里专用的,可以对任何数据类型做序列化,结果是 bytes 类型***

***shelve 只提供一个 open 方法,操作有点像字典.***

## pickle :four_leaf_clover:

用于python特有的类型和python的数据类型间进行转换

pickle模块也提供了四个方法 , 与json一样 dumps , dump , loads , load

由于pickle是对于python特有的类型 , 所以 load 和 loads方法不仅支持字典 , 列表 , 它还能把python中任意的数据类型进行序列化

```python
-------dumps和loads--------
# 导入pickle模块
import pickle
# 创建一个字典
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
# 将字典转换成二进制内容
p_d = pickle.dumps(dic)
# 将二进制内容转换成字典
p_l = pickle.loads(p_d)
# 打印p_d
print(p_d)
# b‘\x80\x03}q\x00(X\x02\x00\x00\x00k2q\x01X\x02\x00\x00\x00v2q\x02X\x02\x00\x00\x00k1q\x03X\x02\x00\x00\x00v1q\x04u.‘
# 打印p_d的类型
print(type(p_d))
# <class ‘bytes‘>
# 打印p_l
print(p_l)
# {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}
# 打印p_l的类型
print(type(p_l))
# <class ‘dict‘>
---------dump 和 load---------
# 创建一个文件句柄
f = open(‘pickle_file‘,‘wb‘)
# 写入内容
pickle.dump(‘lyon‘,f)
# 关闭文件
f.close()
# 创建一个文件句柄
f = open(‘pickle_file‘,‘rb‘)
# 读出内容
p_f = pickle.load(f)
# 关闭文件
f.close()
# 打印
print(p_f)
# lyon
```

**但是pickle仅仅只能对python中的数据进行序列化 , 反序列化时其他语言就无法读懂了这是什么了** , 所以我们一般用推荐使用json

## shelve :four_leaf_clover:

shelve也是python提供给我们的序列化工具 , 比pickle用起来简单一些

shelve只提供给我们一个open方法 , 是用key来访问的 , 使用起来和字典类似

```python
# 导入shelve模块
import shelve
# shelve提供open方法
f = shelve.open(‘shelve_file‘)
# 直接对文件句柄进行操作,就可以写入文件中
f[‘key‘] = {‘int‘:10, ‘float‘:9.5, ‘string‘:‘Sample data‘}
# 关闭文件
f.close()
# 打开文件
f1 = shelve.open(‘shelve_file‘)
# 直接用key取值,key不存在就报错
existing = f1[‘key‘]
# 关闭文件
f1.close()
# 打印结果
print(existing)
# {‘float‘: 9.5, ‘int‘: 10, ‘string‘: ‘Sample data‘}
```

shelve不支持多个应用同时往一个数据库进行操作 , 所以当我们知道我们的应用如果只进行操作 , 我们可以设置shelve.open() 方法的参数来进行

shelve.open(filename, flag=‘c‘, protocol=None, writeback=False)

```python
import shelve
# flag参数为设置操作模式,r 设置只读模式
f = shelve.open(‘shelve_file‘, flag=‘r‘)
existing = f[‘key‘]
f.close()
print(existing)
```

` writeback `参数 , 可以减少我们出错的概率 , 并且让对象的持久化对用户更加的透明了 ; 但这种方式并不是所有的情况下都需要 , 首先 , 使用writeback以后 , shelf在open()的时候会增加额外的内存消耗 , 并且当数据库在close()的时候会将缓存中的每一个对象都写入到数据库 , 这也会带来额外的等待时间 , 因为shelve没有办法知道缓存中哪些对象修改了 , 哪些对象没有修改 , 因此所有的对象都会被写入

```python
import shelve
f1 = shelve.open(‘shelve_file‘)
print(f1[‘key‘])
f1[‘key‘][‘new_value‘] = ‘this was not here before‘
f1.close()
# 设置writeback
f2 = shelve.open(‘shelve_file‘, writeback=True)
print(f2[‘key‘])
f2[‘key‘][‘new_value‘] = ‘this was not here before‘
f2.close()
```

时间: 2024-10-01 04:34:22

各类模块的粗略总结(time,re,os,sys,序列化,pickle,shelve.#!json )的相关文章

6 - 常用模块(os,sys,time&amp;datetime,random,json&amp;picle,shelve,hashlib)

导入模块 想使用 Python 源文件,只需在另一个源文件里执行 import 语句 import module1[, module2[,... moduleN] from语句让你从模块中导入一个指定的部分到当前命名空间中 from modname import name1[, name2[, ... nameN]] 内置的函数 dir() 可以找到模块内定义的所有名称.以一个字符串列表的形式返回 >>> import sys >>> dir(sys) ['__disp

什么是序列化, pickle, shelve(春节再整理), json, configparser(春节再整理)模块

一序列化. 二.pickle模块. 三.json模块. 一.序列化. 什么是序列化:在我们存储数据或网络传输数据的时候,需要对我们的对象进行处理,把对象处理成方便存储和传输的数据格式,这个过程叫序列化,不同的序列化,结果也不同,但是目的是一样的,都是为了存储和传输. 在python 中有三种序列化方案:1.pickle   2.shelve  3.json 二.pickle模块. pickle 模块把我们的python对象变成bytes写入到文件中,所以着东西不是给人看的,给机器看的. pick

python os,sys,logging模块的使用

os模块 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作目录:相当于shell下cd os.curdir 返回当前目录: ('.') os.pardir 获取当前目录的父目录字符串名:('..') os.makedirs('dirname1/dirname2') 可生成多层递归目录 os.removedirs('dirname1') 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此

8.模块介绍 time &amp;datetime模块 random os sys shutil json &amp; picle shelve xml处理 yaml处理 configparser hashlib subprocess logging模块 re正则表达式

本节大纲: 模块介绍 time &datetime模块 random os sys shutil json & picle shelve xml处理 yaml处理 configparser hashlib subprocess logging模块 re正则表达式 模块,用一砣代码实现了某个功能的代码集合. 类似于函数式编程和面向过程编程,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合.而对于一个复杂的功能来,可能需要多个函数才能完成(函数又可以在不同的.p

day6 模块time datetime random os sys json pikle

不写容易忘,感觉好多都陌生了,重新补回来 模块:用一坨代码实现了某个功能的代码集合 time & datetime模块 #_*_coding:utf-8_*_ import time import datetime   print(time.clock()) #返回处理器时间,3.3开始已废弃 print(time.process_time()) #返回处理器时间,3.3开始已废弃 print(time.time()) #返回当前系统时间戳 print(time.ctime()) #输出Tue

Python time、datetime、os、random、sys、hashlib、json、shutil、logging、paramiko模块的使用

1.time & datetime模块 #_*_coding:utf-8_*_ import time import datetime print(time.clock()) #返回处理器时间,3.3开始已废弃 print(time.process_time()) #返回处理器时间,3.3开始已废弃 print(time.time()) #返回当前系统时间戳 print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间 print(time.ct

Python中模块之os &amp; sys的功能介绍

os & sys的功能介绍 1. os模块 1. os的变量 path 模块路径 方法:os.path 返回值:module 例如:print(os.path) >>> <module 'ntpath' from 'D:\\python3.5.2\\lib\\ntpath.py'> #返回posixpath和netpath两个模块中任意一个模块 name 模块名 方法:os.name 返回值:str 例如:print(os.name) >>> nt

python 常用模块 time random os模块 sys模块 json &amp; pickle shelve模块 xml模块 configparser hashlib subprocess logging re正则

python 常用模块 time random os模块 sys模块 json & pickle shelve模块 xml模块 configparser hashlib  subprocess logging re正则 转自老男孩老师Yuan:http://www.cnblogs.com/yuanchenqi/articles/5732581.html 模块&包(* * * * *) 模块(modue)的概念: 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,

Python进阶(九)----os,sys,hashlib模块

Python进阶(九)----os,sys,hashlib模块 一丶序列化模块 什么是序列化: ? 将一种数据结构,转换成一个特殊的序列(特殊字符串,用于网络传输,或文件保存) ? 真正的意义:变量从内存中变成可存储或传输的过程称之为序列化 json模块: ? 是所有语言公认的一种序列,最常用,支持的数据结构有限:"list(tuple), int .str ,bool,None,float." ### dumps ,loads : 主要网络传输 , 用于文件的读取. import j