10 must-know patterns per scrivere codice pulito con Python.
Python è un linguaggio di programmazione elegante e con un’alta leggibilità, ma la sola sintassi non basta per scrivere codice pulito.
Molti sviluppatori hanno ancora bisogno di imparare le best practices e i design patterns per scrivere codice pulito con Python.
Che cos’è il codice pulito?
Questa è una citazione di Bjarne Stroustrup il creatore del linguaggio di programmazione C++. Illustra in modo semplice che cos’è il codice pulito.
Mi piace il codice elegante ed efficiente. La logica dovrebbe essere tanto semplice da rendere difficile ai bug di rimanere nascosti, le dipendenze dovrebbero essere minime per facilitare la manutenzione, la gestione degli errori completa con una strategia articolata, e le prestazioni vicine a quelle ottimali per non indurre gli sviluppatori a rendere il codice disordinato con ottimizzazioni senza principi.
Il codice pulito fa una cosa e la fa bene.
Da questa citazione derivano alcuni principi:
- Il codice pulito è specializzato.
Ogni funzione, classe, o modulo dovrebbe fare una cosa e farla bene. - Il codice è semplice da leggere e ha intenzioni chiare.
Secondo Grady Booch autore del libro Object Oriented Analysis and Design il codice pulito si legge come prosa ben scritta. - Con codice pulito è facile fare debug.
- Il codice pulito è facile da manutenere.
Può essere facilmente letto e migliorato da altri sviluppatori. - Il codice pulito è performante.
- Il codice pulito è specializzato.
Se è vero che uno sviluppatore è libero di scrivere il proprio codice come preferisce, perché non esiste una regola fissa, o vincolante che lo costringa a scrivere codice pulito, è pur vero, che un codice scritto male, può causare dei debiti tecnici che possono avere severe conseguenze.
Allora, per questo, è meglio scrivere codice pulito.
Design Patterns per scrivere codice pulito in Python
Convenzione sui nomi
La convenzione sui nomi è una degli aspetti più utili e importanti per scrivere codice pulito. Quando dai dei nomi alle variabili, alle funzioni, alle classi, etc. usa nomi significativi che mostrano l’intenzione. Devi preferire dei nomi descrittivi e specifici, anche se lunghi, a nomi brevi, ma ambigui.
Ecco degli esempi.
- Usa un nome lungo descrittivo e facile da leggere.
Eviterai di scrivere inutili commenti.
# Not Recommended # The au variables is the number of active users au = 105 # Recommended total_actrive_users = 105
2. Usa nomi descrittivi che mostrano l’intenzione.
Gli altri sviluppatori dovrebbero essere capaci di comprendere cosa contengono le variabili dal nome. In pratica il tuo codice dovrebbe essere semplice da leggere, ma anche da comprendere (parlante, codice ben scritto non ha bisogno di commenti).
# Not Recommended
c = ['UK', 'USA', 'UAE']
for x in c:
print(c)
# Recommended
countries = ['UK', 'USA', 'UAE']
for country in countries:
print(country)
3. Evita di usare abbreviazioni, possono essere ambigue.
Una variabile dovrebbe avere un nome descrittivo lungo piuttosto che un nome corto. Può generare confusione.
# Not Recommended fn = 'Francesco' ln = 'Dattolo' cre_tmstp = 1649688474 # Recommended first_name = 'Francesco' last_name = 'Dattolo' creation_timestamp = 1649688474
4. Usa sempre le stesse parole per gli stessi concetti.
Occorre essere coerenti con le convenzioni dei nomi. Mantenere la coerenza nella convenzione dei nomi è importante per non creare confusione agli altri sviluppatori che lavoreranno al codice scritto da te. E questo vale per la denominazione di variabili, file, funzioni e persino strutture di directory.
# Not Recommended
client_first_name = 'Francesco'
customer_last_name = 'Dattolo'
# Recommended
client_first_name = 'Francesco'
client_last_name = 'Dattolo'
# Not Recommended
def fetch_clients(res, var):
# Do something
pass
def fetch_posts(res, var):
# Do something
pass
# Recommended
def fetch_clients(response, variable):
# Do something
pass
def fetch_posts(response, variable):
# Do something
pass
5. Tieni traccia dei problemi del tuo codice sorgente nell’editor.
Un punto importante per mantenere pulito il codice sorgente di Python è rendere facile agli ingegneri di monitorare i problemi. Il monitoraggio dei problemi del codice sorgente nell’editor consente agli ingegneri di:
- Conoscere i debiti tecnici;
- Mostrare il contesto di ogni problema;
- Ridurre il cambio di contesto;
- Risolvere il problema quando si presenta.
6. Non usare i magic numbers.
I numeri magici (magic number) sono numeri con una semantica speciale e codificata che appaiono nel codice ma non hanno alcun significato o spiegazione se presi da soli. Di solito, questi numeri appaiono come letterali in più di una posizione del codice.
import random
# Not Recommended
def roll_dice()
return random.randint(1, 6) # cosa rapprensentano 1 e 6?
# Recommended
DICE_MINIMUM_SCORE = 1
DICE_MAX_SCORE = 6
def roll_dice()
return random.randint(DICE_MINIMUM_SCORE, DICE_MAX_SCORE)
Funzioni
7. Sii coerente con la convenzione che utilizzi per i nomi delle funzioni.
Come per le variabili, utilizza una convenzione per i nomi delle funzioni ed attieniti a questa. Utilizzando convenzioni diverse generi confusione.
# Not Recommended
def get_users():
# do something
pass
def fetch_user(id):
# do something
pass
def get_posts():
# do something
pass
def fetch_post(id):
# do something
pass
# Recommended
def fetch_users():
# do something
pass
def fetch_user(id):
# do something
pass
def fetch_posts():
# do something
pass
def fetch_post(id):
# do something
pass
8. Le funzioni dovrebbero fare una cosa e farla bene.
Scrivi una funzione con poche righe di codice. Deve eseguire un singolo compito. Se il nome di una funzione contiene la congiunzione ‘and’ è probabile che hai bisogno di dividerla in due distinte.
# Not Recommended
def fetch_and_display_users():
users = [] # result from some api call
for user in users:
print(user)
# Recommended
def fetch_users():
users = [] # result from some api call
return users
def display_users(users):
for user in users:
print(user)
9. Non usare flags o flag booleani.
I flag booleani sono variabili che gestiscono valori booleani (vero o falso). Spesso questi flags sono parametri di funzione e determinano il suo comportamento.
# Not Recommended
def transform_text(text, uppercase):
if uppercase:
return text.upper()
else:
return text.lower()
uppercase_text = transform_text(text, True)
lowercase_text = transform_text(text, False)
# Recommended
def transform_to_uppercase(text):
return text.upper()
def transform_to_lowercase(text):
return text.lower()
uppercase_text = transform_to_uppercase(text)
lowercase_text = transform_to_lowercase(text)
Classi
10. Non essere ridondante.
Può verificarsi se aggiungi variabili non necessarie ai nomi delle variabili nelle classi.
# Not Recommended
class Person:
def __init__(self, person_username, person_email, person_phone, person_address):
self.person_username = person_username
self.person_email = person_email
self.person_phone = person_phone
self.person_address = person_address
# Recommended
class Person:
def __init__(self, username, email, phone, address):
self.username = username
self.email = email
self.phone = phone
self.address = address
Nell’esempio sopra, il nome della classe è Person, non c’è bisogno di aggiungere il prefisso person_ al nome delle variabili.
Bonus: Modularizza il tuo codice
Tieni il codice strutturato e manutenibile. Dividi la logica in differenti file o classi chiamati moduli. Un modulo in Python è un semplice file con estensione .py. Ogni modulo dovrebbe fare una cosa e farla bene.
Puoi seguire i principi OOP (Object-Oriented Programming) come l’incapsulamento, l’astrazione, l’ereditarietà e il polimorfismo.
Conclusione
Scrivere codice pulito da molti vantaggi. Migliora la qualità del codice. Permette la corretta manutenzione. Elimina i debiti tecnici.
In questo articolo hai letto alcuni suggerimenti per scrivere codice pulito in Python. Alcuni patterns specifici di Python, ma che possono essere replicati anche in altri linguaggi di programmazione.
Spero che questo articolo ti sia utile per scrivere codice pulito e utilizzare quei patterns che semplificano il tuo codice dandogli qualità.
Questo post è stato scritto da Lawrence Eagles, uno sviluppatore full-stack Javascript, un estimatore di Linux, un tutor appassionato e uno scrittore (no-fiction) tecnico. Lawrence porta una forte miscela di creatività e semplicità. Quando non programma o scrive, ama guardare la pallacanestro
Imparare a scrivere codice “pulito”, clean code, non è facile. Richiede qualcosa di più della semplice conoscenza di principi e tecniche. Ci vuole anche il “sudore”. Dovete fare pratica, e anche andare incontro a insuccessi.
Clean Code di Robert C. Martin
fonte: dev.to