Best practice in Python

Questo articolo spiega le best practice in Python.

Spiegheremo le best practice di Python con esempi di codice reali, introducendo modi per scrivere codice leggibile e manutenibile.

YouTube Video

Best practice in Python

Mettere la leggibilità come massima priorità

Per prima cosa, vediamo cosa significa ‘mettere la leggibilità come massima priorità’.

Python è un linguaggio che valorizza la 'leggibilità'. Per prima cosa, dai priorità a scrivere codice la cui intenzione sia chiara a colpo d’occhio.

1# Bad example: unclear variable names
2a = 10
3b = 5
4c = a * b

In questo codice, i nomi delle variabili non trasmettono il loro significato, quindi ci vuole tempo agli altri per capirlo in seguito.

1# Good example: descriptive variable names
2price = 10
3quantity = 5
4total_cost = price * quantity

Rendendo i nomi delle variabili specifici, il tuo codice stesso funge da documentazione.

Scrivi codice esplicito

Ora vediamo cosa significa ‘scrivere codice esplicito’.

In Python, 'l’intenzione esplicita' è preferita rispetto al 'comportamento implicito'.

1# Bad example: implicit truthy check
2if data:
3    process(data)

In questo codice, non è chiaro cosa ci si aspetta da data, creando terreno fertile per i bug.

1# Good example: explicit condition
2if len(data) > 0:
3    process(data)

Rendendo le condizioni esplicite, l’intenzione del codice corrisponde alla sua specifica.

Mantieni le funzioni piccole e concentrate su una sola responsabilità

Ora vediamo cosa significa ‘mantenere le funzioni piccole e concentrate su una sola responsabilità’.

Quando una funzione fa troppe cose, testarla e mantenerla diventa difficile.

1# Bad example: doing too many things
2def handle_user(user):
3    save_to_database(user)
4    send_email(user)
5    write_log(user)

In questo codice, i processi diventano troppo interconnessi, rendendo difficile il riutilizzo e la modifica.

1# Good example: single responsibility
2def save_user(user):
3    save_to_database(user)
4
5def notify_user(user):
6    send_email(user)
7
8def log_user(user):
9    write_log(user)

Dividendo le funzioni, i loro ruoli diventano chiari e i test diventano più semplici.

Utilizza attivamente gli indizi di tipo (type hints)

Ora vediamo cosa significa 'utilizzare attivamente gli indizi di tipo (type hints)'.

Gli indizi di tipo fungono da documentazione e sono un potente strumento per prevenire bug.

1# Bad example: Without type hints
2def add(a, b):
3    return a + b

In questo codice, i tipi degli argomenti e dei valori di ritorno non sono chiari, aumentando la probabilità di errori.

1# Good example: With type hints
2def add(a: int, b: int) -> int:
3    return a + b

Con gli indizi di tipo, l'autocompletamento dell'IDE, l'analisi statica e la leggibilità migliorano notevolmente.

Indica esplicitamente la possibilità di restituire None

Ora vediamo cosa significa 'indicare esplicitamente la possibilità di restituire None'.

Le funzioni che possono restituire None sono spesso trascurate da chi le utilizza.

1# Bad example: Ambiguous return value
2def find_user(user_id):
3    if user_id == 1:
4        return {"id": 1, "name": "Alice"}
5    return None

In questo codice, non è chiaro se ci sarà un valore di ritorno.

1# Good example: explicit return type
2from typing import Optional, Dict, Any
3
4def find_user(user_id: int) -> Optional[Dict[str, Any]]:
5    if user_id == 1:
6        return {"id": 1, "name": "Alice"}
7    return None

Utilizzando Optional, puoi comunicare la possibilità di restituire None come tipo.

Non catturare le eccezioni in modo troppo generico

Ora vediamo cosa significa 'non catturare le eccezioni in modo troppo generico'.

La gestione delle eccezioni dovrebbe fundamentalmente gestire solo ciò che è necessario.

1# Bad example: catching all exceptions
2try:
3    result = int(value)
4except Exception:
5    result = 0

Questo codice può nascondere bug che avrebbero dovuto essere notati.

1# Good example: catch specific exception
2try:
3    result = int(value)
4except ValueError:
5    result = 0

Restringendo le eccezioni, non trascurerai problemi inaspettati.

Gestisci le risorse in modo sicuro con l’istruzione with

Ora vediamo cosa significa ‘gestire le risorse in modo sicuro con l’istruzione with’.

Le risorse come file e blocchi devono sempre essere rilasciate in modo affidabile.

1# Bad example: manual close
2file = open("data.txt")
3content = file.read()
4file.close()

In questo codice, se si verifica un’eccezione, close() potrebbe non essere chiamato.

1# Good example: using context manager
2with open("data.txt") as file:
3    content = file.read()

Utilizzando un’istruzione with, la pulizia viene eseguita in sicurezza anche in caso di eccezioni.

Usa le list comprehension in modo appropriato

Ora vediamo cosa significa ‘usare le list comprehension in modo appropriato’.

Processi di trasformazione semplici possono essere scritti in modo conciso usando le list comprehension.

1# Bad example: Verbose loop
2squares = []
3for i in range(10):
4    squares.append(i * i)

In questo codice, il processo principale è difficile da individuare.

1# Good example: Clear list comprehension
2squares = [i * i for i in range(10)]

Usando le list comprehension in modo appropriato, la leggibilità del codice migliora.

Evita i numeri magici

Ora vediamo cosa significa ‘evitare i numeri magici’.

Scrivere numeri e stringhe direttamente rende il loro significato poco chiaro.

1# Bad example: magic number
2if status == 404:
3    handle_not_found()

In questo codice, si presume che tu conosca il significato di 404.

1# Good example: named constant
2NOT_FOUND = 404
3
4if status == NOT_FOUND:
5    handle_not_found()

Dare nomi rende chiare le intenzioni.

Scrivi codice che sia manutenibile, non solo codice che 'funziona'

Infine, vediamo cosa significa ‘scrivere codice che sia manutenibile, non solo codice che funziona’.

Il punto importante è se tu in futuro o altre persone potranno capirlo.

1# Bad example: Hard to maintain
2def f(x):
3    return x * 1.08 + 100

In questo codice, la specifica non può essere compresa dal codice stesso.

1# Good example: Easy to maintain
2TAX_RATE = 1.08
3BASE_FEE = 100
4
5def calculate_total(price: float) -> float:
6    return price * TAX_RATE + BASE_FEE

Riflettendo il significato nei nomi, il codice stesso diventa la specifica.

Riepilogo

Le best practice di Python si riducono a scrivere codice facile da capire, piuttosto che codice ingegnoso. Costruire piccole abitudini porta a scrivere codice con meno bug che può essere usato a lungo.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video