Le Tutoriel de Python Date Time

Vue d'ensemble
Le concept de Ticks
time module
datetime module
datetime.timedelta
datetime.date

1. Vue d'ensemble

Python vous fournit 4 modules liés à la date et du temps.

Module	Description
time	time est un module qui ne comprend que des fonctions et des constantes liées à la date et à l'heure, il existe plusieurs classes (classe) écrites en C/C ++ définies sur ce module. Par exemple, la classe struct_time.
datetime	datetime est un module qui est conçu avec une programmation orientée objet pour fonctionner avec la date et l'heure de Python. Il définit plusieurs classes qui représentent la date et l'heure.
calendar	Le calendrier est un module qui fournit des fonctions et plusieurs classes liées à Calendrier, qui supportent la génération d'images du calendrier en tant que texte, html, ....
locale	Ce module contient des fonctions qui sont utilisées pour le formatage ou l'analyse de la date et de l'heure en fonction des paramètres régionaux.

datetime module:

datetime est un module, conçu sur base d'objet pour fonctionner avec la date et l'heure de Python. Il existe plusieurs classes qui représentent la date et l'heure.

Classe	Description
datetime.date	Un objet date représente une date, à l'exception du temps, selon le calendrier Gregorian (calendrier grégorien).
datetime.datetime	Un objet datetime représente une date et l'heure, delon le calendrier Gregorian.
datetime.time	Un objet time représente le temps (time), à l'exception de la date (date).
datetime.tzinfo	Une classe abstraite de base (base abstract class) pour les objets d'information de fuseau horaire (timezone)..
datetime.timezone	Une classe d'enfants direct de la classe tzinfo, en standard UTC (Coordinated Universal Time)(Temps universel coordonné).
datetime.timedelta	Un objet timedelta représente une duration (duration), le décalage entre deux dates ou temps.

calendar module:

calendar est un module qui fournit des fonctions, et quelques classes liées au calendrier, qui supportent de générer (generate) d'images du calendrier en tant que texte, html, ....

2. Le concept de Ticks

En informatique, 12h du matin le 1er janvier 1970 est un temps spécial, il sert à commencer le temps de comptage. Ce moment particulier s'appelle epoch (L'ère informatique).

En Python, le temps entre le moment présent et le temps spécial dessus est exprimé par secondes (seconds). Cette période de temps est appelée Ticks.

La fonction time() dans le module time renvoie le nombre de secondes (seconds) à partir de 12h du matin le 1er Janvier 1970 jusqu'à présent. Elle renvoie le type de point flottant (floating point)

ticketExample.py

# Importez le module time.
import time;

# Le nombre de secondes depuis 12h matin, le premier janvier 1970 jusqu'à présent.
ticks = time.time()  
print ("Number of ticks since 12:00am, January 1, 1970: ", ticks)

Output:

Number of ticks since 12:00am, January 1, 1970: 1492244686.7766237

3. time module

time est un module qui ne comprend que des fonctions, et des variables relatives à la date et du temps. Il y a quelques classes (class) écrites sur C/C++ qui sont définies sur ce module. Par exemple, la classe struct_time.

Sur le module time, le temps est représenté par Ticks ou struct_time. Il a des fonctions qui formate (format) Ticks ou struct_time en string,et vice versa analyse (parse) un string en Ticks ou struct_time.

0	`tm_year`	(for example, 1993)
1	`tm_mon`	range [1, 12]
2	`tm_mday`	range [1, 31]
3	`tm_hour`	range [0, 23]
4	`tm_min`	range [0, 59]
5	`tm_sec`	range [0, 61]; See more below
6	`tm_wday`	range [0, 6], Monday is 0
7	`tm_yday`	range [1, 366]
8	`tm_isdst`	0, 1 or -1; see below
N/A	`tm_zone`	abbreviation of timezone name
N/A	`tm_gmtoff`	offset east of UTC in seconds

tm_sec
La gamme de la seconde (second) est réellement de 0 à 61; cela explique des secondes intercalaires (double leap seconds). Malgré que c'est très rare.

Les fonctions de time appelent des fonctions écrites dans langage C. Ci- dessous est la liste des fonctions générales, afin de la détailler, vous pouvez faire la référence au document sur le site web officiel de Python.

Ticks ==> struct_time

Fonction	Description
time.gmtime([secs])	Convertit le temps en secondes à partir du moment spoch en un struct_time dans UTC, où le drapeau dst est 0. Si le paramètre secs n'est pas fourni ou None, la valeur par défaut va être renvoyée par la fonction time().
time.localtime([secs])	Similaire à la fonction gmtime() mais cette fonction convertit en temps local (local time). et la valeur du drapeau dst est 1.

La fonction gmtime([secs]) et la fonction localtime([secs]) renvoient le type struct_time.

time_gmtimeExample.py

import time

# une seconde après l'époque (epoch).
# La fonction renvoi le type de structure: struct_time
ts = time.gmtime(1) 
print ("1 seconds after epoch: ") 
print (ts)  
print ("\n")

# Actuellement, le même temps de time.gmtime( time.time() )
# La fonction renvoie une struct: struct_time
ts = time.gmtime() 
print ("struct_time for current time: ")
print (ts)

struct_time ==> Ticks

Vous pouvez convertir un struct_time ou un Tuple qui représentent le temps en Ticks (le nombre de secondes est calculé à partir de epoch).

time_mktime_example.py

import time

a_struct_time = time.localtime() 
print ("Current time as struct_time: ");
print (a_struct_time) 
# Convertissez struct_time ou Tuple en Ticks.
ticks = time.mktime(a_struct_time)  
print ("Ticks: ", ticks)

# Un Tuple a 9 éléments.
aTupleTime = ( 2017, 4, 15, 13, 5, 34, 0, 0, 0) 
print ("\n")
print ("A Tuple represents time: ")
print (aTupleTime)

# Convertissez struct_time ou Tuple en Ticks.
ticks = time.mktime(aTupleTime) 
print ("Ticks: ", ticks)

struct_time, Ticks ==> string

Fonction	Description
time.asctime([struct_t])	Convertit un tuple ou struct_time qui représentent un temps comme renvoyés par gmtime() ou localtime() en un string de la forme suivante: 'Sun Jun 20 23:21:05 1993'. Si le paramètre struct_t n'est pas fourni, le temps présent est renvoyé par localtime() va être utilisé. Les informations locales (locale) ne sont pas utilisées par asctime().
time.ctime([secs])	Convertit le temps en secondes (seconds)à partir le moment epoch en un string qui représente le temps local (local time). Si le paramètre secs n'est pas fourni ou None,le temps présent est renvoyé par time() est utilisé. ctime(secs) est équivalent à asctime(localtime(secs)). Les informations locales (locale) ne sont pas utilisées par ctime().

time_asctime_ctime_example.py

import time
 
# Un Tuple a 9 éléments.
# (Année, mois, jour, heur, minute, seconde, wday, yday, isdst)
a_tuple_time = (2017, 4, 15 , 22 , 1, 29, 0, 0, 0) 
a_timeAsString = time.asctime(a_tuple_time) 
print ("time.asctime(a_tuple_time): ", a_timeAsString) 

a_struct_time = time.localtime()
print ("a_struct_time: ", a_struct_time)

a_timeAsString = time.asctime(a_struct_time) 
print ("time.asctime(a_struct_time): ", a_timeAsString)

# Le nombre de secondes de 12h du matin le premier janvier 1970 jusqu'à présent.
ticks = time.time() 
a_timeAsString = time.ctime(ticks)  
print ("time.ctime(ticks): ", a_timeAsString)

Analyser et formater

Le module time fournit quelques fonctions pour analyser (parse) un string dans le temps. Et à l'inverse, formater (format) le temps en string.

Fonction	Description
time.strptime(string[, format] )	Analyse un string qui représente un temps selon un format. La valeur renvoyé est un struct_time comme renvoyé par le fonction gmtime() ou localtime().
time.strftime(format [, t] )	Convertit un Tuple ou struct_time qui représente un temps comme renvoyé par la fonction gmtime() ou localtime() dans un string spécifié par le format. Si elle n'est pas fournie, le temps présent est renvoyé par localtime() est utilisé. Le paramètre format doit être un string. ValueError peut être jeté (throw) si n'importe champ (field) dans le paramètre 't' se trouve à l'extérieur.

Un exemple de l'analyse (parse) un string dans un struct_time.

time_strptime_example.py

import time 
# Une string représentant le temps.
aStringTime = "22-12-2007 23:30:59"  

a_struct_time = time.strptime(aStringTime, "%d-%m-%Y %H:%M:%S") 
print ("a_struct_time:") 
print (a_struct_time)

Voir plus de module time:
https://docs.python.org/3/library/time.html

4. datetime module

datetime est un module qui est conçu avec le programme orienté objet afin de traiter avec la date et le temps en Python. Il définit quelques classes qui représentent la date et l'heure.

Class	Mô tả
datetime.date	Un objet date représente un date (date), à l'exclusion du temps, selon le calendrier Gregorian.
datetime.datetime	Un objet datetime représente une date (date) et un temps, selon le Gregorian.
datetime.time	Un objet time représente un temps (time), à l'exclusion de la date (date).
datetime.tzinfo	Une classe abstraite (base abstract class) donne des informations du temps local aux objets.
datetime.timezone	Une sous classe directe de la classe tzinfo, selon le standard UTC (Coordinated Universal Time) (Le Temps Universel Coordonné).
datetime.timedelta	Un objet timedelta représente une duration, la difference entre deux dates ou moments.

5. datetime.timedelta

timedelta est une classe qui se trouve dans le module datetime, elle décrit une période de temps. Comme la différence entre 2 moments.

La classe timedelta a 7 attributs (attribute), leurs valeurs sont tous 0.

Attribute	Attribute	Range
days		-999999999 : 999999999
seconds		0 : 86399
microseconds	1 seconds = 1000,000 microseconds	0 : 999999
milliseconds	1 seconds = 1000 milliseconds
minutes
hours
weeks

Des opérateurs:

`t1 = t2 + t3`	t2 = (hours = 10, seconds= 2) t3 = (hours = 1, minutes = 3) --> t1 = (hours= 11, minutes = 3, seconds = 2)
`t1 = t2 - t3`	t2 = (hours = 10, seconds= 2) t3 = (hours = 1, minutes = 3) --> t1 = (hours= 8, minutes = 57, seconds = 2)
`t1 = t2 * i t1 = i * t2`	t2 = (hours = 10, seconds= 2) i = 3 --> t1 = (days =1, hours = 6, seconds= 6)

`t1 = t2`	t2 = (hours = 25, seconds= 2) --> t1 = (days: 1, hours: 1, seconds: 2)
`+t1`	return t1
`-t1`	t1 = (hours = 10, seconds= 2) --> -t1 = (days = -1, hours = 13, minutes = 59, seconds= 58)
`abs(t)`	Absolute value, equivalent to + t when t.days> = 0, and is -t when t.days <0. t = (hours= -25, minutes = 3) --> t = (days = -2, hours = 23, minutes = 3) --> abs(t) = (days = 1, hours = 0, minutes = 57)
`str(t)`	Returns the string in the form [D day [s],] [H] H: MM: SS [.UUUUUU], D can get negative value.
`repr(t)`	Returns a string in the form datetime.timedelta (D [, S [, U]]), D can get negative value

6. datetime.date

datetime.date est une classe, dont les objets représentent la date (date), à l'exclusion l'information sur le temps

Constructor

** constructor **

# MINYEAR <= year <= MAXYEAR
# 1 <= month <= 12
# 1 <= day <= le nombre de jours dans le mois et l'années donnés.
date (year, month, day)

Le constructeur de la classe date peut relever une erreur ValueError si les valeurs passées sont invalides (hors limites).

Des constantes:

Constantes	Description
date.min	La première date représentable, date(MINYEAR, 1, 1).
date.max	La dernière date représentable, date(MAXYEAR, 12, 31).
date.resolution	La plus petite différence possible entre les objets de date non égale, timedelta(days=1).

Des opérateurs

`date2 = date1 + timedelta`	Ajouter une duration, timedelta
`date2 = date1 - timedelta`	Soustraire une durée, timedelta
`timedelta = date1 - date2`	Soustraire deux objets date.
`date1 < date2`	Comparer deux objets date.

Des méthodes:

Method	Description
date.replace(year=self.year, month=self.month, day=self.day)	Return a date with the same value, except for the value replaced by the parameter. For example: d == date(2002, 12, 31), d.replace(day=26) == date(2002, 12, 26).
date.timetuple()	Return a time.struct_time such as returned by time.localtime(). The hours, minutes and seconds are 0, and the DST flag is -1. d.timetuple() is equivalent to time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1)), where yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 is the day number within the current year starting with 1 for January 1st.
date.toordinal()	Return the proleptic Gregorian ordinal of the date, where January 1 of year 1 has ordinal 1. For any date object d, date.fromordinal(d.toordinal()) == d.
date.weekday()	Return the day of the week as an integer, where Monday is 0 and Sunday is 6. For example, date(2002, 12, 4).weekday() == 2, a Wednesday. See also isoweekday().
date.isoweekday()	Return the day of the week as an integer (According to ISO standard), where Monday is 1 and Sunday is 7. For example, date(2002, 12, 4).isoweekday() == 3, a Wednesday. See also weekday(), isocalendar().
date.isocalendar()	Return a 3-tuple, (ISO year, ISO week number, ISO weekday).
date.isoformat()	Return a string representing the date in ISO 8601 format, ‘YYYY-MM-DD’. For example, date(2002, 12, 4).isoformat() == '2002-12-04'.
date.__str__()	For a date d, str(d) is equivalent to d.isoformat().
date.ctime()	Return a string representing the date, for example date(2002, 12, 4).ctime() == 'Wed Dec 4 00:00:00 2002'. d.ctime() is equivalent to time.ctime(time.mktime(d.timetuple())). The native C ctime() function conforms to the C standard when it run on flatform.
date.strftime(format)	Return a string representing the date, In the format given by the parameter. Format codes referring to hours, minutes or seconds will see 0 values. See more strftime() and strptime() function of time module.
date.__format__(format)	Same as date.strftime().