常用模块一

time模块和random模块

import time
time.sleep() #让程序执行到这的时候停留一会儿
time.time()  #返回一个以秒位单位的浮点数

表示时间的三种方式：

在python中，通常由三种方式来表示时间：时间戳，元组（struct_time），格式化的时间字符串
①时间戳（timestamp）：通常来说，时间戳表示的是从1970年一月一日00：00：00开始按秒计算的偏移量。运行type(time.time())时，返回的时float类型
②格式化的时间字符串（FormatString）：“1999-12-06”
③元组（struct_time）：struct_time元组共有9个元素：（年月日，时分秒，一年中的第几周，一年中的第几天等）

import time

时间戳
print(time.time())  1552534782.0846364

时间字符串(格式化时间）
print(time.strftime('%Y-%m-%d %H:%M:%S'))year month day hour minute second
#结果：2019-03-14 11:41:53

时间元组：localtime将一个时间戳转化为当前时区的struct——time
print(time.localtime())#结构化时间
#结果：time.struct_time(tm_year=2019, tm_mon=3, tm_mday=14, tm_hour=11, tm_min=56, tm_sec=43, tm_wday=3, tm_yday=73, tm_isdst=0)

①时间戳----->结构化时间
t = time.time()
print(time.localtime(t)) 北京时间
print(time.gmtime(t))  格林威治时间

②结构化时间———>时间戳
print(time.mktime(time.localtime()))1552536642.0

③格式化时间 ———>结构化时间[2019-3 ——>tm_year=2019, tm_mon=3,]
print(time.strptime('2018-3-25','%Y-%m-%d'))

④结构化时间————>格式化时间
print(time.strftime('%m/%d/%Y %H:%M:%S',time.localtime()))
03/14/2019 13:37:28

asctime
print(time.asctime())Thu Mar 14 13:39:24 2019

time1 = time.mktime(time.strptime('2017-09-9  10:25:30' ,'%Y-%m-%d %H:%M:%S'))# 结构化时间转化为时间戳
time2 = time.mktime(time.strptime('2017-09-10  11:55:26' ,'%Y-%m-%d %H:%M:%S'))
cha_time = time2 - time1   #两个时间差
final_time = time.gmtime(cha_time)  #把时间戳转化为结构化时间
print(final_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(final_time.tm_year-1970,
                                                    final_time.tm_mon-1,
                                                    final_time.tm_mday-1,
                                                    final_time.tm_hour,
                                                    final_time.tm_min,
                                                    final_time.tm_sec))

random模块

import random
随机小数
print(random.random())  #大于0且小于1之间的小数
#结果：0.17652598848595968
print(random.uniform(2,3)) #大于2且小于三之间的小数
2.1379289978900364

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

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

打乱列表顺序
l = [1,3,5,7,8,9]
random.shuffle(l)  #打乱列表顺序
print(l) 结果[3, 7, 8, 1, 9, 5] or [8, 3, 5, 9, 7, 1]

栗子：生成随机验证码
#带字母 A~Z a~z  65 ~91
import random
l = ''
for i in range(6):
    litter = chr(random.randint(65,91))
    number = random.randrange(0,10)
    com = random.choice([litter,number])
    l = ''.join([l,str(com)])
print(l)

import random
l = []
for i in range(6):
    litter = chr(random.randint(65,91))
    number = random.randrange(0,10)
    com = random.choice([litter,str(number)])
    l.append(com)
    ret = ''.join(l)
print(ret)

collections模块

再内置数据类型（list,dict ,set, tuple )的基础上，collections模块还提供了
几个额外的数据类型：counter,deque,defaultdict,namedtuple,OrderedDict等

namedtuple：生成可以使用名字来访问元素内容的tuple
deque：双端队列，可以快速的从另外一侧追加和推出对象
counter：计数器，主要用来记数
OrderedDict：有序字典
defaultdict：带有默认值的字典

from collections import namedtuple
Point = namedtuple('point',['x','y','z']) # 'ponit是起的名字'
p = Point(1,2,3)
print(p.x)  #1
print(p.y)  #2
print(p.z)   #3
print(p)    #point(x=1, y=2, z=3)

栗子1：用元组描述一张扑克牌（一张有花色和数字）
Card = namedtuple('card',['suits','number'])
c1 = Card('方块','9')
print(c1)  card(suits='方块', number='9')
print(c1.suits) #方块
print(c1.number)#9

栗子2：用坐标和元的半径表示一个圆
from collections import namedtuple
Circular = namedtuple('circular',['x','y','r'])

使用list存储数据时，按索引访问元素很快，但是插入和删除就很慢了，
因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了实现高效率的插入和删除操作的双向列表，适合用于队列和栈

堆栈：先进后出

队列：先进先出   FIFO
import queue
q = queue.Queue()  #创建一个空的队列
队列提供的方法：put get qsize
q.put(10)   #往队列里面放值
q.put(7)
print(q)    #得到内存地址 <queue.Queue object at 0x000002632DE5A9B0>
print(q.qsize())  #可以看这个队列里面有多少个值
print(q.get())   #从队列里面取值,先取10
print(q.get())   #再取7
print(q.get())   #一直在等待，阻塞了

from collections import deque
dq = deque([1,2])
dq.append('a')     #从后面放数据
dq.appendleft('b')# 从前面放数据
dq.insert(1,'@')     #在1的位置插入了一个'@”
print(dq.pop())       #从后面取数据
print(dq.popleft())   # 从前面取数据

使用字典dict时，key时无序的，在对dict做迭代时，无法确定key的顺序
如果要保持key的顺序，可以使用OrderedDict：
注意OrderedDict的key会按照插入的顺序排列，而不是key本身顺序
from collections import OrderedDict
od = OrderedDict([('a',1),('b',2),('c',3)])
print(od)  #结果时有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)])
for k in od: # 可以for循环
    print(k)

有如下集合[11,22,33,44,55,66,77,88,99]
将所有大于66的值保存至字典的第一个key中，
将所有小于66 的值保存至第二个key的值中
from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99]
my_dict = defaultdict(list) # 默认所有的values都是list
for value in values:
    if value > 66 :
        my_dict['k1'].append(value)
    else :
        my_dict['k2'].append(value)
print(my_dict)
使用dict时，如 果引用的key不存在,就会KeyError,
如果希望key不存在时，返回一个默认值，就可以用defaultdict
from collections import defaultdict
d = defaultdict(lambda :'Lili')
d['k1'] = 'abd'
print(d)  # key1存在 abd
print(d['k2'])# key2不存在，默认返回Lili

from collections import Counter
a = Counter('abdcgkjgsagkL')
print(a)

os模块

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()                         删除一个文件
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.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.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

 序列化模块

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

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

序列化的目的

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

2、将对象从一个地方传递到另一个地方。

3、使程序更具维护性。

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'}]

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)

import json
f = open('file','w')
json.dump({'国籍':'中国'},f)
ret = json.dumps({'国籍':'中国'})
f.write(ret+'
')
json.dump({'国籍':'美国'},f,ensure_ascii=False)
ret = json.dumps({'国籍':'美国'},ensure_ascii=False)
f.write(ret+'
')
f.close()

Serialize obj to a JSON formatted str.(字符串表示的json对象) 
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的中文即可正常显示。) 
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json 
separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。 
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
sort_keys：将数据根据keys的值进行排序。 
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

pickle

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_time2.tm_year)

既然pickle如此强大，为什么还要学json呢？
这里要说明一下，json是一种所有的语言都可以识别的数据结构。
如果我们将一个字典或者序列化成了一个json存在文件里，那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化，其他语言就不能读懂这是什么了～
所以，如果序列化的内容是列表或者字典，非常推荐使用json模块
但如果出于某种原因你不得不序列化其他的数据类型，而未来还会用python对这个数据进行反序列化的话，那么就可以使用pickle