09. I Moduli della Standard Library
In questa lezione parleremo della Standard Library di Python.
La Standard Library di Python
Finora abbiamo visto che ciascun programma che scriviamo può usare una serie di funzioni integrate di Python, come ad esempio la funzione print() e la funzione input(). In aggiunta a queste funzioni Python dispone di una collezione di moduli pronti all'uso in quella che viene chiamata la Standard Library.
Ciascun modulo è come una libreria (un insieme) di funzioni scritte da altri developer molto esperti, realizzate per svolgere compiti comuni come ad esempio la generazione di numeri casuali nel caso del modulo random o funzioni matematiche come nel caso del modulo math, interfacciamento col sistema operativo nel caso del modulo os e tanto altro ancora.
La Standard Library di Python è davvero molto potente e versatile: date uno sguardo a questa pagina del sito della Python Foundation per farvi un'idea del suo potenziale!
Nota: Questa trascrizione include degli approfondimenti e delle aggiunte per fornire maggiori dettagli sui moduli più utilizzati e sui loro metodi. Abbiamo deciso di integrare tali informazioni per arricchire il contenuto: in particolare, abbiamo fornito esempi di utilizzo dei metodi e spiegazioni dettagliate sulla sintassi e sul funzionamento dei moduli più importanti. Speriamo che le integrazioni rendano questa lezione ancora più utile!
Vedremo alcuni dei moduli della standard library più utili e più semplici da utilizzare:
Prima di potere utilizzare le funzioni, le classi e i metodi di questi moduli all'interno dei nostri programmi dovremo importarli, vediamo come!
Come importare un modulo
Ci sono tre diversi modi per importare un modulo nei nostri script di Python.
Il primo consiste semplicemente nel chiamare il modulo tramite il comando import. Con questo tipo di import potete accedere alle funzioni e alle classi del modulo nel vostro codice utilizzando la dot notation: nome_modulo.nome_oggetto.
import mathIl secondo consiste nell’importare solo specifiche classi, variabili e funzioni dal modulo utilizzando from nome_modulo import nome_oggetto: in tal caso possiamo utilizzare ciò che abbiamo importato chiamando gli oggetti direttamente per nome senza far ricorso alla dot notation.
from math import sqrt, expIl terzo consiste nel richiamare tutte le funzioni, le classi e le variabili incluse nel modulo tramite l’asterisco, e anche in questo caso non sarà necessario riscrivere il nome del modulo.
from math import *Se state pensando di lavorare ad un progetto importante e articolato, è decisamente meglio utilizzare la prima o la seconda modalità che vi ho spiegato per mantenere il codice più ordinato e sicuro e sapere esattamente cosa si sta utilizzando in ogni file del nostro codebase.
Esiste inoltre un sistema che ci consente di installare moduli che non fanno parte della Standard Library, ampliando ulteriormente l'insieme di cose che è possibile fare, ma parleremo di ciò più avanti nel corso.
Il modulo random
Questo modulo fornisce una serie di funzioni per generare numeri pseudo-casuali. I numeri ottenuti con random possono essere utili in molte situazioni, per esempio quando è necessario simulare eventi, testare algoritmi o selezionare elementi casuali da una lista. Vediamo alcuni dei metodi di questo modulo:
Il metodo random()
Si tratta della funzione base del modulo, da cui dipendono quasi tutte le altre: utilizza l’algoritmo Mersenne Twister per generare un numero casuale di tipo float compreso tra 0 e 1:
random.random()
# output
0.5576628296719214Il metodo randint(a, b)
Genera un numero intero casuale compreso tra i valori a e b (con a e b inclusi).
# questo programma manda in output 10 numeri pseudo-casuali tra 1 e 50
import random
for numero in range(10):
val = random.randint(1, 50)
print(val)
# output
7
27
22
9
19
11
31
4
36
32Il metodo randrange(start, stop[, step])
Genera un numero intero casuale compreso tra start e stop, con stop escluso. Se si specifica anche il terzo parametro step, i numeri generati saranno suoi multipli.
# Genera solo numeri interi pari
random.randrange(0, 10, 2)
# Genera solo numeri interi dispari
random.randrange(1, 10, 2)Il metodo choice(seq)
Seleziona un elemento casuale dalla sequenza seq, che può essere una lista, una tupla o una stringa.
lista = ['Io', 'Ganimede', 'Callisto', 'Europa']
random.choice(lista)
# output
'Europa'Il modulo math
Questo modulo è utilizzato per eseguire operazioni matematiche e la maggioranza delle sue funzioni restituiscono valori di tipo float. Vediamo alcune delle funzioni più utilizzate di math:
Il metodo sqrt(x)
Restituisce la radice quadrata di x:
math.sqrt(25)
# output
5.0Il metodo pow(x, y)
Restituisce x elevato alla potenza di y:
math.pow(10, 2)
# output
100.0Il metodo exp(x)
Restituisce l’esponenziale di x, cioé e elevato x:
math.exp(x)
# output
7.38905609893065I metodi ceil(x) e floor(x)
La prima restituisce l’arrotondamento per eccesso di x (il più piccolo numero intero maggiore o uguale a x), la seconda restituisce l’arrotondamento per difetto di x (il più grande numero intero minore o uguale a x).
math.ceil(33.23)
# output
34
math.floor(23.532)
# output
23I metodi sin(x), cos(x) e tan(x)
Restituiscono rispettivamente il seno, il coseno e la tangente di x in radianti.
math.sin(1.5707963267948966)
# output
1.0
math.cos(0)
# output
1.0
math.tan(0.7853981633974483)
# output
0.9999999999999999I metodi degrees(x) e radians(x)
Convertono l'angolo x da gradi a radianti e viceversa.
math.degrees(1.0471975511965976)
# output
59.99999999999999
math.radians(45)
# output
0.7853981633974483Il modulo datetime
In Python il tempo non rappresenta un tipo specifico di dato: questo modulo permette di creare oggetti per rappresentare data e ora e fornisce tutta una serie di metodi per effettuare con esse varie operazioni, come convertire gli oggetti in stringhe o calcolare durate. Alcune delle classi più utilizzate di datetime sono le seguenti:
La classe date()
Restituisce un oggetto date che rappresenta una data specificata dall'utente. Come parametri opzionali accetta l’anno, il mese e il giorno:
d = datetime.date(2027, 1, 1)
print(f"{type(d)}: {d}")
# output
<class 'datetime.date'>: 2027-01-01La classe time()
Restituisce un oggetto time che rappresenta un orario specificato dall'utente. Come parametri opzionali accetta l’ora, il minuto, il secondo e il microsecondo:
t = datetime.time(8, 57, 15)
print(f"{type(t)}: {t}")
# output
<class 'datetime.time'>: 08:57:15La classe datetime()
Restituisce un oggetto datetime che rappresenta una data e un orario specificati dall'utente. Come parametri opzionali accetta l’anno, il mese, il giorno, l’ora, il minuto, il secondo e il microsecondo:
dt = datetime.datetime(2025, 5, 25, 1, 1, 1)
print(f"{type(dt)}: {dt}")
# output
<class 'datetime.datetime'>: 2025-05-25 01:01:01La classe timedelta()
Restituisce un oggetto timedelta che rappresenta una durata di tempo. Come parametri opzionali accetta settimane, giorni, ore, minuti, secondi, millisecondi e microsecondi.
td = datetime.timedelta(days=5, hours=7, minutes=30, seconds=2)
print(f"{type(td)}: {td}")
# output
<class 'datetime.timedelta'>: 5 days, 7:30:02Il modulo platform
Questo modulo fornisce una serie di metodi per ottenere informazioni sul sistema operativo, la macchina e l'ambiente in cui il codice Python viene eseguito. Queste informazioni possono essere utili per personalizzare il comportamento del codice in base all'ambiente di esecuzione.
platform.system()
# output
'Windows'
platform.machine()
# output
'AMD64'
platform.processor()
# output
'Intel64 Family 6 Model 141 Stepping 1, GenuineIntel'
platform.architecture()
# output
('64bit', 'WindowsPE')
platform.python_version()
# output
'3.10.3'Il modulo tkinter
Questo modulo fornisce un’interfaccia di programmazione per creare applicazioni grafiche multipiattaforma. La libreria contiene una serie di widget come pulsanti, etichette, caselle di testo, menu e finestre, che possono essere utilizzati per creare interfacce utente interattive.
È possibile creare finestre e widget, impostare il loro aspetto e la loro posizione, gestire gli eventi generati dall'utente e molto altro ancora. Creiamo come esempio una finestra che contiene un semplice pulsante cliccabile:
import tkinter as tk
root = tk.Tk()
root.geometry("400x400")
button = tk.Button(root, text='Cliccami!')
button.pack()
Se volete imparare a creare interfacce grafiche con Tkinter potete seguire la nostra serie di lezioni dedicate.
Il modulo turtle
Questo modulo permette di creare immagini e disegni grafici utilizzando una "tartaruga" virtuale controllabile tramite una serie di comandi da inserire nel codice. Ad esempio, se avviate questo codice vedrete che la tartaruga disegnerà un quadrato:
import turtle
t = turtle.Turtle()
for i in range(4):
t.forward(100)
t.left(90)
turtle.done()
Il modulo turtle è perfetto per imparare i concetti di base della programmazione e della grafica perché permette di sperimentare con diverse forme e colori per creare immagini complesse. Provate ad eseguire questo codice che utilizza la tartaruga per disegnare curve di Hilbert:
import turtle
def hilbert_curve(t, order, size, orientation):
if order == 0:
return
t.right(orientation * 90)
hilbert_curve(t, order - 1, size, -orientation)
t.forward(size)
t.left(orientation * 90)
hilbert_curve(t, order - 1, size, orientation)
t.forward(size)
hilbert_curve(t, order - 1, size, orientation)
t.left(orientation * 90)
t.forward(size)
hilbert_curve(t, order - 1, size, -orientation)
t.right(orientation * 90)
turtle.setup(width=800, height=800)
turtle.speed('fastest')
turtle.penup()
turtle.goto(-350, 350)
turtle.pendown()
hilbert_curve(turtle, 5, 20, 1)
turtle.exitonclick()
Il modulo os
Viene utilizzato per interagire con il sistema operativo. Le sue funzionalità sono tantissime, ma quelle che incontrerete più spesso riguardano la navigazione nelle cartelle del filesystem. Molti metodi di os accettano come parametro un percorso (in inglese path):
Il metodo listdir(path)
Questo metodo restituisce una lista contenente i nomi di tutti i file e tutte le cartelle della directory specificata dal parametro path, in ordine arbitrario:
os.listdir('C:\\Users\\Username\\Documents')
# output
['Lavoro', 'Testi Canzoni', 'Pdf', 'Nuova Cartella']Per vedere nel dettaglio alcuni dei metodi più utilizzati del modulo os potete andare a leggere la serie di lezioni dedicate alla gestione di file e cartelle.
Il modulo shutil
Questo modulo (abbreviazione di Shell Utility) fornisce un insieme di funzioni per la gestione del filesystem e semplifica molte operazioni come copiare, spostare o eliminare file o directory, archiviare in formato ZIP, ecc. Ne parliamo in modo approfondito durante le lezioni dedicate alla gestione di file e cartelle.
Il modulo re
Questo modulo permette di compiere vari tipi di operazioni con le espressioni regolari (re è l'acronimo di regular expression), ovvero sequenze di caratteri utilizzate per cercare, sostituire e manipolare stringhe di testo.
Tutti i metodi di re che vedremo accettano come parametro opzionale anche flags, che permette specificare comportamenti aggiuntivi per la funzione, ad esempio re.IGNORECASE, che esegue la ricerca senza considerare maiuscole e minuscole, e re.MULTILINE, che esegue la ricerca su più righe del testo.
Il metodo search(pattern, string)
Questo metodo cerca la stringa pattern all’interno della stringa string e restituisce un oggetto match corrispondente alla prima occorrenza trovata, dove span è una tupla contenete gli indici della posizione iniziale e finale della corrispondenza nella stringa.
string = "All work and no play makes Jack a dull boy"
pattern = "l"
re.search(pattern, string)
# output
<re.Match object; span=(1, 2), match='l'>Il metodo findall(pattern, string)
Questo metodo cerca la stringa pattern all’interno della stringa string e restituisce una lista di stringhe.
string = "All work and no play makes Jack a dull boy"
pattern = "jack"
re.findall(pattern, string, re.IGNORECASE)
# output
['Jack']Il metodo sub(pattern, repl, string)
Questo metodo sostituisce tutte le occorrenze della stringa pattern all’interno della stringa string con la stringa repl.
stringa = "La mia email è mia.mail@gmail.com."
pattern = r"\b\w+\.\w+@\w+\.\w+\b"
nuova_stringa = re.sub(pattern, "EMAIL", stringa)
print(nuova_stringa)
# output
La mia email è EMAIL.Il modulo zipfile
Questo modulo fornisce diverse funzionalità per la creazione, la lettura e la modifica di archivi ZIP, che sono file compressi contenenti uno o più file o directory. Tramite zipfile possiamo estrarre i file contenuti nell file .zip e aggiungerli o rimuoverli senza dover decomprimere e ricreare l'intero archivio. Per imparare ad utilizzare questo modulo potete leggere la lezione sugli archivi zip nella serie dedicata alla gestione di file e cartelle.
Il modulo json
Questo modulo serve per codificare e decodificare i dati in formato JSON (JavaScript Object Notation): si tratta di un formato molto comune utilizzato soprattutto nella comunicazione tra client e server e come file di configurazione (anche su VSCode). La struttura di un oggetto JSON è simile a quella di un dizionario: i dati sono strutturati come coppie chiave: valore (dette proprietà) circondate da parentesi graffe e separate tra loro da una virgola.
Per aprire i file JSON si utilizza l’istruzione with.
La funzione load(fp)
Accetta come argomento un file da cui caricare i dati JSON e restituisce un oggetto Python corrispondente in base alla tabella di conversione:
with open('pianeti.json', 'r') as file:
data = json.load(file)
print(data)
# output
{'pianeta': 'Giove', 'massa terrestre': 317.83, 'satelliti': 95}La funzione loads(s)
Accetta come argomento una stringa s contenete dei dati JSON e la converte in un oggetto Python in base alla tabella di conversione:
elemento = '{"nome": "Cloro", "simbolo": "Cl", "numero atomico": 17}'
data = json.loads(elemento)
print(data)
# output
{'nome': 'Cloro', 'simbolo': 'Cl', 'numero atomico': 17}La funzione dump(obj, fp)
Accetta come argomento obj un oggetto da convertire in formato JSON e come argomento fp un file su cui scrivere i dati:
data = {'nome': 'Silvia', 'età': 30, 'città': 'Milano'}
with open('data.json', 'w') as file:
json.dump(data, file)La funzione dumps(obj)
Accetta un oggetto (obj) da convertire in formato JSON e restituisce una stringa contenente i dati:
data = {'nome': 'Mario', 'età': 45, 'città': 'Roma'}
json_data = json.dumps(data)
print(json_data)
# output
{"nome": "Mario", "et\u00e0": 45, "citt\u00e0": "Roma"}