python day7： time,datetime,sys,pickle,json模块

python day 7

2019/10/10

学习资料来自老男孩教育

目录

• python day 7
  • 1. time模块
  • 2. datetime模块
    • 2.1 date类
    • 2.2 time类
    • 2.3 datetime类
    • 2.4 timedelta类
    • 2.5 tzinfo时区类
  • 3. sys模块
  • 4.pickle序列化模块与json序列化模块

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