Python : classes et méthodes (partie 1), avec un peu de menuiserie en prime.

Pour une lecture plus agréable (page plus large), je vous invite à cliquer sur ce lien et à lire ce chapitre dans la rubrique consacrée au langage Python.

En programmation orientée objet (POO) et notamment dans le langage Python, tout est objet ! En fait, c’est un peu comme dans le monde réel… Nous sommes entourés d’objets de toutes sortes.

Ces objets virtuels sont instanciés par des classes. Une classe, c’est d’abord un type d’objet. Par exemple le nombre entier 23 est un objet de type ‘int’, c’est-à-dire instancié par la classe ‘int’ :

print(type(23))

Résultat : class ‘int’

Et ce qui est trop méga kisscool, c’est que Python autorise n’importe qui à définir ses propres classes et à les lancer en production.

Une classe se déclare en utilisant le mot-clé class suivi du nom que le programmeur lui a donné. Par convention, le nom d’une classe commence toujours par une majuscule :

class Truc(object):

Elle hérite des caractéristiques de la mère de toutes les classes fondamentales, à savoir object (entre les parenthèses). Notez bien qu’en Python 3, cette indication est devenue facultative.

Cette classe baptisée Truc (pour l’exemple) permet donc d’instancier de nouveaux objets sur lesquels on applique différentes méthodes.

Les méthodes

Tout comme une fonction, une méthode se déclare avec le mot-clé def. Il existe toutefois deux différences majeures entre les fonctions et les méthodes :

  1. Une méthode est toujours encapsulée dans une classe, c’est-à-dire déclarée et définie à l’intérieur d’une classe.
  2. Contrairement à une fonction qui peut n’avoir aucun paramètre, une méthode d’instance compte toujours au moins un paramètre qui est la référence de l’instance. Par convention, cette dernière est nommée self. Même s’il est possible de la baptiser d’un nom plus court (par exemple : s), il est conseillé de ne pas le faire et de respecter la convention du self.

Instancions un meuble de bibliothèque virtuel

Ce que je suis en train de vous raconter est un peu abstrait voire totalement abscons… Alors avant de manipuler les classes et les méthodes, notamment avec le module Tkinter, prenons un peu de bon temps et amusons-nous  à créer virtuellement un objet de notre quotidien, en l’occurrence un meuble de bibliothèque.

biblio

Pour ce faire, nous allons définir une classe ElementsDeMeuble() qui va nous permettre de produire les différents éléments qui composent un meuble de bibliothèque, à savoir sept étagères et deux montants. Les étagères et les montants seront donc des objets de type ElementsDeMeuble().

Allez, c’est parti! Définissons la classe :

class ElementsDeMeuble (object) :
    """Production des différents éléments qui, une fois assemblés,
       composeront le meuble."""

    def __init__(self, largeur = 0, longueur = 0, quantite = 0)
        """Définition de la méthode constructeur qui se déclenche
           automatiquement lorsque la classe est activée.
           Elle est dotée de paramètres par défaut qui permettent
           d’éviter de générer une erreur (largeur = 0, etc...)."""

        # Création des attributs d’instance self :
        self.largeur = largeur    # en millimètres
        self.longueur = longueur  # en millimètres
        self.quantite = quantite

    def debiter(self):
        "Débit des éléments"

# Création des différents objets:
etagères = ElementsDeMeuble(1000, 300, 7)
etagères.debit() #Application de la méthode debit sur l'objet nouvellement créé.

montants= ElementsDeMeuble(2000, 300, 2)
montants.debit()

Nous obtenons deux montants de 2000 mm de longueur et 300 mm de largeur ainsi que sept étagères de 1000 mm de longueur et 300 mm de largeur.

Maintenant que nous avons tous nos éléments, nous allons pouvoir créer l’objet meuble de bibliothèque. Pour ce faire, nous allons définir la classe Meuble(). Notre meuble de bibliothèque sera donc un objet de type Meuble() :

class Meuble (object) :
    "Assemblage des différents éléments du meuble."

    def __init__(self, etageres = 0, montants = 0, trous = 0, vis = 0)
        "méthode constructeur"
        self.etageres = etageres
        self.montants = montants
        self.trous = trous
        self.vis = vis

    def percer(self):
        "Usinage des éléments"

    def visser(self):
        "Montage des éléments"

# Création de l'objet meuble de bibliothèque:
meuble_bibliotheque = Meuble(étagères, montants, 26, 26)

# Application des méthodes
# percer et visser sur l'objet nouvellement créé:
meuble_bibliotheque.percer()
meuble_bibliotheque.visser()

Et le résultat, c’est que nous obtenons au bout du compte un meuble de bibliothèque certes virtuel mais tout à fait fonctionnel!

Créons une interface graphique avec la bibliothèque Tkinter

Tkinter est une bibliothèque graphique libre pour Python  permettant de créer des objets, en l’occurrence des interfaces graphiques, par instanciation de différentes classes. Tkinter signifie Tool kit interface.

Il faut tout d’abord télécharger Tkinter  en entrant la commande suivante dans un terminal:

sudo apt-get install python3-tk

Ouvrons l’éditeur de texte Gedit et écrivons les premières lignes de code :

#!/usr/bin/env python3
# -*- coding: utf8 -*-

from tkinter import*

Ligne n° 4 : Importation de la bibliothèque Tkinter

Complétons notre code :

#!/usr/bin/env python3
# -*- coding: utf8 -*-

from tkinter import*

main_window = Tk()
main_window.mainloop()

Ligne n° 6 : Création de l’objet main_window (= fenêtre principale) par instanciation de la classe Tk(). À ce stade, si on exécute le programme, nous n’obtenons rien du tout!

Ligne n° 7 : Il faut en effet appliquer la méthode mainloop() sur l’objet main_window pour déclencher le réceptionnaire d’événements et ainsi matérialiser la fenêtre. Voici le résultat obtenu:

fen_1

Rajoutons un widget de type bouton nous permettant de quitter l’application. Pour cela, nous allons créer un objet quitter, par instanciation de la classe Button(). Nous avons la possibilité de lui passer plusieurs paramètres nous permettant de choisir la taille et la couleur du bouton ainsi que la couleur du texte :

#!/usr/bin/env python3
# -*- coding: utf8 -*-

from tkinter import*

main_window = Tk()
quitter = Button(main_window, width = 20, height = 5,\\
          text = 'quitter', bg = 'green', fg = 'white',\\
          command = main_window.quit)
quitter.pack(padx=60, pady=40)
main_window.mainloop()

Lignes n° 7, 8 et 9 : Création de l’objet quitter par instanciation de la classe Button(). Nous lui passons plusieurs paramètres qui sont :

  • la fenêtre parente (ou le widget parent) : main_window,
  • la largeur : width = 20
  • la hauteur : height = 5
  • le texte : text = ‘quitter’
  • la couleur de fond : bg = ‘green’
  • la couleur du texte : fg = ‘white’
  • la commande qui se déclenche lorsque nous cliquons sur le bouton : command = main_window.quit. Il s’agit en l’occurrence de la méthode quit() que nous appliquons sur la fenêtre principale pour fermer cette dernière.

À ce stade, si nous exécutons le programme, le bouton n’apparaîtra pas et c’est tout à fait normal car il faut d’abord appliquer une méthode qui va placer le bouton dans le widget parent. C’est ce que nous faisons à la ligne n° 10.

Ligne n° 10 : Application de la méthode de placement pack() sur le widget quitter avec les paramètres padx et pady. padx réserve un espace à droite et à gauche du widget tandis que pady réserve un espace en haut et en bas.

Et le résultat, c’est un joli bouton tout vert qui ferme l’application lorsque nous cliquons dessus!

fen_2

 


Vus : 220
Publié par Miamondo : 41