Apprendre Python et s'initier à la programmation

Qu'est-ce qu'un objet ? Un objet est une entité qui possède des caractéristiques et qu'on va pouvoir manipuler. On peut faire un parallèle immédiat avec les objets du monde réel.

Prenons, par exemple, l'objet GSM (pour être précis, on devrait dire téléphone mobile puisque GSM désigne une norme, mais ce dernier terme est abusivement utilisé pour désigner le téléphone), qui possède une certaine marque, un modèle, un numéro de série, une couleur, un niveau de charge de la batterie, un niveau de luminosité de l'écran, etc. Ces différentes caractéristiques sont appelées attributs de l'objet. Pour un objet donné, chaque attribut possède une valeur, dont l'ensemble définit l'état de l'objet. La figure 1 montre deux objets de type GSM, avec leurs cinq attributs et valeurs associées.

Alors que les attributs sont communs aux deux GSM, les valeurs de ces derniers peuvent être différentes. Mais comme on peut le constater sur cet exemple, plusieurs attributs peuvent également avoir les mêmes valeurs (la marque et le modèle, dans cet exemple).

En plus des attributs, un objet offre toute une série de fonctionnalités. On peut, par exemple, effectuer et recevoir un appel, envoyer un SMS, écouter un fichier MP3, consulter le niveau de charge de la batterie, prendre une photo, jouer à un jeu, etc. Il s'agit d'opérations qui vont être appliquées à un objet.

Pour résumer, un objet est une entité qui possède des attributs et propose des fonctionnalités. Chaque objet est unique et possède son état propre, qui est défini par la valeur de ses attributs.

Python est, entre autres, un langage de programmation orienté objet. On manipule dès lors déjà des objets depuis le début, sans vraiment le savoir. Par exemple, les listes, les chaines de caractères et les ensembles sont des objets. Lorsqu'on crée un objet, les trois éléments illustrés sur la figure 2 existent :

• l'objet, c'est-à-dire les valeurs de ses attributs, est en mémoire ;
• une variable, du même type que l'objet, est déclarée et initialisée ;
• une référence vers l'objet est stockée dans la variable.

L'instruction suivante crée un nouvel ensemble contenant six nombres entiers représentant les valeurs des faces d'un dé :

dice = {1, 2, 3, 4, 5, 6}

Un ensemble est un objet de type set, qui stocke les valeurs des six faces du dé. Une référence vers cet objet est stockée dans la variable dice, dont le type est le même que celui de l'objet, à savoir set.

En réalité, tout est objet en Python. D'autres types d'objets qu'on a déjà vus sont donc les nombres entiers et flottants et les booléens.

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 :

def toseconds(t):
    return 3600 * t.hour + 60 * t.minute + t.second

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 :

from datetime import time

start = time(14, 45, 21)
end = time(16, 15, 56)

diff = toseconds(end) - toseconds(start)
print("La différence est de", diff, "secondes.")

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 :

def after(start, duration):
    minute = start.minute + (duration % 60)
    hour = start.hour + (duration // 60) + (minute // 60)
    return time(hour, minute % 60, start.second)

É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 kitxmlcodeinlinelatexdvp90finkitxmlcodeinlinelatexdvp 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 kitxmlcodeinlinelatexdvp60finkitxmlcodeinlinelatexdvp, il faut augmenter les heures d'une unité et diminuer les minutes de kitxmlcodeinlinelatexdvp60finkitxmlcodeinlinelatexdvp 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 :

start = time(14, 45, 21)
end = after(start, 90)

print('Après 90 minutes, il sera', end)
print(type(end))

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

Une méthode est donc toujours appelée sur un objet. Ce dernier, appelé objet cible, est celui sur lequel la méthode appelée pourra opérer. Déclarons, par exemple, deux objets de type set :

numbers = {8, 3, 1, -2, 0}
letters = {'A', 'P', 'Q'}

Ces deux instructions créent deux objets en mémoire, ceux-ci étant référencés par les variables numbers et letters, comme le montre la figure 4. Le premier ensemble contient cinq éléments et le second trois.

Les objets de type set possèdent une méthode pop qui permet de récupérer un élément arbitraire dans l'ensemble. On peut évidemment appeler cette méthode sur chacun des deux objets, en utilisant numbers ou letters comme objet cible. La méthode pop agira à chaque fois sur l'objet cible, en en récupérant un élément de manière arbitraire, comme le montre l'exemple suivant, avec un résultat d'exécution possible :

print(numbers.pop())
print(letters.pop())

8
Q

On peut stocker des références vers le même objet dans plusieurs variables différentes, c'est-à-dire créer des alias. On a déjà vu cette notion précédemment, mais revoyons un nouvel exemple :

s = {9, 12, -5}
a = s

Dans cet exemple, un objet est créé par la première instruction et une référence vers ce dernier est stockée dans la variable s. La deuxième instruction copie juste le contenu de la variable s dans la variable a, c'est-à-dire la référence vers l'objet comme le montre la figure 5. On dit que la variable a est un alias de la variable s.

Les deux variables permettent d'agir sur le même objet. Par exemple, si on utilise la variable a pour ajouter un élément dans l'ensemble, puis qu'on affiche le contenu de l'ensemble avec la variable s, on verra que le changement a bien eu lieu sur l'unique objet qui existe en mémoire, référencé par les deux variables :

a.add('NEW')
print(s)

{'NEW', 9, -5, 12}

Les objets ressemblent beaucoup aux tuples nommés, ces derniers étant en quelque sorte les précurseurs des objets. Tous les deux permettent de stocker des données, appelées champs pour les tuples nommés et attributs pour les objets, accessibles avec l'opérateur d'accès. Alors qu'un tuple nommé est toujours non modifiable, les attributs d'un objet peuvent être modifiés s'ils ne sont pas en lecture seule.

Si on veut effectuer des opérations sur un tuple nommé, il faut définir une fonction qui reçoit le tuple nommé en paramètre. Pour effectuer des opérations sur un objet, on l'utilise comme objet cible lors de l'appel d'une méthode. La figure 6 résume ces deux types d'appels.

Enfin, une dernière différence entre les tuples nommés et les objets est qu'avec ces derniers, l'accès aux attributs peut être restreint aux méthodes de l'objet. Ils sont en effet parfois simplement cachés, et dès lors accessibles ni en lecture ni en écriture. Pour un tuple nommé, ils sont par contre toujours accessibles en lecture.

En Python, toutes les données sont de type objet, même les nombres entiers, par exemple. La figure 7 montre un objet de type int créé en mémoire et dont une référence est stockée dans la variable temperature. On l'obtient avec l'instruction suivante :

temperature = 19

Tout ce qu'on a vu sur les objets s'applique donc aussi sur les types de données qu'on a vus depuis le début du livre. Par exemple, l'instruction x = temperature crée un alias.

Quelles sont les méthodes disponibles pour les objets de type int ? On peut le savoir à l'aide de la fonction prédéfinie dir, qui renvoie une liste comme le montre l'exemple suivant :

temperature = 19
print(dir(temperature))

['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

On voit, par exemple, une méthode real qui permet d'obtenir la partie réelle du nombre et une méthode imag qui permet d'obtenir la partie imaginaire. Dans le cas d'un nombre entier, cette dernière renverra évidemment toujours kitxmlcodeinlinelatexdvp0finkitxmlcodeinlinelatexdvp.

Les méthodes dont les noms sont entourés de __ sont privées et ne devraient pas être utilisées directement, mais indirectement. Par exemple, la méthode __add__ correspond à l'opérateur d'addition (+). Les deux instructions suivantes font exactement la même opération, et affichent toutes les deux kitxmlcodeinlinelatexdvp30finkitxmlcodeinlinelatexdvp :

print(temperature + 11)
print(temperature.__add__(11))

Comme expliqué dans le chapitre suivant, Python permet de définir des notations simplifiées pour appeler des méthodes, remplaçant l'appel par l'utilisation d'un opérateur.