1、python

 

什么是时间元组？

很多Python函数用一个元组装起来的9组数字处理时间

 

python中时间日期格式化符号：

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

 

1>time模块：
 
返回当前时间的时间戳timestamp
 
In   : time.time()
Out: 1408008711.730218
 
struct_time时间元组：接收时间戳，并返回时间元组
 
将一个时间戳转换成一个当前时区的struct_time，如果seconds参数未输入，则以当前时间为转换标准
未提供secs参数时，按当前时间为准
In   : time.localtime()
Out: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=14, tm_hour=17, tm_min=23, tm_sec=48, tm_wday=3, tm_yday=226, tm_isdst=0)

提供secs为当前时间戳时
In   : time.time()
Out: 1408008232.217969
In   : time.localtime(time.time())
Out: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=14, tm_hour=17, tm_min=24, tm_sec=2, tm_wday=3, tm_yday=226, tm_isdst=0)
 
time.mktime(t)
接收时间元组，返回时间戳
 
In   : time.mktime(time.localtime())
Out: 1560426996.0
 
获取格式化的时间

接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
In   : time.asctime()
Out: Thu Jun 13 19:32:35 2019
 
日期转化成字符串。
  
格式化输出想要的时间
In   : time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
Out: 2019-06-13 19:41:41
 
不加参数时，默认的输出当前时间
In   : time.strftime('%Y-%m-%d %H:%M:%S')
Out: 2019-06-13 19:41:41
 
字符串转换为时间元组。
 
In   : time.strptime('%Y-%m-%d %H-%M-%S','2019-06-13 19:44:35')
Out: time.struct_time(tm_year=2019, tm_mon=6, tm_mday=13, tm_hour=19, tm_min=46, tm_sec=56, tm_wday=3, tm_yday=164, tm_isdst=-1)
 
time.gmtime()
将一个时间戳转换为UTC时区（0时区）的struct_time类型的对象
 
In   : a=os.path.getmtime('E:\pythonwork\os.py')
In   : b=time.strftime('%Y-%m-%d %H:%M:%S',time.gmtime(a))
Out:1563505908.7631714
Out:2019-07-19 03:11:48
 
time 模块常用方法小记
time.sleep(secs)
线程推迟指定的时间运行
适合放在脚本里，定时sleep一会然后继续干啥
In        : while True:
   ......: time.sleep(3)
   ......: print(time.strftime('%H:%M:%S'))
   ......:
20:08:08
20:08:11
20:08:14
......
 
 
2>datetime模块： 
 
datetime模块常用的主要有下面这四个类：
1. datetime.date: 是指年月日构成的日期(相当于日历)
2. datetime.time: 是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)
3. datetime.datetime: 上面两个合在一起，既包含时间又包含日期
4. datetime.timedelta: 时间间隔对象(timedelta)。一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。
 
2.1>datetime.date 类
 
2.1.1>新建一个date对象，日期为今天，既可以直接调用datetime.date.today()，也可以直接向datetime.date()传值，如下：
In   : today = datetime.date.today()
Out: 2019-06-11
In   : time = datetime.date(2014,8,6)
Out: 2014-08-06
 
2.1.2>datetime.date.strftime(format) 格式化为需要的时间，如常用的 “年-月-日 小时：分钟：秒” 格式
In   : today = datetime.date.today()
In   : today.strftime('%Y-%m-%d %H:%M:%S')
Out: '2014-08-15 00:00:00’
date对象中小时、分钟、秒默认都是0，纪元年的那个时间
 
2.1.3>datetime.date.timetuple()转成struct_time格式，这样传递给time.mktime(t)后，直接转成时间戳格式
In   : today = datetime.date.today()
In   : today.timetuple()
Out: time.struct_time(tm_year=2019, tm_mon=6, tm_mday=13, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=164, tm_isdst=-1)
In   : time.mktime(today.timetuple())
Out: 1560428792.0
 
2.1.4>datetime.date.replace(year,month,day) 返回一个替换后的date对象
In   : today = datetime.date.today()
In   : today.replace(year=2018)
Out: 2018-06-13
 
2.1.5>datetime.date.fromtimestamp(timestamp)将时间戳转化为date对象
In   :datetime.date.fromstamp(1560428792.0)
Out: 2019-06-13
 
2.2>datetime.time类
2.2.1>创建时间
In   : t=datetime.time(8,43,20)
Out: 08:45:20
 
2.2.2>datetime.time.strftime()
格式化输出
In   : t.strftime(%Y-%m-%d %H:%M:%S')
Out: '1900-01-01 08:45:20'
time对应年、月、日为1900，01，01，纪元年的时间
 
2.2.3>datetime.time.replace(),返回一个替换后的date对象
In   : t.replace(hour=9)
Out: 09:45:20
 
2.3>datetime.datetime类
2.3.1>新建一个datetime对象，日期为今天，既可以直接调用datetime.datetime.today()，也可以直接向datetime.datetime()传值，如下：
In   : tt = datetime.datetime.today()
Out: 2019-06-13 21:13:58.990742
 
In   : tt = datetime.datetime(2019,6,13,21,14,45,99089)
Out: 2019-06-13 21:15:45.099089
 
2.3.2>datetime.datetime.now()，当不指定时区时，和datetime.datetime.today()结果一样
In   : tt = datetime.datetime.now()
Out: 2019-06-13 21:19:00.345391
 
2.3.3>datetime.datetime.strftime()，格式化为所需要的时间
In   : tt = datetime.datetime.now()
In   : tt.strftime('%Y-%m-%d %H:%M:%S')
Out: 2019-06-13 21:22:09
 
2.3.4>datetime.datetime.timetuple()，转成struct_time格式，这样传递给time.mktime(t)后，转化成时间戳格式
In   : tt = datetime.datetime.now
In   : tt.timetuple()
Out: time.struct_time(tm_year=2019, tm_mon=6, tm_mday=13, tm_hour=21, tm_min=27, tm_sec=25, tm_wday=3, tm_yday=164, tm_isdst=-1)
In   : time.mktime(tt.timetuple())
Out: 1560432519.0
 
2.3.5>datetime.datetime.replace(year,month,day)，返回一个替换后的date对象
In   : tt = datetime.datetime(2019,6,13,21,30,23,790899)
In   : tt.replace(year=2018)
Out: 2018-06-13 21:30:23.790899
 
2.3.6>datetime.datetime.fromtimestamp()，将时间戳转化成date对象
In   : datetime.datetime.fromtimestamp(1560432519.0)
Out: 2019-06-13 21:28:39
 
2.4>datetime.timedelta类
主要做时间的加减法用，如下：
In   : today = datetime.datetime.today()
In   : yesterday = today - datetime.timedelta(days=1)
Out: 2019-06-12 21:15:45.099089
 
time & datetime 常用模块小记
获取时间差，计算程序执行的时间：
 
使用time模块：
In    : def t():
  ......:   start = time.time()
  ......:   time.sleep(10)
  ......:   end = time.time()
  ......:   print(end - start)
  ......:
 
In    : t():
10.0014948845
 
使用datetime模块：
In   : starttime = datetime.datetime.now()
In   : endtime = datetime.datetime.now()
In   : print(endtime - starttime).seconds
 
 
3>日历：

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。

 

打印某月的日历
import calendar
cal=calendar.month(2019,6)
print(cal)

执行以上程序，输出结果为：

 

模块包含了以下内置函数：

calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
 
calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。
 
calendar.isleap(year)

是闰年返回 True，否则为 false。

import calendar
cal=calendar.isleap(2019)
print(cal)

执行以上程序，返回的结果为:

 

calendar.leapdays(y1,y2)

返回在Y1，Y2两年之间的闰年总数。

import calendar
cal=calendar.leapdays(2008,2016)
print(cal)

执行以上程序，返回的结果为:

 
calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
 
calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
import calendar
cal=calendar.monthcalendar(2019,7)
print(cal)

执行以上程序，返回的结果为:

 

calendar.monthrange(year,month)

返回两个整数。第一个是该月的星期几，第二个是该月有几天。星期几是从0（星期一）到 6（星期日）。

import calendar
cal=calendar.monthrange(2019,7)
print(cal)

执行以上程序，返回的结果为:

(0, 31)解释：0 表示 2019 年 7 月份的第一天是周一，31 表示 2019 年 7 月份总共有 31 天。

 

calendar.prcal(year,w=2,l=1,c=6)

相当于 print calendar.calendar(year,w,l,c).
 
calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar（year，w，l，c）。
 
calendar.setfirstweekday(weekday)
设置每周的起始日期码。0（星期一）到6（星期日）。
 
calendar.timegm(tupletime)
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。 

calendar.weekday(year,month,day)

返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

 

 

perf_counter 进度条实例：

import time

scale = 50

print("执行开始".center(scale//2,"-"))  # .center() 控制输出的样式，宽度为 25//2，即 22，汉字居中，两侧填充 -

start = time.perf_counter() # 调用一次 perf_counter()，从计算机系统里随机选一个时间点A，计算其距离当前时间点B1有多少秒。当第二次调用该函数时，默认从第一次调用的时间点A算起，距离当前时间点B2有多少秒。两个函数取差，即实现从时间点B1到B2的计时功能。
for i in range(scale+1):  
    a = '*' * i             # i 个长度的 * 符号
    b = '.' * (scale-i)  # scale-i） 个长度的 . 符号。符号 * 和 . 总长度为50
    c = (i/scale)*100  # 显示当前进度，百分之多少
    dur = time.perf_counter() - start    # 计时，计算进度条走到某一百分比的用时
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='')  # \r用来在每次输出完成后，将光标移至行首，这样保证进度条始终在同一行输出，即在一行不断刷新的效果；{:^3.0f}，输出格式为居中，占3位，小数点后0位，浮点型数，对应输出的数为c；{}，对应输出的数为a；{}，对应输出的数为b；{:.2f}，输出有两位小数的浮点数，对应输出的数为dur；end=''，用来保证不换行，不加这句默认换行。
    time.sleep(0.1)     # 在输出下一个百分之几的进度前，停止0.1秒
print("\n"+"执行结果".center(scale//2,'-'))

 执行以上程序，输出结果为：