Introduzione al Progetto
In questa lezione extra, concluderemo il corso condividendo consigli pratici e trucchi utili per programmare in modo efficace con Python. Tratteremo anche il PEP 8, lo standard di stile per scrivere codice Python, e lo Zen di Python, una filosofia che rappresenta l’essenza di Python.
Sommario
Soluzioni esercizi lezione 10
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Esercizio 1: Grafico Lineare
# Dati per le vendite mensili
mesi = ["Gennaio", "Febbraio", "Marzo", "Aprile", "Maggio", "Giugno"]
vendite = [1000, 1500, 1200, 1700, 2000, 1900]
plt.figure(figsize=(8, 5))
plt.plot(mesi, vendite, marker='o', linestyle='-', color='b', label='Vendite Mensili')
plt.title('Grafico Lineare delle Vendite Mensili')
plt.xlabel('Mesi')
plt.ylabel('Vendite (€)')
plt.legend()
plt.grid(True)
plt.show()
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Esercizio 2: Grafico a Barre
# Dati per le vendite per dipartimento
dipartimenti = ["IT", "HR", "Finance"]
vendite_dipartimenti = [3000, 4000, 5000]
plt.figure(figsize=(8, 5))
plt.bar(dipartimenti, vendite_dipartimenti, color=['blue', 'green', 'orange'])
plt.title('Vendite per Dipartimento')
plt.xlabel('Dipartimenti')
plt.ylabel('Vendite (€)')
plt.show()
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Esercizio 3: Pie Chart
# Dati per i linguaggi di programmazione
linguaggi = ["Python", "Java", "C++", "JavaScript"]
percentuali = [40, 25, 20, 15]
plt.figure(figsize=(8, 5))
plt.pie(percentuali, labels=linguaggi, autopct='%1.1f%%', startangle=140, colors=['gold', 'lightblue', 'lightgreen', 'pink'])
plt.title('Percentuali di Utilizzo dei Linguaggi di Programmazione')
plt.show()
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Esercizio 4: Scatter Plot
# Dati per ore di studio e punteggi
dati = {
"Ore di Studio": [1, 2, 3, 4, 5, 6, 7, 8],
"Punteggio Esame": [50, 55, 60, 65, 70, 75, 85, 90]
}
df = pd.DataFrame(dati)
plt.figure(figsize=(8, 5))
plt.scatter(df["Ore di Studio"], df["Punteggio Esame"], color='purple', marker='o')
plt.title('Scatter Plot: Ore di Studio vs Punteggio Esame')
plt.xlabel('Ore di Studio')
plt.ylabel('Punteggio Esame')
plt.grid(True)
plt.show()
Obiettivi della lezione EXTRA
Scrivere codice leggibile e ben strutturato è fondamentale per:
- Facilitarne la comprensione, sia per te stesso che per altri sviluppatori.
- Migliorare la manutenibilità nel tempo.
- Ridurre errori e ambiguità.
La leggibilità è uno dei pilastri di Python, come vedremo nello Zen di Python.
Lo Zen di Python
Matplotlib è una libreria Python per creare grafici statici, animati e interattivi. È altamente personalizzabile e spesso utilizzata insieme a Pandas per rappresentare visivamente dataset.
import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
Beautiful is better than ugly.
Il codice ben scritto e leggibile è preferibile a quello disordinato e confuso, anche se funziona.
# Non leggibile
x=[1,2,3]
for i in x:print(i)
# Leggibile
numeri = [1, 2, 3]
for numero in numeri:
print(numero)
Explicit is better than implicit.
È meglio essere chiari ed espliciti che fare assunzioni nascoste.
# Implicito
risultato = True + 2 # Funziona, ma è poco chiaro che True equivale a 1.
# Esplicito
risultato = 1 + 2
Simple is better than complex.
Preferisci soluzioni semplici e dirette rispetto a quelle inutilmente complicate.
# Complesso
def somma_complessa(a, b):
return a.__add__(b)
# Semplice
def somma(a, b):
return a + b
Complex is better than complicated.
La complessità può essere accettabile, ma solo se necessaria. Evita la complicazione non necessaria.
Esempio:
- Complesso accettabile: Algoritmi avanzati per grandi dataset.
- Complicato: Aggiungere funzioni inutili solo per mostrare abilità tecniche.
Flat is better than nested.
- È preferibile un codice con una struttura “piatta” rispetto a uno con troppi livelli di annidamento (nested).
# Troppo annidato
if condizione1:
if condizione2:
if condizione3:
print("Troppo annidato")
# Migliore
if condizione1 and condizione2 and condizione3:
print("Struttura più piatta")
Sparse is better than dense.
Usa spazi e righe vuote per migliorare la leggibilità.
# Denso
def funzione(x): return x**2+2*x+1
# Sparso
def funzione(x):
return x**2 + 2*x + 1
Readability counts.
Il codice leggibile è fondamentale per la collaborazione e la manutenzione.
Esempio:
- Usa nomi di variabili descrittivi.
- Segui le linee guida di PEP 8.
Special cases aren't special enough to break the rules.
Non creare eccezioni inutili o ad-hoc che violano le buone pratiche.
Non creare funzioni personalizzate per casi rari se ci sono soluzioni standard disponibili.
Although practicality beats purity.
A volte una soluzione pratica è meglio di una completamente “perfetta” o teorica, purché rimanga leggibile e funzionale.
# Perfettamente "puro" ma meno pratico
def somma(lista):
from functools import reduce
return reduce(lambda x, y: x + y, lista)
# Pratico e semplice
def somma(lista):
return sum(lista)
Errors should never pass silently.
Gli errori devono essere gestiti, non ignorati, per evitare comportamenti imprevedibili.
try:
x = int("abc") # Questo causerà un errore
except ValueError as e:
print(f"Errore: {e}")
Unless explicitly silenced.
Se un errore deve essere ignorato, fallo in modo esplicito.
try:
x = int("abc")
except ValueError:
pass # Errore ignorato esplicitamente
In the face of ambiguity, refuse the temptation to guess.
Se una situazione è ambigua, non fare assunzioni. Sii esplicito.
# Ambiguo
x = None
if x:
print("Questo può essere confuso")
# Chiaro
if x is not None:
print("Più esplicito e chiaro")
There should be one-- and preferably only one --obvious way to do it.
Ogni problema dovrebbe avere una soluzione “ovvia” e standard.
Evita di reinventare la ruota: usa funzioni e moduli standard.
Although that way may not be obvious at first unless you're Dutch.
Alcune soluzioni richiedono pratica per essere evidenti, a meno che tu non sia olandese. Questo è un riferimento scherzoso a Guido van Rossum, il creatore di Python (che è olandese).
Now is better than never.
È meglio fare progressi adesso che procrastinare indefinitamente.
Although never is often better than right now.
Non bisogna fare le cose in fretta e male. È meglio aspettare piuttosto che implementare una soluzione subottimale.
If the implementation is hard to explain, it's a bad idea.
Se una soluzione è difficile da spiegare, probabilmente è complicata inutilmente.
If the implementation is easy to explain, it may be a good idea.
Una soluzione semplice e ben spiegata è probabilmente quella giusta.
Namespaces are one honking great idea -- let's do more of those!
I namespace (spazi dei nomi) aiutano a organizzare il codice e a evitare conflitti di nomi. Usali al massimo.
import numpy as np # Usa alias per evitare conflitti
Il PEP8
Indentazione
# Corretto
def funzione():
if True:
print("Indentazione corretta")
# Errato
def funzione():
if True:
print("Errore: uso di tab")
Lunghezza delle righe
# Continuazione con parentesi
x = (1 + 2 + 3 +
4 + 5 + 6)
# Continuazione con backslash
y = 1 + 2 + 3 + \
4 + 5 + 6
Spazi Bianchi
# Usa uno spazio prima e dopo gli operatori matematici o logici.
# Corretto
a = 10 + 5
# Errato
a=10+5
# Niente spazi intorno alle parentesi
# Corretto
funzione(argomento)
# Errato
funzione( argomento )
Nomi di variabili, funzioni e classi
# Usa snake_case per i nomi di variabili e funzioni
nome_variabile = 10
def calcola_somma(a, b):
return a + b
# Usa CamelCase per i nomi delle classi
class NomeClasse:
pass
# Usa MAIUSCOLO_SNAKE_CASE per le costanti
COSTANTE = 100
Importazioni
Gli import devono essere scritti all’inizio del file.
# Corretto
import os
import sys
# Errato
import os, sys
Gli import sono organizzati in tre blocchi, separati da una riga vuota:
- Import standard: Moduli della libreria standard di Python.
- Import di terze parti: Librerie esterne (es. NumPy, Pandas).
- Import locali: File o moduli definiti nel progetto.
# Import standard
import os
import sys
# Import di terze parti
import pandas as pd
# Import locali
from mio_modulo import funzione
Commenti
Commenti inline
- Usa i commenti inline solo se strettamente necessari.
- Devono essere separati dal codice da almeno due spazi.
x = 10 # Questo è un commento inline
Commenti multi-linea
Utilizza un blocco di commenti per spiegare parti complesse.
# Questo è un commento multi-linea
# che spiega una logica complessa.
Docstring
- Usa le docstring per documentare moduli, classi e funzioni.
- Le docstring devono essere racchiuse tra tripli apici (
""").
def calcola_area(base, altezza):
"""
Calcola l'area di un rettangolo.
Args:
base (float): La base del rettangolo.
altezza (float): L'altezza del rettangolo.
Returns:
float: L'area del rettangolo.
"""
return base * altezza
Classi e Metodi
- La prima riga di ogni classe dovrebbe essere una docstring che ne descrive lo scopo.
- Usa il metodo speciale
__init__per inizializzare gli attributi di un oggetto.
class Rettangolo:
"""Classe per rappresentare un rettangolo."""
def __init__(self, base, altezza):
self.base = base
self.altezza = altezza
def area(self):
"""Calcola l'area del rettangolo."""
return self.base * self.altezza
Gestione delle eccezioni
Gestisci le eccezioni in modo esplicito, specificando il tipo di errore che intendi catturare.
try:
risultato = 10 / 0
except ZeroDivisionError:
print("Errore: divisione per zero.")
Struttura delle righe vuote
- Usa due righe vuote tra definizioni di classi o funzioni a livello globale.
- Usa una riga vuota per separare metodi all’interno di una classe.
class ClasseEsempio:
def metodo1(self):
pass
def metodo2(self):
pass
Evitare il codice "magico"
Evita valori “magici” nel codice (numeri o stringhe senza contesto). Usa costanti o variabili con nomi descrittivi.
# Errato
if x == 42:
print("Risultato trovato.")
# Corretto
RISULTATO_ATTESO = 42
if x == RISULTATO_ATTESO:
print("Risultato trovato.")
Strumenti per verificare il PEP8
#bash
#Uno strumento per analizzare la qualità del codice e verificare la conformità al PEP 8.
pip install flake8
flake8 nome_file.py
#Un formatter automatico che applica le regole del PEP 8.
pip install black
black nome_file.py
#Un altro strumento per verificare la qualità del codice.
pip install pylint
pylint nome_file.py
Consigli e Trucchi per Programmare in Python
List Comprehension
Le list comprehension sono uno strumento potente per creare liste in modo conciso e leggibile.
# Creare una lista di quadrati
quadrati = [x ** 2 for x in range(10)]
print(quadrati)
Utilizzare il f-string
Le f-string rendono più semplice e leggibile la formattazione delle stringhe.
nome = "Alice"
eta = 25
print(f"Ciao, mi chiamo {nome} e ho {eta} anni.")
Gestire file con il contesto with
Usare il blocco with per la gestione dei file garantisce che vengano chiusi correttamente.
with open("file.txt", "r") as file:
contenuto = file.read()
Usare enumerate() per iterare con un indice
Se hai bisogno di un indice durante un ciclo for, usa enumerate():
nomi = ["Alice", "Bob", "Charlie"]
for i, nome in enumerate(nomi):
print(f"Indice {i}: {nome}")
Utilizzare zip() per iterare su più liste
La funzione zip() permette di iterare su più liste contemporaneamente.
nomi = ["Alice", "Bob", "Charlie"]
eta = [25, 30, 35]
for nome, anni in zip(nomi, eta):
print(f"{nome} ha {anni} anni.")
Debugging e Buone Pratiche
Usa print() per il debugging
Inserire dei print() strategici aiuta a capire cosa sta accadendo nel codice. Puoi usare f-string per stampare variabili:
x = 10
print(f"Il valore di x è: {x}")
Usa il modulo logging
Per progetti più complessi, usa logging invece di print().
import logging
logging.basicConfig(level=logging.INFO)
logging.info("Questo è un messaggio di log")
Gestione degli errori
Gestisci sempre gli errori con try/except:
try:
risultato = 10 / 0
except ZeroDivisionError as e:
print(f"Errore: {e}")
Conclusioni sul corso
Con questa lezione extra hai imparato:
- Le linee guida di PEP 8 per scrivere codice leggibile e manutenibile.
- I principi dello Zen di Python per creare codice elegante e coerente.
- Consigli e trucchi utili per migliorare la tua produttività in Python.
Seguendo queste buone pratiche, sarai in grado di scrivere codice Python più professionale, leggibile e robusto. Continua a esplorare, a sperimentare e a migliorare ogni giorno! 🚀
Homepage del Corso Introduttivo
Sei curioso di scoprire il mondo della programmazione?
Con il mio corso gratuito di Python potrai infatti scoprire gli aspetti del linguaggio.
Ogni lezione è spiegata in modo chiaro e pratico.
Inoltre, grazie a esercizi e materiali di supporto, potrai quindi mettere subito in pratica ciò che impari.