Les classes et objets en Python

En Python, une classe constitue un modèle pour créer des objets, encapsulant des données sous forme d'attributs et des comportements via des méthodes. La programmation orientée objet repose sur trois principes clés : l'encapsulation, l'héritage et le polymorphisme, améliorant la fiabilité, la réutilisabilité et la maintenance du code.

Concept d'objet

Un objet est une instance concrète d'une classe, représentant une entité abstraite avec des propriétés (attributs) et des opérations (méthodes). L'encapsulation protège l'état interne de l'objet, tandis que l'héritage permet d'étendre des fonctionnalités existantes sans duplication de code. Le polymorphisme offre la capacité à un objet de répondre différemment à des messagse communs, facilitant la conception de logiciels flexibles.

Classes et instances

Une classe définit une structure de données, tandis qu'une insatnce est une réalisation spécifique de cette classe. En Python, la classe est appelée objet de classe, et ses instances sont des objets d'instance.

# Exemple de définition de classe
class Individu:
    pass

# Création d'une instance
personne = Individu()
print(personne)

Attributs

Les attributs stockent les données d'une classe. On distingue les attributs d'instance, liés à un objet spécifique via self, et les attributs de classe, partagés par toutes les instances.

class Employe:
    compteur = 0  # Attribut de classe

    def __init__(self, nom, age):
        self.nom = nom  # Attribut d'instance
        self.age = age
        Employe.compteur += 1

employe1 = Employe("Alice", 30)
print(employe1.nom, Employe.compteur)

Les attributs privés, préfixés par deux underscores, ne sont pas accessibles directement depuis l'extérieur. Le décorateur @property permet d'exposer des attributs privés de manière contrôlée.

class Personne:
    def __init__(self, nom):
        self.__nom = nom

    @property
    def nom(self):
        return self.__nom

individu = Personne("Bob")
print(individu.nom)

Méthodes

Les méthodes sont des fonctions définies dans une classe. Les méthodes d'instance utilisent self comme premier paramètre pour accéder à l'objet courant. Les méthodes statiques et de classe offrent des fonctionnalités supplémentaires, comme l'accès sans instance.

class Calculatrice:
    @staticmethod
    def additionner(a, b):
        return a + b

resultat = Calculatrice.additionner(5, 3)
print(resultat)

Constructeurs et destructeurs

La méthode __init__ initialise une instance, tandis que __del__ libère les ressources lors de la destruction de l'objet.

class Fichier:
    def __init__(self, chemin):
        self.chemin = chemin
        print("Fichier ouvert")

    def __del__(self):
        print("Fichier fermé")

fichier = Fichier("/tmp/test.txt")
del fichier

Héritage et polymorphisme

L'héritage permet à une classe dérivée d'hériter des attributs et méthodes d'une classe de base. Le polymorphisme se manifeste par la redéfinition de méthodes dans les sous-classes.

class Forme:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def calculer_aire(self):
        pass

class Cercle(Forme):
    def __init__(self, rayon):
        super().__init__(rayon, 0)

    def calculer_aire(self):
        import math
        return math.pi * self.x ** 2

class Rectangle(Forme):
    def __init__(self, largeur, hauteur):
        super().__init__(largeur, hauteur)

    def calculer_aire(self):
        return self.x * self.y

cercle = Cercle(5)
print(cercle.calculer_aire())

Exercices pratiques

Calcul des propriétés géométriques

Implémentez une hiérarchie de classes pour calculer le périmètre et l'aire d'un cercle, ainsi que la surface et le volume d'une sphère.

import math

class FigureGeometrique:
    def __init__(self, rayon):
        self.rayon = rayon

    def perimetre(self):
        pass

    def surface(self):
        pass

class Cercle(FigureGeometrique):
    def __init__(self, rayon):
        super().__init__(rayon)

    def perimetre(self):
        return 2 * math.pi * self.rayon

    def surface(self):
        return math.pi * self.rayon ** 2

class Sphere(FigureGeometrique):
    def __init__(self, rayon):
        super().__init__(rayon)

    def surface(self):
        return 4 * math.pi * self.rayon ** 2

    def volume(self):
        return (4/3) * math.pi * self.rayon ** 3

rayon = float(input("Entrez le rayon : "))
cercle = Cercle(rayon)
print(f"Périmètre du cercle : {cercle.perimetre():.2f}")
print(f"Aire du cercle : {cercle.surface():.2f}")
sphere = Sphere(rayon)
print(f"Surface de la sphère : {sphere.surface():.2f}")
print(f"Volume de la sphère : {sphere.volume():.2f}")

Conversion de températures

Créez une classe pour convertir entre Celsius et Fahrenheit.

class ConvertisseurTemperature:
    def __init__(self, valeur):
        self.valeur = valeur

    def celsius_vers_fahrenheit(self):
        return self.valeur * 9/5 + 32

    def fahrenheit_vers_celsius(self):
        return (self.valeur - 32) * 5/9

celsius = float(input("Température en Celsius : "))
conv1 = ConvertisseurTemperature(celsius)
print(f"Fahrenheit : {conv1.celsius_vers_fahrenheit():.1f}")

fahrenheit = float(input("Température en Fahrenheit : "))
conv2 = ConvertisseurTemperature(fahrenheit)
print(f"Celsius : {conv2.fahrenheit_vers_celsius():.1f}")