python常用的内置模块主要有以下几种
不管一个模块import几次，它只会被导入一次
random 随机数模块
os 和操作系统打交道的模块
sys 和python解释器打交道的模块
序列化模块 python中的数据类型和str转换的模块
collections python 中的扩招数据类型
堆栈 先进后出
queue 队列 先进先出
time模块
import time
print("获取当前时间戳:",time.time()) #1575795813.3868337
print("当前的格式化时间",time.strftime("%Y-%m-%d %H %M %S")) #当前的格式化时间 2019-12-08 17 03 33
print("结构化时间：",time.localtime())
#time.struct_time(tm_year=2019, tm_mon=12, tm_mday=8, tm_hour=17, tm_min=3, tm_sec=33, tm_wday=6, tm_yday=342, tm_isdst=0)
t=time.time()
print(time.localtime(t)) #把指定的时间戳转换成结构化时间
#time.struct_time(tm_year=2019, tm_mon=12, tm_mday=8, tm_hour=17, tm_min=3, tm_sec=33, tm_wday=6, tm_yday=342, tm_isdst=0)
tl=time.localtime()
#mktime 把结构化的时间转成时间戳
mkt=time.mktime(tl)
print(mkt)
mkp=time.strptime("2035:9:30","%Y:%m:%d")#字符串格式的时间 转成结构化
print(mkp)
mkf=time.strftime("%M-%m:%Y $%H",time.localtime(3000000930)) #把结构化时间转成格式化
print(mkf)
# 基于time 和collection.OrderedDict 模块的时间转换程序
from collectionsimport OrderedDict
def getTimePass():
now=int(time.time());
od=OrderedDict([ #必须用有序的对象，因为要按顺序判断从大到小的数值才行
("年",60*60*24*365),
("月",60*60*24*30),
("日",60*60*24),
("时",60*60),
("分",60),
("秒",1)
])
fh="之后";
have=False
def getD(s):
nonlocal have,od
st ='';
s=int(s)
for iin od:
if have:
st='{0}{1}{2}'.format(st,s//od[i],i)
s = s % od[i];
continue;
if s//od[i] >0:
have=True;
st='{0}{1}'.format(s//od[i],i)
s=s%od[i];
have=False
return st;
while 1:
t=input("请输入时间：")
f=input("请输入时间的格式，时间戳请输入0：")
if f.upper()=="Q":break;
if f=='0':
if not t.isdigit():print("请输入数字格式的时间戳");continue;
it=int(t)
else:
it=int(time.mktime(time.strptime(t,f)))
print(it,now)
if it<now: fh = "之前"
sec = getD(abs(it - now))
print("您输入的时期是：",sec,fh)
# getTimePass()
random模块
import random
print(random.random()) # 随机生成0-1之间的小数
print(random.randint(0,5)) #随机生成0-5之间的整数，包括5
print(random.randrange(0,10,2)) #随机生成0-10之间的偶数，包括0，不包括10 ，可以设置步长
li1=[1,2,34,5,7,8,9,8,323,8,234,9,87,98,4,64,0]
print(random.choice(li1)) #随机在数组里选出一项
random.choice("asdkjfdfg") #随机选一个字符
print(random.sample(li1,3)) #随机在li1中选三个项，可重复
random.shuffle(li1) #shuffle随机乱序 直接在当前list上更改
print(li1)
print(random.uniform(3,5)) #生成随机浮点数，
os 模块
import os
print(os.getcwd()) #获取当前目录路径
os.chdir("..") #chdir 改变当前执行目录，可以是相对的，可以是绝对的
os.chdir("d:/xampp")
print(os.getcwd())
os.chdir("..")
print(os.urandom(32)) #随机生成一个32为的butes字节
os.makedirs("fuckos/setmake/makelove") #递归形式的生成文件夹目录，哪一层的文件加没有就生成哪个文件夹
os.chdir("./fuckos")
os.curdir #返回当前目录: ('.') ,只是一个 .
os.pardir #获取当前目录的父目录字符串名：('..') 只是 两个 .
os.removedirs('setmake/makelove') #递归形式删除目录，如果删除了当前文件后父目录为空，则将父目录也删除，一直删除到当前的操作目录或者删完文件后父目录不为空为止
os.mkdir("createOne") #只创建一个目录
os.rmdir("createOne") #只删除一个目录，如果该目录不为空，则删除失败
os.rename("oldname","newname") #重命名文件/目录
os.remove() #删除一个文件
os.chdir("..")
print(os.listdir(".")) #当前目录的文件列表
print(os.stat('.')) #获取文件/目录信息
print(os.sep) #获取当前系统的分割符 \ 是windows linux 就是/ 想要适应window和linux的时候用os.sep来拼接目录路径
print(os.linesep) #输出当前平台使用的行终止符 win 下是 "\t\n" linux 下是 "\n"
print(os.pathsep) #输出用于分割文件路径的符号 win下 是 ; linux下是：
os.system("dir") #调用操作系统的cmd 用cmd 来执行这个函数的参数
print(os.popen("dir").read()) #调用操作系统的cmd 来执行参数，并且返回执行结果，可以调用read()来获取结果
print(os.environ) #获取当前系统的环境变量key-value形式
#os.path 所有关于路径的操作
os.path.abspath(path) # 返回path规范化的绝对路径
os.path.isabs(path) #如果path是绝对路径，返回True
os.path.basename(path) #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.join(path1[, path2[, ...]]) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.exists("./") #判断一个目录是不是存在
os.path.isdir("./shit") #判断这个目录是文件还是文件夹
os.path.isdir() #是不是目录
os.path.isfile(); #是不是文件
os.path.join("c:","programfile","fuck") #将各个参数拼接成目录
#os.path.getsize() 获取文件大小，如果是文件夹则获取不准确，文件夹大小最大为4096 ，如果要获取一个文件夹所有文件大小就循环累加
os.path.getsize(os.getcwd())
os.path.getatime(path) #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间
sys 模块
为什么一个模块不会被重复导入 模块被导入之前，会先去sys.modules查找，看看是否存在。如果被导入则不在导入,如果没被导入，则会开始按照sys.path去寻找这个模块，如果都没找到，则报错引入模块的时候python会根据这个路径列表去挨个查找文件夹的模块，如果都没找到才会报错 。可以项操作list一样操作path.添加或删除路径
导入模块顺序的讲究 在文件最开始导入，多个模块一起导入
# 内置模块-》扩展的-》自己写的自定义的
import sys
print(sys.version) #python解释器程序的版本信息
print(sys.platform) #运行平台名称 通常容易window 64为都会被获取为win32
print(sys.path)
#sys.path=['']
print(sys.argv) #当前文件的硬盘路径
print(sys.exit()) #手动退出程序
序列化 json ,pickle,shelve
json 通用的序列化格式
json dumps 序列化 loads 反序列化
#json dump load 写入文件用,一次性的读和一次性的写入，因为会一次读完，所以写的格式如果不是标准的数据格式的字符串将无法load成功
import json
dic1={"k":1}
print(type(dic1),dic1); #<class 'dict'> {'k': 1}
str_d=json.dumps(dic1)
print(type(str_d),str_d) #<class 'str'> {"k": 1}
dic_d=json.loads(str_d)
print(type(dic_d),dic_d) #<class 'dict'> {'k': 1}
tup1=(1,2,3,4)
print(json.dumps(tup1)) #[1, 2, 3, 4] 转成了list,因为json只认识列表，元组json里边没有
#json dump load 写入文件用,一次性的读和一次性的写入，因为会一次读完，所以写的格式如果不是标准的数据格式的字符串将无法load成功
f=open("test","w",encoding="utf-8");
dic1={"key1":"sdfkasdjf盛开的房间","key2":"大山东卡士大夫"}
json.dump(dic1,f) #中文会转bytes类型
f.close()
f=open("test",encoding="utf-8")
dic1=json.load(f)
f.close()
print(dic1)
f=open("test","a",encoding="utf-8")
dict1={"国籍":"美国","英雄":"就是我"}
json.dump(dict1,f,ensure_ascii=False) #加上ensure_ascii=False 则不转换bytes类型，以字符串类型保存
f.close()
#pickle dumps loads 同json里的功能 pickle序列化完了之后是【【【bytes类型】】】
import pickle
dic1={"k23":'sdfasd',"w无第三方":"86411"}
pics=pickle.dumps(dic1)
print(type(dic1),dic1)
print(type(pics),pics) #与json不同的是，这个序列化之后是bytes类型
dic_d=pickle.loads(pics)
print(type(dic_d),dic_d)
f=open("test1","wb")
pickle.dump(dic1,f)
pickle.dump(dic1,f)
f.close();
f=open("test1","rb");
res1=pickle.load(f)
res2=pickle.load(f)
print(res1,res2)
# shelve 可以对文件直接操作 像操作字典一样
import shelve
f=shelve.open("test2")
f["key"]={"阿斯兰":"12345","fsdkfjksdf":"98765434"} #通过赋值的方式,直接在文件里创建了一个键为key,值为等号右边内容的信息
f.close()
f1=shelve.open("test2")
print(f1["key "]) #读的时候直接通过键名获取文件对应键名key的内容
f.close()
#shelve模块有个限制，不支持多个应用同一时间往同一个DB进行写操作，所以如果我们打开文件只为了读，应该以只读的方式打开
f2=shelve.open("test2",flag="r")
f2['key1']={"123654":"sdfkjasdf撒打开房间阿萨德分",'123234':"阿斯蒂芬撒打开房间"}
f2.close()
f3=shelve.open("test2",flag='r') #虽然是只读模式，但是存在bug, 只读的时候还是可以修改，
reads=f3["key1"]
reads1=f3["key"]
f3.close()
print(reads,reads1)
collection 模块
#namedtuple 利用了tuple不可变的特性，让每个有名字的项都有着不可变的属性，方便使用
from collections import namedtuple
Point=namedtuple('point',['x',"y",'z'])
p=Point(1,2,3)
print(p)
print(p.x,p.y)
# 比如可以使用的地方：扑克牌，花色和数字
Card=namedtuple('card',['type','number']) #初始化模型
peach1=Card("红心",1) #实例化
Circle=namedtuple('Circle',["x","y","r"]) #x,y 和半径
queue 队列 FIFO first in first out 队列和双端队列因为不能随机变元素顺序,所以执行起来相对来说比list快
import queue
q=queue.Queue()
q.put(1) #添加项
q.put(1)
q.put(1)
q.put(3)
print(q) #直接打印看不到里边数据，也不可以for循环
que=queue.Queue();
que.put(10)
que.put(5,539,6) #可以一次性放多个
print(que.get())
print(que.get())
# print(que.get()) #取值取不到了，程序开始等待，不再往下执行，叫做【【阻塞】】，直到再次put进去值的时候才会继续执行
print(que.qsize()) #获取queue里有几个值，如果不想阻塞程序，则需要判断此值之后在调用get
deque 双端队列 可以从前后两边放，也可以从前后两边取，无法从中间取
from collections import deque
de=deque();
de.append(1); #从后边加数
de.appendleft(2) #从前边加数
de.insert(1,3) #从某个索引位置添加项
print(de) #不同于队列，这个可以打印出来
de.pop() #在右边删除并 返回 一个元素
de.popleft() #在左边删除并返回一个元素
de.append([2,3])
print(de)
de.appendleft((4,5))
for i in de:
print("双端队列de的值：",i)
