Patron Factory

Fait partie de la section Object Oriented Programming du Journey Python de Coddy — leçon 46 sur 64.

Le Factory Pattern crée des objets sans spécifier leur classe exacte. Au lieu d'appeler directement des constructeurs, vous utilisez une méthode de fabrique qui décide 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 factory 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 Factory Pattern vous permet de créer des objets sans connaître leur classe exacte. La méthode de fabrique décide quelle classe instancier en fonction des paramètres. Utilisez *args pour gérer des produits ayant des paramètres de constructeur différents. 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 l'héritage et le polymorphisme.

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

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

Chaque fichier contient des commentaires TODO détaillés pour guider votre implémentation. Suivez attentivement ces commentaires pour vous assurer que votre code répond à toutes les exigences.

Aide-mémoire

Le Factory Pattern (ou Patron de Fabrique) 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écide quelle classe instancier.

Implémentation de base d'une fabrique :

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}")

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

Fabrique flexible utilisant *args pour différents paramètres de constructeur :

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}")

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

Avantages clés : Le Factory Pattern rend le code plus flexible et plus facile à étendre avec de nouveaux types de produits sans modifier le code client existant.

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")