Importazione di Python da una directory principale: una guida rapida

Ti sei mai trovato immerso fino alle ginocchia nei file Python, lottando per importare un modulo da una directory principale? Se è così, sei in buona compagnia. Il sistema di importazione di Python a volte può sembrare un labirinto tortuoso, ma non preoccuparti, siamo qui per aiutarti a navigare!

Per importare da una directory principale in Python, puoi utilizzare il modulo sys . Inserendo la directory richiesta nell'elenco sys.path, si fornisce all'interprete la posizione del modulo desiderato. Dopo aver modificato sys.path, è possibile importare il modulo di destinazione utilizzando l'istruzione di importazione standard.

In questo articolo, esploreremo come importare dalle directory principali in Python. Inoltre, esamineremo casi d'uso specifici di importazione che ti aiuteranno a comprendere meglio la struttura sottostante delle directory.

Entriamo in esso!

Sommario

• Come importare in Python
  • Cos'è il sistema di importazione Python?
  • Dimostrazione dell'importazione dalla directory padre
    • 1. Creazione delle directory e dei file necessari
    • 2. Aggiunta di file Python
    • 3. Modifica dei file Python
    • 4. Esecuzione del codice
  • Come gestire ImportError e ModuleNotFoundError in Python
• Struttura della directory Python
  • Struttura del pacchetto
  • Cosa sono i file init.py?
• Percorso di ricerca Python
  • 1. Cos'è l'elenco sys.path in Python?
  • 2. Cosa sono le variabili d'ambiente PythonPath?
• Importazioni della directory padre
  • 1. Importazioni relative
  • 2. Regolazione di sys.path
• Come lavorare con moduli e pacchetti
  • 1. Cosa sono gli spazi dei nomi?
  • 2. Cosa sono le variabili e le definizioni?
  • 3. Cosa sono le dichiarazioni di importazione?
• Pensieri finali

Come importare in Python

Passeremo direttamente all'argomento di oggi: l'importazione in Python. Quelle semplici righe di codice all'inizio dei tuoi script Python che spesso iniziano con import o from ? Questi sono il tuo biglietto per sfruttare la potenza delle vaste librerie e moduli di Python.

In questa sezione, esamineremo il codice per l'importazione dalla directory padre in Python. Esamineremo anche potenziali errori che possono verificarsi durante l'importazione di moduli dalla directory principale.

Cos'è il sistema di importazione Python?

Il sistema di importazione Python consente un efficiente riutilizzo e organizzazione del codice. Semplifica la gestione di progetti complessi.

Per importare un modulo o un pacchetto in Python, puoi utilizzare l' istruzione import . I moduli sono distribuiti come pacchetti, che sono directory con una raccolta di file Python.

Per importare un modulo dalla directory padre, puoi utilizzare il modulo sys.path per aggiungere la directory padre al percorso di Python. Dopo aver aggiunto la directory principale, puoi importare il modulo utilizzando l' istruzione import .

Dimostrazione dell'importazione dalla directory padre

Per darti una chiara dimostrazione dell'importazione dalla directory principale, esaminiamo una serie di passaggi per aiutarti a comprendere l'intero processo.

1. Creazione delle directory e dei file necessari

Innanzitutto, apri Esplora file e vai all'unità locale desiderata. Sto usando la mia unità E locale, quindi creerò una nuova directory chiamata my_project .

All'interno di my_project , crea un'altra directory denominata module_dir .

Quindi, ora dovresti avere:

E:
|-- /my_project
    |-- /module_dir

2. Aggiunta di file Python

Successivamente, crea un nuovo file .py denominato main.py nella directory my_project .

Successivamente, crea un altro file Python chiamato my_module.py in module_dir .

La tua struttura dovrebbe ora assomigliare a questa:

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

Se utilizzi Visual Studio Code , la struttura della tua directory dovrebbe essere simile alla seguente:

3. Modifica dei file Python

Apri il tuo my_module.py e aggiungi il seguente codice:

def my_function():
    print("Hello from my_module!")

Quindi vai avanti e salva e chiudi il file.

Ora apri main.py e aggiungi il seguente codice:

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import the module from the parent directory
from module_dir import my_module

# Use a function from my_module
my_module.my_function()

In questo script, per prima cosa cerchiamo di capire la posizione della directory un livello superiore rispetto allo script che stiamo eseguendo (che è la directory padre). Quindi, stiamo dicendo a Python di guardare anche in questa cartella principale quando ha bisogno di importare moduli.

Dopo averlo fatto, stiamo importando un modulo chiamato my_module che si trova all'interno di una directory chiamata module_dir situata in questa directory principale. Infine, chiamiamo una funzione denominata my_function da my_module .

Dopo aver aggiunto il codice sopra, salva e chiudi il file.

4. Esecuzione del codice

Per eseguire questo codice, apri il terminale dell'editor di codice desiderato ed esegui il file main.py. Se utilizzi Visual Studio Code, l'output dovrebbe essere simile al seguente:

main.py importerà la funzione da my_module.py , come mostrato nell'immagine sopra.

Questo esempio mostra in dettaglio come funziona il file system e l'importazione dalla directory principale in Python.

Come gestire ImportError e ModuleNotFoundError in Python

Python solleverà un'eccezione ImportError quando il modulo che stai tentando di importare non viene trovato durante il processo di importazione.

ImportError è una sottoclasse dell'eccezione ModuleNotFoundError . Viene generato quando il modulo importato non esiste o non può essere caricato.

Di seguito sono riportati esempi di scenari in cui possono verificarsi:

• Il modulo o il pacchetto non si trova in sys.path .

• Il nome del modulo o del pacchetto è errato o non esiste.

• C'è un problema con il codice del modulo, che ne impedisce l'importazione corretta.

Quando si verificano questi errori, è possibile utilizzare le seguenti soluzioni:

• Doppio controllo dell'ortografia e dell'esistenza del modulo o del pacchetto.

• Aggiunta della directory necessaria a sys.path utilizzando append() o insert() .

• Risoluzione di eventuali problemi nel codice del modulo che potrebbero ostacolarne l'importazione.

Per ulteriori informazioni sulla gestione degli errori in Python, guarda il seguente video:

Dopo aver compreso come funziona l'importazione in Python, è anche importante acquisire familiarità con la struttura delle directory di Python.

La struttura della directory e l'importazione vanno di pari passo poiché l'importazione richiede una comprensione della struttura della directory, quindi esaminiamola nella sezione successiva.

Struttura della directory Python

Comprendere la struttura delle directory di Python è molto più che sapere dove mettere i tuoi script o dove trovare la libreria che hai appena installato.

È come avere una scrivania pulita e ben organizzata: saprai esattamente dove si trova ogni cosa e la tua produttività salirà alle stelle, quindi esaminiamo le nozioni di base in questa sezione.

Struttura del pacchetto

La struttura delle directory di un progetto Python è essenziale per una corretta organizzazione. Se strutturi correttamente il tuo pacchetto, ti aiuterà a ridurre al minimo la possibilità di conflitti di denominazione. Inoltre, ti consentirà anche di navigare facilmente attraverso il tuo filesystem.

Quella che segue è una tipica struttura di directory del progetto Python:

project/
?
??? package1/
?   ??? __init__.py
?   ??? module1.py
?   ??? module2.py
?
??? package2/
?   ??? __init__.py
?   ??? module3.py
?   ??? module4.py
?
??? main.py

Nell'esempio precedente, project è la directory radice contenente due pacchetti secondari, package1 e package2 . Ogni pacchetto ha i suoi file .py e un file init.py univoco.

Cosa sono i file init.py?

I file init.py sono importanti per definire il comportamento del pacchetto quando viene importato. Questi file vengono eseguiti quando viene importato il loro pacchetto principale.

I file init.py possono essere vuoti o contenere codice di inizializzazione. Indicano anche a Python che la cartella deve essere trattata come un pacchetto.

Per importare un modulo da una directory principale, puoi utilizzare il metodo sys.path . Dovrai aggiungere il percorso della directory padre a sys.path .

Per dimostrarlo, costruiamo sul nostro esempio precedente. Avevamo la seguente struttura di directory:

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

Ora aggiungiamo il file init.py alla directory my_module . Puoi lasciare questo file vuoto per ora. La sua presenza indica a Python che questa directory dovrebbe essere trattata come un pacchetto.

La tua struttura di directory dovrebbe ora essere simile alla seguente:

Dopo aver aggiunto il file init.py , devi apportare modifiche al tuo file main.py per istruirlo a trattare la cartella module_dir come un pacchetto. Il tuo file main.py ora dovrebbe avere il seguente codice:

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import my_module from the package module_dir
import module_dir

# Call my_function from my_module
my_module.my_function()

In questo esempio, main.py importa il pacchetto module_dir , quindi chiama la funzione my_function() da my_module all'interno di quel pacchetto.

Notare il cambiamento nella chiamata a my_function ; poiché ora trattiamo module_dir come un pacchetto, dobbiamo includere il nome del pacchetto quando chiamiamo le funzioni dai moduli all'interno del pacchetto.

The output will be similar to the previous one. The only change we made was to treat module_dir as a package with the inclusion of init.py file.

Python Search Path

Ever wondered how Python knows where to find the modules you’re trying to import? Or maybe you’ve encountered an annoying ‘ModuleNotFoundError’ and couldn’t figure out why?

In this section, we’re going to tackle these mysteries head-on and delve into the concept of the Python search path.

The Python search path, also known as sys.path, is Python’s little roadmap to finding all the modules you need. Like a diligent scout, Python uses this path to scour your computer for modules whenever you use the import statement.

Understanding how it works can save you from headaches and help you troubleshoot when things go awry, so let’s go over some basics!

1. What is the sys.path List in Python?

The sys.path list is a crucial component when importing modules in a directory. It’s a list of strings that represents the module search path.

Each string in the list is a directory location where Python looks for modules (*.py files) or packages (folders containing init.py files).

The following example shows you how to view your current sys.path list:

import sys

for path in sys.path:
    print(path)

After running the above code, you’ll see an output like the following:

You can also add new directories to the sys.path list so that Python finds your custom modules.

For instance:

import sys
sys.path.append('/path/to/new/module/directory')

2. What are PythonPath Environment Variables?

Another way you can manage the module search path is by using the PYTHONPATH environment variable.

PYTHON PATH is a string containing a list of directories that is appended to the default sys.path list. This means you can add directories to PYTHONPATH. This allows Python to search for modules in those directories when importing.

Setting the PYTHONPATH environment variable depends on your operating system:

• Unix-based systems (Linux, macOS): You can use the export command in your terminal or add the following line to your shell configuration file (.bashrc, .zshrc or similar):

  export PYTHONPATH="/path/to/module/directory1:/path/to/module/directory2"

• Windows OS: Go to System Properties > Environment Variables, and under User variables, click New to create a new variable with the name: “PYTHONPATH” and the value as a list of directory paths separated by a semi-colon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Once the path variable is set, you can run your Python script. It will search for imported modules in those directories as well as the default ones in sys.path.

When organizing your code into files and folders, you’ll frequently come across relative imports and adjusting sys.path.

In the next section, we’ll explore both and see how they fit into the framework for Python imports.

Parent Directory Imports

You can organize code into different folders and files to improve both readability and maintainability. However, importing modules from parent directories can be a bit tricky.

In this section, we’ll discuss two approaches to achieve this:

1. Relative Imports

2. Adjusting sys.path

1. Relative Imports

Relative imports allow you to import modules based on their relative position in the directory hierarchy.

You can use the dot (.) notation to refer to the current directory or double dot (..) notation to refer to the parent directory.

Suppose you have a directory structure like the following:

parent_directory/
?
??? module_a.py
?
??? sibling_directory/
    ??? module_b.py

Inside module_b.py, you can use relative imports to access module_a.py:

from .. import module_a

The double dot refers to the parent directory. It is important to note that relative imports only work if the parent directory is a package (has an init.py file).

2. Adjusting sys.path

You can also import modules from a parent directory by modifying the sys.path.

Prima dell'istruzione import , puoi aggiungere il percorso della directory principale a sys.path . Innanzitutto, devi importare il modulo sys . Quindi, usi il modulo os per ottenere il percorso della directory principale.

Supponiamo di avere una struttura di directory come la seguente:

project_root/
?
??? parent_directory/
?   ??? module_a.py
?
??? current_directory/
    ??? module_b.py

In module_b.py , puoi aggiungere il percorso della directory principale a sys.path in questo modo:

import os
import sys

parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)

import module_a

Ora, Python cercherà module_a.py nella directory principale durante l'importazione in module_b.py .

È possibile utilizzare l'approccio di importazione relativa o l' approccio sys.path per importare i moduli da una directory padre.

Come lavorare con moduli e pacchetti

In Python, moduli e pacchetti sono un modo per organizzare e riutilizzare il codice. Puoi usarli per suddividere progetti complessi in parti gestibili.

Questa sezione discuterà come lavorare con moduli e pacchetti in Python . Includeremo anche concetti chiave come:

1. Spazi dei nomi

2. Variabili e definizioni

3. Dichiarazioni di importazione

1. Cosa sono gli spazi dei nomi?

Gli spazi dei nomi in Python sono un modo per garantire che i nomi di variabili, funzioni e classi non siano in conflitto tra moduli diversi.

Ci sono diversi livelli di spazi dei nomi in Python, come ad esempio:

• Global Namespace: si riferisce allo spazio dei nomi dell'intero modulo.

• Spazio dei nomi locale: si riferisce allo spazio dei nomi all'interno di una funzione o di una classe.

È possibile ottenere un nome in un particolare spazio dei nomi con la notazione spazio dei nomi[nome] .

2. Cosa sono le variabili e le definizioni?

In uno script Python, puoi definire variabili, funzioni e classi. Queste definizioni sono memorizzate nello spazio dei nomi dello script.

Importando lo script come pacchetto, puoi accedere e riutilizzare le sue definizioni in altre parti del tuo progetto.

Di seguito è riportato un esempio di come definire una variabile e una funzione nello stesso spazio dei nomi:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Questo modulo ha una variabile my_variable e una funzione my_function .

Per eseguire questo codice, puoi creare un nuovo file chiamato my_variable.py e inserire il codice come mostrato di seguito:

Ora puoi importare questo file e usarlo in un altro script come mostrato di seguito:

Dopo aver eseguito il file main.py , otterrai un output simile al seguente:

3. Cosa sono le dichiarazioni di importazione?

Puoi importare file, moduli o pacchetti in Python con l' istruzione import

Alcuni metodi di importazione comuni sono:

• import module_name : questo metodo importa un modulo, rendendo tutte le sue definizioni accessibili con la notazione module_name.definition_name .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : questo metodo importa una definizione specifica da un modulo, permettendoti di usarla direttamente senza il prefisso del modulo.

from mymodule import my_function

result = my_function(3)

• from module_name import * : questo metodo importa tutte le definizioni da un modulo, ma non è consigliato in quanto può portare a conflitti di denominazione.

Pensieri finali

Comprendere come importare da una directory principale in Python è importante per mantenere una base di codice organizzata.

Questa conoscenza ti consente di progettare i tuoi progetti in modo più modulare. Aumenta anche la riusabilità del tuo codice. Strutturando il codice in moduli e pacchetti separati, puoi evitare di ripetere il codice e semplificarne la manutenzione e l'aggiornamento.

L'abilità di utilizzare le istruzioni import e from è molto preziosa quando si lavora su progetti più grandi in cui le funzionalità sono suddivise in diverse directory.

Sapendo come regolare correttamente il percorso di Python per importare i moduli, puoi accedere alle funzionalità definite in una directory mentre lavori in un'altra.

Ricorda, la chiave per padroneggiare Python, o qualsiasi linguaggio di programmazione, sta nella pratica costante e in una curiosità insaziabile. Quindi, continua a esplorare, continua a sperimentare e continua a sfidare te stesso.

Con questa guida rapida, dovresti essere ben attrezzato per gestire qualsiasi puzzle di importazione che Python ti lancia. Ma non fermarti qui. C'è un intero universo di tecniche e trucchi Python che aspettano di essere scoperti!