Come funziona l'importazione. Perché i moduli importati non ereditano altri moduli importati

Question

Ho solo "pensato" Ho capito come funzionano i moduli e l'importazione, ma ovviamente ho bisogno di più istruzione.

Ecco un esempio di programma (solo un caso di test di somerthing sto facendo che è molto più grande nella portata e le dimensioni) e un modulo:

quick.py

import gtk 
from quick_window import * 

w.show_all() 
gtk.main() 

quick_window.py

w = gtk.Window() 
w.connect('destroy', lambda w: gtk.main_quit()) 
l=gtk.Label('Hello') 
w.add(l) 

esecuzione ottengo

$ python quick.py 
Traceback (most recent call last): 
    File "quick.py", line 2, in <module> 
    from quick_window import * 
    File "/home/woodnt/Dropbox/python/weather_project/plugins/quick_window.py", line 3, in <module> 
    w = gtk.Window() 
NameError: name 'gtk' is not defined 

Per farlo funzionare, devo importare anche (er, reimportare) gtk nel modulo in questo modo:

import gtk 

w = gtk.Window() 
w.connect('destroy', lambda w: gtk.main_quit()) 
l=gtk.Label('Hello') 
w.add(l) 

Perché dovrei avere importare gtk più di una volta? Significa che ho 2 "gtk" in memoria?

Devo importare tutto all'interno di ciascun modulo di cui ho bisogno all'interno di quel modulo?

So che ogni modulo ha il proprio spazio dei nomi, ma ho pensato che ereditasse anche i "globali" incluso il modulo importato dal programma chiamante.

Ho avuto l'impressione che l'importazione del modulo * sia come tagliare e incollare il codice direttamente in quella posizione. C'è un altro modo per farlo?

L'aiuto è molto apprezzato.

Narnie

Answer 1

I dettagli dell'importazione diventano molto complicati, ma concettualmente è molto semplice.

quando si scrive:

import some_module 

È equivalente a questo:

some_module = import_module("some_module") 

dove import_module è un po 'come:

def import_module(modname): 
    if modname in sys.modules: 
     module = sys.modules[modname] 
    else: 
     filename = find_file_for_module(modname) 
     python_code = open(filename).read() 
     module = create_module_from_code(python_code) 
     sys.modules[modname] = module 
    return module 

Due cose da notare qui: l'assegnazione di some_module è specifico: una dichiarazione di importazione non fa davvero nulla nel modulo corrente tranne assegnare un modulo obje ct al nome specificato.Ecco perché non ottieni automaticamente i nomi dal modulo importato e perché non è come copiare il codice importato nel modulo corrente.

Inoltre, nella pseudo-funzione import_module, se il nome è già stato importato da qualche parte, si troverà nell'elenco globale di tutti i moduli (sys.modules), quindi verrà semplicemente riutilizzato. Il file non verrà più aperto, non verrà eseguito di nuovo, i globali in quei moduli non otterranno nuovi valori, e così via. Importare lo stesso modulo in molti posti non è uno spreco o un lavoro extra, è molto veloce.

Answer 2

importazione è necessaria per portare il contenuto del file py nello spazio dei nomi di quel modulo - se non si importa, i nomi non è possibile fare riferimento.

qualche informazione in più: http://effbot.org/zone/import-confusion.htm

Quando Python importa un modulo, prima controlla il Registro di modulo (sys.modules) per vedere se il modulo è già importato. In questo caso, Python utilizza l'oggetto modulo esistente così com'è.