常用模块一
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+'\n') json.dump({'国籍':'美国'},f,ensure_ascii=False) ret = json.dumps({'国籍':'美国'},ensure_ascii=False) f.write(ret+'\n') 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
