Python bibliothèques standard et bibliothèques tierces couramment utilisées 3-Modules de traitement de date et d'heure

Le traitement du temps est une situation courante en programmation, comme la conversion des types d'heure : lorsque l'interface back-end transmet des paramètres, elle transmet généralement un horodatage dans la valeur de retour de l'interface obtenue par le front-end doit généralement être formatée au préalable. affichage. En Python, les modules qui gèrent le temps incluent l'heure et la date/heure.

1. Module Time

1. Introduction au module time

Le module time est une bibliothèque intégrée à Python spécialement utilisée pour traiter le temps. Il est livré avec de nombreuses méthodes qui peuvent convertir différents types d'heure entre eux. Par exemple, vous pouvez convertir le type d'horodatage en tuple d'heure, le tuple d'heure en heure formatée, l'heure formatée en horodatage... .

Types d'heure courants

. En Python, il existe généralement plusieurs façons de représenter l'heure :

• Time stamp : time.time(), aucun paramètre, obtenez l'horodatage actuel, type à virgule flottante 
• Time string : time.ctime(), seconds - > string; time.asctime(), tuple -> string;
• Time tuple (struct_time) : time.localtime()
• Format time : 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.

Le type d'horodatage peut être converti en tuple d'heure, le tuple d'heure peut être converti en heure formatée, l'heure formatée peut être convertie en horodatage...

① Timestamp

conversion de tuple d'heure entre eux

time.time () renvoie le formulaire de valeur de retour d'horodatage de l'heure actuelle : 1677563451.2548294
• time.localtime() renvoie le tuple temporel de l'heure actuelle, formulaire de valeur de retour ：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() change l'heure Le tuple est converti en heure à virgule flottante et la valeur de retour est dans le formulaire : 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
  '''

② Tuple temporel

Conversion de l'heure formatée

time.strftime() Passez le tuple temporel, vous pouvez convertir le tuple temporel en heure formatée au format, format de valeur de retour : 2023-02-28 13 : 52:02
• time.strptime() Passez l'heure formatée, vous pouvez convertir l'heure formatée en un tuple d'heure, format de valeur de retour : 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)
  '''

③ timestamp

format time conversion

Les horodatages et les heures formatées ne peuvent pas être convertis directement les uns aux autres. pour conversion.

# 时间戳<===>格式化时间 相互转换
# 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
'''

④ Convertissez le type d'heure spécifié en une chaîne de temps

time.asctime() Convertissez le tuple de temps en une chaîne de temps, le paramètre est un tuple de temps et la valeur de retour est sous la forme : mar 28 février 11:51:05 2023 ;
time.ctime() convertit l'horodatage en une chaîne d'heure, le paramètre est un horodatage et la valeur de retour est sous la forme : mar 28 février 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. Module Datetime

1. Introduction au module datetime

Datetime est un module fourni avec Python pour le traitement de l'heure et des dates. Il existe trois formats pour exprimer l'heure en Python : l'horodatage, le tuple et l'heure formatée. Semblable au module time, le module datetime peut également convertir les types datetime en ces trois types.

Les catégories datetime couramment utilisées sont :

date : classe de date, principalement utilisée pour traiter l'année, le mois et le jour
• time : classe de temps, principalement utilisée pour traiter les heures, les minutes et les secondes ; : La classe de date et d'heure, l'utilisation complète de la classe de date et de la classe d'heure, peut être utilisée pour traiter l'année, le mois, le jour, l'heure, la minute, la seconde ;
• timedelta : représente l'intervalle de temps, utilisé pour traiter l'addition et la soustraction de temps ;
• tzinfo : utilisé pour traiter les informations de fuseau horaire ;

2. Méthodes ou attributs couramment utilisés de la classe date

La classe date contient trois paramètres, à savoir : l'année, le mois, le jour et le format de retour est l'année. -mois-jour.

Définissez la date spécifiée

import datetime

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

Obtenez l'année, le mois et le jour de la date d'aujourd'hui

# 获取今天日期的年份、月份、日
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

Jugez quel jour de la semaine est aujourd'hui

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

La date actuelle est automatiquement convertie en d'autres formats

# 当前日期的其他格式
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

Remplacez la date

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

Spécifiez la conversion de format pour les dates

# 指定格式转换为日期
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

Les méthodes ou attributs courants de la classe 3.time

datetime.time() peuvent transmettre plusieurs paramètres :

• 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. Voir aussi l'introduction de Tim Peters au chapitre Algorithmes dans

le Python Cookbook, publié par O'Reilly.

Ce module évite de nombreux pièges courants pour mesurer les temps d'exécution. Voir également le Python Cookbook de Tim Peters, publié par O'Reilly.

Utilisation de la bibliothèque : voir la classe Timer.

Utilisation de la bibliothèque : voir la classe Timer.

Utilisation de la ligne de commande :

Utilisation de la ligne de commande :

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

Options : Option :

-n/--number N : combien de fois exécuter « instruction » (par défaut : voir ci-dessous)

-r/--repeat N : combien de fois répéter le minuteur (par défaut 5)

-s/--setup S : instruction à exécuter une fois initialement ('pass' par défaut).

Le temps d'exécution de cette instruction de configuration n'est PAS chronométré.

-p/--process : utilisez time.process_time() ( la valeur par défaut est time.perf_counter())

-v/--verbose : imprimer les résultats de synchronisation bruts ; répéter pour plus de précision des chiffres

-u/--unit : définir l'unité de temps de sortie (nsec, usec, msec ou sec )

-h/--help : imprimez ce message d'utilisation et quittez

-- : séparez les options de la déclaration, utilisez lorsque la déclaration commence par -

statement : la déclaration doit être chronométrée (par défaut 'pass')

Un multi L'instruction -line peut être donnée en spécifiant chaque ligne comme un

argument séparé ; les lignes en retrait sont possibles en plaçant un

argument entre guillemets et en utilisant des espaces de début. Plusieurs options -s sont

traitées de la même manière.

En spécifiant chaque ligne. en tant qu'argument autonome ; les lignes en retrait peuvent être créées en plaçant les arguments entre guillemets et en utilisant des espaces de début. Les inclusions multiples d’options -s sont gérées de la même manière.

Si -n n'est pas donné, un nombre approprié de boucles est calculé en essayant

puissances successives de 10 jusqu'à ce que le temps total soit d'au moins 0,2 seconde soit 0,2 seconde.

Remarque : il existe une certaine surcharge de base associée à l'exécution d'une instruction

pass. Elle diffère selon les versions. Le code ici n'essaie pas

de le masquer, mais vous devez en être conscient.

mesuré en appelant le programme sans arguments.

Remarque : Exécutez l'instruction pass. Cela varie selon les versions. Le code ici ne tente pas de le cacher, mais vous devez en être conscient. Les frais généraux de base peuvent être mesurés en appelant un programme sans paramètres.

Classes :

Timer

Fonctions :

timeit(string, string) -> float

repeat(string, string) -> list

default_timer() -> float

Utilisation spécifique :

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

La signification de chaque option :

-n N --number=NLe nombre de fois la déclaration est exécutée ; lorsque l'instruction commence par

Options	Prototype	Signification
-r N	--repeat=N	Nombre de fois pour répéter le test (par défaut 5 fois)
-s	- -configuration= S	Instructions initialement exécutées, telles que : variables, propriétés, etc. à transmettre dans
-p	--process	Mesurez le temps de processus au lieu de l'exécution réelle time (utilisez time.process_time( ) au lieu de time.perf_counter() par défaut)
-v	--verbose	imprime les résultats de synchronisation bruts, répétez pour plus de précision numérique
-u	--unit	Définissez l'unité de temps de sortie (nsec, usec, msec ou sec)
-h	--help	Informations d'aide sur la sortie
--		Séparez les options des instructions, utilisez -
déclaration		La déclaration à chronométrer (la valeur par défaut est "pass")

四、时间应用场景实践

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!