Maison >développement back-end >Tutoriel Python >Résumé de la conversion du temps Python que vous pouvez apprendre en une seule étape (super complet)

Résumé de la conversion du temps Python que vous pouvez apprendre en une seule étape (super complet)

Python当打之年avant: 2023-08-11 16:12:59654parcourir

Dans la vie et au travail, chacun de nous est confronté au temps chaque jour :

Quand te lèves-tu le matin ?
Combien de minutes faut-il pour que le métro arrive ?
Quand commence la pause déjeuner à midi ?
Quel jour de la semaine est demain ?
Cela fait 2 mois que vous avez acheté des vêtements pour la dernière fois ?
Mon patron m'a demandé d'ajouter une fonction de tâche planifiée au code, que dois-je faire ?

Différentes situations rencontreront différents problèmes de temps : Points horaires spécifiques, intervalles de temps, jours de la semaine, etc. Nous sommes constamment en collision avec le temps. Cet article utilisera Python pour expliquer en détail les classes liées au temps, leurs méthodes et attributs

Résumé de la conversion du temps Python que vous pouvez apprendre en une seule étape (super complet)

1. Timestamp

1.1 Introduction à timestamp

Dans l'explication formelle des fonctions liées au temps Avant ça, il faut d'abord avoir un concept : Timestamp. Cet article fait spécifiquement référence à l'horodatage unix.

Timestamp Timestamp fait référence à l'ajout d'un texte d'identification, tel que l'heure ou la date, etc., à une série de données pour garantir que la séquence de mise à jour des données locales est cohérente avec celle distante.

unixL'horodatage est le nombre de secondes écoulées depuis le 1er janvier 1970 (minuit UTC/GMT), indépendamment des secondes intercalaires. 1970-01-01 est souvent l'heure que nous obtenons après la conversion de l'horodatage vide lorsque l'heure dans MySQL est vide. Une heure est exprimée sous la forme d'un horodatage UNIX au format 3 600 secondes ; un jour est exprimé sous la forme d'un horodatage UNIX de 86 400 secondes et les secondes intercalaires ne sont pas comptées. Le tableau de comparaison spécifique est le suivant : unix时间戳是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数，不考虑闰秒。1970-01-01就是经常我们在MySQL中时间为空的时候，转化空的时间戳之后得到的时间。一个小时表示为UNIX时间戳格式为：3600秒；一天表示为UNIX时间戳为86400秒，闰秒不计算。具体的对照表如下：

1.2时间戳转化网站

下面介绍几个时间戳和具体时间之间相互转化的网站：

1、站长工具：https://tool.chinaz.com/tools/unixtime.aspx

2、在线工具：https://tool.lu/timestamp/

3、Json在线解析：https://www.sojson.com/unixtime.html

4、Unix时间戳在线转换（菜鸟工具）：https://c.runoob.com/front-end/852

5、北京时间（时间与时间戳互换工具）：http://www.beijing-time.org/shijianchuo/

介绍完时间戳的基本知识，下面重点讲解3个与时间和日期相关的Python库：

calendar
time
datetime

2.calendar

calendar

1.2 site Web de conversion d'horodatage

1. Outils pour les webmasters : https://tool.chinaz.com/tools/unixtime.aspx

🎜2 Outils en ligne : https://tool.lu/timestamp/🎜🎜3. ://www.sojson.com/unixtime.html🎜🎜4. Conversion en ligne de l'horodatage Unix (outil débutant) : https://c.runoob.com/front-end/852🎜🎜5. outil d'échange) : http://www.beijing-time.org/shijianchuo/🎜🎜Après avoir présenté les connaissances de base des horodatages, concentrons-nous sur trois bibliothèques Python liées à l'heure et à la date : 🎜

🎜calendar🎜🎜
🎜time🎜🎜
🎜dateheure🎜🎜 li>

2.calendar🎜 🎜

🎜calendrier La signification chinoise de "calendrier", donc en fait, c'est adapté aux dates, notamment sous forme de calendrier. 🎜🎜🎜Contenu du module 2.1🎜🎜🎜🎜🎜🎜Ce qui suit est un exemple :🎜

2.2calendrier

Nous affichons le calendrier de l'année 2020 à venir, en utilisant les paramètres par défaut :

import calendar
year = calendar.calendar(2020)
print(year)

Modifiez les paramètres et affichez-le à nouveau :

Nous avons trouvé Le le calendrier entier change Il est plus large et la semaine est également affichée en anglais avec 3 lettres Veuillez expliquer la signification des trois paramètres :

w : Intervalle de largeur quotidien .
l : nombre de lignes par semaine
où la longueur de chaque ligne est de :
, 3 mois par ligneEnfin, jetez un œil au prochain calendrier 2021 :

21*w+18+2*c

2.3isleap(year)

. Si tel est le cas, il renvoie True, sinon il renvoie False.

Les années ordinaires peuvent être divisibles par 4, mais ne peuvent pas être divisibles par 100, c'est pourquoi on les appelle années bissextiles ordinaires.

Les années sont en centaines et doivent être divisibles par 400. On les appelle années bissextiles du siècle

.

2,4 jours bissextiles (y1, y2)

se trouvent entre deux années, y1 y compris, mais pas y2, similaire à

dans le découpage Python, y compris la tête mais pas la queue

2,5 mois (année, mois, w = 2, l = 1)

Cette fonction renvoie annéeannéemoisLe calendrier mensuel n'a que deux lignes de titres, une pour chaque semaine. La largeur de l'intervalle quotidien est de w caractères et la longueur de chaque ligne est 7*w + 6, où l est le nombre de lignes par semaineyear年的month月的日历，只有两行标题，一周一行。每日间隔宽度为w个字符，每行的长度为7*w + 6，其中l是每星期的行数

首先看看默认效果；

接下来我们改变w和l两个参数：

1、改变w，我们发现星期的表示变成了3个字母；同时每天之间的间隔变宽了（左右间隔）

2、改变参数l

Regardez d'abord Regardez l'effet par défaut

Ensuite, nous changeons w et l Paramètres : 1. Modifiez `w`, on constate que la représentation de la semaine est devenue 3 lettres ; en même temps, l'intervalle entre chaque la journée est devenue plus large (intervalle gauche et droite)

Résumé de la conversion du temps Python que vous pouvez apprendre en une seule étape (super complet) 2. paramètresl, nous constatons que l'intervalle (supérieur et inférieur) avant chaque semaine devient plus large

2,6 moiscalendrier (année, mois)
renvoie l'année sous forme de liste Calendrier du mois, en liste ou sous forme de liste. Chaque sous-liste dure une semaine.
S'il n'y a pas de date de ce mois, elle est représentée par 0. Chaque sous-liste commence au 1er de la semaine, et les caractéristiques sont résumées comme suit :

Chaque sous-liste représente une semaine

Du lundi au dimanche, les dates qui n'apparaissent pas dans ce mois sont remplacées par 0

🎜Prenons décembre 2020 comme exemple : 🎜🎜🎜🎜🎜Par rapport au calendrier ci-dessus, nous avons constaté que : 🎜La position où apparaît 0 n'apparaît pas en décembre🎜🎜🎜Jetons un coup d'œil au calendrier de mars 2020 : 🎜

2,7monthrange(year,month)

Le résultat renvoyé par cette fonction est un tuple Il y a deux valeursdans le tuple (a,b)

La valeur a représente le jour du. semaine où commence le mois; Il est stipulé que 6 représente le dimanche, et la valeur est 0-6
La valeur b représente le nombre total de jours dans le mois

Expliquons-le à travers un exemple , prenons comme exemple décembre 2020 :

Le 1 dans le résultat signifie que décembre commence le 2 de la semaine (0-6, 6 représente le dimanche), et que le mois compte au total 31 jours

2.8weekday(y,m,d)

La méthode des jours de la semaine consiste à saisir l'année, le mois et le jour, nous pouvons alors savoir de quel jour de la semaine nous sommes La valeur de retour est 0-6, 0 représente lundi ; , 6 représente dimanche

Expliquons-le à travers un exemple, en prenant le 12 décembre comme exemple :

Double 12 Nous sommes samedi et le résultat renvoyé est 5. 5 représente samedi, ce qui correspond exactement.

3.time

Le module time est le module le plus couramment utilisé impliquant des fonctions temporelles Il est souvent utilisé dans les exigences liées au temps de Python. L'utilisation de ce module est expliquée en détail. ci-dessous.

3.1 Contenu du module

Regardons d'abord l'utilisation globale du module

3.2time

time.time() consiste à obtenir l'heure actuelle. Plus strictement parlant, il s'agit d'obtenirHorodatage de l'heure actuelle. time.time()是获取当前的时间，更加严格地说，是获取当前时间的时间戳。

再次理解时间戳：它是以1970年1月1日0时0份0秒为计时起点，计算到当前的时间长度（不考虑闰秒）

3.3localtime

time.localtime是打印当前的时间，得到的结果是时间元组，具体含义：

笔记：结果是时间元组

time.localtime的参数默认是time.time()

Comprenez à nouveau l'horodatage : il est basé sur 0:00:00 le 1er janvier 1970 comme point de départ et est calculé sur la durée actuelle (sans tenir compte des secondes intercalaires)

3.3localtime

time.localtime

imprimer l'heure actuelle strong> Le résultat est un tuple temporel, avec une signification spécifique :

Notes : Résultats C'est un tuple temporel

Les paramètres par défaut de time.localtime sont time.time() horodatage , vous pouvez le saisir vous-même Un certain horodatage pour obtenir son heure correspondante🎜🎜🎜🎜🎜Horodatage actuel par défaut🎜🎜🎜🎜🎜🎜Spécifiez un horodatage🎜🎜

3.4gmtime

localtime()Le résultat estHeure locale, si l'internationalisation est requise, utilisez gmtime() , il est préférable d’utiliser l’heure de Greenwich. localtime()得到的是本地时间，如果需要国际化，使用gmtime()，最好是使用格林威治时间。

格林威治标准时间：位于英国伦敦郊区的皇家格林威治天文台的标准时间，本初子午线经过那里。

3.5asctime

time.asctime的参数为空时，默认是以time.localtime的值为参数，得到当前的日期、时间、星期；另外，我们也可以自己设置参数，参数是时间元组

使用当前时间的默认时间元组localtime
自己指定一个时间元组

获取当前时间的具体时间和日期：

3.6ctime

ctime

Heure moyenne de Greenwich : heure standard à l'Observatoire royal de Greenwich, dans la banlieue de Londres, en Angleterre, là où passe le premier méridien. 🎜🎜 Résumé de la conversion du temps Python que vous pouvez apprendre en une seule étape (super complet)

🎜🎜🎜3.5asctime🎜🎜🎜Lorsque le paramètre de time.asctime est vide, la valeur par défaut estPrenez la valeur de time.localtime comme paramètre pour obtenir la date, l'heure et la semaine actuelles ; de plus, nous pouvons également définir les paramètres nous-mêmes, Le paramètre est un tuple temporel🎜

🎜Utiliser la valeur par défaut de l'heure actuelle Time tuple localtime🎜🎜🎜
🎜Spécifier un tuple d'heure vous-même🎜🎜🎜 🎜🎜🎜🎜Obtenez l'heure et la date spécifiques de l'heure actuelle : 🎜🎜🎜🎜🎜3.6ctime🎜🎜🎜ctime est par défaut un horodatage ; sinon, vous pouvez également spécifier un horodatage🎜

3.7mktime

mktime() prend également un tuple temporel comme paramètre, et renvoie un horodatage, Équivalent àinverse de l'heure locale Processus strftime() est dans le format que nous avons spécifiéConvertir le tuple temporel en chaîne ; si aucun tuple temporel n'est spécifié, la valeur par défaut est l'heure actuellemktime()也是以时间元组为参数的，它返回的是时间戳，相当于是localtime的逆向过程：

3.8strftime

strftime()是按照我们指定的格式将时间元组转化为字符串；如果不指定时间元组，默认是当前时间localtime()。常用到的时间格式见下表：

我们举例说明：
- 字符串中的分隔符我们可以任意指定
- 可以同时显示年月日时分秒等
3.9strptime

strptime()
- donnez un exemple :
- 🎜 peut afficher l'année, le mois, le jour, l'heure, la minute, la seconde, etc. en même temps🎜🎜🎜 ul>🎜🎜🎜🎜3.9strptime🎜🎜🎜strptime() Il s'agit de convertir une chaîne en un tuple temporel. Ce à quoi nous devons prêter une attention particulière, c'est qu'il a deux paramètres : 🎜🎜🎜🎜🎜La chaîne à être converti🎜🎜🎜🎜🎜🎜Le format correspondant à la chaîne horaire, le format est au dessus 🎜🎜 mentionné dans le tableau ?
4.datetime

Bien que time le module peut déjà résoudre de nombreux problèmes, mais dans le travail réel et les besoins de l'entreprise, nous avons besoin de plus d'outils pour nous rendre plus pratiques et plus rapides à utiliser, datetime est l'un des modules très utiles. Plusieurs classes couramment utilisées dans le module datetime sont les suivantes : time模块已经能够解决很多的问题，但是实际工作和业务需求中需要更多的工具，让我们使用起来更方便和快捷，datetime便是其中一个很好用的模块。datetime模块中几个常用的类如下：
- date：日期类，常用属性：year/month/day
- time：时间类，常用属性：hour/minute/second/microsecond
- datetime：日期时间类
- timedelta：时间间隔，即两个时间点之间的时间长度
- tzinfo
  - date : classe de date, attributs communs : année/mois/jour 🎜
  - time : classe de temps, attributs couramment utilisés : <code style="font-size: hériter;line-height: hériter;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left : 2px; couleur : rgb(233, 105, 0);arrière-plan : rgb(248, 248, 248);">heure/minute/seconde/microseconde🎜🎜
  - datetime : classe de date et d'heure🎜🎜
    
    timedelta : intervalle de temps, c'est-à-dire la durée entre deux points temporels🎜🎜
  - tzinfo : classe de fuseau horaire🎜
  4.1模块内容
  
  4.2date
  
  首先我们引入date类，并创建一个日期对象：
  
  1、然后我们可以操作这个日期对象的各种属性：后面加上()
```
print("当前日期：",today)  # 当前日期
print("当前日期(字符串)：",today.ctime())   # 返回日期的字符串
print("时间元组信息：",today.timetuple())   # 当前日期的时间元组信息
print("年：",today.year)   # 返回today对象的年份
print("月：",today.month)  # 返回today对象的月份
print("日：",today.day)   # 返回today对象的日
print("星期：",today.weekday())  # 0代表星期一，类推
print("公历序数：",today.toordinal())  # 返回公历日期的序数
print("年/周数/星期：",today.isocalendar())   # 返回一个元组：一年中的第几周，星期几

# 结果显示
当前日期： 2020-12-25
当前日期(字符串)：Fri Dec 25 00:00:00 2020
时间元组信息：time.struct_time(tm_year=2020, tm_mon=12, tm_mday=25, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=360, tm_isdst=-1)
年： 2020
月： 12
日： 25
星期： 4
公历序数： 737784
年/周数/星期： (2020, 52, 5)
```
  2、date类中时间和时间戳的转换：
  
  具体时间的时间戳转成日期：
  
  3、格式化时间相关，格式参照time模块中的strftime方法
```
from datetime import datetime, date, time
today = date.today()

print(today)
# 2020-12-26  默认连接符号是-

print(today.strftime("%Y/%m/%d"))  # 指定连接符
# 2020/12/26

print(today.strftime("%Y:%m:%d"))
# 2020:12:26

print(today.strftime("%Y/%m/%d %H:%M:%S"))  # 转化为具体的时间
# 2020/12/26 00:00:00
```
  4、修改日期使用replace方法
  
  4.3time
  
  time类也是要生成time对象，包含hour、minute、second、microsecond，我们还是通过例子来学习：
```
from datetime import time

t = time(10,20,30,40)
print(t.hour)  # 时分秒
print(t.minute)
print(t.second)
print(t.microsecond)  # 微秒

# 结果
10
20
30
40
```
  4.4datetime
  
  datetime类包含date类和time类的全部信息，下面?是类方法相关的：
```
from  datetime import datetime

print(datetime.today())
print(datetime.now())
print(datetime.utcnow())# 返回当前UTC日期和时间的datetime对象
print(datetime.fromtimestamp(1697302830))  # 时间戳的datetime对象
print(datetime.fromordinal(699000) )
print(datetime.combine(date(2020,12,25), time(11,22,54)))  # 拼接日期和时间
print(datetime.strptime("2020-12-25","%Y-%m-%d"))

# 结果
2020-12-25 23:24:42.481845
2020-12-25 23:24:42.482056
2020-12-25 15:24:42.482140
2023-10-15 01:00:30
1914-10-19 00:00:00
2020-12-25 11:22:54
2020-12-25 00:00:00
```
  再看看相关对象和属性相关：
```
from datetime import datetime 

d = datetime(2020,12,25,11,24,23)

print(d.date())
print(d.time())
print(d.timetz())  # 从datetime中拆分出具体时区属性的time
print(d.replace(year=2021,month=1))  # 替换
print(d.timetuple())  # 时间元组
print(d.toordinal())  # 和date.toordinal一样
print(d.weekday())
print(d.isoweekday())
print(d.isocalendar())
print(d.isoformat())
print(d.strftime("%Y-%m-%d :%H:%M:%S"))

# 结果
2020-12-25
11:24:23
11:24:23
2021-01-25 11:24:23
time.struct_time(tm_year=2020, tm_mon=12, tm_mday=25, tm_hour=11, tm_min=24, tm_sec=23, tm_wday=4, tm_yday=360, tm_isdst=-1)
737784
4
5
(2020, 52, 5)
2020-12-25T11:24:23
2020-12-25 :11:24:23
```
  4.5timedelta
  
  timedelta对象表示的是一个时间段，即两个日期date或者日期时间datetime之间的差；支持参数：weeks、days、hours、minutes、seconds、milliseconds、microseconds
  
  4.6tzinfo
  
  本地时间指的是我们系统本身设定时区的时间，例如中国处于北京时间，常说的东八区UTC+8:00。datetime类有一个时区属性tzinfo。
  
  tzinfo是一个关于时区信息的类，是一个抽象的基类，不能直接被实例化来使用。它的默认值是None，无法区分具体是哪个时区，需要我们强制指定一个之后才能使用。
  
  因为本身系统的时区刚好在中国处于东八区，所以上述代码是能够正常运行的，结果也是OK的。那如果我们想切换到其他时区的时间，该如何操作呢？这个时候我们需要进行时区的切换。
  
  1、我们先通过utcnow()获取到当前的UTC时间
```
utc_now = datetime.utcnow().replace(tzinfo=timezone.utc)  # 指定utc时区
print(utc_now)

# 结果
2020-12-26 01:36:33.975427+00:00
```
  2、通过astimezone()将时区指定为我们想转换的时区，比如东八区（北京时间）：
```
# 通过astimezone切换到东八区

beijing = utc_now.astimezone(timezone(timedelta(hours=8)))
print(beijing)

# 结果
2020-12-26 09:36:33.975427+08:00
```
  用同样的方法切到东九区，东京时间：
```
# UTC时区切换到东九区：东京时间

tokyo = utc_now.astimezone(timezone(timedelta(hours=9)))
print(tokyo)

# 结果
2020-12-26 10:36:33.975427+09:00
```
  还可以直接从北京时间切换到东京时间：
```
# 北京时间（东八区）直接切换到东京时间（东九区）

tokyo_new = beijing.astimezone(timezone(timedelta(hours=9)))
print(tokyo_new)

# 结果
2020-12-26 10:36:33.975427+09:00
```
  5.常用时间转化
  
  下面介绍几个工作中用到的时间转化小技巧：
  1. 时间戳转日期
  2. 日期转时间戳
  3. 格式化时间
  4. 指定格式获取当前时间
  5.1时间戳转成日期
  
  时间戳转成具体时间，我们需要两个函数：
  - time.localtime：将时间戳转成时间元组形式
  - time.strftime：将时间元组数据转成我们需要的形式
```
import time
now_timestamp = time.time()  # 获取当前时间的时间戳

# 时间戳先转成时间元组，strftime在转成指定格式
now_tuple = time.localtime(now_timestamp)
time.strftime("%Y/%m/%d %H:%M:%S", now_tuple)

# 结果
&#39;2020/12/26 11:19:01&#39;
```
  假设我们指定一个具体的时间戳来进行转换：
```
import time
timestamp = 1608852741  # 指定时间戳

a = time.localtime(timestamp)  # 获得时间元组形式数据
print("时间元组数据：",a)
time.strftime("%Y/%m/%d %H:%M:%S", a)  # 格式化

# 结果
时间元组数据：time.struct_time(tm_year=2020, tm_mon=12, tm_mday=25, tm_hour=7, tm_min=32, tm_sec=21, tm_wday=4, tm_yday=360, tm_isdst=0)
&#39;2020/12/25 07:32:21&#39;
```
  如果我们不想指定具体的格式，只想获取时间戳对应的时间，直接通过time.ctime即可：
```
import time
time.ctime(1608852741)

# 结果
&#39;Fri Dec 25 07:32:21 2020&#39;
```
  5.2日期时间转成时间戳
  
  日期时间转成时间戳格式，我们需要使用两个方法：
  - strptime()：将时间转换成时间数组
  - mktime()：将时间数组转换成时间戳
  通过具体的案例来学习一下：
```
date = "2020-12-26 11:45:34"

# 1、时间字符串转成时间数组形式
date_array = time.strptime(date, "%Y-%m-%d %H:%M:%S")

# 2、查看时间数组数据
print("时间数组：", date_array)

# 3、mktime时间数组转成时间戳
time.mktime(date_array)

# 结果
时间数组：time.struct_time(tm_year=2020, tm_mon=12, tm_mday=26, tm_hour=11, tm_min=45, tm_sec=34, tm_wday=5, tm_yday=361, tm_isdst=-1)
1608954334.0
```
  5.3格式化时间
  
  工作需求中有时候给定的时间格式未必是我们能够直接使用，所以可能需要进行格式的转换，需要使用两个方法：
  - strptime()：将时间转换成时间数组
  - strftime()：重新格式化时间
  通过案例来进行学习：
```
import time

old = "2020-12-12 12:28:45"

# 1、转换成时间数组
time_array = time.strptime(old, "%Y-%m-%d %H:%M:%S")

# 2、转换成新的时间格式(20201212-20:28:54)
new = time.strftime("%Y%m%d-%H:%M:%S",time_array)  # 指定显示格式

print("原格式时间：",old)
print("新格式时间：",new)

# 结果
原格式时间： 2020-12-12 12:28:45
新格式时间： 20201212-12:28:45
```
  5.4指定格式获取当前时间
  
  为了能够获取到指定格式的当前时间，我们分为3个步骤：
  - time.time()：获取当前时间
  - time.localtime()：转成时间元组
  - time.strftime()：重新格式化时间
  通过一个案例来学习：
```
# 1、时间戳
old_time = time.time()
# 2、时间元组
time_array = time.localtime(old_time)
# 3、指定格式输出
new_time = time.strftime("%Y/%m/%d %H:%M:%S", time_array)
print(new_time)

# 结果
2020/12/26 11:56:08
```
  6.总结
  
  本文通过各种案例详细介绍了Python中关于时间输出和转化的3个模块：calendar、time、datetime，最后总结了4个工作中常用的时间转化技巧，希望对大家掌握Python中的时间输出和转化有所帮助，不再被时间困扰。