21 settembre 2025Italiano

Esplora i design pattern creazionali di Python: Singleton, Factory, Abstract Factory, Builder e Prototype. Scopri implementazioni, vantaggi e applicazioni reali.

Python Design Patterns: Un'immersione Profonda nei Pattern Creazionali

I design pattern sono soluzioni riutilizzabili a problemi comuni nella progettazione del software. Forniscono un modello per risolvere questi problemi, promuovendo la riusabilità, la manutenibilità e la flessibilità del codice. I design pattern creazionali, in particolare, si occupano dei meccanismi di creazione degli oggetti, cercando di creare oggetti in un modo adatto alla situazione. Questo articolo fornisce un'esplorazione completa dei design pattern creazionali in Python, incluse spiegazioni dettagliate, esempi di codice e applicazioni pratiche rilevanti per un pubblico globale.

Cosa sono i Design Pattern Creazionali?

I design pattern creazionali astraggono il processo di creazione delle istanze. Disaccoppiano il codice client dalle classi specifiche di cui viene creata l'istanza, consentendo una maggiore flessibilità e controllo sulla creazione degli oggetti. Utilizzando questi pattern, puoi creare oggetti senza specificare la classe esatta dell'oggetto che verrà creato. Questa separazione degli interessi rende il codice più robusto e più facile da mantenere.

L'obiettivo principale dei pattern creazionali è astrarre il processo di creazione delle istanze degli oggetti, nascondendo le complessità della creazione degli oggetti dal client. Ciò consente agli sviluppatori di concentrarsi sulla logica di alto livello delle loro applicazioni senza essere impantanati nei dettagli essenziali della creazione degli oggetti.

Tipi di Design Pattern Creazionali

In questo articolo tratteremo i seguenti design pattern creazionali:

Singleton: Garantisce che una classe abbia una sola istanza e fornisce un punto di accesso globale ad essa.
Factory Method: Definisce un'interfaccia per la creazione di un oggetto, ma lascia che siano le sottoclassi a decidere quale classe creare un'istanza.
Abstract Factory: Fornisce un'interfaccia per la creazione di famiglie di oggetti correlati o dipendenti senza specificare le loro classi concrete.
Builder: Separa la costruzione di un oggetto complesso dalla sua rappresentazione, consentendo allo stesso processo di costruzione di creare rappresentazioni diverse.
Prototype: Specifica il tipo di oggetti da creare utilizzando un'istanza prototipica e crea nuovi oggetti copiando questo prototipo.

1. Pattern Singleton

Il pattern Singleton garantisce che una classe abbia una sola istanza e fornisce un punto di accesso globale ad essa. Questo pattern è utile quando è necessario esattamente un oggetto per coordinare le azioni in tutto il sistema. Viene spesso utilizzato per la gestione delle risorse, la registrazione o le impostazioni di configurazione.

Implementazione

Ecco un'implementazione Python del pattern Singleton:

            
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

# Esempio di utilizzo
s1 = Singleton()
s2 = Singleton()

print(s1 is s2) # Output: True

Spiegazione:

_instance: Questa variabile di classe memorizza l'unica istanza della classe.
__new__: Questo metodo viene chiamato prima di __init__ quando viene creato un oggetto. Controlla se esiste già un'istanza. In caso contrario, crea una nuova istanza usando super().__new__(cls) e la memorizza in _instance. Se esiste già un'istanza, restituisce l'istanza esistente.

Casi d'uso

Connessione al database: Garantire che sia aperta una sola connessione a un database alla volta.
Gestore di configurazione: Fornire un unico punto di accesso alle impostazioni di configurazione dell'applicazione.
Logger: Creazione di una singola istanza di logging per gestire tutte le operazioni di logging nell'applicazione.

Esempio

Consideriamo un semplice esempio di un gestore di configurazione implementato usando il pattern Singleton:

            
class ConfigurationManager(Singleton):
    def __init__(self):
        if not hasattr(self, 'config'): # Assicurati che __init__ venga chiamato una sola volta
            self.config = {}

    def set_config(self, key, value):
        self.config[key] = value

    def get_config(self, key):
        return self.config.get(key)

# Esempio di utilizzo
config_manager1 = ConfigurationManager()
config_manager1.set_config('database_url', 'localhost:5432')

config_manager2 = ConfigurationManager()
print(config_manager2.get_config('database_url')) # Output: localhost:5432

2. Pattern Factory Method

Il pattern Factory Method definisce un'interfaccia per la creazione di un oggetto, ma lascia che siano le sottoclassi a decidere quale classe creare un'istanza. Factory Method consente a una classe di rimandare la creazione di istanze alle sottoclassi. Questo pattern promuove un basso accoppiamento e ti consente di aggiungere nuovi tipi di prodotto senza modificare il codice esistente.

Implementazione

Ecco un'implementazione Python del pattern Factory Method:

            
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

# Codice client
def get_animal(factory: AnimalFactory):
    animal = factory.create_animal()
    return animal.speak()


dog_sound = get_animal(DogFactory())
cat_sound = get_animal(CatFactory())

print(f"Dog says: {dog_sound}") # Output: Dog says: Woof!
print(f"Cat says: {cat_sound}") # Output: Cat says: Meow!

Spiegazione:

Animal: Una classe base astratta che definisce l'interfaccia per tutti i tipi di animali.
Dog e Cat: Classi concrete che implementano l'interfaccia Animal.
AnimalFactory: Una classe base astratta che definisce l'interfaccia per la creazione di animali.
DogFactory e CatFactory: Classi concrete che implementano l'interfaccia AnimalFactory, responsabili della creazione di istanze Dog e Cat, rispettivamente.
get_animal: Una funzione client che utilizza la factory per creare e utilizzare un animale.

Casi d'uso

Framework UI: Creazione di elementi UI specifici della piattaforma (ad es. pulsanti, campi di testo) utilizzando factory diverse per sistemi operativi diversi.
Sviluppo di giochi: Creazione di diversi tipi di personaggi o oggetti di gioco in base al livello di gioco o alla selezione dell'utente.
Elaborazione di documenti: Creazione di diversi tipi di documenti (ad es. PDF, Word, HTML) utilizzando factory diverse in base al formato di output desiderato.

Esempio

Considera uno scenario in cui desideri creare diversi tipi di metodi di pagamento in base alla selezione dell'utente. Ecco come puoi implementare questo utilizzando il pattern Factory Method:

            
from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(Payment):
    def process_payment(self, amount):
        return f"Processing credit card payment of ${amount}"

class PayPalPayment(Payment):
    def process_payment(self, amount):
        return f"Processing PayPal payment of ${amount}"

class PaymentFactory(ABC):
    @abstractmethod
    def create_payment_method(self):
        pass

class CreditCardPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return CreditCardPayment()

class PayPalPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return PayPalPayment()

# Codice client
def process_payment(factory: PaymentFactory, amount):
    payment_method = factory.create_payment_method()
    return payment_method.process_payment(amount)


credit_card_payment = process_payment(CreditCardPaymentFactory(), 100)
paypal_payment = process_payment(PayPalPaymentFactory(), 50)

print(credit_card_payment) # Output: Processing credit card payment of $100
print(paypal_payment) # Output: Processing PayPal payment of $50

3. Pattern Abstract Factory

Il pattern Abstract Factory fornisce un'interfaccia per la creazione di famiglie di oggetti correlati o dipendenti senza specificare le loro classi concrete. Ti consente di creare oggetti progettati per funzionare insieme, garantendo coerenza e compatibilità.

Implementazione

Ecco un'implementazione Python del pattern Abstract Factory:

            
from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def paint(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_checkbox(self):
        pass

class WinFactory(GUIFactory):
    def create_button(self):
        return WinButton()

    def create_checkbox(self):
        return WinCheckbox()

class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()

    def create_checkbox(self):
        return MacCheckbox()

class WinButton(Button):
    def paint(self):
        return "Rendering a Windows button"

class MacButton(Button):
    def paint(self):
        return "Rendering a Mac button"

class WinCheckbox(Checkbox):
    def paint(self):
        return "Rendering a Windows checkbox"

class MacCheckbox(Checkbox):
    def paint(self):
        return "Rendering a Mac checkbox"

# Codice client
def paint_ui(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    return button.paint(), checkbox.paint()

win_button, win_checkbox = paint_ui(WinFactory())
mac_button, mac_checkbox = paint_ui(MacFactory())

print(win_button) # Output: Rendering a Windows button
print(win_checkbox) # Output: Rendering a Windows checkbox
print(mac_button) # Output: Rendering a Mac button
print(mac_checkbox) # Output: Rendering a Mac checkbox

Spiegazione:

Button e Checkbox: Classi base astratte che definiscono le interfacce per gli elementi UI.
WinButton, MacButton, WinCheckbox e MacCheckbox: Classi concrete che implementano le interfacce degli elementi UI per le piattaforme Windows e Mac.
GUIFactory: Una classe base astratta che definisce l'interfaccia per la creazione di famiglie di elementi UI.
WinFactory e MacFactory: Classi concrete che implementano l'interfaccia GUIFactory, responsabili della creazione di elementi UI per le piattaforme Windows e Mac, rispettivamente.
paint_ui: Una funzione client che utilizza la factory per creare e dipingere elementi UI.

Casi d'uso

Framework UI: Creazione di elementi UI coerenti con l'aspetto di un sistema operativo o piattaforma specifico.
Sviluppo di giochi: Creazione di oggetti di gioco coerenti con lo stile di un livello o tema di gioco specifico.
Accesso ai dati: Creazione di oggetti di accesso ai dati compatibili con un database o un'origine dati specifica.

Esempio

Considera uno scenario in cui desideri creare diversi tipi di mobili (ad es. sedie, tavoli) con stili diversi (ad es. moderno, vittoriano). Ecco come puoi implementare questo utilizzando il pattern Abstract Factory:

            
from abc import ABC, abstractmethod

class Chair(ABC):
    @abstractmethod
    def create(self):
        pass

class Table(ABC):
    @abstractmethod
    def create(self):
        pass

class FurnitureFactory(ABC):
    @abstractmethod
    def create_chair(self):
        pass

    @abstractmethod
    def create_table(self):
        pass

class ModernFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return ModernChair()

    def create_table(self):
        return ModernTable()

class VictorianFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return VictorianChair()

    def create_table(self):
        return VictorianTable()

class ModernChair(Chair):
    def create(self):
        return "Creating a modern chair"

class VictorianChair(Chair):
    def create(self):
        return "Creating a Victorian chair"

class ModernTable(Table):
    def create(self):
        return "Creating a modern table"

class VictorianTable(Table):
    def create(self):
        return "Creating a Victorian table"

# Codice client
def create_furniture(factory: FurnitureFactory):
    chair = factory.create_chair()
    table = factory.create_table()
    return chair.create(), table.create()


modern_chair, modern_table = create_furniture(ModernFurnitureFactory())
victorian_chair, victorian_table = create_furniture(VictorianFurnitureFactory())

print(modern_chair) # Output: Creating a modern chair
print(modern_table) # Output: Creating a modern table
print(victorian_chair) # Output: Creating a Victorian chair
print(victorian_table) # Output: Creating a Victorian table

4. Pattern Builder

Il pattern Builder separa la costruzione di un oggetto complesso dalla sua rappresentazione, consentendo allo stesso processo di costruzione di creare rappresentazioni diverse. È utile quando è necessario creare oggetti complessi con più componenti opzionali e si desidera evitare la creazione di un numero elevato di costruttori o parametri di configurazione.

Implementazione

Ecco un'implementazione Python del pattern Builder:

            
class Pizza:
    def __init__(self):
        self.dough = None
        self.sauce = None
        self.topping = None

    def __str__(self):
        return f"Pizza with dough: {self.dough}, sauce: {self.sauce}, and topping: {self.topping}"

class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()

    def set_dough(self, dough):
        self.pizza.dough = dough
        return self

    def set_sauce(self, sauce):
        self.pizza.sauce = sauce
        return self

    def set_topping(self, topping):
        self.pizza.topping = topping
        return self

    def build(self):
        return self.pizza

# Codice client
pizza_builder = PizzaBuilder()
pizza = pizza_builder.set_dough("Thin crust").set_sauce("Tomato").set_topping("Pepperoni").build()

print(pizza) # Output: Pizza with dough: Thin crust, sauce: Tomato, and topping: Pepperoni

Spiegazione:

Pizza: Una classe che rappresenta l'oggetto complesso da costruire.
PizzaBuilder: Una classe builder che fornisce metodi per impostare i diversi componenti dell'oggetto Pizza.

Casi d'uso

Generazione di documenti: Creazione di documenti complessi (ad es. report, fatture) con diverse sezioni e opzioni di formattazione.
Sviluppo di giochi: Creazione di oggetti di gioco complessi (ad es. personaggi, livelli) con diversi attributi e componenti.
Elaborazione dei dati: Creazione di strutture dati complesse (ad es. grafici, alberi) con diversi nodi e relazioni.

Esempio

Considera uno scenario in cui desideri costruire diversi tipi di computer con diversi componenti (ad es. CPU, RAM, memoria). Ecco come puoi implementare questo utilizzando il pattern Builder:

            
class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None
        self.graphics_card = None

    def __str__(self):
        return f"Computer with CPU: {self.cpu}, RAM: {self.ram}, Storage: {self.storage}, Graphics Card: {self.graphics_card}"

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu
        return self

    def set_ram(self, ram):
        self.computer.ram = ram
        return self

    def set_storage(self, storage):
        self.computer.storage = storage
        return self

    def set_graphics_card(self, graphics_card):
        self.computer.graphics_card = graphics_card
        return self

    def build(self):
        return self.computer

# Codice client
computer_builder = ComputerBuilder()
computer = computer_builder.set_cpu("Intel i7").set_ram("16GB").set_storage("1TB SSD").set_graphics_card("Nvidia RTX 3080").build()

print(computer)
# Output: Computer with CPU: Intel i7, RAM: 16GB, Storage: 1TB SSD, Graphics Card: Nvidia RTX 3080

5. Pattern Prototype

Il pattern Prototype specifica il tipo di oggetti da creare utilizzando un'istanza prototipica e crea nuovi oggetti copiando questo prototipo. Ti consente di creare nuovi oggetti clonando un oggetto esistente, evitando la necessità di creare oggetti da zero. Questo può essere utile quando la creazione di oggetti è costosa o complessa.

Implementazione

Ecco un'implementazione Python del pattern Prototype:

            
import copy

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj

class Car:
    def __init__(self):
        self.name = ""
        self.color = ""
        self.options = []

    def __str__(self):
        return f"Car: Name={self.name}, Color={self.color}, Options={self.options}"

# Codice client
prototype = Prototype()
car = Car()
car.name = "Generic Car"
car.color = "White"
car.options = ["AC", "GPS"]

prototype.register_object("generic", car)

car1 = prototype.clone("generic", name="Sports Car", color="Red", options=["AC", "GPS", "Spoiler"])
car2 = prototype.clone("generic", name="Family Car", color="Blue", options=["AC", "GPS", "Sunroof"])

print(car1)
# Output: Car: Name=Sports Car, Color=Red, Options=['AC', 'GPS', 'Spoiler']
print(car2)
# Output: Car: Name=Family Car, Color=Blue, Options=['AC', 'GPS', 'Sunroof']

Spiegazione:

Prototype: Una classe che gestisce i prototipi e fornisce un metodo per clonarli.
Car: Una classe che rappresenta l'oggetto da clonare.

Casi d'uso

Sviluppo di giochi: Creazione di oggetti di gioco simili tra loro, come nemici o potenziamenti.
Elaborazione di documenti: Creazione di documenti basati su un modello.
Gestione della configurazione: Creazione di oggetti di configurazione basati su una configurazione predefinita.

Esempio

Considera uno scenario in cui desideri creare diversi tipi di dipendenti con diversi attributi (ad es. nome, ruolo, reparto). Ecco come puoi implementare questo utilizzando il pattern Prototype:

            
import copy

class Employee:
    def __init__(self):
        self.name = None
        self.role = None
        self.department = None

    def __str__(self):
        return f"Employee: Name={self.name}, Role={self.role}, Department={self.department}"

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj


# Codice client
prototype = Prototype()
employee = Employee()
employee.name = "Generic Employee"
employee.role = "Developer"
employee.department = "IT"

prototype.register_object("generic", employee)

employee1 = prototype.clone("generic", name="John Doe", role="Senior Developer")
employee2 = prototype.clone("generic", name="Jane Smith", role="Project Manager", department="Management")

print(employee1)
# Output: Employee: Name=John Doe, Role=Senior Developer, Department=IT
print(employee2)
# Output: Employee: Name=Jane Smith, Role=Project Manager, Department=Management

Conclusione

I design pattern creazionali forniscono strumenti potenti per la gestione della creazione di oggetti in modo flessibile e manutenibile. Comprendendo e applicando questi pattern, puoi scrivere codice più pulito e robusto, più facile da estendere e adattare alle mutevoli esigenze. Questo articolo ha esplorato cinque pattern creazionali chiave: Singleton, Factory Method, Abstract Factory, Builder e Prototype, con esempi pratici e casi d'uso reali. Padroneggiare questi pattern è un passo essenziale per diventare uno sviluppatore Python competente.

Ricorda che la scelta del pattern giusto dipende dal problema specifico che stai cercando di risolvere. Considera la complessità della creazione degli oggetti, la necessità di flessibilità e il potenziale per modifiche future quando selezioni un pattern creazionale per il tuo progetto. In questo modo, puoi sfruttare la potenza dei design pattern per creare soluzioni eleganti ed efficienti alle comuni sfide di progettazione del software.