浅谈python中处理时间的模块

我们知道,Python提供了三种时间函数,时间模块 time、基本时间日期模块 datetime 和日历模块 Calendar。

一、time模块

1、在time模块中,可以用三种表现形式来表示时间,分别是时间戳、格式化时间字符串和结构化时间:

1).时间戳,通过time.time()获得

>>> time.time()
1545027641.4434128

2).格式化时间字符串,通过类似于time.strftime("%Y-%m-%d %H:%M:%S")这样的表达式获得

>>> time.strftime("%Y-%m-%d %H:%M:%S")
‘2018-12-17 14:22:49‘

下面是python中时间日期格式化符号:

%a    本地星期名称的简写(如星期四为Thu)
%A    本地星期名称的全称(如星期四为Thursday)
%b    本地月份名称的简写(如八月份为agu)
%B    本地月份名称的全称(如八月份为august)
%c    本地相应的日期表示和时间表示
%d    一个月中的第几天(01 - 31)
%f    微秒(范围0.999999)
%H    一天中的第几个小时(24小时制,00 - 23)
%I    第几个小时(12小时制,0 - 11)
%j    一年中的第几天(001 - 366)
%m    月份(01 - 12)
%M    分钟数(00 - 59)
%p    本地am或者pm的标识符
%S    秒数(00 - 59)
%U    一年中的星期数。(00 - 53星期天是一个星期的开始。)第一个星期天之 前的所有天数都放在第0周。
%w    一个星期中的第几天(0 - 6,0是星期天)
%W    和%U基本相同,不同的是%W以星期一为一个星期的开始。
%x    本地相应的日期表示
%X    本地相应的时间表示
%y    两位数的年份表示(00-99)
%Y    四位数的年份表示(000-9999)
%z    与UTC时间的间隔(如果是本地时间,返回空字符串)
%Z    时区的名字(如果是本地时间,返回空字符串)
%%    %本身

3).结构化时间,或者叫时间元祖,通过time.localtime()获得,返回一个时间元祖

>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=17, tm_hour=14, tm_min=36, tm_
sec=24, tm_wday=0, tm_yday=351, tm_isdst=0)

其中:

tm_year(年)                  2018
tm_mon(月)                   1 到 12
tm_mday(日)                  1 到 31
tm_hour(时)                  0 到 23
tm_min(分)                   0 到 59
tm_sec(秒)                   0 到 61 (60或61 是闰秒)
tm_wday(weekday)             0到6 (0是周一)
tm_yday(一年的第几天)          1 到 366
tm_isdst(是否是夏令时)         -1, 0, 1, -1是决定是否为夏令时的标志

2.关于time模块的一些基本使用方法:

1)time.sleep(t)  其中参数 t 指推迟执行的秒数

2)time.time() 返回当前时间的时间戳

import time

def f():
    time.sleep(3)
t1 = time.time()
f()
t2 = time.time()
print(t2-t1)

#3.001171588897705

3)time.localtime([ sec ]) 格式化时间戳为本地的时间。 如果sec参数未输入,则以当前时间为转换标准。

4)time.gmtime([ sec ]) 格式化时间戳为格林威治标转时间。 如果sec参数未输入,则以当前时间为转换标准。

5)time.strftime(format[, t]) 其中参数format表示格式化字符串,可选参数是一个struct_time对象

6)time.strptime(string[,format])  是time.strftime()方法的逆向操作

>>> time.strftime("%Y-%m-%d %H:%M:%S")
‘2018-12-17 15:17:17‘
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
‘2018-12-17 07:17:42‘
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(1545030000))
‘2018-12-17 15:00:00‘
time.strptime(‘2018-12-17‘, ‘%Y-%m-%d‘)

time.struct_time(tm_year=2018, tm_mon=12, tm_mday=17, tm_hour=0, tm_min
0, tm_sec=0, tm_wday=0, tm_yday=351, tm_isdst=-1)

7)time.asctime([t]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2018"的字符串,其中 t -- 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值。没有传参则默认为time.localtime()。

>>> time.asctime()
‘Mon Dec 17 15:20:51 2018‘
>>> time.asctime(time.localtime())
‘Mon Dec 17 15:21:03 2018‘
>>> time.asctime(time.localtime(1545030000))
‘Mon Dec 17 15:00:00 2018‘
>>> time.asctime(time.gmtime())
‘Mon Dec 17 07:21:36 2018‘
>>> time.asctime((2018, 12, 17, 15, 0, 0, 0, 351, 0))
‘Mon Dec 17 15:00:00 2018‘

8)time.ctime([ sec ]) 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。 如果参数未给或者为None的时候,将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))。没有返回值。

>>> time.ctime()
‘Mon Dec 17 15:29:33 2018‘
>>> time.ctime(1545030000)
‘Mon Dec 17 15:00:00 2018‘

9)time.clock() 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时。这个需要注意,在不同的系统上含义不同。在UNIX系统上,它返回的是"进程时间",它是用秒表示的浮点数(时间戳)。而在WINDOWS中,第一次调用,返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。

import time

def procedure():
    time.sleep(3)

t = time.clock()
procedure()
print (time.clock() - t, "seconds process time")

#2.999830285124656 seconds process time

10)time.mktime(t) 执行与gmtime(), localtime()相反的操作,它接收struct_time对象作为参数,返回用秒数来表示时间的浮点数。如果输入的值不是一个合法的时间,将触发 OverflowError 或 ValueError。其中 t -- 结构化的时间或者完整的9位元组元素。

 time.mktime(time.localtime())
 1545033603.0

 time.mktime((2018, 12, 17, 16, 0, 0, 0, 351, 0))
 1545033600.0

二)datatime模块

datatime模块重新封装了time模块,提供更多接口,提供的类有:time,date,datetime,timedelta,tzinfo。

1.time类

time类表示时间值,属性有hour minute  second microsecond tzinfo

>>> import datetime
>>> t = datetime.time(11, 12, 13)
>>> print(t)
11:12:13
>>> print(t.hour)
11
>>> print(t.minute)
12
>>> print(t.second)
13
>>> print(t.microsecond)
0
>>> print(t.tzinfo)
None

2.date类

日期值用date 类表示。实例具有属性year,month和 day。

>>> today = datetime.date.today()
>>> print(today)
2018-12-17
>>> today.year
2018
>>> today.month
12
>>> today.day
17
>>> t = today.timetuple()
>>> print(t)
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=17, tm_hour=0, tm_min=0, tm_se
c=0, tm_wday=0, tm_yday=351, tm_isdst=-1)
>>> d1 = datetime.date(2018,10,1)
>>> print(d1)
2018-10-01
>>> d2 = d1.replace(month=11)
>>> print(d2)
2018-11-01

3.timedelta类

用于时间的加减

>>> print(datetime.timedelta(microseconds=1))
0:00:00.000001
>>> print(datetime.timedelta(milliseconds=1))
0:00:00.001000
>>> print(datetime.timedelta(seconds=1))
0:00:01
>>> print(datetime.timedelta(minutes=1))
0:01:00
>>> print(datetime.timedelta(hours=1))
1:00:00
>>> print(datetime.timedelta(days=1))
1 day, 0:00:00
>>> print(datetime.timedelta(weeks=1))
7 days, 0:00:00
>>> today = datetime.date.today()
>>> print(today)
2018-12-17
>>> one_day = datetime.timedelta(days=1)
>>> print(one_day)
1 day, 0:00:00
>>> yesterday = today - one_day
>>> print(yesterday)
2018-12-16
>>> tomorrow = today + one_day
>>> print(tomorrow)
2018-12-18
>>> print(tomorrow - yesterday)
2 days, 0:00:00
>>> print(yesterday - tomorrow)
-2 days, 0:00:00

4.datetimetime类

datetime相当于date和time结合起来。其属性有year, month, day, hour , minute , second , microsecond , tzinfo

>>> today = datetime.datetime.today()
>>> print(today)
2018-12-17 21:43:12.993074
>>> t = today.strftime("%a %b %d %H:%M:%S %Y")
>>> print(t)
Mon Dec 17 21:43:12 2018

5.tzinfo类

tzinfo类表示时区,但由于是抽象类,不能直接实现

三、calendar

calendar模块有很广泛的方法用来处理年历和月历

>>> import calendar
>>> cal = calendar.month(2018, 12)
>>> print(cal)
   December 2018
Mo Tu We Th Fr Sa Su
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

基本方法:

#设置每周以周三开始算
>>> calendar.setfirstweekday(2)
#判断是否是闰年
>>> print(calendar.isleap(2018))
False
#返回某月的第一天是星期几和这个月的天数
>>> print(calendar.monthrange(2018, 12))
(5, 31)
#返回某月每一周的列表集合
>>> print(calendar.monthcalendar(2018, 12))
[[0, 0, 0, 1, 2, 3, 4], [5, 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17, 18], [
19, 20, 21, 22, 23, 24, 25], [26, 27, 28, 29, 30, 31, 0]]
>>> calendar.setfirstweekday(0)
>>> print(calendar.monthcalendar(2018, 12))
[[0, 0, 0, 0, 0, 1, 2], [3, 4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16], [17
, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30], [31, 0, 0, 0, 0, 0, 0]]

原文地址:https://www.cnblogs.com/m-chen/p/10132548.html

时间: 2024-11-08 03:01:37

浅谈python中处理时间的模块的相关文章

浅谈python中的递归

python 浅谈 递归函数 最近在自学一些python,找了些资料.自己慢慢研究到了递归函数这一章,碰到个很经典的例子.汉诺塔的移动.一开始尝试自己写的时候发现,这东西怎么可能写的出来.但是看到别人写出来以后发现,这东西真的能写出来. 本着借鉴的目的想去分析一下别人写的东西.觉得很有意思想给大家分享一下,如果有误请大家指正首先大家可以先自己想想如何能写出来. 先说一下:所谓的递归,我认为就是不断重复调用.直到return 出当前的递归循环.在我拆分的过程中,大家不妨先自己想一下结果,然后看一下

浅谈Python中的编码规则

注:本人用Python3.4作为学习版本,以下学习心得只适用于Python3.4. 之前拜读了金角大王Alex关于编码的解答,收获颇多.特此致谢,以下仅谈一谈作为一个初学者,对编码的理解. 我所了解的编码,大致分为两类:第一类是支持中文的编码集:第二类是支持英文的编码集.至于别国的编码集,暂且不做讨论. 常见编码:ASCII:Unicode:UTF-8:big5,:GB2312:GBK:GB18030 接下来,我对以上编码进行分类: 只支持英文和特殊字符的编码:ASCII ASCII是基于拉丁字

浅谈python中得import xxx,from xxx import xxx, from xxx import *

在python中import跟from import都是用来导入的,但是导入的机制不同 1.import xxx:导入模块,或者文件夹,对于调用模块或者文件夹中子模块的变量或者函数,需要使用"模块".XX来调用 2.from xx import xx:导入的是函数或者变量,类,可以直接使用xx 3.from xx import *:导入xx中得全部"公开"变量,属性,公开指的是不是以"_"开头,除非模块或包中的"__all__"

浅谈python中的一般方法、静态方法(staticmethod)和类方法(classmethod)

我们先来简单谈谈python类中一般方法.静态方法和类方法的区别. 1.类中的一般方法 一般方法在定义的时候,需要有表示类实例的参数(通常以self表示,例如def foo(self,arg1,arg2--)),一般方法不能通过类名.方法名()来调用,必须先创建类的实例,然后通过实例.方法名()来调用. 2.类中的静态方法 类中的静态方法用"@staticmethod"来修饰,静态方法在定义的时候,不需要表示类的实例,可想类外的方法定义一样.静态方法可以通过类名.方法名()和实例.方法

浅谈python中字典

1.字典的定义方式有以下: a=dict(one=1,two=2,three=3) b={'one':1,'two':2,'three':3} c=dict(zip(['one','two','three'],[1,2,3])) d=dict([('two',2),('one',1),('three',3)]) e=dict({'three':3,'one':1,'two':2}) 其中这四种定义方式完全等效,有一点需要牢记,标准库中所有的映射类型都是通过字典(dict)来实现,其中只有可散列(

浅谈python中的“ ==” 与“ is”、还有cmp

总之,比较内容相等使用 '==' 1.is" 是用来比较 a 和 b 是不是指向同一个内存单元,而"=="是用来比较 a 和 b指向的内存单元中的值是不是相等 2.python有一个叫小整数对象池的东西,python为了优化速度,会把[-5,256]之间的数据提前存放在小整数对象池中,程序中只要用的[-5,256]之间的数据不会再重新创建一份,都是指向对象池中的同一份数据,除了这个区间之外的整数数据,每次使用时系统都会重新申请一块内存,用来存储数据,这样之前的现象也就不奇怪了

浅谈Python中with(上下文管理器)的用法

例子一 首先来看一段代码: class Foo(object): def __init__(self): print('实例化一个对象') def __enter__(self): print('进入') def __exit__(self, exc_type, exc_val, exc_tb): print('退出') obj = Foo() with obj: print('正在执行') 上面代码执行结果为: 实例化一个对象 进入 正在执行 退出 结论1 我们知道,实例化Foo,得到obj对

浅谈python中selenium库调动webdriver驱动浏览器的实现原理

最近学web自动化时用到selenium库,感觉很神奇,遂琢磨了一下,写了点心得. 当我们输入以下三行代码并执行时,会发现新打开了一个浏览器窗口并访问了百度首页,然而这是怎么做到的呢? 1 from selenium import webdriver 2 driver = webdriver.Chrome() 3 driver.get('http://www.baidu.com') 首先我们来看一下selenium库的结构: 很显然,selenium就是一个软件包,里面有两个一级子包,commo

浅谈python中的引用和拷贝问题

一.引用 a = ['a', 'b', 'c'] b = a print(id(a)) print(id(b)) 135300560 135300560 可以看到,变量a 和 b 的 id是完全一样的,这就说明a和b是同时指向内存的同一个区域的,即b随a的变化而变化. a = ['a', 'b', 'c'] b = a a[1] = 'd' print(b) b[2] = 'e' print(a) ['a', 'd', 'c'] ['a', 'd', 'e'] 二.浅拷贝 浅拷贝只是复制了的父对