python中import time用法_python3中time模块的用法及说明

python中，导入time模块使用的命令是

import time

可以使用以下命令查看time模块内置的能够使用的方法：

dir(time)

可以使用以下命令查看time模块中每个内置方法的说明：

help(time.time_method)

比如time模块下有一个time.time的方法，现在我想查看这个方法的官方文档，就可以使用这样的命令：

help(time.time)

时间的表示形式：

在python中，通常有三种方式来表示时间

时间戳(timestamp):通常来说，时间戳表示从1970年1月1日00:00:00开始按秒计算的偏移量，它的值是float类型

格式化的时间字符串(Format String):‘2017-06-20’

结构化时间(struct_time)：struct_time元组共有９个元素：(年，月，日，时，分，秒，一年中的第几周，一年中的第几天等)

time模块中内置的常用的方法

asctime

接受时间元组并返回一个可读的形式"Tue May 30 17:17:30 2017"(2017年5月30日周二17时17分30秒)的24个字符的字符串

>>> time.asctime()

'Thu Jun 22 19:27:19 2017'

ctime

作用相当于asctime(localtime(secs)),未给参数相当于asctime()

ctime(seconds) -> string

>>> time.ctime()

'Thu Jun 22 19:34:35 2017'

gmtime

接收时间辍(1970纪元年后经过的浮点秒数)并返回格林威治天文时间下的时间元组t(t.tm_isdst始终为0)

gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst)

>>> time.gmtime()

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=22, tm_hour=11, tm_min=35, tm_sec=12, tm_wday=3, tm_yday=173, tm_isdst=0)

localtime

接收时间辍(1970纪元年后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取为０或１，取决于当地当时是不是夏令时)

localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min, tm_sec,tm_wday,tm_yday,tm_isdst)

>>> time.localtime()

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=22, tm_hour=19, tm_min=35, tm_sec=35, tm_wday=3, tm_yday=173, tm_isdst=0)

mktime

接受时间元组并返回时间辍(1970纪元年后经过的浮点秒数)

mktime(tuple) -> floating point number

>>> time.mktime(time.localtime())

1498131370.0

sleep

推迟调用线程的运行，secs的单位是秒

strftime

把一个代表时间的元组或者struct_time(如由time.localtime()和time.gmtime()返回)转化为格式化的时间字符串．如果t未指定，将传入time.localtime()，如果元组中任命一个元素越界，将会抛出ValueError异常

strftime(format[, tuple]) -> string

Commonly used format codes:

%Y Year with century as a decimal number.===>完整的年份

%m Month as a decimal number [01,12].===>月份(01-12)

%d Day of the month as a decimal number [01,31].===>一个月中的第几天(01-31)

%H Hour (24-hour clock) as a decimal number [00,23].===>一天中的第几个小时(24小时制，00-23)

%M Minute as a decimal number [00,59].===>分钟数(00-59)

%S Second as a decimal number [00,61].===>秒(01-61)

%z Time zone offset from UTC.===>用+HHMM或者-HHMM表示距离格林威治的时区偏移(H代表十进制的小时数，M代表十进制的分钟数)

%a Locale's abbreviated weekday name.===>本地(local)简化星期名称

%A Locale's full weekday name.===>本地完整星期名称

%b Locale's abbreviated month name.===>本地简化月份名称

%B Locale's full month name.===>本地完整月份名称

%c Locale's appropriate date and time representation.===>本地相应的日期和时间表示

%I Hour (12-hour clock) as a decimal number [01,12].===>一天中的第几个小时(12小时制，01-12)

%p Locale's equivalent of either AM or PM.===>本地am或者pm的相应符

>>> time.strftime("%Y-%m-%d")

'2017-06-22'

>>> time.strftime("%Y-%m-%d %H-%H-%S")

'2017-06-22 19-19-28'

strptime

把一个格式化时间字符串转化为struct_time,实际上它和strftie()是逆操作

strptime(string, format) -> struct_time

>>> time.strptime("2017-06-21","%Y-%m-%d")

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=172, tm_isdst=-1)

>>> time.strptime("2017-06-21 12-34-45","%Y-%m-%d %H-%M-%S")

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=21, tm_hour=12, tm_min=34, tm_sec=45, tm_wday=2, tm_yday=172, tm_isdst=-1)

struct_time

把一个时间转换成结构化时间

>>> time.struct_time(time.localtime())

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=22, tm_hour=19, tm_min=42, tm_sec=7, tm_wday=3, tm_yday=173, tm_isdst=0)

time

返回当前时间的时间戳(1970元年后的浮点秒数)

>>> time.time()

1498131760.7711384

>>> time.time()

1498131764.7621822

几种时间形式的转换

1.把时间戳转换成结构化时间，使用time.localtime或time.gmtime命令。

>>> t1=time.time()

>>> print(t1)

1498132526.8227696

>>> t2=time.localtime(t1)

>>> print(t2)

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=22, tm_hour=19, tm_min=55, tm_sec=26, tm_wday=3, tm_yday=173, tm_isdst=0)

2.把结构化时间转换成时间戳，使用time.mktime命令

>>> t3=time.struct_time(time.localtime())

>>> print(t3)

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=22, tm_hour=19, tm_min=58, tm_sec=29, tm_wday=3, tm_yday=173, tm_isdst=0)

>>> t4=time.mktime(t3)

>>> print(t4)

1498132709.0

3.把结构化时间转换成时间字符串，使用time.strftime命令

>>> t1=time.localtime()

>>> print(t1)

time.struct_time(tm_year=2017, tm_mon=6, tm_mday=22, tm_hour=20, tm_min=0, tm_sec=37, tm_wday=3, tm_yday=173, tm_isdst=0)

>>> t2=time.strftime("%Y-%m-%d",t1)

>>> print(t2)

2017-06-22

4.把字符串时间转换成结构化时间，使用time.strptime命令

>>> t1="2017-05-20 08:08:10"

>>> print(t1)

2017-05-20 08:08:10

>>> t2=time.strptime(t1,"%Y-%m-%d %H:%M:%S"）

>>> print(t2)

time.struct_time(tm_year=2017, tm_mon=5, tm_mday=20, tm_hour=8, tm_min=8, tm_sec=10, tm_wday=5, tm_yday=140, tm_isdst=-1)

工作中常用到的转换方法

# coding: utf-8

# @Time: 2019/9/18 11:14

# @Author: renpingsheng

from __future__ import division

import time

import datetime

def get_cutten_timestr(flag=True):

"""

获取当前时间字符串

@return:

"""

if flag:

return datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

return datetime.datetime.now().strftime('%Y-%m-%d')

def parse_timestr_to_timestamp(time_str, flag=True):

"""

把时间字符串转换为时间戳格式

:param time_str: 时间字符串,格式为：2019-01-01 12:12:12 或 2019-01-01

:param flag: 标志位，决定输入时间字符串的格式

:return: 时间戳格式

"""

if flag:

struct_time = time.strptime(time_str, "%Y-%m-%d %H:%M:%S") # 2019-01-01 12:12:12

else:

struct_time = time.strptime(time_str, "%Y-%m-%d") # 2019-01-01

return time.mktime(struct_time)

def parse_month_to_timestamp(month_str, flag=True):

"""

把月份字符串转化为时间戳

:param month_str: 月份，例如：2019-01 或者 2019.01

:param flag: 标志位，控制输入月份字符串的格式

:return:

"""

if flag:

struct_time = time.strptime(month_str, "%Y-%m")

else:

struct_time = time.strptime(month_str, "%Y.%m")

return time.mktime(struct_time)

def parse_timestamp_to_timestr(time_stamp, flag=True):

"""

把时间戳转换为时间字符串

:param time_stamp: 时间戳

:param flag: 标志位，可以指定输出时间字符串的格式

:return: 时间字符串,格式为：2019-01-01 12:12:12 或 2019-01-01

"""

localtime = time.localtime(time_stamp)

if flag:

time_str = time.strftime("%Y-%m-%d %H:%M:%S", localtime)

else:

time_str = time.strftime("%Y-%m-%d", localtime)

return time_str

def get_day_list(start_timestamp, end_timestamp, flag=True):

"""

传入开始时间戳和结束时间戳，获取时间段内的日期列表

:param start_timestamp: 开始时间戳

:param end_timestamp: 结束时间戳

:param flag: 标志位

:return: 日期列表

"""

tmp = range(int(start_timestamp), int(end_timestamp), 3600 * 24)

if flag:

tmp_range = [{"day_str": parse_timestamp_to_timestr(i, flag=False)} for i in tmp]

else:

tmp_range = [parse_timestamp_to_timestr(i, flag=False) for i in tmp]

return tmp_range

def day_range(interval_day):

"""

获取指定天内的时间字符串的列表

:return:

"""

c_time = (int(time.time() / (24 * 3600)) + 1) * 24 * 3600

day_range_str = c_time - 24 * 3600 * interval_day

day_list = [{"day_str": parse_timestamp_to_timestr(t, flag=False)} for t in range(day_range_str, c_time, 3600 * 24)]

return day_list

def covert_time(time_str):

"""

把时间段转换为秒数

:param time_str:

:return:

"""

if time_str.endswith("h"):

stamp = float(time_str.strip("h")) * 3600

elif time_str.endswith("m"):

stamp = float(time_str.strip("m")) * 60

else:

stamp = float(time_str)

return stamp

def parse_timestr_to_datetime(timestr, flag=1):

"""

把时间字符串转化为datetime

:param timestr: 时间字符串，例如：2019-01-01 12:12:12 或者 2019.01.01 12:12:12

:param flag: 标志位，控制输入时间字符串的格式

:return:

"""

if flag == 1:

tmp_datetime = datetime.datetime.strptime(timestr, "%Y-%m-%d %H:%M:%S")

elif flag == 2:

tmp_datetime = datetime.datetime.strptime(timestr, "%Y.%m.%d %H:%M:%S")

elif flag == 3:

tmp_datetime = datetime.datetime.strptime(timestr, "%Y-%m-%d")

elif flag == 4:

tmp_datetime = datetime.datetime.strptime(timestr, "%Y-%m-%d %H:%M")

else:

tmp_datetime = datetime.datetime.strptime(timestr, "%Y-%m-%d %H:%M:%S")

return tmp_datetime

################################################

def parse_format_timestr(format_timestr):

"""

将格式字符串转换为时间戳

:param format_timestr: 格式字符串,格式： "Sat Mar 28 22:24:24 2016"

:return:

"""

tmp_timestamp = time.mktime(time.strptime(format_timestr, "%a %b %d %H:%M:%S %Y"))

return tmp_timestamp

def parse_datetime_to_string(datetime_str, flag=True):

"""

把datetime时间转化成时间字符串

:param datetime_str: datetime生成的时间，例子：datetime.datetime.now()

或者： datetime.datetime.now() - datetime.timedelta(hours=1) # 一个小时之前

或者： datetime.datetime.now() - datetime.timedelta(days=1) # 一天之前

:return:

"""

# 将日期转化为字符串 datetime => string

# 在数据库中定义字段信息时为：models.DateTimeField(auto_now_add=True)

# 查询数据库之后，使用此方法把查询到的时间转换成可用的时间字符串

# when_insert__range=(an_hour_time, now_time)

# an_hour_time和 now_time 都是 datetime时间字符串，查询两个datetime时间字符串之间的数据

if flag:

return datetime_str.strftime('%Y-%m-%d %H:%M:%S')

else:

return datetime_str.strftime('%Y-%m-%d')

def parse_datetime_to_timestamp(datetime_str):

"""

把datetime转化成时间戳

@param datetime_str: datetime时间，比如：datetime.datetime.now()

@return: 时间戳，比如：1565663994.0

"""

return time.mktime(datetime_str.timetuple())

def parse_timestamp_to_datetime(timestamp, flag=True):

"""

把时间戳转化为datetime时间

@param timestamp: 时间戳，比如：1553361411

@param flag: 标志位，决定转化成datetime的时间

@return:

"""

if flag:

return datetime.datetime.fromtimestamp(timestamp) # 东八区的datetime时间

return datetime.datetime.utcfromtimestamp(timestamp) # 正常的UTC时间

def parse_dur_time(d1, d2):

"""

获取两个datetime时间 间隔的日期数(天数，小时数和秒数)

:param d1: 开始时间

:param d2: 结束时间

:return:

"""

dur_str = ""

dur_day = (d2 - d1).days

dur_second = (d2 - d1).seconds

if dur_day > 0:

dur_str += "%s天" % str(dur_day)

if dur_second - 3600 > 0:

dur_hour = dur_second // 3600

dur_str += "%s小时" % str(dur_hour)

if (dur_second % 3600) > 60:

dur_minute = (dur_second % 3600) // 60

dur_str += "%s分钟" % str(dur_minute)

dur_str += "%s秒" % str(dur_second % 60)

return dur_str