连串化模块

By admin in 4858.com on 2019年4月21日

一丶random模块

一、time 模块

一、time模块

意味着时间的三种艺术

在Python中,常常有那三种办法来代表时间:时间戳、元组(struct_time)、格式化的大运字符串:

(壹)时间戳(timestamp)
:平常来说,时间戳表示的是从壹97零年十二月二十六日00:00:00初始按秒总结的偏移量。大家运维“type(time.time())”,再次回到的是float类型。

(二)格式化的流年字符串(Format String): ‘19九八-1贰-0陆’

%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 当前时区的名称
%% %号本身

(3)元组(struct_time)
:struct_time元组共有几个因素共多少个要素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

索引(Index) 属性(Attribute) 值(Values)
0 tm_year(年) 比如2011
1 tm_mon(月) 1 – 12
2 tm_mday(日) 1 – 31
3 tm_hour(时) 0 – 23
4 tm_min(分) 0 – 59
5 tm_sec(秒) 0 – 61
6 tm_wday(weekday) 0 – 6(0表示周日)
7 tm_yday(一年中的第几天) 1 – 366
8 tm_isdst(是否是夏令时) 默认为-1

 

 

 

 

 

 

 

 

 

 

 

 首先,大家初步入time模块,来认知一下python中象征时间的二种格式:

#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
          tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)

小结:时间戳是Computer能够识别的时间;时间字符串是人能够看懂的小时;元组则是用来操作时间的

三种格式之间的转变

4858.com 1

#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间,与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳 
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传,则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

4858.com 2

 

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数,直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#%a %d %d %H:%M:%S %Y串 --> 结构化时间
#time.ctime(时间戳)  如果不传参数,直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017'

 

后日内容:

  取随机数的模块

#导入random模块
import random

#取随机小数:
r = random.random()     #取大于零且小于一之间的小数
print(r)    #0.7028485217376959
r = random.uniform(1,2)   #取大于一且小于二之间的小数
print(r)      #1.2376900963409765

#取随机整数
r = random.randint(2,8) #取大于二且小于八之间的整数
print(r)      #7
r = random.randrange(2,8,2) #取大于等于二且小于十之间的整数,每两个取一个
print(r)      #6

#随机选择一个返回
r = random.choice(["a","123",["dasd"],"das"])   #123
print(r)
#随机选择多个返回,返回的个数为函数的第二个参数
r = random.sample(["a","123",["dasd"],"das"],2) #['123', 'a']
print(r)

#打乱列表顺序
item = [1,3,5,7,9]
r = random.shuffle(item)  #只打乱,无返回值
print(r)
print(item)

 

壹、表示时间的两种方法:时间戳、元组(struct_time)、格式化的时刻字符串xxxx

(一)时间戳(timestamp)
:平时来讲,时间戳表示的是从一玖陆七年11月十二日00:00:00从头按秒计算的偏移量。咱们运营“type(time.time())”,重返的是float类型。

(二)格式化的年月字符串(Format String): ‘一玖九九-1二-0陆’

4858.com 34858.com 4

%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 当前时区的名称
%% %号本身

格式化时间标识

 

(3)元组(struct_time)
:struct_time元组共有柒个要素共几个成分:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

索引(Index) 属性(Attribute) 值(Values)
0 tm_year(年) 比如2011
1 tm_mon(月) 1 – 12
2 tm_mday(日) 1 – 31
3 tm_hour(时) 0 – 23
4 tm_min(分) 0 – 59
5 tm_sec(秒) 0 – 61
6 tm_wday(weekday) 0 – 6(0表示周日)
7 tm_yday(一年中的第几天) 1 – 366
8 tm_isdst(是否是夏令时) 默认为-1

 首先,我们初步入time模块,来认知一下python中象征时间的三种格式:

4858.com 54858.com 6

#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
          tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)

二种时光情势的应用

 

二、random模块

>>> import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于3之间的整数


#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回,返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

练习:生成随机验证码

import random
def yzm():
    l1=[str(i) for i in range(10)]
    l2=[chr(i) for i in range(65,91)]
    l3=[chr(i) for i in range(97,123)]
    l1.extend(l2)
    l1.extend(l3)
    l=[random.choice(l1) for i in range(4)]
    return "".join(l)
print(yzm())

#写一个验证码
#首先 要有数字
#其次 要有字母
#一共 4位
#可以重复
# new_num_l = list(map(str,range(10)))  #['0','1'...'9']
# # alph_l = []   #用来存字母
# # for i in range(65,91):
# #     alph = chr(i)
# #     alph_l.append(alph)   #['A'..'Z']
# alph_l = [chr(i) for i in range(65,91)]  #列表推导式
# new_num_l.extend(alph_l)
# # ret_l = []   #存生成的随机数字或字母
# # for i in range(4):
# #     ret_l.append(random.choice(new_num_l))
# ret_l = [random.choice(new_num_l) for i in range(4)]
# #ret_l中有4个元素
# # ret = random.sample(new_num_l,4)
# print(''.join(ret_l))
def myrandom():
    new_num_l = list(map(str,range(10)))
    alph_l = [chr(i) for i in range(65,91)]  #列表推导式
    new_num_l.extend(alph_l)
    ret_l = [random.choice(new_num_l) for i in range(4)]
    return ''.join(ret_l)
print(myrandom())
print(myrandom())

三、os模块

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

'''
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command)  运行shell命令,获取执行结果
os.environ  获取系统环境变量


os.path
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[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
'''

五、sys模块

sys模块是与python解释器交互的一个接口

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

  一.时间模块 (time)

演练题,随机生成大小写数字的验证码

4858.com 74858.com 8

def func(x=6,alpha=True):
    s = ""
    for i in range(x):
        num = str(random.randint(0,9))
        if alpha:
            alpha_upper = chr(random.randint(65,90))
            alpha_lower = chr(random.randint(97, 122))
            num = random.choice([num,alpha_lower,alpha_upper])
        s += num
    return s

print(func(4,alpha=False))
print(func())

验证码

 

2、三种时光格式的相互转换

4858.com 9

4858.com 104858.com 11

#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间,与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳 
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传,则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

三种时光格式的转换

 

4858.com 12

4858.com 134858.com 14

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数,直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#%a %d %d %H:%M:%S %Y串 --> 结构化时间
#time.ctime(时间戳)  如果不传参数,直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017'

View Code

 

陆、系列化模块

何以叫系列化——将原本的字典、列表等剧情调换来八个字符串的长河就称为序列化

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

为什么要有序列化模块

种类化的目标

一、以某种存款和储蓄方式使自定义目的持久化;

二、将目的从三个地点传递到另贰个地点。

三、使程序更具维护性

 

4858.com 15

 

 

 

  2.随机数 (random)

连串化模块。二丶time模块

二、sys模块

 

sys模块是与python解释器交互的3个接口

 

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxsize         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

 

 Json

 Json模块提供了七个成效:dumps、dump、loads、load

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

loads和dumps

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

load和dump

  3.sys模块

  代表时间的二种办法

三、os模块

pickle

 

  4.os模块

    在python中,经常有这三种办法来代表时间:时间戳,元组(struct_time),格式化的光阴字符串:

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

 

4858.com 164858.com 17

'''
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command)  运行shell命令,获取执行结果
os.environ  获取系统环境变量

os.path
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[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

os模块的用法

 

 

留神: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)是创建时间(详细信息参见平台的文档)。

 

 

json & pickle 模块

 

用以体系化的三个模块

 

  • json,用于字符串 和 python数据类型间张开转移
  • pickle,用于python特有的类型 和 python的数据类型间开始展览调换

 

pickle模块提供了八个职能:dumps、dump(系列化,存)、loads(反体系化,读)、load
 (不仅能够体系化字典,列表…可以把python中随便的数据类型连串化

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time.tm_year)

pickle

那儿机智的您又要说了,既然pickle如此强大,为何还要学json呢?
此处大家要证美赞臣(Meadjohnson)下,json是一种具备的言语都足以分辨的数据结构。
假诺我们将一个字典或然种类化成了五个json存在文件里,那么java代码恐怕js代码也得以拿来用。
而是如若大家用pickle举办种类化,别的语言就不能够读懂那是哪些了~
之所以,若是您系列化的始末是列表大概字典,大家非凡推荐您使用json模块
但万1由于某种原因你不得不类别化其余的数据类型,而未来你还会用python对那一个数额实行反种类化的话,那么就足以选拔pickle

  5.系列化模块

      (一)时间戳(timestamp):平时来说,时间戳表示的是从一9陆九年三月二1010日00:00:00上马按秒总结的偏移量.大家运维”type(time.time())”,重回的是float类型.

四、序列化

 

系列化的目标

 

一、以某种存款和储蓄情势使自定义对象持久化;

 

2、将目的从一个地方传递到另一个地点。

 

三、使程序更具维护性。

 

4858.com 18

 shelve

shelve也是python提供给我们的系列化学工业具,比pickle用起来更简便一些。
shelve只提必要大家二个open方法,是用key来访问的,使用起来和字典类似。

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

shelve

那个模块有个限制,它不援助多个利用同权且间往同贰个DB进行写操作。所以当大家知道大家的施用假如只实行读操作,大家得以让shelve通过只读形式展开DB

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

是因为shelve在私下认可意况下是不会记录待持久化对象的其余修改的,所以我们在shelve.open()时候供给修改默许参数,不然对象的修改不会保留。

 

 

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

writeback形式有帮助和益处也有弱点。优点是压缩了大家失误的概率,并且让对象的持久化对用户特别的透明了;但那种方法并不是享有的情况下都亟待,首先,使用writeback未来,shelf在open()的时候会增添额外的内存消耗,并且当DB在close()的时候会将缓存中的每1个目的都写入到DB,那也会推动格外的等候时间。因为shelve未有主意知道缓存中怎样对象修改了,哪些对象未有退换,由此全部的对象都会被写入。

 

1.时间模块(time)

意味着时间的二种方法:

  1.时间戳(timestamp)

  二.格式化的年月字符串(Format String) 

  3.元组(结构化) (struct time)

1.时间戳:

time.sleep()  #使程序滞留一段时间,该时间以 秒 为单位。
time.time()  #时间戳, 即 记录某个时间点

贰.格式化时间字符串的各类参数用法:如下

4858.com 194858.com 20

%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 当前时区的名称
%% %号本身


print(time.strftime('%Y.%m.%d %X'))
print(time.strftime('%Y.%m.%d %x'))
print(time.strftime('%y%m%d %H%M%S '))
print(time.strftime('%y%m%d %I%M%S %a'))
print(time.strftime('%y%m%d %I%M%S %A'))
print(time.strftime('%y%m%d %I%M%S %A %b'))
print(time.strftime('%y%m%d %I%M%S %A %B'))
print(time.strftime('%y%m%d %I%M%S %A %B %c'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %w'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %W'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %W %Z'))




结果:
2017.08.08 18:51:58
2017.08.08 08/08/17
170808 185158 
170808 065158 Tue
170808 065158 Tuesday
170808 065158 Tuesday Aug
170808 065158 Tuesday August
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 2
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 32
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 32 ?D1¨²¡À¨º¡Á?¨º¡À??

View Code

3.元组(结构化):struct_time元组共有九个成分共几个成分:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

4858.com 21

m = time.localtime()   #类似命名元组  用于计算比对。
print(m)
print(m.tm_year)

结果:

time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=18, tm_min=54, tm_sec=21, tm_wday=1, tm_yday=220, tm_isdst=0)
2017

Process finished with exit code 0

 小结:时间戳是Computer能够识其余时间;时间字符串是人能够看懂的大运;元组则是用来操作时间的

两种格式之间的调换:

  1.时间戳(timestamp)

  贰.格式化的年华字符串(Format String) 

  3.元组(结构化) (struct time)

4858.com 22

4858.com 234858.com 24

#时间戳  转  结构化    和      结构化 转  时间戳
print(time.gmtime())   #伦敦时间
print(time.localtime()) #北京时间
s = time.gmtime(1500000000) #时间戳  转  结构化
d = time.localtime(1500000000) #时间戳  转  结构化
print(s)
print(d)
print(time.mktime(s))   #结构化 转  时间戳
print(time.mktime(d))  #结构化 转  时间戳

结果:
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=11, tm_min=26, tm_sec=54, tm_wday=1, tm_yday=220, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=19, tm_min=26, tm_sec=54, tm_wday=1, tm_yday=220, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

1499971200.0
1500000000.0

Process finished with exit code 0

#结构化  转  字符串    和   字符串  转   结构化
print(time.strftime('%Y%m%d %X'))  #结构化转 字符串
print(time.strptime('2017-03-16','%Y-%m-%d'))   #字符串  转   结构化

结果:
20170808 19:29:32
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)

Process finished with exit code 0

View Code

      (2)格式化的岁月字符串(Format String): “19九陆-12-1陆”

4858.com 254858.com 26

%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 当前时区的名称
%% %号本身

python中时间日期格式化符号:

python中时间日期格式化符号:

 

json

4858.com 27

Json模块提供了四个职能:dumps、dump、loads、load

4858.com 284858.com 29

复制代码
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
复制代码

dumps和loads

4858.com 304858.com 31

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

dump和load

 

 

4858.com 32

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

4858.com 33

2.随机数(random)模块:

import random
#随机小数
print(random.random()) #大于0且小于1的小数。
print(random.uniform(1,3)) #大于1小于3的小数

#随机整数
print(random.randint(1,5))  #随机1-5的之间的整数。顾头顾尾
print(random.randrange(10))
print(random.randrange(1,10,2))

#随机选择一个返回
print(random.choice([1,2,3,4,[11,111,1111],'zxc']))

#随机选择多个返回,返回的个数为函数的第二个参数
print(random.sample([1,2,3,4,[5,6,7,8]],2))  #任意返回多个值,后面参数2 是用户之间定义的。

#打乱列表顺序
item = [1,3,5,7,9]
print(item)
random.shuffle(item)
print(item)


结果:
0.8872507582462091
1.3964555681725257
1
3
7
4
[[5, 6, 7, 8], 4]
[1, 3, 5, 7, 9]
[7, 1, 3, 9, 5]

Process finished with exit code 0

1.写一个验证码 1.要有数字, 2,要有字母  3,一共四位  4 可以重复
拿字母,用acsii 码, 拿到后,就转换成字符串。 65-90  97-122。

4858.com 344858.com 35

第一种方法:
def v_code ():
    code = '' \
           ''
    for i in range (4):
        num = random.randint(0,9)
        alf = chr(random.randint(65,90))
        alp = chr(random.randint(97,122))
        add = random.choice([num,alf,alp])
        code = ''.join([code,str(add)])
    return code
print(v_code())


第二种方法:
list1 = list (range(10))
new_list = list(map(str,list1))
alf = list(range(65,91))
alp = list(range(95,123))
alf_l=[]
for i in range (65,91):
    alf = chr(i)
    alf_l.append(alf)
alp_l=[]
for i in range (95,123):
    alp = chr(i)
    alp_l.append(alp)
new_list.extend(alf_l)
new_list.extend(alp_l)
ret = []
ret = random.sample(new_list,4)
print(''.join(ret))

View Code

       (3)元组(strict_time):struct_time元组共有八个成分:(年,月,日,时,分,秒,一年中第几周,一年中第几天,是或不是是夏令时)

索引(index) 属性(Attribute) 值(Values)
0 tm_year(年) 2018
1

tm_mon(月)

1-12
2 tm_mday(日) 1-31
3 tm_hour(时) 0-23
4 tm_min(分) 0-59
5 tm_sec(秒) 0-60
6 tm_wday(deekday) 0-6(0表示周一)
7 tm_yday(一年中的第几天) 1-366
8 tm_isdst(是否是夏令时) 默认为0

pickle

3.OS模块

 

'''
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command)  运行shell命令,获取执行结果
os.environ  获取系统环境变量

os.path
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[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
'''

代表时间的两种格式:

#导入时间模块
import time

# time.sleep(3) #程序走到这儿会等待3s钟

# 时间戳时间   浮点型数据类型,以s为单位
t = time.time()     #1534752249.0591378
print(t)

#格式化时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))  #strftime =  str format time
print(time.strftime('%c'))      #国外时间格式

# 结构化时间
# 时间元组,localtime将一个时间戳转换成当时时区的struct_time
struct_time = time.localtime()  # 北京时间
print(struct_time)
#time.struct_time(tm_year=2018, tm_mon=8, tm_mday=20,
#    tm_hour=16, tm_min=9, tm_sec=8, tm_wday=0, tm_yday=232, tm_isdst=0)

 

json & pickle 模块

 

用于类别化的多少个模块

  • json,用于字符串 和
    python数据类型间举办转变

  • pickle,用于python特有的类型 和 python的数据类型间开始展览转换

 4858.com 36

 

pickle模块提供了四个功用:dumps、dump(系列化,存)、loads(反类别化,读)、load
 (不仅可以种类化字典,列表…能够把python中私自的数据类型连串化

4858.com 374858.com 38

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time.tm_year)

pickle模块

 

Pickle的主题材料和具有别的编制程序语言特有的连串化难点同样,正是它只好用于Python,并且大概两样版本的Python相互都不协作,因而,只可以用Pickle保存那一个不根本的数据,不能够学有所成地反系列化也没涉及。

 

4.sys模块:

sys模块是与python解释器交互的三个接口

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

小结:时间戳是Computer可以识其余时间,时间字符串是人能够看懂的年月,元组则是用来操作时间的

shelve

 shelve模块比pickle模块轻便,唯有3个open函数,重临类似字典的对象,可读可写;key必须为字符串,而值能够是python所扶助的数据类型

4858.com 394858.com 40

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()

shelve模块

 

 

伍.体系化模块:

怎么着叫体系化——将原先的字典、列表等剧情转变到七个字符串的长河就叫做序列化

体系化的目标

1、以某种存款和储蓄格局使自定义目的持久化;

2、将目标从三个地方传递到另2个地方。

三、使程序更具维护性。

4858.com 41

json:

  Json模块提供了多个效益:dumps、dump、loads、load

4858.com 424858.com 43

import json
d = {'k':1}
ret1= json.dumps(d)   #字典转字符串
print(ret1,type(ret1))
ret2= json.loads(ret1)   #字符串转字典
print(ret2,type(ret2))

f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)    #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()
print(dic)

f = open('json_file')
dic2 = json.load(f)   #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

结果:
{"k": 1} <class 'str'>
{'k': 1} <class 'dict'>
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

Process finished with exit code 0

View Code

pickle:

用于种类化的多个模块

4858.com, 

  • json,用于字符串 和 python数据类型间张开转移
  • pickle,用于python特有的类型 和 python的数据类型间张开转移

 

pickle模块提供了四个职能:dumps、dump(系列化,存)、loads(反体系化,读)、load
 (不仅能够类别化字典,列表…能够把python中随机的数据类型体系化

此间大家要验证一下,json是1种具备的言语都足以辨认的数据结构。
若是大家将二个字典或然体系化成了3个json存在文件里,那么java代码只怕js代码也足以拿来用。
唯独一旦大家用pickle进行系列化,其余语言就无法读懂这是哪些了~
据此,要是您种类化的剧情是列表大概字典,我们分外推荐您使用json模块
但万壹出于某种原因你不得不体系化别的的数据类型,而未来你还会用python对这几个数目开始展览反类别化的话,那么就能够动用pickle

shelve:

shelve也是python提要求大家的连串化工具,比pickle用起来更简便一些。
shelve只提要求大家二个open方法,是用key来访问的,使用起来和字典类似。

4858.com 444858.com 45

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

View Code

那一个模块有个限制,它不协理五个应用同一时半刻间往同三个DB举办写操作。所以当大家通晓我们的选择即使只举办读操作,大家能够让shelve通过只读格局伸开DB

4858.com 464858.com 47

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

View Code

出于shelve在暗中认可情形下是不会记录待持久化对象的此外改变的,所以我们在shelve.open()时候必要修改暗中认可参数,不然对象的修改不会保留。

4858.com 484858.com 49

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

View Code

writeback形式有优点也有欠缺。优点是缩减了笔者们失误的票房价值,并且让对象的持久化对用户越来越的透明了;但那种格局并不是怀有的图景下都急需,首先,使用writeback今后,shelf在open()的时候会加多额外的内部存储器消耗,并且当DB在close()的时候会将缓存中的每二个目的都写入到DB,那也会推动非凡的等候时间。因为shelve未有主意知道缓存中哪些对象修改了,哪些对象未有改换,由此全部的目标都会被写入。

 

二种格式之间的退换

4858.com 50

#时间戳时间转换成字符串时间
#获取当前时间戳
t = time.time()
print(t)    #1534753176.4760094
# 时间戳转换成结构化时间
ti = time.localtime(t)
print(ti)
#time.struct_time(tm_year=2018, tm_mon=8, tm_mday=20,
#       tm_hour=16, tm_min=19, tm_sec=36, tm_wday=0, tm_yday=232, tm_isdst=0)
# 结构化时间转换成字符串时间
sti = time.strftime("%Y-%m-%d %H:%M:%S",ti)
print(sti)  #2018-08-20 16:22:06



# 字符串时间转换成时间戳时间
t  = "2018-08-20 16:22:06"
#字符串时间转换成结构化时间
st = time.strptime(t,"%Y-%m-%d %H:%M:%S")
print(st)
#time.struct_time(tm_year=2018, tm_mon=8, tm_mday=20,
#        tm_hour=16, tm_min=22, tm_sec=6, tm_wday=0, tm_yday=232, tm_isdst=-1)
#结构化时间转换成时间戳
ti = time.mktime(st)
print(ti)       #1534753326.0

 

五、random模块

 

4858.com 514858.com 52

>>> import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的整数


#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回,返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

random模块的用法

 

 

验证码示例:

第一种方法
import random
num=list(map(str,range(10)))
# print(num)
word=[]
for i in range(65,90):
    word.append(chr(i))
num.extend(word)
ret=[]
for i in range(4):
    ret.append(random.choice(num))
print(''.join(ret))
进级版
from random import choice,randint   #验证码
L=[choice((str(randint(0,9)),chr(randint(65,90)),chr(randint(95,122))))for i in range(4)]
print(''.join(L))

 

 练习:

4858.com 534858.com 54

import time
ti_old = "2018-8-19 22:10:8"
ti_new = "2018-8-20 16:34:3"
true_time=time.mktime(time.strptime(ti_old,'%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime(ti_new,'%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))
#过去了0年0月0天18小时23分钟55秒

测算时间差

 

 

三丶sys模块

  sys模块时与python解释器交互的多个接口

import sys


print(sys.argv)     #['D:/Learn/day18/1.1.py']  程序本身的路径

for i in range(0,9):
    print(i)    #0
    sys.exit()  #遇到sys.exit()  退出程序,正常退出时exit(0),错误退出sys.exit(1)

print(sys.version)    #获取Python解释程序的版本信息
#3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)]

print(sys.path) #返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
#"C:\Program Files\Python36\python.exe" D:/Learn/day18/1.1.py
#['D:\\Learn\\day18', 'D:\\Learn', 'C:\\Program Files\\Python36\\python36.zip',
# 'C:\\Program Files\\Python36\\DLLs', 'C:\\Program Files\\Python36\\lib',
# 'C:\\Program Files\\Python36', 'C:\\Program Files\\Python36\\lib\\site-packages',
# 'E:\\pycharm\\PyCharm 2018.1.3\\helpers\\pycharm_matplotlib_backend']

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

 sys.argv登入验证:

4858.com 554858.com 56

# sys.argv 登录验证
import sys
name = sys.argv[1]      #sys.argv[0]的内容是文件的路径
password = sys.argv[2]
# print(sys.argv)
if name == 'mark' and password == '123':
    print('登录成功')
else:
    sys.exit()

sys.argv

 在命令行情势下 输入 python + 文件夹的职位 py文件前边可以输入字符串,以空格相隔

 4858.com 57

4858.com 58

 

四丶os模块

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

import os

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

os.system("bash command")  #运行shell命令,直接显示
os.popen("bash command.read()")  #运行shell命令,获取执行结果
os.getcwd() #获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  #改变当前脚本工作目录;相当于shell下cd

 

# os.path
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第二个元素
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[,....]])  #将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  #返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) #返回path的大小

 

 

 

5丶 系列化模块

  什么叫系列化 —–将本来的字典丶列表等内容调换到三个字符串的进程就叫做系列化

  为啥要把别的数据类型转变来字符串呢? 因为能够在网络上传输的只好是bytes,可以存款和储蓄在文书里的也只有bytes和str

  种类化的目标

  一.丶以某种存款和储蓄格局使自定义对象持久化

  二丶将目的从一个地点传递到另1个地方

  三丶使程序更具维护性.

  4858.com 59

 

   1丶json

    json模块提供了八个效益:dumps丶dump丶loads丶load

 dumps和loads是在内部存款和储蓄器中做多少调换

  dumps :将数据类型转成字符串连串化

  loads:字符串转成数据类型 反系列化

 dump和load是平昔将数据类型写入文件,直接从文件中读出数据类型

  dump:数据类型写入文件种类化

  load :文件读出数据类型 反连串化

4858.com 604858.com 61

import json
dic = {'key':'value','key2':'value2'}
ret = json.dumps(dic)   #序列化,将字典转换成字符串
print(dic,type(dic))
print(ret,type(ret))
#注意,json转换完的字符串类型的字典中的字符串是由""表示的
res = json.loads(ret)   #反序列化:将一个字符串格式的字典转换成字典格式
print(res,type(res))

loads和dumps

4858.com 624858.com 63

# dump:
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)    ##dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()
#load:
f = open('json_file')
dic2 = json.load(f)
f.close()
print(type(dic2),dic2)

dump和load

 

 json在装有语言之间都通用,json种类化的数据在python上类别化了,拿在java中也足以反系列化

能够管理的数据类型是十二分有限的”字符串 列表 字典 数字

字典中的key只可以是字符串

4858.com 644858.com 65

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)
#separators 分隔符,实际上是(item_separator, dict_separator)的一个元组,默认的就
#       是(‘,’,’:’);这表示dictionary内keys之间用“,”隔开,而KEY和value之间用“:”隔开。 
#indent 应该是一个非负的整型,如果是0就是顶格分行显示,如果为空就是一行最紧凑显示,
#       否则会换行且按照indent的数值显示前面的空白分行显示,这样打印出来的json数据也叫pretty-printed json
#sort_keys 将数据根据keys的值进行排序
#ensure_ascii 当它为True的时候,所有非ASCII码字符显示为\uXXXX序列,只需在dump时
#       将ensure_ascii设置为False即可,此时存入json的中文即可正常显示。

json的格式化输出

 

   2.pickle

    json和pickle都以用来类别化的三个模块

      json用于字符串和python数据类型间展开转移

      pickle用于python特有的档期的顺序和python的数据类型间展开转移

   pickle模块也提供了七个功效:

    dumps丶dump(序列化,存)

    loads(反种类化,读)

    load(不仅能够种类化字典,列表…能够把python中自便的数据类型体系化)

 

import pickle

dic = {(1,2,3):{'a','b'},1:'abc'}
str_dic = pickle.dumps(dic)
print(str_dic)      #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)     #字典{(1, 2, 3): {'a', 'b'}, 1: 'abc'}

import time
struct_time  = time.localtime(1000000000)
print(struct_time)      #time.struct_time(tm_year=2001,......
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)     #2001

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有