Importa modulo in Python con esempi
Anna Blake
In quali moduli sono contenuti? Python?
Un modulo è un file con codice Python. Il codice può essere sotto forma di variabili, funzioni o classi definite. 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 come un modulo in Python. Per utilizzare il modulo, è necessario importarlo utilizzando l'importazione parola chiave. La funzione o le variabili presenti all'interno del file possono essere utilizzate in un altro file importando il modulo. Questa funzionalità è disponibile in altre lingue, come dattiloscritto, JavaScript, java, ruby, 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 di display.py importa il file moduletest.py, come mostrato di seguito:
import test
Durante l'importazione, non devi menzionare test.py ma solo il nome del file.
Passo 5) Quindi puoi chiamare la funzione display_message() da test.py all'interno di display.py, devi utilizzare 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 creerà una classe e farà riferimento alla 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 , ci sono gli attributi brand_name, model e manu_year. Le funzioni definite all'interno della classe sono car_details(), get_Car_brand(), 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 da Car.py utilizzando il modulo Car.
Utilizzo del modulo da a importare
Puoi importare solo una piccola parte del modulo, ovvero solo le funzioni richieste e i nomi delle variabili dal modulo invece di importare il codice completo.
Quando desideri importare solo elementi specifici, puoi utilizzare la parola chiave "da" per importare ciò che desideri.
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
In test.py ci sono 2 funzioni come mostrato:
Nome file: test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Ora vuoi la funzione display_message(). È possibile 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!
Ora, se ti capita di utilizzare la funzione display_message1() , verrà generato un errore indicante 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
Importa consente di importare l'intero modulo utilizzando import seguito dal nome del modulo, ovvero il nome del file o la 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 importato, per fare riferimento alle variabili e alle funzioni all'interno del modulo, è necessario prefissare il nome del modulo.
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 alla funzione 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()
Dir() è una funzione integrata in Python. Dir() restituisce tutte le proprietà e i metodi, incluse le proprietà integrate dell'oggetto specificato.
Quindi, quando dir() viene utilizzato sul modulo, ti fornirà le variabili, le funzioni presenti all'interno del modulo.
Ecco un esempio funzionante di dir() su un modulo. Abbiamo una classe chiamata Car.py, importiamo Car e assegniamo 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 json modulo come mostrato nell'esempio seguente. Verranno visualizzate tutte le proprietà e i metodi disponibili in 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']
Pack
Un pacchetto è una directory con tutti i moduli definiti al suo interno. Per fare a Python l'interprete lo tratta come un pacchetto, la tua directory dovrebbe avere il file init.py. init.py rende la directory come un pacchetto. Ecco il layout del pacchetto su cui lavoreremo.
Il nome del pacchetto è il mio pacco. Per iniziare a lavorare con il pacchetto, crea una directory chiamata package/. All'interno della 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")
Le pacchettoÈ pronto per l'uso. Ora chiama il pacchetto all'interno di uno qualsiasi dei tuoi file come mostrato di seguito:test.py:
Qui, mypackage.module1 viene importato e gli viene assegnato un nome alias come mod1. Allo stesso modo, puoi utilizzare altri moduli module2.py e module3.py dal mio pacchetto.
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 dimostrato il pacchetto con un semplice modulo con funzioni al suo interno. Secondo il tuo progetto, puoi anche creare pacchetti con sottopacchetti. Sottocartelle/con moduli con classi definite.
Python Percorso di ricerca del modulo
Durante l'esecuzione, quando si incontra Python nome del modulo di importazione, l'interprete tenta di individuare il modulo. Cerca il modulo nell'elenco dei moduli integrati. Later in tutto, le directory definite all'interno di 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
Puoi ottenere i dettagli di sys.path importando il modulo sys e stampando sys.path. Ti darà 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
Puoi anche convertire il nome del modulo in una forma più breve assegnandogli un nome alias. L'alias può essere creato utilizzando la 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 utilizzerà 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 . Quindi è possibile fare riferimento alla funzione e alle variabili di test.py 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 è il mio progetto/. Ha due sottocartelle pacchetto1 e pacchetto2.
La cartella package1 ha 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 modulo1.py c'è una funzione chiamata miafunzione1.
- Nel module2.py c'è una funzione chiamata myfunc2.
- Nel module3.py c'è una funzione chiamata myfunc3.
- Nel module4.py c'è una funzione chiamata myfunc4.
Utilizzo delle importazioni assolute
Per le importazioni assolute, devi aggiungere l'intero percorso 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 lavorare con la funzionemyfunc1, dovrai importare come segue:
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
Per lavorare con la funzione myfunc3 dovrai importare come segue:
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 rintracciare i moduli per il controllo del codice.
- Facile da usare e molto diretto.
- Se il progetto viene spostato su un percorso diverso, le importazioni rimarranno le stesse.
Svantaggi dell'utilizzo delle importazioni assolute
Ecco gli svantaggi dell'utilizzo delle importazioni assolute:
svantaggi:
- Il percorso di importazione può diventare molto lungo nel caso in cui i moduli siano nidificati e se il nome dei moduli è lungo.
Utilizzo delle importazioni relative
Considerando la stessa struttura di cartelle menzionata in seguito, vedremo come importare le stesse utilizzando i relativi import.
Nell'importazione relativa, il modulo da importare è relativo alla posizione corrente, ovvero la posizione in cui è presente l'istruzione di importazione.
Sintassi
Nelle importazioni relative, è necessario aggiungere un punto (.) prima del nome del modulo durante l'importazione utilizzando da.
Ci saranno 2 punti (..) prima del nome del modulo se il modulo si trova al livello superiore rispetto alla posizione corrente.
Facendo riferimento alla figura della struttura delle cartelle menzionata sopra, abbiamo i seguenti moduli con le loro funzioni, a cui dobbiamo fare riferimento.
- Nel modulo1.py c'è una funzione chiamata miafunzione1.
- Nel module2.py c'è una funzione chiamata myfunc2.
- Nel module3.py c'è una funzione chiamata myfunc3.
- Nel module4.py c'è una funzione chiamata myfunc4.
Per lavorare con la funzionemyfunc1 dovrai importare come segue:
from .module1 import myfunc1
Per lavorare con la funzione myfunc3, dovrai importare come segue:
from .subpkg.module3 import myfunc3
Vantaggi delle importazioni relative
vantaggi:
- È facile lavorare con le importazioni relative.
- Dalla posizione attuale, le importazioni possono essere ridotte rispetto alle importazioni assolute.
Svantaggi delle importazioni relative
svantaggi:
- Utilizzando le importazioni relative, è difficile risalire a dove risiede il codice
Sommario
- Importa in Python ti aiuta a fare riferimento al codice, ovvero a .functions/objects che sono scritti in un altro file. Viene anche usato per importare librerie/pacchetti python che sono installati usando pip(python package manager), e che devi poi usare nel tuo codice.
- La funzionalità di importazione è disponibile in altre lingue come dattiloscritto, JavaScript, java, ruby, ecc.
- Un modulo Python è il codice scritto all'interno del file, ad esempio (test.py). All'interno del tuo file puoi definire le tue variabili, funzioni o la tua classe. L'intero file diventa un modulo e può essere importato all'interno di un altro file per fare riferimento al codice.
- Con la funzionalità del modulo, puoi suddividere il codice in file diversi invece di scrivere tutto in un unico file. Later, utilizzando import, puoi fare riferimento al codice all'interno del file che ti serve.
- Python ha i suoi moduli integrati e anche librerie/pacchetti esterni installati utilizzando a gestore di pacchetti Python (pip), ad esempio panda, NumPy, ecc. sono indicati come moduli.
- È possibile importare solo una piccola parte del modulo, ovvero solo le funzioni richieste e i nomi delle variabili dal modulo invece di importare il codice completo.
- Puoi anche convertire il nome del modulo in una forma più breve assegnandogli un nome alias. L'alias può essere creato utilizzando la parola chiave.
- Un pacchetto è una directory con tutti i moduli definiti al suo interno. Per fare a Python l'interprete lo tratta come un pacchetto, la tua directory dovrebbe avere il __init.pyfile. init.py rende la directory come un pacchetto. Ecco il layout del pacchetto su cui lavoreremo.
- Durante l'esecuzione, quando si incontra Python nome del modulo di importazione, l'interprete tenta di individuare il modulo. Cerca il modulo nell'elenco dei moduli integrati. Later in tutto, le directory definite all'interno di sys.path.
- Per le importazioni assolute, devi aggiungere l'intero percorso del modulo direttamente dalla cartella principale del progetto.
- Nell'importazione relativa, il modulo da importare è relativo alla posizione corrente, ovvero la posizione in cui è presente l'istruzione di importazione.
