 |
 |
 |
Il manuale di riferimento di Python |  |
 |
 |
|
|
|
Il manuale di riferimento di Python | |
|
|
import_stmt |
::= | "import" module ["as" name]
( "," module ["as" name] )* |
| "from" module "import" identifier
["as" name] | ||
( "," identifier ["as" name] )* | ||
| "from" module "import" "*" | ||
module |
::= | (identifier ".")* identifier |
Le istruzioni import vengono eseguite in due passi: (1) cercare un modulo, ed inizializzarlo se necessario; (2) definire un nome o nomi nello spazio dei nomi locale (nel medesimo ambito di visibilità in cui viene eseguita l'istruzione import). La prima forma (senza from) ripete questi passi per ogni identificatore nella lista. La forma con from) svolge il passo (1) una volta e quindi svolge ripetutamente il passo 2.
In questo contesto, per ``inizializzare'' una built-in, un modulo estensione significa chiamare una funzione di inizializzazione che deve essere fornita dal modulo per l'uso (nelle implementazioni di riferimento, il nome della funzione è ottenuto antecedendo la stringa ``init'' al nome del modulo); per ``inizializzare'' un modulo codificato Python significa eseguire il corpo del modulo.
Il sistema mantiene una tavola dei moduli che sono stati o saranno
inizializzati, indicizzandoli per nome. Questa tavola è accessibile
come sys.modules. Quando il nome di un modulo viene trovato in
questa tavola, il passo (1) è finito. Altrimenti, inizia la ricerca
per la definizione di un modulo. Quando un modulo è stato trovato,
viene caricato. Dettagli della ricerca di moduli e dei processi di
caricamento sono implementazioni specifiche delle diverse
piattaforme. Questo di solito comporta la ricerca per un modulo
``built-in'' con un dato nome e quindi la ricerca di una lista di
posizione data come sys.path.
Se viene trovato un modulo built-in, il suo codice di inizializzazione built-in viene eseguito ed il passo (1) è terminato. Se non ci sono file che hanno corrispondenze, viene sollevata un'eccezione ImportError. Se viene trovato un file, viene analizzato, restituendo un blocco di codice eseguibile. Se avviene un errore di sintassi, viene sollevata un'eccezione SyntaxError. Altrimenti, viene creato un modulo vuoto con un dato nome ed inserito nella tavola dei moduli, e quindi viene eseguito il blocco di codice nel contesto di questo modulo. Eccezioni durante questa esecuzione terminano il passo (1).
Quando il passo (1) finisce senza avere sollevato eccezioni, il passo (2) può iniziare.
La prima forma dell'istruzione import collega il nome del modulo nello spazio dei nomi locale all'oggetto modulo, e quindi va ad importare il prossimo identificatore, se c'è nè qualcuno. Se il nome del modulo viene seguito da as, il nome successivo ad as viene usato come spazio dei nomi locale per il modulo.
La forma from non collega il nome del modulo: attraversa la lista degli identificatori, guarda in ognuno di loro con riguardo al modulo trovato al passo (1) e collega il nome allo spazio dei nomi locale all'oggetto così trovato. Come con la prima forma di import, un nome locale alternativo può essere fornito specificndo "as nome locale". Se un nome non viene riscontrato, viene sollevata un'eccezione ImportError. Se la lista degli identificatori viene sostituita da una stella ("*"), tutti i nomi pubblici definiti nel modulo vengono legati allo spazio dei nomi locale dell'istruzione import.
I nomi pubblici definiti da un modulo vengono determinati dalla
ricerca nello spazio dei nomi dei moduli per una variabile chiamata
__all__; se definita, deve essere una sequenza di stringhe che
rappresentano nomi definiti o importati da quel modulo. I nomi dati
in __all__ vengono considerati pubblici e sono necessari perché
esistano. Se __all__ non viene definito, la gamma dei nomi
pubblici include tutti i nomi trovati nello spazio dei nomi del modulo
che non iniziano con un carattere di sottolineatura ("_").
__all__ dovrebbe contenere l'intera API pubblica. Questo viene
inteso per evitare l'esportazione accidentale di elementi che non sono
parte dell'API (come moduli della libreria che erano stati importati e
usati senza il modulo).
La forma from con "*" può solo trovarsi nell'ambito di visibilità del modulo. Se la forma di import col carattere jolly -- "import *" -- viene usata in una funzione e la funzione contiene o è un blocco annidato con variabili libere, il compilatore solleverà un'eccezione SyntaxError.
Nomi dei moduli gerarchici: quando il nome dei moduli
contiene uno o più punti, il percorso di ricerca del modulo viene
effettuato differentemente. La sequenza di identificatori sopra
l'ultimo punto viene usata per trovare un
``package''; l'identificatore finale viene quindi
cercato all'interno del package. Un package è generalmente una
sottodirectory di una directory su sys.path che ha un file
__init__.py..
[XXX Non può si può parlare di questo ora: vedere l'URL
http://www.python.org/doc/essays/packages.html per maggiori
dettagli, anche su come la ricerca dei moduli lavora dall'interno di
un package.]
La funzione built-in __import__() viene fornita per supportare applicazioni che determinano quali moduli necessitano di essere caricati dinamicamente; riferirsi a Funzioni built-in nel La libreria di riferimento di Python per ulteriori informazioni.
|
|
|
Il manuale di riferimento di Python | |
|
|