Tutorial sui moduli Python: come importarli, scriverli e usarli

Importare moduli in Python

Per usare le funzionalità presenti in un modulo, devi importarlo nel programma corrente. Devi usare la parola chiave import insieme al nome del modulo desiderato. Quando l'interprete incontra un'istruzione import, importa il modulo nel tuo programma.

Puoi usare le funzioni all'interno di un modulo usando l'operatore punto (.) insieme al nome del modulo.

Per prima cosa, vediamo come usare i moduli della libreria standard. Nell'esempio qui sotto, il modulo math viene importato nel programma così da poter usare la funzione sqrt().

import math  # Import the math module
num = 4
print(math.sqrt(num))  # Call the sqrt() function from the math module

Per motivi di efficienza, ogni modulo viene importato una sola volta per sessione dell'interprete. Quindi, se modifichi i tuoi moduli, devi riavviare l'interprete.

Se vuoi ricaricare un modulo che hai già importato (ad esempio dopo averlo modificato), usa importlib.reload().

Nota che la vecchia funzione built-in reload() non esiste più in Python 3 — importlib.reload() è il modo attuale e ufficiale per ricaricare i moduli in Python 3.4+

import importlib
importlib.reload(module_name)

Nota: Ricaricare moduli chiave come sys, __main__, builtins e altri non è consigliato. Molti moduli di estensione non sono progettati per essere inizializzati più di una volta e possono fallire in modi imprevedibili quando ricaricati. Limìtati a ricaricare solo i tuoi moduli durante lo sviluppo.

In arrivo: Python sta introducendo i "lazy imports". Questi velocizzeranno l'avvio rimandando il caricamento dei moduli fino al primo utilizzo. È utile perché, soprattutto nei progetti grandi, molti moduli vengono importati all'inizio di un file ma non servono subito.

Come scrivere i tuoi moduli Python

Ora che hai imparato come importare un modulo nel tuo programma, è il momento di scriverne uno tuo e usarlo in un altro programma. Scrivere un modulo è come scrivere qualsiasi altro file Python. Iniziamo scrivendo una funzione per sommare/sottrarre due numeri in un file calculation.py.

def add(x,y):
    return (x+y)
def sub(x,y):
    return (x-y)

Se provi a eseguire questo script dalla riga di comando, non succederà nulla perché non hai detto al programma di fare qualcosa. Crea un altro script Python nella stessa directory con il nome module_test.py e scrivici il seguente codice.

import calculation            #Importing calculation module
print(calculation.add(1,2))   #Calling function defined in the calculation module 

Se esegui module_test.py, vedrai "3" come output. Quando l'interprete ha incontrato l'istruzione import, ha importato il modulo calculation nel tuo codice e poi, usando l'operatore punto, hai potuto accedere alla funzione add().

Proteggere il codice eseguibile con if __name__ == "main__"

C'è un'abitudine importante da acquisire quando scrivi moduli: racchiudere qualsiasi codice che vuoi eseguire solo direttamente (non quando importato) in un blocco if __name__ == "__main__".

# calculation.py
def add(x, y):
    return x + y

def sub(x, y):
    return x - y

if __name__ == "__main__":
    # This only runs when you execute calculation.py directly
    # It will NOT run when another script imports this module
    print(add(1, 2))

Altri modi per importare moduli in Python

Ci sono altri modi per importare moduli:

• istruzione from .. import

• istruzione from .. import *

• rinominare il modulo importato

Usare from module import name

L'istruzione from..import ti permette di importare funzioni/variabili specifiche da un modulo invece di importare tutto. Nell'esempio precedente, quando hai importato calculation in module_test.py sono state importate sia le funzioni add() che sub(). Ma se nel tuo codice ti servisse solo la funzione add()? Ecco un esempio per illustrare l'uso di from..import.

from calculation import add
print(add(1,2))

Nell'esempio sopra, viene importata e usata solo la funzione add(). Hai notato l'uso di add()? Ora puoi accedervi direttamente senza usare il nome del modulo. Puoi importare anche più attributi, separandoli con una virgola nell'istruzione di import. Guarda il seguente esempio:

from calculation import add,sub

Usare from module import *

Puoi importare tutti gli attributi di un modulo usando questa istruzione. Questo renderà visibili nel tuo codice tutti gli attributi del modulo importato.

Ecco un esempio per illustrare l'uso di from .. import *:

from calculation import *
print(add(1,2))
print(sub(3,2))

Nota che in ambito professionale dovresti evitare di usare from..import e from..import*. Inquinano il tuo namespace con ogni nome presente nel modulo, rendono impossibile capire da dove provenga una funzione leggendo il codice e possono sovrascrivere in modo silenzioso nomi che hai già definito. Preferisci import espliciti.

Rinominare moduli in Python

Puoi rinominare il modulo che stai importando, utile quando vuoi dare un nome più significativo al modulo o quando il nome è troppo lungo da usare ripetutamente. Puoi usare la parola chiave as per rinominarlo. Il seguente esempio spiega come usarla nel tuo programma.

import calculation as cal
print(cal.add(1,2))

Ti sei risparmiato un po' di digitazione rinominando calculation in cal.

Nota che ora non puoi più usare calculation.add(1,2), perché calculation non è più riconosciuto nel tuo programma. Cosa succede: una volta che assegni un alias a un modulo con as, il nome originale non è più disponibile in quello script.

Percorso di ricerca dei moduli in Python

Potresti aver bisogno che i tuoi moduli siano usati in programmi o progetti diversi e la loro posizione fisica nella directory potrebbe variare. Se vuoi usare un modulo che si trova in un'altra directory, Python ti offre alcune opzioni.

Quando importi un modulo chiamato calculation, l'interprete cerca prima un modulo integrato con quel nome. Se non lo trova, cerca un file chiamato calculation.py in un elenco di directory indicato dalla variabile sys.path. sys.path contiene queste posizioni:

• La directory che contiene lo script di input (o la directory corrente)

• PYTHONPATH (un elenco di nomi di directory con la stessa sintassi della variabile di shell PATH)

• Il valore predefinito dipendente dall'installazione

Supponi che module_test.py sia nella directory /home/datacamp/ e che tu abbia spostato calculation.py in /home/test/. Puoi modificare sys.path per includere /home/test/ nell'elenco dei percorsi in cui l'interprete Python cercherà il modulo. Per questo, devi modificare module_test.py nel seguente modo:

import sys
sys.path.append('/home/test/')

import calculation
print(calculation.add(1,2))

File compilati in bytecode in Python

Importare un modulo aumenta il tempo di esecuzione dei programmi, quindi Python ha alcune soluzioni per velocizzare il tutto. Un modo è creare file compilati in bytecode con estensione .pyc.

Internamente, Python converte il codice sorgente in una forma intermedia chiamata bytecode. Poi la traduce nel linguaggio nativo del tuo computer ed esegue il tutto. Questo file .pyc è utile quando importi di nuovo il modulo da un programma diverso: sarà molto più veloce perché una parte dell'elaborazione necessaria per importare un modulo è già stata fatta. Inoltre, questi file compilati in bytecode sono indipendenti dalla piattaforma.

Nota che questi file .pyc vengono di solito creati nella stessa directory dei corrispondenti file .py. Se Python non ha i permessi di scrittura in quella directory, i file .pyc non verranno creati. Questi file sono solitamente archiviati nella directory __pycache__ accanto ai tuoi file .py, con nomi come calculation.cpython-312.pyc che riflettono la versione di Python utilizzata. Puoi tranquillamente ignorare o aggiungere a .gitignore questa cartella. Python la gestisce automaticamente.

La funzione dir() di Python

La funzione dir() viene usata per scoprire tutti i nomi definiti in un modulo. Restituisce un elenco ordinato di stringhe che contengono i nomi definiti in un modulo.

import calculation
print(calculation.add(1,2))
print(dir(calculation))

['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'add', 'sub']

Nell'output puoi vedere i nomi delle funzioni che hai definito nel modulo, add e sub. L'attributo __name__ contiene il nome del modulo. Tutti gli attributi che iniziano con un trattino basso sono attributi predefiniti di Python associati a un modulo.

Conclusione

Creare un modulo è fondamentale per una migliore gestione del codice e per il riuso. Python ti mette a disposizione alcuni moduli integrati, che possono essere importati usando la parola chiave import. Python ti permette anche di creare i tuoi moduli e usarli nei tuoi programmi. Per ridurre il costo dell'uso dei moduli, fornisce file compilati in bytecode, che rendono l'esecuzione più veloce. Puoi usare dir() per conoscere gli attributi definiti nel modulo utilizzato in un programma. Questo vale sia per i moduli predefiniti sia per quelli definiti dall'utente.

Se vuoi saperne di più su Python, dai un'occhiata al nostro corso Intermediate Python for Data Science.