UKOnline

Construction et utilisation

Pour pouvoir utiliser un objet dans un programme, il faut avant tout le créer, c'est-à-dire préparer de la place en mémoire pour stocker les valeurs de ses attributs, et initialiser ces valeurs. Une fois cela fait, on va pouvoir utiliser l'objet, c'est-à-dire accéder à ses attributs (les lire et les modifier) et exploiter les fonctionnalités offertes par l'objet. L'utilisation d'un objet se fait grâce à la variable stockant une référence vers celui-ci.

Dans cette section, on va utiliser des objets prédéfinis de type time. Ces derniers permettent de représenter un instant temporel identifié par des heures, minutes et secondes. Pour pouvoir utiliser des objets time, il faut avant tout importer le module datetime.

Constructeur

La création d'un nouvel objet passe par l'appel d'un constructeur. Il s'agit d'une fonction particulière dont le nom est le même que celui du type de l'objet à créer.

On a déjà vu plusieurs fois l'utilisation d'un constructeur, notamment lorsqu'on voulait créer des copies de structures de données avec les fonctions list, set et dict, par exemple, ou lorsqu'on effectuait des conversions de données avec les fonctions int, float et str, par exemple.

L'exemple suivant crée deux objets de type time :

Pour créer un nouvel objet time, il faut donc fournir trois paramètres correspondants aux heures, minutes et secondes de l'objet à créer. Les deux objets créés, représentés sur la figure 3, représentent respectivement les instants 14:45:21 et 16:15:56.

Objets time en mémoire
Deux objets de type time sont distincts en mémoire et possèdent chacun leur état propre, caractérisé par la valeur de ses attributs.

Une fois un objet créé, on va pouvoir l'utiliser, et en particulier accéder à ses attributs. Pour cela, on passe par la variable contenant la référence vers l'objet et on utilise l'opérateur d'accès (.).

Un objet de type time possède plusieurs attributs dont hour, minute et second. L'exemple suivant calcule l'équivalent en secondes d'un instant temporel, afin de faire la différence entre deux instants. Pour cela, il suffit de multiplier les heures par $3600$, les minutes par $60$ et de sommer le tout, pour les deux objets :

La différence est de 5435 secondes.

L'accès aux attributs peut être fait en lecture et/ou en écriture. Par exemple, pour les objets de type time, les trois attributs qu'on vient de voir ne sont accessibles qu'en lecture. Si on tente de modifier la valeur d'un de ces attributs, une erreur se produit lors de l'exécution :

Comme on le constate ci-dessous, l'attribut minute des objets de type time n'est pas modifiable :

Traceback (most recent call last):
  File "program.py", line 4, in <module>
    start.minute = 15
AttributeError: attribute 'minute' of 'datetime.time' objects is not writable

Paramètre de type objet

Si on revient sur l'exemple précédent, qui permet de calculer la différence en secondes entre deux instants, on se rend compte qu'il y a de la duplication de code.

Ce n'est pas une bonne pratique, comme on l'a déjà précédemment vu, et on va donc améliorer ce code. Une solution consiste à définir une fonction qui reçoit un objet de type time en paramètre et qui renvoie l'équivalent en secondes de cet instant :

Le paramètre t reçu en paramètre est donc un objet de type time, ce qui permet d'accéder à ses attributs dans le corps de la fonction. Sur base de cette fonction, on peut simplifier le calcul de la différence entre deux instants. Le précédent exemple devient :

Valeur de retour de type objet

En plus de pouvoir recevoir un paramètre de type objet, une fonction peut également renvoyer un objet, ou plus précisément une référence vers un objet. Définissons une fonction after qui reçoit un premier paramètre de type time et un second de type int. Le premier représente un instant dans le temps et le second une durée en minutes. Le but de la fonction est de calculer l'instant qu'il sera une fois la durée écoulée (en supposant que l'on ne dépasse pas 23:59:59).

Pour résoudre ce problème, on va utiliser les opérateurs de division entière et de reste de la division entière. Comme vous le constatez ci-dessous, la fonction renvoie bel et un bien un nouvel objet :

Étant donné duration minutes, duration // 60 représente le nombre d'heures et duration % 60 le nombre de minutes correspondants. Par exemple, un duration de $90$ correspond à une heure et trente minutes. Pour calculer l'instant final, il suffit d'ajouter ces deux quantités aux heures et minutes initiales, et si le nombre de minutes dépasse $60$, il faut augmenter les heures d'une unité et diminuer les minutes de $60$ unités.

Une fois la fonction définie, on peut l'utiliser pour construire des objets de type time, comme on peut le constater sur base de l'exemple suivant :

On voit bien sur le résultat de l'exécution que la valeur renvoyée par l'appel de la fonction after est un objet de type time :

Après 90 minutes, il sera 16:15:21