python day7： time,datetime,sys,pickle,json模块
Posted on 2019-10-11 00:03 bluestarpin 阅读(201) 评论(0) 编辑 收藏 举报python day 7
2019/10/10
学习资料来自老男孩教育
目录
1. time模块
若要使用python的time模块，需要先导入time.
计算机有两种标准时间，一种是基于世界时间的时间戳(即给定日期距1970年1月1日的秒数)，另外一种是struct_time对象的9个数字的元组。
该元组的元素是以下9部分：
year (包括世纪，比如2001)
month (1-12)
day (1-31)
hours (0-23)
minutes (0-59)
seconds (0-59)
weekday (0-6,Monday is 0)
Julian day (给定时间在该年的天数，1-366)
DST (daylight savings time夏令时) flags(-1,0 or 1)
如果flags是0，则时间是标准时区时间。
如果flags是1，则时间是夏令时时间。
如果是-1，则mktime()方法得到的时间是基于日期和时间来定的。
time模块有一个类叫做struct_time，创建实例时，需要接收9个数字来做作为属性。
import time
# print(time.time()) #返回自1970年1月1日的时间戳
# print('start to sleep...')
# time.sleep(5) #让程序休眠5秒
time.time() #输出当前时间戳
#1570612780.9513557
time.localtime(time.time()) #将时间戳转换为本地时间的时间元组,若不传参数，则默认为当前时间戳。
#time.struct_time(tm_year=2019, tm_mon=10, tm_mday=9, tm_hour=17, tm_min=21, tm_sec=19, tm_wday=2, tm_yday=282, tm_isdst=0)
time.asctime(time.localtime()) #将时间元组转换为字符串，如果不传参数，则默认是localtime()返回的时间元组。
#'Wed Oct 9 17:36:30 2019'
time.ctime(time.time()) #将时间戳转换为本地时间的字符串，如果不传参数，则默认是当前时间戳。
#'Wed Oct 9 17:38:43 2019'
time.gmtime(782142314) #将时间戳转换为世界时间的时间元组。世界时间就是格林威治时间(GMT).不传参数则默认是当前时间戳。
#time.struct_time(tm_year=1994, tm_mon=10, tm_mday=14, tm_hour=13, tm_min=45, tm_sec=14, tm_wday=4, tm_yday=287, tm_isdst=0)
time.mktime(time.localtime()) #将时间元组转换成时间戳
#1570614304.0
time.sleep(1) #让程序休眠多少秒。
time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()) #将时间元组按照指定格式转换成为字符串。
#'2019-10-09 17:51:13'
time.strptime('2019-10-09 17:51:13','%Y-%m-%d %H:%M:%S') #将字符串按照指定格式转换为时间元组。
#time.struct_time(tm_year=2019, tm_mon=10, tm_mday=9, tm_hour=17, tm_min=51, tm_sec=13, tm_wday=2, tm_yday=282, tm_isdst=-1)
2. datetime模块
datetime模块相比time模块提供了更多功能，主要有五个类，date(日期),time(时间),datetime(日期时间),timedelta(时间差),tzinfo(时区信息)。
2.1 date类
datetime.date(year,month,day)
- 类方法和类属性
from datetime import *
import time
print(date.max) # 这是date类的类属性max，即一个date类能够表示的最大日期，是9999-12-31。
print(date.min) # 这是date类的类属性min，即一个date类能够表示的最小日期，是0001-01-01。
print(date.fromtimestamp(1214123413)) #这是date类的类方法，将时间戳转换成年月日格式的字符串
2008-06-22 <class 'datetime.date'>
print(date.today()) #这是date类的类方法today，调用了类的fromtimestamp，输出当前年月日。
2019-10-09
- 对象方法和对象属性
from datetime import *
import time
print(date.max) # 这是date类的类属性max，即一个date类能够表示的最大日期，是9999-12-31。
print(date.min) # 这是date类的类属性min，即一个date类能够表示的最小日期，是0001-01-01。
print(date.fromtimestamp(1214123413)) #这是date类的类方法，将时间戳转换成年月日格式的字符串
print(date.today()) #这是date类的类方法today，调用了类的fromtimestamp，输出当前年月日。
d1 = date(2019,10,9) #创建一个date实例(由类创建的一个对象叫类的一个实例，也可以叫date对象)，实例的属性年，月，日必须是整数。
print(d1.year) #这是date实例d1的实例属性year，获得第一个参数2018
print(d1.month) #这是date实例d1的实例属性month，获得第二个参数9
print(d1.day) #这是date实例d1的实例属性day，获得第三个参数2
print(d1.ctime()) #实例d1的对象方法，返回一个本地时间的字符串，Sun Sep 2 00:00:00 2018
print(d1.replace(year=2019,month=9,day=11)) #生成一个新的date对象(实例)，用指定的年，月，日替换原有对象中的属性。(原对象仍保持不变)
print(d1.timetuple())#返回日期对应的time.struct_time对象。
print(d1.weekday()) #返回weekday，如果是星期一，返回1，如果是星期天，返回0，依此类推
print(d1.isoweekday()) #返回基于ISO标准的星期数对应的数值，如果是星期一，返回1，如果是星期天，返回7，依此类推
print(d1.isocalendar()) #返回基于ISO时间的日历的元组。(2019, 41, 3)
print(d1.isoformat(),type(d1.isoformat())) #返回基于ISO标准的字符串，即格式如'YYYY-MM-DD'的字符串
print(d1.strftime('%Y/%m/%d'),type(d1.strftime('%Y/%m/%d'))) #返回指定格式的字符串。
9999-12-31
0001-01-01
2008-06-22
2019-10-09
2019
10
9
Wed Oct 9 00:00:00 2019
2019-09-11
time.struct_time(tm_year=2019, tm_mon=10, tm_mday=9, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=282, tm_isdst=-1)
2
3
(2019, 41, 3)
2019-10-09 <class 'str'>
2019/10/09 <class 'str'>
2.2 time类
datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
- 类方法和类属性
print(time.min) #这是datetime模块里面time类的类属性min，表示能表示的最小时间。
print(time.max) #这是datetime模块里面time类的类属性max，表示能表示的最大时间。
print(time.resolution) #类属性，是1微秒。
print(time.fromisoformat('21:20:53')) #类方法，将字符串转换成基于ISO标准指定格式的时间
00:00:00
23:59:59.999999
0:00:00.000001
21:20:53
- time对象的方法和属性
t1 = time(21,33,20,55) #创建一个time对象t1，即21:33:33.55
print(t1.hour,t1.minute,t1.second,t1.microsecond) #time对象t1具有多个对象属性
t2 = t1.replace(hour=22,minute=22) #将其属性用指定参数进行替换，并返回一个新的time对象。
print(t1.isoformat()) #返回形如'HH:MM:SS'格式的字符串
print(t1.strftime('%H/%M/%S')) #返回指定格式的字符串
21 33 20 55
21:33:20.000055
21/33/20
2.3 datetime类
datetime继承自date类。datetime相当于date和time类的结合。
datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])，year,month,day，是必输参数，其他都是可选参数。
- 类方法和类属性
print(datetime.today()) #类方法，返回一个表示当前本地时间的datetime对象
print(datetime.now()) #类方法，返回一个表示当前本地时间的datetime对象，如果有参数tz,则获取tz参数所指时区的本地时间。
print(datetime.utcnow()) #类方法，返回一个当前utc时间的datetime对象。就是格林威治时间。
print(datetime.fromtimestamp(13421341324)) #类方法，根据时间戳创建一个datetime对象，如果有参数tz，则返回tz所指时区的本地时间。
print(datetime.utcfromtimestamp(134213)) #类方法，根据时间戳创建一个utc时间的datctime对象。
print(datetime.combine(date(2019,10,8),time(11,30,31))) #类方法，根据date对象和time对象创建一个datetime对象。
print(datetime.strptime('2019-10-01 21:33:22','%Y-%m-%d %H:%M:%S')) # 类方法，将格式字符串转换为datetime对象
2019-10-09 21:30:41.375334
2019-10-09 21:30:41.375333
2019-10-09 13:30:41.375333
2395-04-22 22:22:04
1970-01-02 13:16:53
2019-10-08 11:30:31
2019-10-01 21:33:22
- 对象方法和属性
from datetime import *
dt1 = datetime(2019,10,2,12,36,33) #只有年，月，日参数是必输的。创建一个datetime对象。
print(dt1.year,dt1.month,dt1.day,dt1.hour,dt1.minute,dt1.second,dt1.microsecond,dt1.tzinfo) # 对象属性
print(dt1.date(),type(dt1.date())) #对象方法，获取date对象
print(dt1.time(),type(dt1.time())) #对象方法，获取time对象
print(dt1.replace(year = 2018)) #将指定参数进行替换，并返回一个新的datetime对象
print(dt1.timetuple()) #返回本地时间的time.struct_time对象，即时间元组。
print(dt1.utctimetuple()) #返回utc时间的时间元组
print(dt1.toordinal()) #返回当前日期距公历1年1月1日的天数
print(dt1.weekday()) #返回今天是星期几，用数字代替星期几，0是星期天，1是星期一，依此类推
print(dt1.isoweekday()) #返回今天是星期几，用数字代替星期几，7是星期天，1是星期一，依此类推
print(dt1.isocalendar()) #返回以元组形式的(年，月，日)
2019 10 2 12 36 33 0 None
2019-10-02 <class 'datetime.date'>
12:36:33 <class 'datetime.time'>
2018-10-02 12:36:33
time.struct_time(tm_year=2019, tm_mon=10, tm_mday=2, tm_hour=12, tm_min=36, tm_sec=33, tm_wday=2, tm_yday=275, tm_isdst=-1
)
time.struct_time(tm_year=2019, tm_mon=10, tm_mday=2, tm_hour=12, tm_min=36, tm_sec=33, tm_wday=2, tm_yday=275, tm_isdst=0)
737334
2
3
(2019, 40, 3)
2.4 timedelta类
timedelta类是datetime对象加减的类。
使用timedelta可以很方便的在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算，如果要计算月份则需要另外的办法。
dt2 = datetime.now() #创建一个本地当前时间的datetime对象
dt3 = dt2 + timedelta(days=1) #明天
dt4 = dt2 + timedelta(days=-1) #昨天
delta_obj = dt3 - dt2 #获得一个timedelta对象
print(dt2,dt3,sep='\t')
print(type(delta_obj),delta_obj,delta_obj.days,delta_obj.total_seconds(),sep='\n')
#timedelta对象有days, seconds, microseconds,milliseconds, minutes, hours, weeks等属性,total_seconds()方法。
2019-10-09 22:04:11.841300 2019-10-10 22:04:11.841300
<class 'datetime.timedelta'>
1 day, 0:00:00
1
86400.0
2.5 tzinfo时区类
tzinfo是一个关于时区信息的抽象基类，不能直接实例化，必须创建一个子类。
tzinfo的子类必须重载tzname(), utcoffset() and dst()方法.
from datetime import *
class UTC(tzinfo): #UTC类继承自tzinfo类
"""UTC"""
def __init__(self,offset = 0): #构造函数__init__，默认UTC对象的offset属性，即时区基准点是0
self._offset = offset
def utcoffset(self, dt):
return timedelta(hours=self._offset)
def tzname(self, dt): #定义UTC对象的获取时区名字方法，参数是一个datetime对象
return "UTC +%s" % self._offset
def dst(self, dt): #
return timedelta(hours=self._offset)
# 北京时间
bj_time = datetime(2019, 10, 9, 22, 24, 23, tzinfo=UTC(8)) # 设置时区，tzinfo形参是一个UTC对象
# 曼谷时间
bangkok = datetime(2019, 10, 9, 22, 24, 23, tzinfo=UTC(7))
print(bj_time,bangkok,sep='\n')
# 将北京时间转换成曼谷时间
print(bj_time.astimezone(tz=UTC(7)))
#计算时差
timecha = bj_time - bangkok
print(timecha,type(timecha))
2019-10-09 22:24:23+08:00
2019-10-09 22:24:23+07:00
2019-10-09 21:24:23+07:00
-1 day, 23:00:00 <class 'datetime.timedelta'>
ps：完全记不住，只能先放在这儿，用时再看了。只记住time.time(),time.sleep(),datetime.now(),datetime.today(). 至于strftime()，strptime()，只知道要接两个参数，一个是格式化在前，另外一个是时间元组对象。
3. sys模块
sys模块是python内置模块，存储模块搜索路径，命令行参数，以及一些底层功能等的模块。
import sys
#sys模块的argv变量，是一个列表，元素是当前脚本在命令行模式下的传入参数，
# 比如在命令行模式下输入：python sysmodule.py 1 2 3
print(sys.argv)
#输出结果为['sysmodule.py', '1', '2', '3'],第一个元素是程序本身路径
print(sys.path) # 返回模块的搜索路径列表，初始化时使用PYTHONPATH环境变量的值。如果要导入一个模块，必须在sys.path列表中有这个程序的路径。
#
print(sys.version) #程序的版本号
print(sys.int_info) #系统的整数信息
print(sys.platform) #判断系统是哪个系统，windows系统是win32,linux系统是linux
print(sys.stdout) #<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'> 相当于写模式打开了一个文件流对象
print(sys.stdin) #<_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>,相当于读模式打开了一个文件流对象
sys.stdout.write('hello') #stdin , stdout , 以及stderr 变量包含与标准I/O 流对应的流对象,stdin,stdout,stderr在Python中都是文件属性对象,文件具有write等写入方法
ret = sys.stdin.readline()[:-1] #读取用户输入的内容。
print(ret)
sys.exit(0) #退出程序，正常退出时是exit(0)
#在命令行模式中显示进度条
for i in range(21):
sys.stdout.write('\r') #每次都清空原行
sys.stdout.write('*%s%% |%s'%(int(i/20*100),int(i/30*100)*'*'))
sys.stdout.flush() #强制刷新到屏幕
time.sleep(0.1)
4.pickle序列化模块与json序列化模块
将一个对象转换成bytes类型的过程叫序列化，将bytes对象转换成为原对象的过程叫反序列化。pickle只支持python的数据类型，而json在其他语言中也可以使用。
import pickle
with open('../day7_time_os_sys/account.db','rb+') as f:
ret = pickle.load(f) #load方法接收一个文件对象作为参数，将文件中的数据转换为原来的对象类型。这叫做对象的反序列化。
ret[1000]['balance'] += 10000
pickle.dump(ret,f) # dump方法接收一个对象和文件流对象作为参数，将该对象转换为字节对象，并将字节对象写入文件，会将原文件覆盖掉
print(f.tell())
f.seek(0)
data = f.read()
ret2 = pickle.loads(data) #loads方法接收bytes字节对象作为参数，并将字节转换为原来的对象
ret2[1001]['balance'] +=1000
data2 = pickle.dumps(ret2) #dumps方法接收任意对象作为参数，并将其转换为bytes字节对象，这叫做对象的序列化。
f.write(data2)
json的用法与pickle一样，只是更适合不同编程语言类型之间通信，且loads方法返回的对象类型中的元素不太一样。
json时，字典，列表，元组时间的元素如果是字符串，必须以双引号括起来，否则会报错
import json
accounts ={
1000:{
'name':'John',
'email':'john3333@163.com',
'passwd':'abc123',
'balance':15000,
'phone':13641280280,
'bank_acc':{
'ICBC':14324234,
'CBC':23523213,
'ABC':34267898
}
},
1001:{
'name':'Lucy',
'email':'lucy3333@163.com',
'passwd':'abc456',
'balance':-15000,
'phone':13641287898,
'bank_acc':{
'ICBC':1231412,
'CBC':212343213,
'ABC':34137898
}
}
}
with open('account.txt','wb+') as f:
data = json.dumps(accounts) #json的dumps方法接收一个对象作为参数，将该对象序列化成str类型
print(data,type(data))
#因为data是str字符串类型，而打开模式是wb，所以需要将data转换成为bytes类型。
f.write(bytes(data,encoding='utf-8'))
f.flush()
f.seek(0)
data2 = f.read()
data3 = json.loads(str(data2,encoding='utf-8')) #json的loads方法接收一个str对象作为参数，并将其反序列化原对象，该对象的元素的key都将变成字符串类型。
print(data3,type(data3))
'''
‘{"1000": {"name": "John", "email": "john3333@163.com", "passwd": "abc123", "balance": 15000, "phone": 13641280280, "bank_acc": {"ICBC": 14324234, "CBC": 23523213, "ABC": 34267898}}, "1001": {"name": "Lucy", "email": "lucy3333@163.com", "passwd": "abc456", "balance": -15000, "phone": 13641287898, "bank_acc": {"ICBC": 1231412, "CBC": 212343213, "ABC": 34137898}}}’ <class 'str'>
{'1000': {'name': 'John', 'email': 'john3333@163.com', 'passwd': 'abc123', 'balance': 15000, 'phone': 13641280280, 'bank_acc': {'ICBC': 14324234, 'CBC': 23523213, 'ABC': 34267898}}, '1001': {'name': 'Lucy', 'email': 'lucy3333@163.com', 'passwd': 'abc456', 'balance': -15000, 'phone': 13641287898, 'bank_acc': {'ICBC': 1231412, 'CBC': 212343213, 'ABC': 34137898}}} <class 'dict'>
'''
