#--------------------------按图1转换时间

、localtime([secs])将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

time.localtime()  # time.struct_time(tm_year=2018, tm_mon=9, tm_mday=6, tm_hour=20, tm_min=56, tm_sec=16, tm_wday=3, tm_yday=249, tm_isdst=0)  当前时间

time.localtime(1473525444.037215)    # time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, tm_min=37, tm_sec=24, tm_wday=6, tm_yday=255, tm_isdst=0) 给定时间的格式化时间

、gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

time.gmtime() # 结果 time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=6, tm_min=19,tm_sec=48, tm_wday=3, tm_yday=125, tm_isdst=0)     

3、mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime()))   #1473525749.0

4、strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。
　　　　#如果元组中任何一个元素越界，ValueError的错误将会被抛出。

print(time.strftime("%Y-%m-%d %X", time.localtime())) #2016-09-11 00:49:56
print(time.strftime('%Y--%m--%d %X',))  #2018--09--06 21:04:16

# 5、time.strptime(string[, format]) # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

 print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')) #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, # tm_wday=3, tm_yday=125, tm_isdst=-1) 
#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

总结：

time是datetime的底层模块
    时间戳时间-localtime/gmtime-> 结构化时间 -strftime-> 格式化时间
    时间戳时间<-mktime- 结构化时间 <-strptime- 格式化时间

 time.time() # 获取时间戳

 时间戳 --localtime('时间戳')--> 结构化时间

 结构化时间--mktime('结构化时间')--> 时间戳

 结构化时间--strftime('格式','结构化时间')-->  结构化的字符串  # 可以格式自定义，

 结构化字符串时间 --strptime('结构化时间','格式')--> 结构化时间  # 必须参数一一对应

1、当前年月日的凌晨12点对应的时间戳时间是多少

today =time.strftime('%Y-%m-%d')  # 格式化时间

locals_time=time.strptime(today,'%Y-%m-%d')  #  获取到结构化时间，默认返回凌晨时间

print(time.mktime(locals_time))   # 获取时间戳

today =time.strftime('%Y-%m-%d %X')  # 格式化时间

locals_time=time.strptime(today,'%Y-%m-%d %X')  #  获取到结构化时间，默认返回当前时间

print(time.mktime(locals_time))   # 获取时间戳

print(time.time())

公司内的时间操作

例题：

1、将s时间往前推30天

import time

s = '2019-03-20 10:40:00'

local_time = time.strptime(s,'%Y-%m-%d %X') # 转化成结构化时间

print(local_time) #time.struct_time(tm_year=2019, tm_mon=3, tm_mday=20, tm_hour=10, tm_min=40, tm_sec=0, tm_wday　　　　　　　　　　　　　　=2, tm_yday=79, tm_isdst=-1)

x=time.mktime(local_time)+30 * 86000   # 转化成时间戳

new_time = time.localtime(x) #将时间戳转化为结构化时间

print(new_time)

new_time_local =time.strftime('%Y-%m-%d %X',new_time) # 将结构化时间转化为字符串格式

print(new_time_local)

#准确答案

import datetime

#将当前时间推前30天

print(datetime.datetime.now()-datetime.timedelta(30))

当前推后30天

#--------------------------按图2转换时间

# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。

# 如果没有参数，将会将time.localtime()作为参数传入。

print(time.asctime())#Sun Sep 11 00:43:43 2016

# ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为

# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

print(time.ctime())  # Sun Sep 11 00:46:38 2016

print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

输入某年某月某日,判断是这一年中的第几天?(用内置模块实现)

import time

input_ = input('请输入年月日：')

time_local = time.strptime(input_,'%Y-%m-%d %X')

print(time_local.tm_yday)  # 结构化时间调用里面的参数

结构化时间点功能

#时间加减

import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925，返回当前时间

# print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19

# print(datetime.datetime.now() )

# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天

# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天

# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时

# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

# c_time  = datetime.datetime.now()

# print(c_time.replace(minute=3,hour=2)) #时间替换 2018-09-07 02:03:37.591115 其实就是修改时间

import datetime
t = datetime.datetime.now() # 时间操作符获取对象
print(t.date())   # 就可以访问具体的天数
print(t.time())
print(t.timestamp())  #时间戳
print(t.day)
print(t.month)

from datetime import datetime,timedelta  # 从xx导入 建议

print(datetime.now() - timedelta(3))    # 进行加减天数

timedelta功能

import random

print(random.random()) #(,)----float    大于0且小于1之间的小数

print(random.randint(,))  #[,]    大于等于1且小于等于3之间的整数

print(random.randrange(,)) #[,)    大于等于1且小于3之间的整数

print(random.choice([,'',[,]]))  #1或者23或者[,]，这里可以填字符串，在字符串中随机一个字母　　
print(random.choices([1,'23',[4,5],'3','4'],k=3))  #['4', '23', '23'],随机3个
print(random.sample([,'',[,]],)) #列表元素任意2个组合 print(random.uniform(,)) #大于1小于3的小数，如1. item=[,,,,] random.shuffle(item) #打乱item的顺序,相当于"洗牌" print(item)

例： 验证码生成器：

import random
def make_code(n):
    res = ''
    for i in range(n):
        s1 = chr(random.randint(65,90))  # 生成字母chr
        s2 = str(random.randint(0,9))
        res += random.choice([s1,s2])
    return res
print(make_code(9))   # H53FVG8K4

import os

print(os.getcwd())   # 获取当前工作目录，即当前python脚本工作的目录路径  D:\pycharm code\离校\时间模块

os.chdir("D:\pycharm code\day2")  # 改变当前脚本工作目录；相当于shell下cd

print(os.getcwd())  # D:\pycharm code\day2 当再一次判断位置时，发生了变化

# print(os.curdir) # .

# print(os.pardir) # ..

# os.makedirs('abc\\alex')  # 在day2（当前工作目录）下生成abc文件，在abc下再生成alex文件

# os.makedirs('dirname1/dirname2')   # 可生成多层递归目录  （已存在的文件名不能再一次生成）

#os.removedirs('dirname1/dirname2')   # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

# os.mkdir('dirname')   # 生成单级目录；相当于shell中mkdir dirname

# os.rmdir('dirname')   # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

#print(os.listdir('.'))   # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印,['abc', '今日大纲', '作业讲解.py']

# os.remove('哈哈哈')  # 删除一个文件

# os.rename("abc","newname") # 重命名文件/目录 旧名字，新名字

print(os.stat('./newname')) # 获取文件目录信息('path/filename')  os.stat_result(st_mode=16895, st_ino=2533274790436658,

　　　　　　# st_dev=2092381065,st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1536304047, st_mtime=1536300456,st_ctime=1536300456)

s = os.stat('./newname')

print(s.st_size)   # 可打印文件大小

print(os.sep)   # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

s=os.linesep     # 输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n",Mac下为 '\r'

print('c,jjj%s'%s,end=' ')

print('哈哈')

print(os.pathsep)    # 输出用于分割文件路径的字符串 win下为;,Linux下为:

print(os.name)    # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

#os.system("ping www.baidu.com -t")  # 运行shell命令，直接显示,cmd窗口

# print(os.environ)  # 获取系统环境变量

# print(os.path.abspath('D:\BaiduNetdiskDownload'))  # 返回path规范化的绝对路径

print(os.path.split('D:\BaiduNetdiskDownload'))  # 将path分割成目录和文件名二元组返回 ('D:\\', 'BaiduNetdiskDownload')

print(os.path.dirname('D:\BaiduNetdiskDownload'))  # 返回path的目录。其实就是os.path.split(path)的第一个元素 D:\

print(os.path.basename('D:\BaiduNetdiskDownload'))  # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。

# 即os.path.split(path)的第二个元素 BaiduNetdiskDownload

print(os.path.exists('D:\BaiduNetdiskDownload')) # 如果path存在，返回True；如果path不存在，返回False  True

print(os.path.isabs('D:\BaiduNetdiskDownload'))  # 如果path是绝对路径，返回True True

print(os.path.isfile('D:\BaiduNetdiskDownload'))  # 如果path是一个存在的文件，返回True。否则返回False  False

print(os.path.isdir('D:\BaiduNetdiskDownload'))  # 如果path是一个存在的目录，则返回True。否则返回False  True

#os.path.join(path1[, path2[, ...]])  # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

print(os.path.join('/my/','name/is/','vampire_techking'))  # /my/name/is/vampire_techking，注意这里的第二个参数不能以/开头

print(os.path.getatime('D:\BaiduNetdiskDownload'))  # 返回path所指向的文件或者目录的最后存取时间 1536305083.0908828

print(os.path.getmtime('D:\BaiduNetdiskDownload'))  # 返回path所指向的文件或者目录的最后修改时间

print(os.path.getsize('D:\BaiduNetdiskDownload'))  # 返回path的大小 

os.path.abspath(path) #返回绝对路径

os.path.basename(path) #返回文件名

os.path.commonprefix(list) #返回list(多个路径)中，所有path共有的最长的路径。

os.path.dirname(path) #返回文件路径

os.path.exists(path)  #路径存在则返回True,路径损坏返回False

os.path.expanduser(path)  #把path中包含的"~"和"~user"转换成用户目录

os.path.expandvars(path)  #根据环境变量的值替换path中包含的”$name”和”${name}”

os.path.getatime(path)  #返回最后一次进入此path的时间。

os.path.getmtime(path)  #返回在此path下最后一次修改的时间。

os.path.getctime(path)  #返回path的大小

os.path.getsize(path)  #返回文件大小，如果文件不存在就返回错误

os.path.isabs(path)  #判断是否为绝对路径

os.path.isfile(path)  #判断路径是否为文件

os.path.isdir(path)  #判断路径是否为目录

os.path.islink(path)  #判断路径是否为链接

os.path.ismount(path)  #判断路径是否为挂载点（）

os.path.join(path1[, path2[, ...]])  #把目录和文件名合成一个路径

os.path.normcase(path)  #转换path的大小写和斜杠

os.path.normpath(path)  #规范path字符串形式

os.path.realpath(path)  #返回path的真实路径

os.path.relpath(path[, start])  #从start开始计算相对路径

os.path.samefile(path1, path2)  #判断目录或文件是否相同

os.path.sameopenfile(fp1, fp2)  #判断fp1和fp2是否指向同一文件

os.path.samestat(stat1, stat2)  #判断stat tuple stat1和stat2是否指向同一个文件

os.path.split(path)  #把路径分割成dirname和basename，返回一个元组

os.path.splitdrive(path)   #一般用在windows下，返回驱动器名和路径组成的元组

os.path.splitext(path)  #分割路径，返回路径名和文件扩展名的元组

os.path.splitunc(path)  #把路径分割为加载点与文件

os.path.walk(path, visit, arg)  #遍历path，进入每个目录都调用visit函数，visit函数必须有

3个参数(arg, dirname, names)，dirname表示当前目录的目录名，names代表当前目录下的所有文件名，args则为walk的第三个参数

os.path.supports_unicode_filenames  #设置是否支持unicode路径名

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。

>>> os.path.normcase('c:/windows\\system32\\')

'c:\\windows\\system32\\'   

规范化路径，如..和/

>>> os.path.normpath('c://windows\\System32\\../Temp/')

'c:\\windows\\Temp'   

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'

>>> print(os.path.normpath(a))

/Users/jieli/test1

1、os.walk() 方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。

格式：os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])

top -- 是你所要遍历的目录的地址, 返回的是一个三元组(root,dirs,files)。

    root 所指的是当前正在遍历的这个文件夹的本身的地址

    dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)

    files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)

topdown --可选，为 True，则优先遍历 top 目录，否则优先遍历 top 的子目录            (默认为开启)。如果 topdown 参数为 True，walk 会遍历top文件夹，与top 文件夹中每一个子目录。

onerror -- 可选，需要一个 callable 对象，当 walk 需要异常时，会调用。

followlinks -- 可选，如果为 True，则会遍历目录下的快捷方式(linux 下是软连接 symbolic link )实际所指的目录(默认关闭)，如果为 False，则优先遍历 top 的子目录。

import os

for root, dirs, files in os.walk(".", topdown=False):

    for name in files:

        print(os.path.join(root, name))

    for name in dirs:

        print(os.path.join(root, name))     

运行结果：

./.bash_logout

./amrood.tar.gz

./.emacs

./httpd.conf

./www.tar.gz

./mysql.tar.gz

./test.py

./.bashrc

./.bash_history

./.bash_profile

./tmp

./tmp/test.py

walk函数的使用

import sys

# print(sys.argv)

def updata():

    print('上传！！！')

def download():

    print('download……')

if sys.argv[1] == 'post':

    updata()

elif sys.argv[1] =='download':

    download()

import sys

sys.argv          # 命令行参数List，第一个元素是程序本身路径sys.exit(n)       # 退出程序，正常退出时exit(0)  n 为其他数时，都存在其他异常退出，显示1

print(sys.version)       # 获取Python解释程序的版本信息

# sys.maxint        # 最大的Int值

print(sys.path )      # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 会查找环境变量，当然最开始是从就近的工作文件找sys.path.append()  # 可以添加查找给出的绝对目录，添加到列表中

print(sys.platform)       # 返回操作系统平台名称 # win32 或则 linux

sys.stdout.write('#')   # 向终端打印标准化输出 print就是用这个方法做出来的
sys.moudles                # 是一个全局字典，该字典是python启动后就加载在内存中。每当程序员导入新的模块，sys.modules将自动记录该模块

import sys

import time

import random

def progress(percent, width=50):

    if percent >= 1:

        percent = 1   # 百分比保证100%

    show_str = ('[%%-%ds]'%width)%(int(width*percent)*'#')

    print('\r%s %d%%'%(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

data_size = 1025

recv_size = 0

while recv_size < data_size:

    s = random.random()

    time.sleep(s) # 模拟数据的传输延迟

    recv_size += 50 # 每次收1024

    percent = recv_size/data_size  # 接收的比例

    progress(percent,width=70)import sys

import time

import random

def progress(percent, width=50):

    if percent >= 1:

        percent = 1   # 百分比保证100%

    show_str = ('[%%-%ds]'%width)%(int(width*percent)*'#')

    print('\r%s %d%%'%(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

data_size = 1025

recv_size = 0

while recv_size < data_size:

    s = random.random()

    time.sleep(s) # 模拟数据的传输延迟

    recv_size += 50 # 每次收1024

    percent = recv_size/data_size  # 接收的比例

    progress(percent,width=70)

print()函数的参数如下：

    print(*values, sep=' ', end='\n', file=sys.stdout, flush=False)

1、 *values : 表示要打印的值

    表示任何多个无名参数, 各个值之间用‘,’(逗号隔开)，打印出来各个值之间用空格隔开

2、sep=’ ‘： 表示当输入多个打印的值时，各个值之间分割方式， 默认空格，可以自定义

     例：print('a','m','c',sep='\n')   #  a m c 换行

3、 end=‘\n’**: 控制print中传入值输出完后结束符号，默认换行，这里可以设置为其他，如 ‘\t’, ’ ’ 等等， 可以自己定义

    例：print('python', end=' ')

          print('is good')        # python is good

4、file=sys.stdout：设置输出设备，及把print中的值打印到什么地方，默认输出到准端，可以设置file= 文件储存对象，把内容存到该文件中

    例：f = open(r'a.txt', 'w')

         print('python is good', file=f)

         f.close()

     # 则把python is good保存到 a.txt 文件中  

5、flush=False： 该参数主要是刷新， 默认False，不刷新，Ture时刷新，例如在上面 4 中print中设置: 

　　f = open(r'a.txt', 'w') 
　　print('python is good', file=f, flush=True)  # print到f中的内容先从到内存中，
当文件对象关闭时才把内容输出到 a.txt 中，当flush=True时它会立即把内容刷新存到 a.txt 中

# a发送以一个数据给b，由于发送数据，必须是二进制。所以需要经历编码到解码的过程

dic = {'a':(1,2,3)}

s = str(dic).encode(encoding='utf-8')  # 编码

ret = s.decode(encoding='utf-8')  # 解码

print(ret)  # 查看数据

print(type(ret))  # 查看类型

print(type(eval(ret)))  # 还原为字典  eval将字符串转换为字典

# 结果:

{'a': (1, 2, 3)}

<class 'str'>

<class 'dict'>

使用eval不安全，有可能是病毒，接收方，啪的一些，就执行了。

这个时候，就需要用到序列化了

import json  # 导入模块

dic = {"慕容美雪":(170,60,'赏花')}      # 键必须加双引号

ret = json.dumps(dic)  # 序列化

print(type(dic),dic)  # 查看原始数据类型

print(type(ret),ret)  # 查看序列化后的数据

<class 'dict'> {'慕容美雪': (170, 60, '赏花')}

<class 'str'> {"\u6155\u5bb9\u7f8e\u96ea": [170, 60, "\u8d4f\u82b1"]}

从结果中，可以看出：

原始数据类型是字典，序列化之后，就是字符串类型。而且中文变成了看不懂的字符串。

这是因为json.dumps 序列化时对中文默认使用的ascii编码。

想输出真正的中文需要指定ensure_ascii=False

import json  # 导入模块

dic = {"慕容美雪":(170,60,'赏花')}

ret = json.dumps(dic,ensure_ascii=False)  # 序列化时，不使用ascii码

print(type(dic),dic)  # 查看原始数据类型

print(type(ret),ret)  # 查看序列化后的数据

<class 'dict'> {'慕容美雪': (170, 60, '赏花')}

<class 'str'> {"慕容美雪": [170, 60, "赏花"]}

由于json不识别元组，json认为元组和列表是一回事，所以变成了列表。

在json中，引号，统一使用双引号

import json  # 导入模块

dic = {"慕容美雪":(170,60,'赏花')}

ret = json.dumps(dic,ensure_ascii=False)  # 序列化时，不使用ascii码

res = json.loads(ret)  # 反序列化

print(type(res),res)  # 查看反序列化后的数据

执行输出：

<class 'dict'> {'慕容美雪': [170, 60, '赏花']}

从结果中，可以看出，原来的单引号由还原回来了。

反序列化，比eval要安全。所以eval尽量少用。

dump 将序列化内容写入文件

import json  # 导入模块

dic = {"慕容美雪":(170,60,'赏花')}

f = open('美雪','w',encoding='utf-8')

json.dump(dic,f)  # 先接收要序列化的对象，再接收文件句柄

f.close()

执行程序，查看文件美雪内容为：

{"\u6155\u5bb9\u7f8e\u96ea": [170, 60, "\u8d4f\u82b1"]}

要想文件写入中文，可以加参数ensure_ascii=False

import json  # 导入模块

dic = {"慕容美雪":(170,60,'赏花')}

f = open('美雪','w',encoding='utf-8')

json.dump(dic,f,ensure_ascii=False)  # 先接收要序列化的对象，再接收文件句柄

f.close()

执行程序，再次查看文件内容：

{"慕容美雪": [170, 60, "赏花"]}

load 读取文件中的序列化内容

import json  # 导入模块

dic = {"慕容美雪":(170,60,'赏花')}

f = open('美雪','r',encoding='utf-8')

ret = json.load(f)  #接收文件句柄

print(ret)  # 查看内容

print(type(ret))  # 查看变量类型

f.close()  # 最后记得关闭文件句柄

执行输出：

{'慕容美雪': [170, 60, '赏花']}

<class 'dict'>

import 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":[

        "李华",

        "二愣子"

    ]

}

参数说明：

    Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key

    ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。)

    indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json

    separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(',’,’:’)；这表示dictionary内keys之间用","隔开，而KEY和value之间用"："隔开。

    sort_keys：将数据根据keys的值进行排序。 

import json

dic1 = {"S":(170,60,'唱歌')}

dic2 = {"H":(170,60,'唱歌')}

dic3 = {"E":(170,60,'唱歌')}

f = open('she','a',encoding='utf-8')

f.write(json.dumps(dic1)+'\n')  # 写入一行内容，注意，一定要加换行符

f.write(json.dumps(dic2)+'\n')

f.write(json.dumps(dic3)+'\n')

f.close()  # 关闭文件句柄

执行程序，查看文件she内容：

{"S": [170, 60, "\u5531\u6b4c"]}

{"H": [170, 60, "\u5531\u6b4c"]}

{"E": [170, 60, "\u5531\u6b4c"]}

import json

f = open('she','r',encoding='utf-8')

for i in f:

    print(json.loads(i.strip()))

f.close()

执行输出：

{'S': [170, 60, '唱歌']}

{'H': [170, 60, '唱歌']}

{'E': [170, 60, '唱歌']}

import pickle

dic = {(170,60,'唱歌'):"S"}

print(pickle.dumps(dic))

#执行结果：

b'\x80\x03}q\x00K\xaaK<X\x06\x00\x00\x00\xe5\x94\xb1\xe6\xad\x8cq\x01\x87q\x02X\x01\x00\x00\x00Sq\x03s.'

输出结果是bytes类型的，区别于json

dump写入文件

文件模式必须是带b，因为它是bytes类型、

import pickle

dic = {(170,60,'唱歌'):"S"}

f = open('s','wb') #使用dump必须以+b的形式打开文件,编码不需要指定，因为是bytes类型

pickle.dump(dic,f)

f.close()  # 注意要关闭文件句柄

#执行结果是一堆乱码

import pickle

f = open('s','rb')  # bytes类型不需要指定编码

print(pickle.load(f))

f.close()  # 注意要关闭文件句柄

执行结果：

{(170, 60, '唱歌'): 'S'}

import pickle

dic1 = {"张靓颖":(170,60,'唱歌')}

dic2 = {"张韶涵":(170,60,'唱歌')}

dic3 = {"梁静茹":(170,60,'唱歌')}

f = open('singer','wb')

pickle.dump(dic1,f)

pickle.dump(dic2,f)

pickle.dump(dic3,f)

f.close()

#执行结果是一堆乱码

load 读取文件内容

import pickle

f = open('singer','rb')

print(pickle.load(f))

print(pickle.load(f))

print(pickle.load(f))

print(pickle.load(f))  # 多读取一行，就会报错

f.close()

import pickle

f = open('singer','rb')

while True:

    try:

        print(pickle.load(f))

    except Exception:  # 接收一切错误

        break  # 跳出循环

f.close()

执行结果：

{'张靓颖': (170, 60, '唱歌')}

{'张韶涵': (170, 60, '唱歌')}

{'梁静茹': (170, 60, '唱歌')}

import pickle

class A:

    def __init__(self,name,age):

        self.name=name

        self.age=age

a = A('alex',80)

ret = pickle.dumps(a)  # 序列化对象

print(ret)

obj = pickle.loads(ret)  # 反序列化

print(obj.__dict__)  # 查看对象属性<br>f.close()

执行结果：

b'\x80\x03c__main__\nA\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x04\x00\x00\x00alexq\x04X\x03\x00\x00\x00ageq\x05KPub.'

{'name': 'alex', 'age': 80}

将对象a写入文件：

import pickle

class A:

    def __init__(self,name,age):

        self.name=name

        self.age=age

a = A('alex',80)

f = open('a','wb')

obj = pickle.dump(a,f)

f.close()

执行结果：

也是一堆乱码

import pickle

# class A:

#     def __init__(self,name,age):

#         self.name=name

#         self.age=age

# a = A('alex',80)

f = open('a','rb')

obj = pickle.load(f)

print(obj.__dict__)

f.close()

执行报错

AttributeError: Can't get attribute 'A' on <module '__main__' from 'E:/python_script/day25/test.py'>

提示找不到类A

with shelve.open('spam') as db:

    db['eggs'] = 'eggs'

with语句

# 1.创建一个shelf对象，直接使用open函数即可

import shelve

s = shelve.open('test_shelf.db')         #

try:

    s['kk'] = {'int': 10, 'float': 9.5, 'String': 'Sample data'}

    s['MM'] = [1, 2, 3]

finally:

    s.close()

# 2.如果想要再次访问这个shelf，只需要再次shelve.open()就可以了，然后我们可以像使用字典一样来使用这个shelf

import shelve

try:

    s = shelve.open('test_shelf.db')

    value = s['kk']

    print(value)

finally:

    s.close()

# 3.对shelf对象，增、删、改操作

import shelve

s = shelve.open('test_shelf.db', flag='w', writeback=True)

try:

    # 增加

    s['QQQ'] = 2333

    # 删除

    del s['MM']

    # 修改

    s['kk'] = {'String': 'day day up'}

finally:

    s.close()

# 注意：flag设置为‘r’-只读模式，当程序试图去修改一个以只读方式打开的DB时，将会抛一个访问错误的异常。异常的具体类型取决于anydbm这个模块在创建DB时所选用的DB。异常举例：anydbm.error: need ‘c’ or ‘n’ flag to open new db

# 4.循环遍历shelf对象

import shelve

s = shelve.open('test_shelf.db')

try:

    # 方法一：

    for item in s.items():

        print ('键[{}] = 值[{}]'.format(item[0], s[item[0]]))

    # 方法二：

    for key, value in s.items():

        print(key, value)

finally:

    s.close()

# 5.备注一个错误：

# open中的参数filename，起初认为需要手动新建一个.db，或者.dat的文件，目前电脑中无任何真正的数据库文件，所以采用了新建txt文件，修改后缀的方法创建.db，或者.dat的文件。

# 解释器报错，提示内容为："anydbm.error: db type could not be determined"，

# 原因是是filename已经存在，并且格式与shelve不符，所以提示 “db type could not be determined”。

# 解决方法是，删除该文件。首次运行后会自动生成该filename文件。

# 6.稍微复杂些的案例，实现一个简单提问式的数据库

shelve模块代码示例

import shelve             #存取很方便（可以做一个简单的数据存储方案）

f=shelve.open(r'sheve.txt')

f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}   #存

f['stu2_info']={'name':'gangdan','age':53}

f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])

f.close()

import shelve

d=shelve.open(r'a.txt')                   #生成三个文件分别是：a.txt.bak\a.txt.dat\a.txt.dir

d['tom']={'age':18,'sex':'male'}         #存的时候会生成三个文件，不用管，是python的一种处理机制

print(d['tom']['sex'])                   #可以取出字典中的key对应的value

print(d['tom'])                          #取出tom对应的字典

d.close()

import shelve

d=shelve.open(r'a.txt',writeback=True)    #writeback=True，对子字典修改完后要写回，否则不会看到修改后的结果

d['egon']={'age':18,'sex':'male'}         #存的时候会生成三个文件，不用管，是python的一种处理机制

d['egon']['age']=20                       #将年龄修改为20

print(d['egon']['age'])                   #此时拿到的是修改后的年龄

print(d['egon']['sex'])

d.close()