day 17 项目开发常用模块

---恢复内容开始---

time模块

 import time

 print(time.time()) # 时间戳:
 print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串
 print(time.localtime()) #本地时区的struct_time
 print(time.gmtime())    #UTC时区的struct_time

　　

import time
print(time.time())  #1554898789.1836467  当前时间戳

print(time.localtime())  #东八区时间（上海时间）
#time.struct_time(tm_year=2019, tm_mon=4, tm_mday=10, tm_hour=20, tm_min=20, tm_sec=35, tm_wday=2, tm_yday=100, tm_isdst=0)

print(time.gmtime()) #格林威治时间（比上海早8小时）
#time.struct_time(tm_year=2019, tm_mon=4, tm_mday=10, tm_hour=12, tm_min=21, tm_sec=45, tm_wday=2, tm_yday=100, tm_isdst=0)

print(time.localtime(time.time()))
print(time.gmtime(time.time()))
#将时间戳装换为时区的时间

print(time.localtime(33223434))
#参数也可以装换为数字

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

格式化字符串的时间格式

res=time.strftime('%Y-%m-%d %j ')
print(res)  #2019-04-10 100    

t=(2012,10,1,10,19,22,2,200,0)    #t的时间格式是固定的
res=time.strftime('%Y-%m-%d %j days',t)
print(res)  #2012-10-01 200 days

　　

calendar模块

判断闰年：calendar.isleap(year)
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)

　　

datetime模块

当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datatime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)

import  datetime
t=datetime.datetime.now()
print(t,type(t))
# -- ::00.123317 <class 'datetime.datetime'>

m=datetime.timedelta(days=)  #此时的days可以为-
print(m,type(m))
# day, :: <class 'datetime.timedelta'>

yesterday=t-m   #t与m都是对象，可以运算
print(yesterday,type(yesterday))
#-- ::13.008917 <class 'datetime.datetime'>

#当上述的days为-1时，所得结果应该为明天的值

print(t.replace(year=))  #t为对象，可以调用方法
#-- ::10.364061

print(datetime.date.fromtimestamp())
#--  #格式化时间戳

print(time.time())
#.8401482将当前时间装换为时间戳

print(time.localtime())
#time.struct_time(tm_year=, tm_mon=, tm_mday=, tm_hour=, tm_min=, tm_sec=, tm_wday=, tm_yday=, tm_isdst=)
#以特定格式打印参数所对应的时间

小点的使用

sys:系统

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

import sys

print(sys.argv)   #sys.argv[]说白了就是一个从程序外部获取参数的桥梁，这个“外部”很关键

 print(sys.path)            #查看python的环境变量

print(sys.exit(0))
 #sys.exit()会引发一个异常：SystemExit，如果这个异常没有被捕获，那么python解释器将会退出。 如果有捕获此异常的代码，那么这些代码还是会执行。捕获这个异常可以做一些额外的清理工作。 0为正常退出，其他数值（1-127）为不正常，可抛异常事件供捕获。

print(sys.version)          #查看当前python的版本信息

print(sys.maxsize)                #最大的int值

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

　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.environ  获取系统环境变量
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.mkdir('dirname')         #生产单级目录

 os.makedirs('a/b/c')   生成多层目录，全存在会报错，a,b
存在与否不影响

os.rename('111.py','222.py') #重新命名文件(带有file的文件即可）

 os.renames('代码','代码1') #是os.rename的升级版, 既可以重命名文件, 也可以重命名文件的上级目录名，即文件夹

 print(os.getcwd())   #当前工作目录

os,rmdir()  #移除单层空目录

os.rmdir('a/b/c')    #删除最下一层空目录

os.rmdir('a')     #当此层的目录不为空时，会报错

os.rmdir(r'D:\学习\python上课相关\day17\a\b\c')  #可以根据绝对路径来删除目录   

os.removedirs()     #删除多层空目录

 os.removedirs('a/b/c')  #c空，删c，b也变成空，也可以被删除，以此类推，如果b不为空，删除c后就停止操作

os.remove('333.py')  #删除同一目录下的文件

print(os.sep)               #路径分隔符 \

print(os.linesep)           #行终止符   \r\n

print(os.pathsep)           #文件分隔符 ;

print(os.name)              #操作系统名 nt     待续

print(os.environ)           #操作系统环境变量

 print(os.system())          #执行shell脚本    待续

print(os.listdir(r'D:\学习'))   #以列表形式将该目标目录下的所有资源都列举出来

基础组成

os.path.abspath(path)  返回path规范化的绝对路径
print(sys.path.clear())      #sys.path字典控制包的导入    待续
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回Fals
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

print(os.path.isabs(r'D:\学习\python上课相关\day17\代码1'))     #绝对路径
# print(os.path.isdir(r'D:\学习\python上课相关\day17\a'))                    #针对目录，存在为True   记得加'r'
# print(os.path.isfile(r'D:\学习\python上课相关\day17\dirname\111.py'))      #针对文件，存在为True   记得加'r'
# print(os.path.exists(r'D:\学习\python上课相关\day17\dirname\111.py'))      #对于文件和目录，只要存在，就True
# print(os.path.abspath('hah'))                                              #返回path规范化的绝对路径，无论存在与否

'''
执行文件的当前路径：__file__
返回path规范化的绝对路径：os.path.abspath(path)
将path分割成目录和文件名二元组返回：os.path.split(path)
返回path的目录，其实就是os.path.split(path)的第一个元素    os.path.dirname(path)
上一级目录：os.path.dirname(path)
最后一级名称：os.path.basename(path)
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
路径拼接：os.path.join(path1[, path2[, ...]])
最后存取时间：os.path.getatime(path)
最后修改时间：os.path.getmtime(path)
目标大小：os.path.getsize(path)
'''
print(os.path.split(r'D:\学习\python上课相关\day17\知识点再敲.py'))
#将文件的完整路径划分为两个元素的元组，其中一个是文件名

print(os.path.dirname(r'D:\学习\python上课相关\day17\知识点再敲.py'))       #回到该文件上一层目录
print(os.path.dirname(os.path.dirname(r'D:\学习\python上课相关\day17\知识点再敲.py'))) #回到该文件的上上一层目录
print(os.path.dirname(os.path.dirname(__file__)))  #结果同上
print(os.path.basename(r'D:\学习\python上课相关\day17\知识点再敲.py'))      #回到最后一级名称
print(os.path.join(r'D:\学习\python上课相关\day17\a\b\c\a.py','hah','haha'))    #多个路径拼接

#将项目目录添加至环境变量
print(sys.path)       #原先的环境变量
BASE_PATH=os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_PATH)
print(sys.path)        #添加后的环境变量

#拼接项目中某一文件或文件夹的绝对路径
file_path=os.path.join(BASE_PATH,'part1','时间模块.py')     #拼接
print(file_path)                                            #输出拼接后的路径
print(os.path.exists(file_path))                            #验证该绝对路径是否存在

#辅助上传下载
print(os.path.getsize(r'D:\学习\python上课相关\day17\知识点再敲.py'))  #输出目标文件的字节大小
文件夹（文件）的大小在上传下载时会传递过去，可以用来作为精度条的依据

#规范化路径
print(os.path.normcase(r'D:\学习///python上课相关/day17\知识点再敲.py'))     #规范化路径
将路径里的  / 转换为 \

print(os.path.normpath(r'D:\学习///python上课相关///day17\知识点再敲.py.'))
#比os.path.normcase 效果更好，可以将多个斜杠装换为一个

#重点
BASE_PATH = os.path.dirname(os.path.dirname(__file__))   #将当前文件的上上一层目录添加到环境变量里
sys.path.append(BASE_PATH)
 BASE_PATH1 = os.path.normpath(os.path.join(__file__, '..', '..'))#通过规范化输入将拼接的路径导入环境变量里
 sys.path.append(BASE_PATH1)

需要掌握的要点

json序列化

#将json类型的对象与json类型的字符串相互装换
#{}与[]嵌套形成的数据（python中建议数据从{}开始）

　

序列化

import json

dic={'a':1,
     'b':[1,2,3,4]
     }

#序列化，将python里的字典装换为字符串传递给其他语言保存
print(type(dic))
json_str=json.dumps(dic)
print(json_str,type(json_str))

print(str(dic),type(str(dic)))    强行转换为str 达到的效果是一样的

with    open('','w',encoding='utf-8')as w:
    json.dump(dic,w)      #通过序列化 将字典装换为str， 写入文件
    w.write(json_str)     #直接写入也可达到效果
    w.write(dic)           #字典类型不可以直接写入文件里

文件里只能写字符串，但可以把字典转成json串，json串是字符串，可以存到文件里
.dump()不需要使用.write()方法，只需要写哪个字典、哪个文件即可；而.dumps()需要使用.write()方法写入
如果要把字典写到文件里面的时候，dump()好用；但如果不需要操作文件，
或需要把内容存到数据库和Excel，则需要使用dumps()先把字典转成字符串，再写入

#1.单纯将字符串装换为字典
json_str='''{"a":1,"b":2,"c":3}'''
new_dic=json.loads(json_str)
print(new_dic)

json_str = '''{"a": 1, "b": [1, 2, 3, 4, 5]}'''
new_dic=json.loads(json_str)
print(new_dic,type(new_dic))      #将字符串类型装换成了字典

#字典里的key值如果使用了单引号，那么会报错

#2.从文件中将字符串类型读出且转换为字典
with open('','r',encoding='utf-8')as r:
    w=r.read()
    res=json.loads(w)
    print(res)

with open('','r',encoding='utf-8')as r:
    res=json.load(r)
    print(res,type(res))
#二者效果一样，区别点在于一个使用了loads 一个用了load
#loads()传的是字符串，而load()传的是文件对象
#使用loads()时需要先读文件再使用，而load()则不用

不管是dump还是load，带s的都是和字符串相关的，不带s的都是和文件相关的。

反序列化

json的反序列化只能对字典类型的字符串有效，如果存在其他的类型的字符串，则会报错。

数据在文件里储存有两种格式：

直接以str格式储存，需要指定编码格式；

以bytes格式储存，不需要指定编码啊格式，但是需要提前将数据编码为字节类型！！！

pickle序列化

可以将任意类型对象与字符串进行装换
import pickle
dic={'a':1,
     'b':[1,2,3,4]
     }
res=pickle.dumps(dic)
print(res,type(res))

with open('','wb')as w:
    pickle.dump(dic,w)       #将字典装换为字符串通过2进制写入文件

with open('','rb')as w:
    res=pickle.load(w)           #将文件中的二进制字符串读出为字典
    print(res)

　

---恢复内容结束---