Modulo in Python

In questo articolo, imparerai come creare ed esportare moduli personalizzati in Python. Inoltre, scoprirai le diverse tecniche di importazione e utilizzo di moduli personalizzati e integrati in Python.

Cos'è un modulo in Python?

Un modulo è un file che contiene istruzioni e definizioni Python.

I file che contengono codice Python, come example.py, sono chiamati moduli e il loro nome di modulo è example.

Usiamo i moduli per分解grandi programmi in file piccoli e gestibili. Inoltre, i moduli offrono la riutilizzabilità del codice.

Possiamo definire le funzioni più utilizzate nel modulo e importarle, invece di copiare la loro definizione in altri programmi.

Creiamo un modulo. Inserisci il seguente contenuto e salvalo come example.py.

# Esempio di modulo Python
def add(a, b):
　　　"Questo programma somma due numeri"
　　　　　　　e restituisce il risultato della somma"
　　　result = a + b
　　　return result

Qui, abbiamo definito una funzione add() in un modulo chiamato example.Funzione. Questa funzione accetta due numeri e restituisce la loro somma.

Come importare moduli in Python?

Possiamo importare le definizioni interne di un modulo in un altro modulo o in un interprete interattivo di Python.

Usiamo la parola chiave import per farlo. Per importare il modulo definito in precedenza, digitiamo il seguente contenuto nel prompt di Python.

>>> import example

Questo non immette direttamente il nome della funzione definita in example nel simbolo attuale. Funziona solo qui, immettendo il nome del modulo.

Utilizzando il nome del modulo, possiamo accedere alle funzioni utilizzando l'operatore punto. Ad esempio:

>>> example.add(4, 5.5)
9.5

Python ha molti moduli standard disponibili.

Puoi vedereModuli standard PythonL'elenco completo e le loro用途. Questi file si trovano nella directory Lib della posizione di installazione di Python.

Puoi importare moduli standard allo stesso modo di un modulo definito dall'utente.

Ci sono molti modi per importare moduli. Li elenchiamo di seguito.

Istruzione di importazione Python

Possiamo utilizzare l'istruzione import per importare moduli e accedere alle loro definizioni interne utilizzando l'operatore punto, come descritto sopra. Ecco un esempio.

# Esempio di istruzione di importazione
# Importazione del modulo matematico standard
import math
print("Il valore di π", math.pi)

Quando eseguiamo il programma, l'output è:

Il valore di π 3.141592653589793

Rinomina dell'importazione

Possiamo rinominare l'importazione del modulo come segue.

# Importazione del modulo tramite rinomina
import math as m
print("Il valore di π", m.pi)

Abbiamo rinominato il modulo math in m. In alcuni casi, questo può risparmiarci tempo nella scrittura.

Attenzione, il nome 'math' non è riconosciuto nel nostro ambito. Pertanto, math.pi non è valido, mentre m.pi è il modo corretto di utilizzarlo.

Estrazione da Python from ... import

Possiamo importare nomi specifici dal modulo senza dover importare l'intero modulo. Ecco un esempio.

#　Importare solo pi dal modulo matematico
from math import pi
print("Il valore di π", pi)

Importiamo solo l'attributo pi dal modulo.

In questo caso, non usiamo il simbolo di punto. Possiamo importare più attributi come segue.

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045

Importare tutti i nomi

Possiamo utilizzare la seguente costruzione per importare tutti i nomi (definizioni) dal modulo.

#　Importare tutti i nomi dal modulo standard math
from math import *
print("Il valore di pi", pi)

Abbiamo importato tutte le definizioni dal modulo matematico. Questo rende tutti i nomi tranne quelli con trattino basso beginning visibili nella nostra gamma.

Importare tutto con l'asterisco (*) non è una buona abitudine di programmazione. Questo può portare a definizioni duplicate degli identificatori. Questo può anche influenzare la leggibilità del nostro codice.

Percorso di ricerca dei moduli Python

Quando Python importa un modulo, cerca in più posizioni. L'interprete cerca prima un modulo integrato, poi (se non lo trova) entra nella lista di directory definita da sys.path. La ricerca avviene in questo ordine.

• Directory corrente.

• PYTHONPATH (variabile d'ambiente con elenco di directory).

• Directory predefinite relative all'installazione.

>>> import sys
>>> sys.path
['',
'C:\\Python33\\Lib\\idlelib',
'C:\\Windows\\system32\\python33.zip',
'C:\\Python33\\DLLs',
'C:\\Python33\\lib',
'C:\\Python33',
'C:\\Python33\\lib\\site-packages'

Possiamo aggiungere o modificare questa lista per aggiungere il nostro percorso.

Ricaricare il modulo

L'interprete Python importa un modulo solo una volta durante la sessione. Questo rende le cose più efficienti. Questo è un esempio che spiega come funziona.

Supponiamo che ci sia il seguente codice my_module in un modulo chiamato.

#　Questo modulo mostra
#　Importazioni multiple e riaggiunta
print("Questo codice è stato eseguito")

Ora abbiamo visto l'effetto dell'importazione multipla.

>>> import my_module
Questo codice è stato eseguito
>>> import my_module
>>> import my_module

Possiamo vedere che il nostro codice è stato eseguito solo una volta. Questo significa che il nostro modulo è stato importato solo una volta.

Ora, se il nostro modulo subisce cambiamenti durante l'esecuzione del programma, dovremo ricaricarlo. Un metodo è riavviare l'interprete. Ma questo non aiuta molto.

Python fornisce un metodo semplice. Possiamo utilizzare la funzione reload() del modulo imp per ricaricare il modulo. Ecco come si fa.

>>> import imp
>>> import my_module
Questo codice è stato eseguito
>>> import my_module
>>> imp.reload(my_module)
Questo codice è stato eseguito
<modulo 'my_module' da '.\\my_module.py'>

Funzione integrata dir()

Possiamo utilizzare la funzione dir() per trovare i nomi definiti all'interno del modulo.

Ad esempio, abbiamo definito una funzione add() nel modulo example iniziale.

>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',
'add'

Qui possiamo vedere un elenco di nomi ordinati (e add). Tutti i nomi che iniziano con un trattino basso sono attributi di default associati al modulo Python (non li abbiamo definiti noi stessi).

Ad esempio, l'attributo __name__ contiene il nome del modulo.

>>> import example
>>> example.__name__
'example'

Puoi utilizzare la funzione dir() senza alcun parametro per trovare tutti i nomi definiti nella namespace corrente.

>>> a = 1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']