Tutoriel Python - sommaire

Python : modules, bibliothèques - gestion des dates et heures

Avant d'aborder le traitement des dates et heures en Python je voudrais revenir sur les notions de module et de bibliothèque.

Ne confondez pas bibliothèque Python et module Python.

Les modules Python sont installés mais ne sont pas disponibles (sauf le module de base). Il faut donc éventuellement en activer certains ; dans le jargon Python on dit "importer".

Les bibliothèques (ou librairies) sont des extensions du langage Python. Il faut alors les installer sur votre ordinateur (avec l'utilitaire PIP : voir plus loin dans ce chapitre).
Une bibliothèque peut comprendre plusieurs modules ; par exemple le module pyplot est un composant de la bibliothèque matplotlib.

Les modules

Un module est un ensemble de fonctions.
Par défaut seules les fonctions du module de base dite "fonctions natives" sont disponibles.

Problématique

>>>pow(9,2)
81
>>> randint(25)
...
NameError: name 'randint' is not defined
>>> sqrt(9)
...
NameError: name 'sqrt' is not defined
>>>

La fonction pow() est une native. Par contre randint() appartient au module "random" et sqrt() au module "math".
Donc avant d'appeler ces deux dernières fonctions, il faut importer les modules ad hoc.

Importer un module : première solution

Si vous utilisez la syntaxe import nomModule [as alias] il faudra ensuite produire des commandes dans lesquelles les fonctions sont préfixées par le nom du module OU par son alias.

Commandes à tester :

>>>import random as rd
>>>import math
>>>import datetime as dt
>>>math.sqrt(25) 
>>>rd.randint(100)
>>>dt.time(12,30)

Ici j'ai donné l'alias "rs" au module random" et "dt" au module datetime.

Et si vous oubliez de préfixer les fonctions vous aurez un message d'erreur.

>>>import math
>>>sqrt(25)
...
NameError: name 'sqrt' is not defined
>>> math.sqrt(25)
5.0

Importer un module : deuxième solution

Pour importer, par exemple, les modules math & random on peut produire les commandes :

from math import*
from random import *

Si vous importez un module avec la syntaxe from nomModule import * vous n'aurez pas besoin de préfixer ensuite les fonctions dans les commandes.

sqrt(25)
5
randint(0,100)
78

Importer un module : quelle solution retenir ?

À priori la deuxième solution semble préférable puisqu'elle dispense de préfixer ensuite les fonctions dans les commandes.
Paradoxalement il faut éviter cette syntaxe si vous devez importer de nombreux modules.
Cette technique présente un réel inconvénient. Mais plutôt qu'un long discours un petit exemple !
Dans le module time il existe une fonction time() et dans le module datetime il existe aussi une fonction time() et elles ne sont pas substituables ; elles ne font pas la même chose ! La première produit un "timestamp" et l'autre génère une heure.
Si j'ai besoin de ces deux fonction ; comment importer correctement les deux modules pour disposer des deux fonctions ?

Mauvaise solution

>>> from time import *
>>> from datetime import *
>>> time()
datetime.time(0, 0)

L'interpréteur prend en compte la fonction datetime.time(); la fonction time.time() n'est plus disponible car écrasée par la deuxième importation.

La bonne démarche

>>> import time
>>> import datetime as dt
>>> time.time()
1704283959.2512217
>>>heure =  dt.time(12,30)
>>>heure.hour
12

Je peux désormais utiliser les deux fonctions time() des différents modules !

Vous devez vous dire à ce stade que vous ne savez toujours pas à quoi servent ces deux fonctions time(). Rassurez vous les modules time & datetime sont évoqués plus loin dans ce chapitre.

Découverte d'un module

Mais comment connaitre la liste des fonctions d'un module ?

>>>import math
>>>help(math)
Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.

        The result is between 0 and pi.

    acosh(x, /)
        Return the inverse hyperbolic cosine of x.

    asin(x, /)
        Return the arc sine (measured in radians) of x.

        The result is between -pi/2 and pi/2.

    asinh(x, /)
        Return the inverse hyperbolic sine of x.
	...

Pour découvrir toutes les fonctions d'un module il suffit de l'importer puis de taper la commande help(nomModule).
Pour avancer d'une page dans la liste tapez sur "espace".
La commande dir(nomModule) donne simplement la liste des fonctions du module.

>>> import random as rand
>>> dir(rand)
 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 
'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate',
 'paretovariate', 'randbytes', 'randint', 'random',
 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 
 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
>>>

Les bibliothèques (ou librairies) Python

La plupart des modules sont installés dans la version standard de Python mais d'autres doivent être chargées si nécessaire.
Si, par exemple, vous voulez tracer la courbe d'une fonction du deuxième degré (f(x) = ax2 + bx + c) vous devrez utiliser des fonctions qui n'existent pas dans les modules installés mais disponibles dans la bibliothèque matplolib.

Pour télécharger cette bibliothèque, sans prise de tête, il suffit d'utiliser l'utilitaire pip.
Par exemple pour programmer des jeux vidéo en Python vous devrez disposer de la bibliothèque pygame.

pip : gestionnaire de paquets

Un des atouts de Python est la multitude de bibliothèques (ou librairies) disponibles.
Pour que le téléchargement de ces bibliothèques ne devienne pas un parcours du combattant il a été imaginé un outil qui s'appelle pip.
pip est un gestionnaire de paquets utilisé pour installer et gérer des librairies Python.
À partir des versions 3 de Python, l'utilitaire pip est inclus par défaut dans la distribution officielle du langage.

Utilisation de pip

Attention il faut lancer cet utilitaire à partir d'un terminal windows (CMD ou PowerShell) : "invite de commande".
Sous windows, tapez "cmd" dans la zone de recherche de la barre d'état.

Quelques commandes utiles du gestionnaire pip :
• installer une bibliothèque : pip install nomLibrairie
• connaitre la version de pip : pip --version
• désinstaller une librairie : pip uninstall nomlibrairie
• afficher la liste des bibliothèques installées : pip list

Par exemple, si vous voulez installer le micro framework python flask il suffit de taper : pip install flask

Ci-dessous capture d'écran qui montre toutes les librairies Python installées sur mon PC (commande : pip list) :

Notez que les librairies matplolib & numpy ont été installées.

Mais revenons à des modules préinstallés : time & datetime.

Le module time

Le module "time" fournit entre autres la date et l'heure de votre système. Il propose aussi une fonction de temporisation : sleep(n).

Quelques fonctions de ce module

>>> import time
>>> time.time()
1610096656.5586228
>>> time.localtime()
time.struct_time(tm_year=2021, tm_mon=1, tm_mday=8, tm_hour=10, tm_min=5, tm_sec=4, 
tm_wday=4, tm_yday=8, tm_isdst=0)
>>> time.strftime("%A %d %B %Y")
'Friday 08 January 2021'
>>> time.strftime("%H : %M : %S")
'11 : 58 : 16'
>>> time.sleep(20)
>>>

La commande time.time() retourne un nombre qui est le "timestamp" : le nombre de secondes entre le 1er janvier 1970 et l'instant présent. Le timestamp est une notion que l'on retrouve dans pratiquement tous les langages.

La commande time.localtime() affiche la date et l'heure système d'une façon plus claire.

La fonction localtime() retourne un tuple avec différents éléments :
• tm_year : l'année sous forme d'un entier
• tm_mon : le numéro du mois (de 1 à 12 et non pas de 0 à11)
• tm_mday : le numéro du jour dans le mois
• tm_hour : heure ; tm_min : minutes ; tm_sec : secondes
• tm_wday : le jour de la semaine sous forme d'un entier compris entre 0 et 6
• tm_yday : le jour de l'année, entre 1 et 366

Vous voyez donc que j'ai utilisé l'interpréteur le 8 janvier 2021.

time.strftime("%A %d %B %Y") : affiche la date système avec le format habituel pour un francophone : nomJour, rangJour, nomMois, anneé
time.strftime("%H : %M : %S") : affiche de l'heure du système avec un formatage : heures:minutes:secondes
L'argument de cette fonction est une chaine composé de différents symboles de formatage.

Les symboles de formatage à utiliser :

time.sleep(20) : mise en pause durant 20 secondes. Vous constatez qu'après avoir appuyé sur ENTER les triples chevrons sont invisibles et le curseur clignote. Au bout de 20 secondes, les chevrons réapparaissent.
Cette fonction ne présente pas beaucoup d'intérêt en mode commande par contre en mode programmé une temporisation peut être très utile ...

Afficher la date en français ?

>>> import locale
>>> locale.setlocale(locale.LC_ALL, '')
'French_France.1252'
>>> import time
>>> time.strftime("%A%d%m%Y")
'lundi12082024'
>>> time.strftime("%A %d %B %Y")
'lundi 12 août 2024'
>>>

Le module locale donne accès à la base de données contenant les paramètres régionaux.

Le module datetime

Le module datetime comprend trois fonctions importantes : date(), datetime(), time() respectivement pour créer une date, une heure, un instant (date & heure).

Quelques fonctions de ce module

>>> import datetime as dt
>>> naissance =dt.date(1954,2,19)
>>> naissance
datetime.date(1954, 2, 19)
>>> naissance.year
1954
>>> naissance.month
2
>>> naissance.day
19

>>> heure =dt.time(14,45)
>>> heure.hour
14
>>> heure. minute
45
>>> minuit = dt.time()
>>> print(minuit)
00:00:00
>>> print(type(minuit))
<class 'datetime.time'>
>>> cejour = dt.date.today()
>>> print(cejour)
2022-04-17
>>> datecourante = cejour.strftime("%d - %m -%Y")
>>> datecourante
'17 - 04 - 2022'
>>> print(type(datecourante))
class 'str'
>>> instant_present = dt.datetime.now()
>>> print(instant_present)
2022-04-17 05:33:53.918780
>>>

Commentaire

J'ai importe le module datetime avec un alias : dt car le nom du module est long. L'appel des fonctions du module importé aura pour syntaxe : dt.nomFonction()
Nous avons dans le module "datetime" trois méthodes importantes : date(), time() & datetime().

La fonction date(Y,M,D) crée un objet avec la date précisée par les trois arguments. On peut appliquer à cet objet les propriétés : year, month, day.
La fonction time() crée un objet avec l'heure précisée avec jusqu'à trois arguments (heure, minute,seconde). Pour produire l'heure de minuit (00:00:00) il suffit d'utiliser la méthode time sans argument.
On peut appliquer à une heure les propriétés : hour, minute, seconde.
La méthode date() suivie de today() retourne la date du jour.
La fonction datetime() suivie de now() retourne l'instant présent : date et heure courantes.
On retrouve dans le module datetime la méthode strftime() que nous avions déjà utilisé avec le module time
Je ne reviens pas sur les symboles de formatage. Je précise simplement que la méthode retourne une chaine !

Calcul d'une durée en jours entre deux dates

Je vais maintenant vous montrer comment calculer la différence en jours entre deux dates.
Commandes dans la console : >>> import datetime as dt >>> jour_an =dt.date(2022,1,1) >>> premier_mai = dt.date(2022,5,1) >>> intervalle = premier_mai - jour_an >>> print(intervalle) 120 days, 0:00:00 >>> print(type(intervalle)) <class 'datetime.timedelta'>

J'importe le module datetime sous le pseudo "dt".
Je crée une date "jour_an" avec la méthode date(année,mois,jour).
Je crée une deuxième date avec toujours cette méthode.
Dans "intervalle" je calcule la durée en jours entre ces deux dates qui retourne un tuple.
La variable "intervalle" est un objet timedelta de la classe datetime.

Programme pour calculer l'âge à partir de l'année de naissance

"""
Nom du programme : calculer_age.py
Objet : calcul de l'âge (en années) à partir de l'année de naissance
"""
from datetime import date
 
def calculAge(annee_naiss):
    cejour = date.today()
    annee2 =cejour.year
    delta =annee2-annee_naiss
    return delta

while True:
    try : 
        naissance = input("Saisir année de naissance ou 'fin' : ")
        if naissance =="fin":
                break
        naissance =eval(naissance)
        print(f"{calculAge(naissance)} ans")
    except:
        print("saisie incorrecte")

La fonction "calculAge()" :
Dans cette fonction il faut extraire de la date du jour l'année.

Le programme principal :
Une boucle infinie permet de calculer plusieurs âges, de recommencer la saisie après une saisie incorrecte grâce à la "gestion des exceptions".
Je rappelle que toute valeur saisie via input() est de type string donc ne pas oublier la conversion.

Le rendu

Saisir année de naissance ou 'fin' : 19oo
saisie incorrecte
Saisir année de naissance ou 'fin' : 1960
64 ans
Saisir année de naissance ou 'fin' : 1977
47 ans
Saisir année de naissance ou 'fin' : fin
>>>

Le module calendar

Le module calendar est un module intégré qui fournit des fonctions pour travailler avec des calendriers.
Il vous permet de créer et de manipuler des calendriers, de les imprimer et de réaliser divers calculs impliquant des dates et des heures.

Afficher le calendrier d'un mois

>>> import calendar
>>> calendar.prmonth(2023,12)
   December 2023
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
>>> calendar.prmonth(2023,11)
   November 2023
Mo Tu We Th Fr Sa Su
       1  2  3  4  5
 6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30

>>> a =2024
>>> m =1
>>> calendar.prmonth(a,m)
    January 2024
Mo Tu We Th Fr Sa Su
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31
>>>

J'ai affiché les calendriers des mois de décembre et novembre 2023 mais auss de janvier 2924 gràce à la méthode premonth(annee,mois).

Afficher le calendrier d'une année

Le programme tient en quelques lignes !

# nom du programme : calendrier_2024.py
import calendar
# Create calendrier 2024
a = 2024
for  m in range(1,13) :
    calendar.prmonth(a,m)
    print("-----") 

Nombre de jours dans un mois ?

Cette fois je vais employer la méthode monthrange(année,mois) de la classe calendar.

>>> import calendar
>>> info = calendar.monthrange(2023,12)
>>> print(info)
(4, 31)

La commande calendar.monthrange() retourne sous forme d'un tuple le rang du premier jour du mois et le nombre de jours dans le mois. On apprend que le mois de décembre 2023 commence par un vendredi ("weekday" de rang 4) et comprend 31 jours.

Savoir si une année est bissextile ou pas ?

Ici je vais utiliser une fonction qui retourne un booléen.

...
>>> bissextile = calendar.isleap(2022)
>>> print(bissextile)
False

Afficher le calendrier d'un mois, la première colonne étant DIMANCHE

C'est un peu plus compliqué : il faut enchainer trois commandes.

>>> c=calendar.TextCalendar(calendar.SUNDAY)
>>> c_2023_12 =c.formatmonth(2023,12)
>>> print(c_2023_12)
   December 2023
Su Mo Tu We Th Fr Sa
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

Calendar.TextCalendar(calendar.SUNDAY) indique à la console de créer un calendrier texte ; la première colonne du calendrier sera celle des dimanches.
c.formatmonth(2023,12) : établissement du calendrier du mois de décembre 2023

Programme pour afficher le calendrier de l'année 2024

Attention ce script génère du HTML !

# nom du programme : calendrier_html_2024.py
import calendar
# Create calendrier 2024 au format HTML
a = 2024
c =calendar.HTMLCalendar(calendar.SUNDAY)
for  m in range(1,13) :
    c_mois =c.formatmonth(a,m)
    print(c_mois)

Le rendu

Il suffit de copier tout le code HTML généré par ce programme dans un document HTML puis de rajouter la partie HEAD et de nommer ce fichier "calendrier2024.htm"
Ci-dessous la page "calendrier2024.htm" affichée dans un Iframe :