Python에서 일반적으로 사용되는 표준 라이브러리 및 타사 라이브러리 3-날짜 및 시간 처리 모듈

시간 처리는 시간 유형 변환과 같은 프로그래밍의 일반적인 상황입니다. 백엔드 인터페이스가 매개변수를 전달할 때 일반적으로 프런트엔드에서 얻은 인터페이스 반환 값의 타임스탬프를 형식화해야 합니다. 표시. Python에서 시간을 처리하는 모듈에는 시간과 날짜/시간이 포함됩니다.

1. 시간 모듈

1. 시간 모듈 소개

시간 모듈은 시간을 처리하는 데 특별히 사용되는 Python 내장 라이브러리입니다. 서로 다른 시간 유형을 서로 변환할 수 있는 다양한 방법이 제공됩니다. 예를 들어 타임스탬프 유형을 시간 튜플로, 시간 튜플을 형식화된 시간으로, 형식화된 시간을 타임스탬프로 변환할 수 있습니다... .

2. Python에는 일반적으로 시간을 나타내는 여러 가지 방법이 있습니다.

타임 스탬프: time.time(), 매개변수 없음, 현재 타임스탬프 가져오기, 부동 소수점 유형

• 시간 문자열: time.ctime(), 초 - > string; time.asctime(), tuple -> string;
• 시간 튜플(struct_time): time.localtime()
• 시간 형식: time.strftime()

• import time
  
  # 时间戳类型
  t1 = time.time()
  print(t1)
  r_time = round(t1 * 1000)# 四舍五入，精确到毫秒
  print(r_time)
  '''
  1677555790.7605402
  1677555790761
  '''
  
  # 时间字符串
  t2 = time.asctime()
  print(t2)
  '''
  Tue Feb 28 11:44:15 2023
  '''
  
  # 时间元组
  t3 = time.localtime()
  print(t3)
  '''
  依次对应：年份，月份，一个月的第几天，几点，几分，几秒，星期几，一年中的第几天，是否为闰年
  time.struct_time(tm_year=2023, tm_mon=2, tm_mday=28, tm_hour=11, tm_min=44, tm_sec=53, tm_wday=1, tm_yday=59, tm_isdst=0)
  '''

3.

타임스탬프 유형을 타임 튜플로 변환 가능, 타임 튜플을 형식화된 시간으로 변환, 형식화된 시간을 타임스탬프로 변환 가능...

① Timestamptime tuple을 서로 변환

time.time ()는 현재 시간의 타임스탬프 반환 값 형식을 반환합니다. 1677563451.2548294

time.localtime()은 현재 시간의 시간 튜플을 반환하며 반환 값 형식은 ：time.struct_time(tm_year=2023, tm_mnotallow=2, tm_mday=28, tm_hour=13, tm_min=52, tm_sec=2, tm_wday=1, tm_yday=59, tm_isdst=0)
• time.mktime()은 시간을 변경합니다. 튜플은 부동 소수점 시간으로 변환되고 반환 값은 form: 1677556220.0

• # 时间戳<===>时间元组 相互转换
  # 1-时间戳转换为时间元组
  tt1 = time.localtime(time.time())
  print(tt1)
  '''
  time.struct_time(tm_year=2023, tm_mon=2, tm_mday=28, tm_hour=11, tm_min=48, tm_sec=57, tm_wday=1, tm_yday=59, tm_isdst=0)
  '''
  # 2-时间元组转换为时间戳
  tt2 = time.mktime(time.localtime())
  print(tt2)
  '''
  1677556220.0
  '''

• ② 시간 튜플
형식화된 시간 변환

time.strftime() 시간 튜플을 전달하면 시간 튜플을 형식화된 시간 형식으로 변환할 수 있습니다. 반환 값 형식: 2023-02-28 13: 52:02

time.strptime() 형식화된 시간을 전달하면 형식화된 시간을 시간 튜플로 변환할 수 있습니다. 반환 값 형식: time.struct_time(tm_year =2023, tm_mon=2, tm_mday=28, tm_hour=13 , tm_min=52, tm_sec=2, tm_wday=1, tm_yday=59, tm_isdst=0)

• # 时间元组<===>格式化时间 相互转换
  # 1-时间元组转换为格式化时间
  tt3 = time.localtime()
  print(time.strftime("%Y-%m-%d %H:%M:%S".format(tt3)))
  '''
  2023-02-28 13:52:02
  '''
  # 2-格式化时间转换为时间元组
  tt4 = time.strptime("2023-02-28 11:54:25", "%Y-%m-%d %H:%M:%S")
  print(tt4)
  '''
  time.struct_time(tm_year=2023, tm_mon=2, tm_mday=28, tm_hour=11, tm_min=54, tm_sec=25, tm_wday=1, tm_yday=59, tm_isdst=-1)
  '''

• 3 Timestamp
형식화된 시간 변환

타임스탬프와 형식화된 시간은 서로 직접 변환할 수 없습니다. 전환을 위해.

# 时间戳<===>格式化时间 相互转换
# 1-格式化时间转换为时间戳
time_format = "2023-02-28 19:11:56"
# 先将格式化时间转换为时间元组
time_stamp1 = time.strptime(time_format, "%Y-%m-%d %H:%M:%S")
# 再将时间元组转换为时间戳
tt7 = time.mktime(time_stamp1)
print(tt7)
'''
1677582716.0
'''
# 2-时间戳转换为格式化时间
time_stamp2 = 1677582716.0
tt8 = time.strftime("%Y-%m-%d %H:%M:%S".format(time_stamp2))
print(tt8)
'''
2023-02-28 19:11:56
'''

4 지정된 시간 유형을 시간 문자열로 변환

time.asctime() 시간 튜플을 시간 문자열로 변환합니다. 매개변수는 시간 튜플이며 반환 값은 Tue Feb 28 형식입니다. 11:51:05 2023;

time.ctime()은 타임스탬프를 시간 문자열로 변환하고 매개변수는 타임스탬프이며 반환 값은 Tue Feb 28 11:51:05

• # 指定类型时间转换为时间字符串
  # 1-时间元组转换为时间字符串
  tt5 = time.asctime(time.localtime())
  print(tt5)
  '''
  Tue Feb 28 11:51:05 2023
  '''
  # 2-时间戳转换为时间字符串
  timestamp = 1677582279.0
  tt6 = time.ctime(timestamp)
  print(tt6)
  '''
  Tue Feb 28 11:51:05 2023
  '''

  ;
• 2. Datetime 모듈

1. datetime 모듈 소개

Datetime은 시간과 날짜를 처리하기 위해 Python에 포함된 모듈입니다. Python에서 시간을 표현하는 형식에는 타임스탬프, 튜플, 형식화된 시간이라는 세 가지 형식이 있습니다. time 모듈과 유사하게 datetime 모듈은 datetime 유형을 이 세 가지 유형으로 변환할 수도 있습니다.

일반적으로 사용되는 날짜/시간 범주는 다음과 같습니다.

date: 주로 연도, 월, 일을 처리하는 데 사용되는 날짜 클래스

time: 주로 시간, 분, 초를 처리하는 데 사용되는 시간 클래스; : 날짜 클래스와 시간 클래스를 종합적으로 사용하는 날짜 및 시간 클래스는 연도, 월, 일, 시, 분, 초를 처리하는 데 사용할 수 있습니다.
• timedelta: 시간 간격을 나타내며 시간 덧셈과 뺄셈을 처리하는 데 사용됩니다.
• tzinfo: 시간대 정보를 처리하는 데 사용됩니다.
• 2. 날짜 클래스 공통 메서드 또는 속성

날짜 클래스에는 세 가지 매개변수, 즉 연도, 월, 일이 포함되며 반환 형식은 연-월-입니다. 낮.

지정된 날짜 설정

import datetime

# 设置指定日期
set_date = datetime.date(day=1, month=3, year=2025)
print(set_date)# 2025-03-01

오늘 날짜의 연월일 구하기

# 获取今天日期的年份、月份、日
today = datetime.date.today()
print("标准日期格式:", today.isoformat())# 标准日期格式: 2023-03-01
print("当前日期的三元元祖: 年、第几周、一周的第几天:", today.isocalendar())# 当前日期的三元元祖: 年、第几周、一周的第几天: (2023, 9, 3)
print("当前日期:", today)# 当前日期: 2023-03-01
print("当前年月日:", today.today())# 当前年月日: 2023-03-01
print("当前年份:", today.year)# 当前年份: 2023
print("当前月份:", today.month)# 当前月份: 3
print("当前日:", today.day)# 当前日: 1

오늘이 무슨 요일인지 판단하세요

# 判断今天是这周的第几天
today = datetime.date.today()
print("当前日期是这周的第几天(星期一==0/周日==6):", today.weekday())# 当前日期是这周的第几天(星期一==0/周日==6): 2
print("当前日期是这周的第几天(星期一==1/周日==7):", today.isoweekday())# 当前日期是这周的第几天(星期一==1/周日==7): 3

현재 날짜는 자동으로 다른 형식으로 변환됩니다

# 当前日期的其他格式
today = datetime.date.today()
print("当前日期的时间字符串形式:", today.ctime())# 当前日期的时间字符串形式: Wed Mar1 00:00:00 2023
print("当前日期的元组形式:", today.timetuple())
print("当前日期的格式化时间形式:", today.strftime("%Y-%m-%d %H:%M:%S"))# 当前日期的格式化时间形式: 2023-03-01 00:00:00

날짜 바꾸기

# 替换日期
today = datetime.date.today()
new_day = today.replace(year=2038, month=8, day=31)
print("替换后的日期为:", new_day)# 替换后的日期为: 2038-08-31

날짜 변환 형식 지정

# 指定格式转换为日期
today = datetime.date.today()
t1 = today.fromtimestamp(1691453288)# 注意精确到秒、不是毫秒
print("从时间戳转换为日期:", t1)# 从时间戳转换为日期: 2023-08-08
t2 = today.fromisoformat("2025-03-03")
print("从三元组转换为日期:", t2)# 从三元组转换为日期: 2025-03-03
t3 = today.fromisocalendar(year=2038, week=9, day=7)
print("从三元组转换为日期:", t3)# 从三元组转换为日期: 2038-03-07

3.time 클래스 일반 메서드 또는 속성

datetime.time()은 여러 매개변수를 전달할 수 있습니다.

• hour 小时
• minute 分钟
• second 秒
• microsecond 微秒
• tzinfo 时区

常用属性

t = datetime.time(hour=12, minute=59, second=59, microsecond=59)# 实例化time对象，传入时、分、秒、微秒
print("当前时间:", t)# 当前时间: 12:59:59.000059
# 常用属性
print("时:", t.hour)# 时: 12
print("分:", t.minute)# 分: 59
print("秒:", t.second)# 秒: 59
print("微秒:", t.microsecond)# 微秒: 59
print("最大时间:", t.max)# 最大时间: 23:59:59.999999
print("最小时间:", t.min)# 最小时间: 00:00:00

常用方法

t = datetime.time(hour=12, minute=59, second=59, microsecond=59)# 实例化time对象，传入时、分、秒、微秒
print("当前时间:", t)# 当前时间: 12:59:59.000059
# 常用方法
print("返回格式化时间:", t.isoformat())# 格式化时间: 12:59:59.000059
print("从格式化时间转换:", t.fromisoformat('12:00:00'))# 从格式化时间转换: 12:00:00
print("转换为格式化时间:", t.strftime("%Y-%m %H:%M:%S"))# 转换为格式化时间: 1900-01 12:59:59

4.datetime类常用方法或属性

常用属性

dt = datetime.datetime.now()# 实例化datetime类
print("当前日期:", dt)# 当前日期: 2023-03-01 15:17:00.350579
# 常用属性
print("当前年份:", dt.year)# 当前年份: 2023
print("当前月份:", dt.month)# 当前月份: 3
print("当前日:", dt.day)# 当前日: 1
print("时:", dt.hour)# 时: 15
print("分:", dt.minute)# 分: 17
print("秒:", dt.second)# 秒: 0
print("微秒:", dt.microsecond)# 微秒: 350579
print("最大时间:", dt.max)# 最大时间: 9999-12-31 23:59:59.999999
print("最小时间:", dt.min)# 最小时间: 0001-01-01 00:00:00

常用方法

dt = datetime.datetime.now()# 实例化datetime类
print("当前日期:", dt)# 当前日期: 2023-03-01 15:17:00.350579
# 常用方法
print("今天日期时间:", dt.today())# 今天日期时间: 2023-03-01 15:23:55.703063
print("当前日期:", dt.date())# 当前日期: 2023-03-01
print("当前日期时间的格式化输出:", dt.isoformat())# 当前日期时间的格式化输出: 2023-03-01T15:23:55.703063
print("当前日期的三元组:", dt.isocalendar())# 当前日期的三元组: (2023, 9, 3)
print("当前日期一周中的第几天:", dt.isoweekday())# 当前日期一周中的第几天: 3
print("从指定日期时间转换并格式化输出:", dt.fromisoformat("2023-02-28 19:11:56"))# 从指定日期时间转换并格式化输出: 2023-02-28 19:11:56
print("从指定时间戳转换并格式化输出:", dt.fromtimestamp(1677644920))# 从指定时间戳转换并格式化输出: 2023-03-01 12:28:40
print("从三元组转换并格式化输出:", dt.fromisocalendar(year=2025, week=4, day=2))# 从三元组转换并格式化输出: 2025-01-21 00:00:00

5.timedelta类

datetime.timedelta() 类可以传递多个参数，用来表示时间间隔，返回形式为标准时间格式：0:00:00

• days：时间间隔单位为天
• hour：时间间隔单位为小时
• minute：时间间隔单位为分钟
• second：时间间隔单位为秒
• milliseconds：时间间隔单位为毫秒
• microsecond：时间间隔单位为微秒

print(datetime.timedelta(days=3))# 3 days, 0:00:00
print(datetime.timedelta(hours=3))# 3:00:00
print(datetime.timedelta(minutes=10))# 0:10:00
print(datetime.timedelta(milliseconds=5000))# 0:00:05
print(datetime.timedelta(microseconds=5000000))# 0:00:05

三、timeit模块

timeit 模块提供了多种方法，可以用来测量 Python 小段代码执行时间。它既可以在命令行界面直接使用，也可以通过导入模块进行调用。

timeit 模块定义了三个实用函数和一个公共类，分别为timeit.timeit()方法、timeit.repeat()方法、timeit.default_timer()方法、timeit.Timer类。部分源码如下：

def timeit(stmt="pass", setup="pass", timer=default_timer,
 number=default_number, globals=None):
"""Convenience function to create Timer object and call timeit method."""
return Timer(stmt, setup, timer, globals).timeit(number)

def repeat(stmt="pass", setup="pass", timer=default_timer,
 repeat=default_repeat, number=default_number, globals=None):
"""Convenience function to create Timer object and call repeat method."""
return Timer(stmt, setup, timer, globals).repeat(repeat, number)

从上述源码中可以看出，无论是timeit还是repeat方法，都是先生成Timer对象，然后调用了Timer对象的timeit或repeat函数。

1.timeit.timeit()

timeit.timeit(stmt='pass', setup='pass', timer=, number=1000000)

创建一个 Timer 实例，参数分别是：

• stmt（需要测量的语句或函数）
• setup（初始化代码或构建环境的导入语句）
• timer（计时函数）
• number（每一次测量中语句被执行的次数）

注：由于 timeit() 正在执行语句，语句中如果存在返回值的话会阻止 timeit() 返回执行时间。timeit() 会取代原语句中的返回值。

"""timeit()方法"""
# 统计代码运行时间
# stmt：要测试的代码，setup：初始化导入语句、要传入的变量属性等
tm1 = timeit.timeit(stmt="[i**2 for i in testlist]", setup="testlist=range(1000)", number=3)# 统计代码运行时间
print(tm1)# 0.0007954000000000017
# 统计代码运行时间，setup为复合语句
tm2 = timeit.timeit(stmt="[i**2 for i in testlist]", setup="a=1000;testlist=range(a)", number=3)# 统计代码运行时间
print(tm2)# 0.0007886000000000282

2.timeit.repeat()

timeit.repeat(stmt='pass', setup='pass', timer=, repeat=3, number=1000000)

创建一个 Timer 实例，参数分别是：

• stmt（需要测量的语句或函数）
• setup（初始化代码或构建环境的导入语句）
• timer（计时函数）
• repeat（重复测量的次数）
• number（每一次测量中语句被执行的次数）

"""repeat()方法"""
# 统计代码运行时间，重复两次，返回结果为列表
# stmt：要测试的代码，setup：初始化导入语句、要传入的变量属性等
tp1 = timeit.repeat(stmt="[i**2 for i in testlist]", setup="testlist=range(1000)", number=3, repeat=5)
print(tp1)# [0.0007632000000000194, 0.0007527999999999979, 0.000754300000000041]
# 统计代码运行时间，setup为复合语句
tp2 = timeit.repeat(stmt="[i**2 for i in testlist]", setup="a=1000;testlist=range(a)", number=3, repeat=5)
print(tp2)# [0.0007581999999999867, 0.0007580999999999838, 0.0007536000000000209]

3.timeit.default_timer()

timeit.default_timer()默认的计时器，一般是 time.perf_counter()，time.perf_counter() 方法能够在任一平台提供最高精度的计时器（它也只是记录了自然时间，记录自然时间会被很多其他因素影响，例如计算机的负载）。

4.timeit.Timer类

timeit.Timer是计算小段代码执行速度的类：

timer = timeit.Timer(stmt='pass', setup='pass', timer=)

timer.timeit(number=10)

timer.repeat(number=10, repeat=5)

构造函数需要的参数有：

• stmt（需要测量的语句或函数）
• setup（初始化代码或构建环境的导入语句）
• timer（计时函数）

前两个参数的默认值都是 'pass'，timer 参数是平台相关的；前两个参数都可以包含多个语句，多个语句间使用分号（;）或新行分隔开。

第一次测试语句的时间，可以使用 timeit() 方法；repeat() 方法相当于持续多次调用 timeit() 方法并将结果返回为一个列表。

stmt 和 setup 参数也可以是可供调用但没有参数的对象，这将会在一个计时函数中嵌套调用它们，然后被 timeit() 所执行。注意，由于额外的调用，计时开销会相对略到。

"""Timer类"""
timer = timeit.Timer(stmt="[i**2 for i in testlist]", setup="a=1000;testlist=range(a)")
# 调用timeit方法
print(timer.timeit(number=3))# 0.0008310999999999735
# 调用repeat方法，返回一个时间列表
print(timer.repeat(number=3, repeat=3))# [0.0007549000000000028, 0.0007492000000000054, 0.0007519999999999749]

5.timeit的命令行模式

通过"python -m timeit -h"查看帮助信息：

Tool for measuring execution time of small code snippets.

用于测量小代码片段执行时间的工具。

This module avoids a number of common traps for measuring execution

times. O'Reilly에서 출판한 Python Cookbook

에서 Tim Peters의 알고리즘 장 소개를 참조하세요.

이 모듈은 실행 시간 측정과 관련된 많은 일반적인 함정을 방지합니다. O'Reilly가 출판한 Tim Peters의 Python Cookbook도 참조하세요.

라이브러리 사용법: Timer 클래스를 참조하세요.

라이브러리 사용법: Timer 클래스를 참조하세요.

명령줄 사용법:

명령줄 사용법:

python timeit.py [-n N] [-r N] [-s S] [-p] [-h] [--] [문]

옵션: 옵션:

-n/--number N: '문'을 실행할 횟수(기본값: 아래 참조)

-r/--repeat N: 타이머를 반복할 횟수(기본값 5)

-s/--setup S: 처음에 한 번 실행되는 문입니다(기본값 'pass').

이 설정 문의 실행 시간은 정해지지 않습니다.

-p/--process: time.process_time() 사용 ( 기본값은 time.perf_counter())

-v/--verbose: 원시 타이밍 결과를 인쇄합니다. 더 많은 자릿수 정밀도를 위해 반복합니다.

-u/--unit: 출력 시간 단위를 설정합니다(nsec, usec, msec 또는 sec )

-h/--help: 이 사용법 메시지를 인쇄하고 종료합니다

--: 명령문에서 옵션을 분리합니다. 명령문이 다음으로 시작할 때 사용합니다. -

statement: 시간이 지정된 명령문(기본값 'pass')

A 멀티 -line 문은 각 줄을

별도의 인수로 지정하여 제공할 수 있습니다. 인수를 따옴표로 묶고 선행 공백을 사용하면 들여쓰기가 가능합니다. 여러 -s 옵션은

유사하게 처리됩니다.

독립형 인수로서 인수를 따옴표로 묶고 선행 공백을 사용하여 들여쓰기된 줄을 만들 수 있습니다. 여러 -s 옵션 포함도 유사하게 처리됩니다.

-n이 지정되지 않으면 총 시간이 0.2초 이상이 될 때까지 10의 성공 거듭제곱을 시도하여 적절한 루프 수를 계산합니다.

참고:

pass 문 실행과 관련된 특정 기준 오버헤드가 있습니다. 이는 버전마다 다릅니다. 여기의 코드는 이를 숨기려고

하지 않지만, 기준 오버헤드는 다음과 같습니다.

인수 없이 프로그램을 호출하여 측정되었습니다.

참고: pass 문을 실행하세요. 버전마다 다릅니다. 여기의 코드는 이를 숨기려고 시도하지 않지만 이를 알고 있어야 합니다. 기준 오버헤드는 매개변수 없이 프로그램을 호출하여 측정할 수 있습니다.

클래스:

Timer

함수:

timeit(string, string) -> float

repeat(string, string) -> list

default_timer() -> float

특정 사용법:

python timeit .py [-n N] [-r N] [-s S] [-p] [-h] [--] [문]

각 옵션의 의미:

옵션--number=N횟수 명령문이 실행되었습니다 을 사용하세요.

프로토타입	의미	-n N
-r N	--repeat=N	테스트 반복 횟수(기본값 5회)
-s S	--set 위로= S	처음에 실행된 명령문(예: 변수, 속성 등이 전달됨
-p	--process	실제 실행 대신 프로세스 시간을 측정) time (기본 time.perf_counter() 대신 time.process_time( ) 사용)
-v	--verbose	더 정확한 숫자를 위해 반복합니다.
-u	--unit	출력 시간 단위 설정(nsec, usec, msec 또는 sec)
-h	--help	도움말 정보 출력
--		문이 다음으로 시작하는 경우 -
성명		시간을 초과할 명령문(기본값은 "통과")

四、时间应用场景实践

1.获取当前时间的时间戳

背景

这种场景主要适用于在接口传参时的时间日期转换，因为在后端接口传参中，一般都是用时间戳进行传递，而不是传统的"2023-02-28 19:11:56"格式。例如当前有一个新增车辆的接口，其中部分字段涉及到时间日期转换：道路运输证有效期止、行驶证有效期止：

在页面上我选择的都是2023-03-31，但在真实的接口传参中，会自动将其转换为时间戳的形式：

时间2023-03-31自动转换为了时间戳1680192000000，我们再通过工具将1680192000000转换为正常的格式化时间看看确实为2023-03-31，转换正确：

时间戳转换网站：​​https://www.php.cn/link/6e187996e9cc9d93c5f4452695768290​​

Python接口调用

使用Python进行接口测试或模拟接口调用，也需要传递时间戳，Python中time.time()可以直接获取到当前时间的时间戳，但是获取到的是浮点型的数，可以借助round方法进行四舍五入，然后再*1000，从而精确到毫秒：

# 获取当前时间的时间戳
current_time = time.time()
print(current_time)# 1677635951.946926
timestamp = round(current_time) * 1000
print(timestamp)# 1677635952000

# 将时间戳转换为格式化时间
format_time = time.strftime("%Y-%m-%d %H:%M:%S".format(current_time))
print(format_time)# 2023-03-01 09:59:11

将上述代码优化一下，封装成函数，直接进行调用：

def get_current_timestamp():
# 获取当前时间的时间戳
current_time = time.time()
timestamp = round(current_time) * 1000
return timestamp


def timestamp_to_format(timestamp):
# 将时间戳转换为格式化时间
format_time = time.strftime("%Y-%m-%d %H:%M:%S".format(timestamp))
return format_time

2.获取指定日期时间的时间戳

同样是模拟接口调用，但是在造数据时，时间字段我想要模拟的不是当前时间，而是指定的日期时间，如三小时前、三天前等。以下分别介绍time模块和datetime模块如何快速模拟指定时间：

time模拟3小时前的时间戳

我们都知道1小时有3600秒，也就是3600*1000毫秒，所以如果是模拟3小时前的时间戳，则只需要拿到当前时间的时间戳-3600*1000*3即可：

def get_current_timestamp():
# 获取当前时间的时间戳
current_time = time.time()
timestamp = round(current_time) * 1000
return timestamp

three_hour_timestamp = get_current_timestamp() - 3600 * 3 * 1000
print(three_hour_timestamp)# 1677630754000

通过站长工具转换时间戳为格式化时间，确实是3个小时前的时间：

datetime模拟三天前的时间戳

使用time模块处理的话需要经过一些计算，而使用datetime模块的timedelta类处理则简单得多，直接填写间隔的时长即可，可以是天、小时、分钟、秒等，获取当前日期时间的三天前的时间戳，整体过程大致分为以下步骤：

1. 通过datetime.datetime.now()方法获取当前日期时间；
2. 用当前日期时间减去datetime.timedelta(days=3)返回的时间间隔，得到三天前的日期时间；
3. 用three_days_ago_date.timestamp()将三天前的日期时间转换为时间戳，注意这里得到的是浮点数，且精确到秒，而后端接口传参类型是整数、精确到毫秒，所以我做了int和乘1000的处理。并非所有接口都是这样，不同的接口视具体传参要求而定；

# 获取当前日期时间
now_date = datetime.datetime.now()
print(now_date)# 2023-03-01 11:47:06.361630
# 获取三天前的日期时间
three_days_ago_date = datetime.datetime.now() - datetime.timedelta(days=3)
print(three_days_ago_date)
# 将时间元组转换为时间戳
time_tup = int(three_days_ago_date.timestamp() * 1000)
print(time_tup)# 1677399019273

3.将时间日期格式化输出

这种情况常常用在文件命名上，比如日志文件，通过文件名，可以区分是具体是什么日期时间生成的日志。例如：

# 定义log生成路径、log文件名称
logTime = time.strftime('%Y_%m_%d-%H_%M_%S', time.localtime(time.time()))
# logPath = os.path.dirname(os.path.abspath('.')) + '\log\'
logPath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + '\logs\'
logName = logPath + logger + "_" + logTime + '.log'

生成的日志文件如下：

4.计算代码运行时间

通过time模块处理

在之前介绍装饰器的时候，我们有个案例就是通过time模块来统计代码运行时间的，示例如下：

def timer(func):
def wrapper(*args, **kwargs):
start_time = time.time()
res = func(*args, **kwargs)
end_time = time.time()
timer = end_time - start_time
print("%s函数运行共耗时: %s秒" % (func.__name__, timer))
return res

return wrapper


@timer
def run_timer():
time.sleep(1)
print("测试---统计函数运行时间")


run_timer()
'''
测试---统计函数运行时间
run_timer函数运行共耗时: 1.0101909637451172秒
'''

通过timeit模块处理

import time
import timeit

def run_time():
# 被测函数
time.sleep(1)
print("used 1 second")


# 统计代码运行时间
# stmt：要测试的代码，setup：要传入的变量属性等，number：每次测量中语句被执行的次数
tt = timeit.timeit(stmt=lambda: run_time(), number=3)
print(tt)
'''
used 1 second
used 1 second
used 1 second
3.001044
'''
# 统计代码运行时间，返回结果为列表
# stmt：要测试的代码，setup：要传入的变量属性等，repeat：重复测试的次数，number：每次测量中语句被执行的次数
tp = timeit.repeat(stmt="[i * 2 for i in testlist]", setup="testlist=range(1000)", repeat=5, number=1)
print(tp)
'''
[0.00011680000000025004, 9.259999999988722e-05, 8.76000000000765e-05]
'''

위 내용은 Python에서 일반적으로 사용되는 표준 라이브러리 및 타사 라이브러리 3-날짜 및 시간 처리 모듈의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!