Modularité

Fonctions

En informatique, le développeur débutant se retrouve parfois à écrire un code proche d’un code qu’il a déjà écrit précédemment. Dans ce cas de figure, plutôt que d’écrire une seconde fois une portion de code identique, on doit alors écrire une fonction pour encapsuler cette portion de code afin de le capitaliser.

Cette encapsulation est en fait une stratégie de modularité de code. En effet, en créant une fonction, le développeur crée un module qu’il pourra utiliser facilement et rapidement dans son application en cours de développement, mais également potentiellement dans de futurs projets.

Une fonction permet de regrouper un ensemble d’instructions afin de les exécuter au moment de l’appel de la fonction à l’endroit voulu dans le code source.

Une fonction est généralement créée pour réaliser une fonctionnalité particulière, par exemple :

La réalisation de la fonctionnalité contenue au sein d’une fonction peut nécessiter d’avoir des informations a priori pour réaliser la tâche. Ces informations sont données à l’aide des paramètres de la fonction.

Une fonction peut calculer un résultat à la suite de son exécution et le développeur peut vouloir récupérer ce résultat. Ceci se réalise à l’aide des valeurs retournées par la fonction.

def ma_fonction(<param1>, <param2>, ..., <paramn>) : 
        <instruction 1> 
        <instruction 2> 
        ... 
        <instruction n> 
return <val1>, <val2>, ... , <val n>
 

Programmation orientée objet

La programmation orientée objet (POO) est un concept informatique. Les puristes emploient le terme de paradigme, qui consiste à représenter les informations d’un problème sous la forme d’objets.

Un objet peut être tout élément du problème qui peut être réduit à un ensemble de données (on parle d’attributs) et de fonctionnalités (qu’on nomme méthodes).

Vus sous cet angle, tous les éléments d’un problème quelconque peuvent être vus comme des objets. Afin d’illustrer ce que peut être un objet, citons quelques exemples :

On voit donc qu’un objet peut servir à représenter un objet physique, un élément informatique ou même un concept.

Un des intérêts des objets est que, de par leur modularité, il est possible de les réutiliser d’un projet informatique à l’autre.

Comme nous l’avons dit précédement, un objet contient des données appelées attributs. Ces attributs peuvent être de type simple comme des entiers, des flottants ou des chaînes de caractères.

Un objet est créé à partir d’un moule qu’on nomme classe....

Python, programmation objet et différences principales avec d’autres langages

Python est un langage tout objet. Vous avez déjà manipulé sans le savoir, dans les chapitres précédents, des objets !

En effet, les éléments les plus basiques comme les float et les int sont des objets qui possèdent des attributs et des méthodes. C’est également le cas des list, dont vous avez manipulé quelques méthodes, par exemple append().

Python possède sa propre implémentation du paradigme de POO. Elle est, en comparaison à celle de C++, beaucoup plus accessible au débutant. En termes de différences :

Outre ces différences principales, Python permet l’usage des propriétés, décorateurs, qui n’existent pas en C++.

Enfin, pour conclure cette section, donnons la définition générique en langage Python :

class <nom_de_la_classe> (object): 
 ...

Constructeur et attributs

Le constructeur est la première fonction qui est appelée lors de l’instanciation d’une classe. L’instanciation consiste à la création d’un objet à partir d’un modèle, ici une classe.

Dans la définition générique de la classe, le constructeur correspond à la méthode spéciale : __init__(self, ...).

En Python, cette méthode contient toutes les définitions et les initialisations d’attributs. Pour illustrer le propos, nous allons modéliser un téléphone. Commençons par ses attributs :

L’exemple qui suit correspond à la déclaration des attributs en question. marque, modele et couleur sont des chaînes de caractères initialisées à la valeur vide " ". Quant à annee, c’est un entier initialisé à 0.

class Telephone(object): 
 
    def __init__(self): 
        self.marque = "" 
        self.modele = "" 
        self.couleur = "" 
        self.annee = 0
 

Il est important que le premier argument du constructeur soit toujours self, ce qui correspond à l’instance en cours de la classe.

Par ailleurs, les attributs de la classe sont toujours précédés de self. Ce qui signifie que nous manipulons la classe instanciée.

Méthodes membres

Une classe est composée d’attributs, mais également de méthodes. Le terme méthode désigne les fonctions manipulant les données de la classe et pouvant être accédées depuis une instance de l’objet.

La définition d’une méthode est semblable à la définition d’une fonction classique, à la différence près qu’elle est faite au sein de la classe et qu’une méthode comporte toujours comme premier paramètre self.

Afin d’illustrer ceci, ajoutons à la classe Telephone une méthode pour afficher les valeurs des quatre attributs. Cette méthode se nomme aff_attribut.

class Telephone(object): 
 
    def __init__(self, val_modele, val_couleur, val_annee = 2002): 
        self.marque = "" 
        self.modele = val_modele 
        self.couleur = val_couleur 
        self.annee = val_annee 
 
    def aff_attribut(self): 
        print("Valeur pour l'attribut marque : ", self.marque) 
        print("Valeur pour l'attribut modele : ", self.modele) 
        print("Valeur pour l'attribut couleur : ", self.couleur) 
        print("Valeur pour l'attribut annee : ", self.annee)
 

Cette méthode réalise l’affichage successif des quatre attributs de la classe. Comme pour le constructeur, pour accéder aux attributs, il faut passer par self.<nom_attribut>. Si ce n’est pas le cas, l’interpréteur Python indique que la variable à laquelle nous voulons accéder n’est pas membre de la classe, comme dans le message suivant : « NameError: name ’marque’ is not defined » .

Grâce à cette fonction, nous pouvons réduire la taille du code qui manipule les instances de la classe...

Python et l’encapsulation

En informatique, l’encapsulation est un principe qui consiste à protéger ou à cacher des données de certains objets. En d’autres termes, cela consiste à ne pas rendre possible l’accès à certains attributs depuis une instance d’une classe.

En C++, cela s’effectue à l’aide du mot-clé private, qui permet de protéger l’accès aux données définies sous la portée de ce mot-clé.

Le langage Python ne propose pas de mot-clé private pour réaliser l’encapsulation. Les notions d’attribut et de méthode privés n’existent pas directement en Python.

Les développeurs pallient cette limite en appliquant un ensemble de règles de bon usage (voir par exemple : https://google.github.io/styleguide/pyguide.html).

En pratique, la syntaxe admise pour représenter ce qui est privé est très simple : tous les attributs ou méthodes qui possèdent un caractère _ au début de leur nom sont définis comme privés.

Il est donc de la responsabilité du développeur de ne pas utiliser directement un attribut privé lorsqu’il manipule une instance d’un objet.

Cette syntaxe (qui caractérise Python) doit être connue et respectée, notamment dans le cadre d’un projet collaboratif ou de l’utilisation de sources disponibles en open source.

Transformons maintenant la classe Telephone pour rendre les variables privées. Les seules transformations sont à réaliser dans le constructeur, ainsi que là où les attributs sont utilisés :

class Telephone(objec)): 
 
    def __init__(self, val_modele, val_couleur, val_annee = 2002): 
        self._marque = "" 
        self._modele = val_modele 
        self._couleur...

Méthodes spéciales

Python ne permet pas la surcharge de fonction et la stratégie pour pallier ce manque avec les paramètres par défaut a été présentée. Il existe encore un cas de figure où la surcharge est utile. Il s’agit de la surcharge d’opérateur.

La surcharge d’opérateur consiste à réécrire le comportement d’un opérateur (arithmétique par exemple) pour l’adapter à la structure d’une classe définie par l’utilisateur. À titre d’exemple, il y a peu de chance que l’opérateur + puisse être utilisé directement entre deux instances d’une classe définie par l’utilisateur. Il est donc nécessaire de définir le comportement de l’opérateur d’addition lorsqu’il est appelé sur de tels objets.

En Python, pour réaliser cette opération, il existe un ensemble de méthodes dites spéciales. Pour être tout à fait exact, les méthodes spéciales ne servent pas uniquement à surcharger des opérateurs, elles peuvent être utilisées pour redéfinir le comportement des fonctions.

Par exemple, lorsque vous tapez dans une console IPython (après l’exécution de votre script) :

In [2]: t1
 

vous obtenez en sortie :

Out[2]: <__main__.Telephone at 0x745fc630>
 

Cette manipulation est généralement faite à des fins de débogage. Or, les informations obtenues en sortie sont peu utiles pour détecter un bogue.

La fonction spéciale __repr__ permet de redéfinir le comportement de la fonction mise en œuvre ici et qui permet de contrôler comment est représenté un objet pour obtenir des informations plus intéressantes. Cette redéfinition se fait en ajoutant directement une méthode supplémentaire...

Héritage

L’héritage est une autre manière de réutiliser du code existant, c’est-à-dire de le capitaliser. Le principe est le suivant : une classe dite « fille » hérite des méthodes et attributs de la classe « mère » dont elle dérive.

Généralement, la classe fille est plus spécifique que la classe mère : elle récupère tous les attributs et méthodes de la classe mère et elle est enrichie de nouveaux attributs et de nouvelles méthodes.

Afin d’illustrer notre propos, créons une classe Smartphone qui dérive de la classe Telephone, mais qui a en plus un attribut _os, ainsi que les accesseurs et mutateurs associés.

class Smartphone(Telephone): 
 
    def __init__(self, val_modele, val_couleur, val_os = "Symbian", 
                 val_valeur=750, val_annee=2002): 
        super(Smartphone, self).__init__(val_modele, val_couleur, val_valeur, 
                                   val_annee) 
        self._os = val_os 
 
 
    @property 
    def os(self): 
        return self._os 
 
    @os.setter 
    def os(self, value): 
        self._os = value
 

Dans la définition de la classe Smartphone, la classe Telephone apparaît entre parenthèses. Cela signifie que la classe Smartphone dérive de la classe Telephone. Par conséquent, elle hérite de tous les attributs et méthodes de la classe Telephone.

Le constructeur de la classe Smartphone a en paramètre une valeur permettant d’initialiser le nouvel attribut de la classe ainsi que les valeurs permettant d’initialiser les attributs hérités de la classe Telephone.

Cette initialisation des attributs de la classe mère...

Créer ses propres modules et packages

from telephonie import Telephone 
from telephonie import Smartphone
 

from telephonie import Telephone 
from telephonie import Smartphone 
 
 
print("Instance t1 avec tous les arguments") 
# Instanciation de la classe en précisant tous les paramètres 
t1 = Telephone("3310", "jaune", 35, 1997) 
 
print("Instance t2 avec tous les arguments") 
# Instanciation de la classe en précisant tous les paramètres 
t2 = Telephone("3310", "carbone", 45, 200) 
 
# utilisation de l'opérateur + redéfini pour la classe Telephone 
val_cumul = t1 + t2 
print("Valeur...

Travaux pratiques