Tecniche di Refactoring in Python: Una Guida Completa al Miglioramento della Qualità del Codice

Nel panorama in continua evoluzione dello sviluppo software, mantenere un codice pulito, efficiente e comprensibile è fondamentale. Python, noto per la sua leggibilità, può comunque cadere preda di "code smell" e debito tecnico se non gestito con attenzione. Il refactoring è il processo di ristrutturazione del codice informatico esistente — modificando il factoring — senza modificarne il comportamento esterno. In sostanza, si tratta di ripulire il codice senza romperlo. Questa guida esplora varie tecniche di refactoring in Python, fornendo esempi pratici e best practice per elevare la qualità del tuo codice.

Perché Refactoring del Codice Python?

Il refactoring offre numerosi vantaggi, tra cui:

• Migliore Leggibilità: Rende il codice più facile da capire e mantenere.
• Complessità Ridotta: Semplifica la logica complessa, riducendo la probabilità di errori.
• Maggiore Manutenibilità: Facilita la modifica e l'estensione del codice.
• Aumento delle Prestazioni: Può ottimizzare il codice per una migliore velocità di esecuzione.
• Debito Tecnico Inferiore: Previene l'accumulo di codice difficile da mantenere o estendere.
• Migliore Design: Porta a un'architettura del codice più robusta e flessibile.

Ignorare il refactoring può portare a codice difficile da capire, modificare e testare. Ciò può aumentare significativamente i tempi di sviluppo e il rischio di introdurre bug.

Quando Refactoring?

Sapere quando fare refactoring è cruciale. Ecco alcuni scenari comuni:

• Prima di Aggiungere Nuove Funzionalità: Il refactoring del codice esistente può semplificare l'integrazione di nuove funzionalità.
• Dopo Aver Corretto un Bug: Il refactoring del codice circostante può impedire la ricomparsa di bug simili.
• Durante le Revisioni del Codice: Identifica le aree che possono essere migliorate ed esegui il refactoring.
• Quando Incontri "Code Smells": I "code smell" sono indicatori di potenziali problemi nel tuo codice.
• Refactoring Programmato Regolarmente: Incorpora il refactoring nel tuo processo di sviluppo come attività regolare.

Identificare i Code Smells

I "code smell" sono indicazioni superficiali che di solito corrispondono a un problema più profondo nel sistema. Non indicano sempre un problema, ma spesso giustificano ulteriori indagini.

Code Smells Comuni in Python:

• Codice Duplicato: Codice identico o molto simile che appare in più posizioni.
• Metodo/Funzione Lunga: Metodi o funzioni eccessivamente lunghi e complessi.
• Classe Grande: Classi che hanno troppe responsabilità.
• Lista di Parametri Lunga: Metodi o funzioni con troppi parametri.
• Data Clumps: Gruppi di dati che appaiono frequentemente insieme.
• Primitive Obsession: Utilizzo di tipi di dati primitivi invece della creazione di oggetti.
• Switch Statements: Lunghe catene di istruzioni if/elif/else o switch statements.
• Shotgun Surgery: Apportare una singola modifica richiede apportare molte piccole modifiche a classi diverse.
• Divergent Change: Una classe viene comunemente modificata in modi diversi per motivi diversi.
• Feature Envy: Un metodo accede ai dati di un altro oggetto più dei propri dati.
• Message Chains: Un client chiede a un oggetto di richiedere a un altro oggetto di richiedere ancora un altro oggetto...

Tecniche di Refactoring in Python: Una Guida Pratica

Questa sezione descrive in dettaglio diverse tecniche di refactoring in Python comuni con esempi pratici.

1. Estrai Metodo/Funzione

Questa tecnica prevede di prendere un blocco di codice all'interno di un metodo o funzione e spostarlo in un nuovo metodo o funzione separato. Ciò riduce la complessità del metodo originale e rende riutilizzabile il codice estratto.

Esempio:

            
def print_invoice(customer, details):
    print("***********************")
    print(f"Customer: {customer}")
    print("***********************")

    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]

    print(f"Amount is : {total_amount}")

    if total_amount > 1000:
        print("You earned a discount!")

            

              
                Copy
              
            
          

Refactoring:

            
def print_header(customer):
    print("***********************")
    print(f"Customer: {customer}")
    print("***********************")



def calculate_total(details):
    total_amount = 0
    for order in details["orders"]:
        total_amount += order["amount"]
    return total_amount



def print_invoice(customer, details):
    print_header(customer)
    total_amount = calculate_total(details)
    print(f"Amount is : {total_amount}")

    if total_amount > 1000:
        print("You earned a discount!")

            

              
                Copy
              
            
          

2. Estrai Classe

Quando una classe ha troppe responsabilità, estraine alcune in una nuova classe. Ciò promuove il Single Responsibility Principle.

Esempio:

            
class Person:
    def __init__(self, name, phone_number, office_area_code, office_number):
        self.name = name
        self.phone_number = phone_number
        self.office_area_code = office_area_code
        self.office_number = office_number

    def get_name(self):
        return self.name

    def get_phone_number(self):
        return f"({self.office_area_code}) {self.office_number}"

            

              
                Copy
              
            
          

Refactoring:

            
class PhoneNumber:
    def __init__(self, area_code, number):
        self.area_code = area_code
        self.number = number

    def get_phone_number(self):
        return f"({self.area_code}) {self.number}"


class Person:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number

    def get_name(self):
        return self.name


            

              
                Copy
              
            
          

3. Inserisci Metodo/Funzione

È l'opposto di Estrai Metodo. Se il corpo di un metodo è chiaro quanto il suo nome, puoi inserire il metodo sostituendo le chiamate al metodo con il contenuto del metodo.

Esempio:

            
def get_rating(driver):
    return more_than_five_late_deliveries(driver) ? 2 : 1



def more_than_five_late_deliveries(driver):
    return driver.number_of_late_deliveries > 5

            

              
                Copy
              
            
          

Refactoring:

            
def get_rating(driver):
    return driver.number_of_late_deliveries > 5 ? 2 : 1

            

              
                Copy
              
            
          

4. Sostituisci Temp con Query

Invece di utilizzare una variabile temporanea per contenere il risultato di un'espressione, estrai l'espressione in un metodo. Ciò evita la duplicazione del codice e promuove una migliore leggibilità.

Esempio:

            
def get_price(order):
    base_price = order.quantity * order.item_price
    discount_factor = 0.98 if base_price > 1000 else 0.95
    return base_price * discount_factor

            

              
                Copy
              
            
          

Refactoring:

            
def get_price(order):
    return base_price(order) * discount_factor(order)



def base_price(order):
    return order.quantity * order.item_price



def discount_factor(order):
    return 0.98 if base_price(order) > 1000 else 0.95

            

              
                Copy
              
            
          

5. Introduci Oggetto Parametro

Se hai un lungo elenco di parametri che appaiono frequentemente insieme, valuta la possibilità di creare un oggetto parametro per incapsularli. Ciò riduce la lunghezza dell'elenco dei parametri e migliora l'organizzazione del codice.

Esempio:

            
def calculate_total(width, height, depth, weight, shipping_method):
    # Calculation logic
    pass

            

              
                Copy
              
            
          

Refactoring:

            
class ShippingDetails:
    def __init__(self, width, height, depth, weight, shipping_method):
        self.width = width
        self.height = height
        self.depth = depth
        self.weight = weight
        self.shipping_method = shipping_method



def calculate_total(shipping_details):
    # Calculation logic using shipping_details attributes
    pass

            

              
                Copy