Patron Factory

Fait partie de la section Programmation orientée objet du Journey Python de Coddy. Leçon 46 sur 64.

Le patron Factory crée des objets sans spécifier leur classe exacte. Au lieu d’appeler directement les constructeurs, vous utilisez une méthode de fabrique qui détermine quelle classe instancier.

Voici des classes de produits simples :

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.type = "Car"
    
    def info(self):
        return f"{self.type}: {self.brand}"

class Bike:
    def __init__(self, brand):
        self.brand = brand
        self.type = "Bike"
    
    def info(self):
        return f"{self.type}: {self.brand}"

Créez une classe fabrique pour produire ces objets :

class VehicleFactory:
    def create_vehicle(self, vehicle_type, brand):
        if vehicle_type == "car":
            return Car(brand)
        elif vehicle_type == "bike":
            return Bike(brand)
        else:
            raise ValueError(f"Unknown type: {vehicle_type}")

Utilisez la fabrique au lieu d'appeler directement les constructeurs :

factory = VehicleFactory()
my_car = factory.create_vehicle("car", "Toyota")
my_bike = factory.create_vehicle("bike", "Honda")

print(my_car.info())   # Voiture : Toyota
print(my_bike.info())  # Moto : Honda

Rendez la fabrique plus flexible en utilisant *args :

class FlexibleFactory:
    def create_vehicle(self, vehicle_type, *args):
        if vehicle_type == "car":
            return Car(args[0])  # Juste la marque
        elif vehicle_type == "truck":
            return Truck(args[0], args[1])  # Marque et capacité
        else:
            raise ValueError(f"Unknown type: {vehicle_type}")

class Truck:
    def __init__(self, brand, capacity):
        self.brand = brand
        self.capacity = capacity
        self.type = "Truck"
    
    def info(self):
        return f"{self.type}: {self.brand} ({self.capacity}t)"

Utilisez la fabrique flexible :

flexible = FlexibleFactory()
car = flexible.create_vehicle("car", "Ford")
truck = flexible.create_vehicle("truck", "Volvo", "20")

print(car.info())    # Voiture : Ford
print(truck.info())  # Camion : Volvo (20t)

Sortie :

Car: Toyota
Bike: Honda
Car: Ford
Truck: Volvo (20t)

Point clé : le modèle Factory vous permet de créer des objets sans connaître leur classe exacte. La méthode Factory décide quelle classe instancier en fonction des paramètres. Utilisez *args pour gérer des produits avec différents paramètres de constructeur. Cela rend votre code plus flexible et plus facile à étendre avec de nouveaux types de produits.

Défi

Moyen

Dans ce défi, vous allez implémenter un système de fabrique de formes en utilisant une conception orientée objet appropriée avec héritage et polymorphisme.

Complétez l’implémentation dans les fichiers suivants :

shape.py - Classe Shape de base
circle.py - Implémentation de Circle
rectangle.py - Implémentation de Rectangle
triangle.py - Implémentation de Triangle
shapefactory.py - Classe de fabrique pour créer des formes

Chaque fichier contient des commentaires TODO détaillés pour vous guider dans votre implémentation. Suivez attentivement ces commentaires afin de vous assurer que votre code respecte toutes les exigences.

Essayez vous-même

from shapefactory import ShapeFactory
from shape import Shape
from circle import Circle
from rectangle import Rectangle
from triangle import Triangle
import sys

# Exécuteur de cas de test
test_case = input()

factory = ShapeFactory()

if test_case == "circle_area":
    circle = factory.create_shape("circle", 5)
    print(f"{circle.area():.2f}")

elif test_case == "rectangle_perimeter":
    rectangle = factory.create_shape("rectangle", 4, 6)
    print(f"{rectangle.perimeter()}")

elif test_case == "triangle_perimeter":
    triangle = factory.create_shape("triangle", 3, 4, 5)
    print(f"{triangle.perimeter()}")

elif test_case == "invalid_shape":
    try:
        factory.create_shape("hexagon", 6)
        print("No exception raised")
    except ValueError as e:
        print(str(e))

elif test_case == "case_insensitive":
    circle = factory.create_shape("CiRcLe", 3)
    print(f"{circle.area():.2f}")

elif test_case == "shape_inheritance":
    shapes = [
        factory.create_shape("circle", 2),
        factory.create_shape("rectangle", 2, 3),
        factory.create_shape("triangle", 3, 4, 5)
    ]
    all_shapes = all(isinstance(shape, Shape) for shape in shapes)
    print(all_shapes)

elif test_case == "zero_radius_circle":
    circle = factory.create_shape("circle", 0)
    print(f"{circle.area():.2f} {circle.perimeter():.2f}")

elif test_case == "negative_dimensions":
    rectangle = factory.create_shape("rectangle", -2, -3)
    print(f"{rectangle.area()}")

elif test_case == "large_values":
    circle = factory.create_shape("circle", 1000000)
    print(f"{circle.area():.2e}")

elif test_case == "polymorphism_test":
    shapes = [
        factory.create_shape("circle", 2),
        factory.create_shape("rectangle", 3, 4),
        factory.create_shape("triangle", 3, 4, 5)
    ]
    area_sum = sum(shape.area() for shape in shapes)
    perimeter_sum = sum(shape.perimeter() for shape in shapes)
    print(f"Area sum: {area_sum:.2f}, Perimeter sum: {perimeter_sum:.2f}")

elif test_case == "triangle_area":
    triangle = factory.create_shape("triangle", 3, 4, 5)
    print(f"{triangle.area():.2f}")

elif test_case == "method_override":
    circle = factory.create_shape("circle", 2)
    rectangle = factory.create_shape("rectangle", 3, 4)
    triangle = factory.create_shape("triangle", 3, 4, 5)
    
    # Récupérer les objets de méthode pour comparer les implémentations
    circle_area = Circle.area
    rectangle_area = Rectangle.area
    triangle_area = Triangle.area
    
    circle_perimeter = Circle.perimeter
    rectangle_perimeter = Rectangle.perimeter
    triangle_perimeter = Triangle.perimeter
    
    # Vérifier si toutes les implémentations sont uniques
    unique_areas = len({circle_area, rectangle_area, triangle_area}) == 3
    unique_perimeters = len({circle_perimeter, rectangle_perimeter, triangle_perimeter}) == 3
    
    if unique_areas and unique_perimeters:
        print("All shapes correctly override methods")
    else:
        print("Some shapes share method implementations")