Importa modulo in Python con esempi
Anna Blake
⚡ Riepilogo intelligente
Importa in Python Consente a un file di riutilizzare le variabili, le funzioni e le classi definite in un altro. Un modulo è semplicemente un file .py, mentre un pacchetto raggruppa moduli correlati all'interno di una directory contrassegnata da un file __init__.py.
Le sezioni seguenti spiegano i moduli, i pacchetti, i diversi stili di importazione e il funzionamento delle importazioni assolute e relative in Python.
In quali moduli sono contenuti? Python?
Un modulo è un file con Python codice. Il codice può essere sotto forma di variabili, funzioni o una classe definita. Il nome del file diventa il nome del modulo.
Ad esempio, se il nome del tuo file è guru99.py, il nome del modulo sarà guru99. Con la funzionalità del modulo, puoi suddividere il codice in file diversi invece di scrivere tutto in un unico file.
Qual è la Python modulo di importazione?
Un file è considerato un modulo in Python. Per utilizzare il modulo, è necessario importarlo utilizzando il importare parola chiave. Le funzioni o variabili presenti all'interno del file possono essere utilizzate in un altro file importando il modulo. Questa funzionalità è disponibile in altri linguaggi come TypeScript, Javasceneggiatura, Java, Rubino, ecc.
Come creare e importare un modulo in Python?
Ora creeremo un modulo e lo importeremo in un altro file.
Ecco il flusso per creare e importare il modulo come mostrato nello screenshot:
Segui i passaggi indicati per creare un modulo in Python.
La struttura delle cartelle utilizzata per testare il codice è la seguente:
modtest/ test.py display.py
Passo 1) Crea un file e chiamalo test.py
Passo 2) All'interno di test.py crea una funzione chiamata display_message()
Def display_message():
return "Welcome to Guru99 Tutorials!"
Passo 3) Ora crea un altro file display.py.
Passo 4) All'interno del file display.py, importa il modulo test.py, come mostrato di seguito:
import test
Durante l'importazione, non è necessario specificare il file test.py, ma solo il nome del file stesso.
Passo 5) Quindi puoi chiamare la funzione display_message() da test.py all'interno di display.py. Devi usare module_name.function_name.
Ad esempio test.display_message().
Import test
print(test.display_message())
Passo 6) Quando esegui display.py, otterrai quanto segue Produzione:
Welcome to Guru99 Tutorials!
Importare una classe in Python
In precedenza, abbiamo visto un semplice modulo con una funzione. Qui creeremo una classe e faremo riferimento a tale classe all'interno di un altro file.
La struttura delle cartelle per testare il codice è la seguente:
myproj/ Car.py display.py
Crea un file denominato Car.py con il seguente codice:
Nome file: Car.py
class Car: brand_name = "BMW" model = "Z4" manu_year = "2020" def __init__(self, brand_name, model, manu_year): self.brand_name = brand_name self.model = model self.manu_year = manu_year def car_details(self): print("Car brand is ", self.brand_name) print("Car model is ", self.model) print("Car manufacture year is ", self.manu_year) def get_Car_brand(self): print("Car brand is ", self.brand_name) def get_Car_model(self): print("Car model is ", self.model)
Nel file Car.py sono presenti gli attributi brand_name, model e manu_year. Le funzioni definite all'interno della classe sono car_details(), get_Car_brand() e get_Car_model().
Usiamo ora il file Car.py come modulo in un altro file chiamato display.py.
Nome file: display.py
import Car car_det = Car.Car("BMW","Z5", 2020) print(car_det.brand_name) print(car_det.car_details()) print(car_det.get_Car_brand()) print(car_det.get_Car_model())
Produzione:
BMW Car brand is BMW Car model is Z5 Car manufacture year is 2020 Car brand is BMW Car model is Z5
Quindi possiamo accedere a tutte le variabili e funzioni di Car.py utilizzando il modulo Car.
Utilizzo del modulo da a importare
È possibile importare solo una piccola parte del modulo, ovvero solo le funzioni e i nomi delle variabili necessari, anziché importare l'intero codice.
Quando si desidera importare solo elementi specifici, è possibile utilizzare la parola chiave "from" per importare ciò che si desidera.
Quindi la sintassi è
from module import your function_name , variables,... etc.
La struttura delle cartelle utilizzata per testare il codice è la seguente:
modtest/ test.py display.py
Nel file test.py sono presenti 2 funzioni, come mostrato:
Nome file: test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Ora ti serve la funzione display_message(). Puoi accedere direttamente alla funzione o alla variabile che stai importando, come mostrato di seguito:
Nome del file: display.py
from test import display_message print(display_message())
Produzione:
Welcome to Guru99 Tutorials!
Se si utilizza la funzione display_message1(), verrà generato un errore che indica che la funzione non è definita, come mostrato di seguito:
from test import display_message print(display_message1())
Produzione:
Traceback (most recent call last): File "display.py", line 3, in <module> print(display_message1()) Name Error: name 'display_message1' is not defined
Importando tutto dal modulo
Il comando Import consente di importare l'intero modulo utilizzando il comando import seguito dal nome del modulo, ovvero il nome del file o della libreria da utilizzare.
Sintassi:
Import module
Oppure usando
from module import *
La struttura delle cartelle utilizzata per testare il codice è la seguente:
modtest/ test.py display.py
Di seguito sono riportati i dettagli del codice all'interno di test.py
my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Utilizzando il modulo di importazione
Utilizzando solo il nome del modulo di importazione, per fare riferimento alle variabili e alle funzioni all'interno del modulo, è necessario anteporre il nome del modulo stesso.
Esempio
Nome file: display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
Il nome del modulo test viene utilizzato per fare riferimento alle funzioni e alle variabili all'interno del modulo test.
Produzione:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Utilizzando l'importazione *
Vediamo un esempio utilizzando importare *. utilizzando importare *, le funzioni e le variabili sono direttamente accessibili, come mostrato nell'esempio seguente:
from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)
Produzione:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
La funzione dir()
La funzione dir() è una funzione integrata in PythonLa funzione dir() restituisce tutte le proprietà e i metodi, comprese le proprietà integrate dell'oggetto specificato.
Quindi, quando si utilizza `dir()` sul modulo, verranno visualizzate le variabili e le funzioni presenti all'interno del modulo stesso.
Ecco un esempio funzionante di dir() su un modulo. Abbiamo una classe chiamata Car.py, importiamo Car e assegniamola a dir() per vedere l'output.
La struttura delle cartelle per testare il codice sarà la seguente:
test prop/ Car.py test.py
Nome file: Car.py
class Car: brand_name = "BMW" model = "Z4" manu_year = "2020" def __init__(self, brand_name, model, manu_year): self.brand_name = brand_name self.model = model self.manu_year = manu_year def car_details(self): print("Car brand is ", self.brand_name) print("Car model is ", self.model) print("Car manufacture year is ", self.manu_year) def get_Car_brand(self): print("Car brand is ", self.brand_name) def get_Car_model(self): print("Car model is ", self.model)
Nome file: test.py
import Car class_contents = dir(Car) print(class_contents)
L'output ci fornisce il nome della classe e tutte le funzioni definite in Car.py.
Puoi anche provare a utilizzare dir() su un modulo integrato disponibile in Python. Proviamo lo stesso su json modulo come mostrato nell'esempio seguente. Visualizzerà tutte le proprietà e i metodi disponibili nel json modulo.
Import json
json_details = dir(json)
print(json_details)
Produzione:
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa d', 'loads', 'scanner']
personalizzati
Un pacchetto è una directory con tutti i moduli definiti al suo interno. Per fare a Python L'interprete lo tratta come un pacchetto, quindi la tua directory dovrebbe contenere il file __init__.py. Il file __init__.py trasforma la directory in un pacchetto. Ecco la struttura del pacchetto su cui lavoreremo.
Il nome del pacchetto è il mio pacchettoPer iniziare a lavorare con il pacchetto, crea una directory chiamata mypackage/. All'interno di questa directory, crea un file vuoto chiamato __init__.py. Crea altri 3 file: module1.py, module2.py e module3.py e definisci le funzioni come mostrato nello screenshot. Ecco i dettagli di module1.py, module2.py e module3.py.
modulo1.py
def mod1_func1(): print("Welcome to Module1 function1") def mod1_func2(): print("Welcome to Module1 function2") def mod1_func3(): print("Welcome to Module1 function3")
modulo2.py
def mod2_func1(): print("Welcome to Module2 function1") def mod2_func2(): print("Welcome to Module2 function2") def mod2_func3(): print("Welcome to Module2 function3")
modulo3.py
def mod3_func1(): print("Welcome to Module3 function1") def mod3_func2(): print("Welcome to Module3 function2") def mod3_func3(): print("Welcome to Module3 function3")
Migliori pacchetto è pronto per l'uso. Ora richiama il pacchetto all'interno di uno qualsiasi dei tuoi file, come mostrato di seguito in test.py:
Qui, mypackage.module1 viene importato e gli viene assegnato un nome alias come modalità1Allo stesso modo, è possibile utilizzare gli altri moduli module2.py e module3.py presenti nel pacchetto mypackage.
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
Produzione:
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
Abbiamo appena mostrato il pacchetto con un semplice modulo contenente delle funzioni. In base al vostro progetto, potete anche creare pacchetti che contengono sottocartelle, ovvero sottocartelle con moduli e classi definite.
Python Percorso di ricerca del modulo
Durante l'esecuzione, quando Python si imbatte nome del modulo di importazioneL'interprete tenta di individuare il modulo. Lo cerca nell'elenco dei moduli predefiniti e poi in tutte le directory definite in sys.path.
Riassumendo, l'interprete esegue la seguente ricerca per individuare il modulo:
- Nella tua directory attuale.
- Nell'elenco dei moduli integrati.
- All'interno delle directory sys.path.
È possibile ottenere i dettagli di sys.path importando il modulo sys e stampando sys.path. Verrà visualizzato l'elenco delle directory come mostrato di seguito:
importsys
print(sys.path)
Produzione:
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\ \Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P ython37\\DLLs']
Puoi anche modificare il percorso e mantenere le directory secondo le tue esigenze.
Utilizzo dell'alias del modulo nell'importazione
È anche possibile convertire il nome del modulo in una forma più breve assegnandogli un nome alias. L'alias può essere creato utilizzando il as parola chiave.
Sintassi:
import filename as alias name
La struttura delle cartelle per testare il codice sarà la seguente:
Mod test/ test.py display.py
Di seguito è riportato il codice all'interno di test.py
my_name = "Guru99" my_address = "Mumbai" def display_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Ora useremo un alias per test.py in display.py
Import test as t print(t.display_message()) print(t.display_message1()) print(t.my_name) print(t.my_address)
L'alias utilizzato per il modulo di test è t. Pertanto, le funzioni e le variabili di test.py possono essere richiamate utilizzando l'alias t.
Produzione:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Importazioni assolute e relative in Python
Ora sai come importare un file come modulo all'interno di un altro file. Vediamo ora come gestire i file disponibili nelle cartelle. I file nelle cartelle possono essere importati utilizzando importazioni assolute o relative.
Considera di avere la struttura delle cartelle del progetto, come mostrato di seguito:
La cartella principale è myproject/. Contiene due sottocartelle: package1 e package2.
La cartella package1 contiene due moduli, module1.py e module2.py.
La cartella package2 ha una classe myclass.py, un sottopacchetto subpkg con module3.py e l'ultimo module4.py.
- Nel file module1.py è presente una funzione chiamata myfunc1.
- Nel file module2.py è presente una funzione chiamata myfunc2.
- Nel file module3.py è presente una funzione chiamata myfunc3.
- Nel file module4.py è presente una funzione chiamata myfunc4.
Utilizzo delle importazioni assolute
Per le importazioni assolute, è necessario aggiungere il percorso completo del modulo direttamente dalla cartella principale del progetto.
Vediamo ora come utilizzare le importazioni assolute per fare riferimento alle funzioni presenti in ciascuno dei moduli.
Per utilizzare la funzione myfunc1, è necessario importarla nel modo seguente:
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
Per utilizzare la funzione myfunc3, è necessario importarla nel modo seguente:
from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()
Vantaggi e svantaggi dell'utilizzo delle importazioni assolute
Ecco i vantaggi derivanti dall'utilizzo delle importazioni assolute:
- Diventa facile trace ripristinare i moduli per la verifica del codice.
- Facile da usare e molto diretto.
- Se il progetto viene spostato su un percorso diverso, le importazioni rimarranno comunque invariate.
Svantaggi dell'utilizzo delle importazioni assolute
Ecco gli svantaggi dell'utilizzo delle importazioni assolute:
- Il percorso di importazione può diventare molto lungo nel caso in cui i moduli siano annidati e i nomi dei moduli siano lunghi.
Utilizzo delle importazioni relative
Considerando la stessa struttura di cartelle menzionata in precedenza, vedremo come importarla utilizzando le importazioni relative.
In un'importazione relativa, il modulo da importare è relativo alla posizione corrente, ovvero alla posizione in cui si trova l'istruzione di importazione.
Sintassi
Nelle importazioni relative, è necessario aggiungere un punto (.) prima del nome del modulo durante l'importazione utilizzando da.
Ci saranno due punti (..) prima del nome del modulo se il modulo si trova un livello sopra la posizione corrente.
Facendo riferimento alla struttura delle cartelle illustrata nella figura precedente, disponiamo dei seguenti moduli con le relative funzioni, ai quali dobbiamo fare riferimento.
- Nel file module1.py è presente una funzione chiamata myfunc1.
- Nel file module2.py è presente una funzione chiamata myfunc2.
- Nel file module3.py è presente una funzione chiamata myfunc3.
- Nel file module4.py è presente una funzione chiamata myfunc4.
Per utilizzare la funzione myfunc1, è necessario importarla nel modo seguente:
from .module1 import myfunc1
Per utilizzare la funzione myfunc3, è necessario importarla nel modo seguente:
from .subpkg.module3 import myfunc3
Vantaggi delle importazioni relative
- È facile lavorare con le importazioni relative.
- Dalla posizione attuale, le importazioni possono essere ridotte rispetto alle importazioni assolute.
Svantaggi delle importazioni relative
- Utilizzando le importazioni relative, è difficile trace tornare dove risiede il codice.
