Differenza tra "import X" e "da X import *"?

Question

In Python, io non sono davvero chiare sulla differenza tra le seguenti due righe di codice:

import X 

o

from X import * 

Non che sia solo importare tutto dal modulo X? Qual è la differenza?

Answer 1

Dopo import x, è possibile fare riferimento a cose in x come x.something. Dopo from x import *, è possibile fare riferimento a cose in x direttamente come something. Poiché il secondo modulo importa i nomi direttamente nello spazio dei nomi locale, crea il potenziale per i conflitti se importi da molti moduli. Pertanto, lo from x import * è sconsigliato.

È inoltre possibile eseguire from x import something, che importa solo lo something nello spazio dei nomi locale, non tutto in x. Questo è meglio perché se si elencano i nomi che si importano, si sa esattamente cosa si sta importando ed è più facile evitare conflitti di nomi.

Answer 2

import X 

Crea un'etichetta nello spazio dei nomi locale che fa riferimento all'oggetto modulo.

from X import * 

Crea un'etichetta per ogni attributo membro del modulo X, direttamente nel namespace locale.

Entrambe le operazioni aggiungono X a sys.modules, vero, ma l'effetto sul namespace locale è la differenza.

Answer 3

import X: questo importa tutto come X.var1, X.var2, ecc

from X import *: questo importa everthing come var1, var2 ecc, vale a dire che inonda lo spazio dei nomi locale

vedere la differenza dopo due chiamate:

>>> import math 
>>> len(globals()) 
5       #no of variables in namespace 
>>> globals() 
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'math': <module 'math' from '/usr/local/lib/python2.7/lib-dynload/math.so'>, '__package__': None} 
>>> 
>>> 
>>> from math import * 
>>> len(globals()) 
47      #no of variables in namespace 
>>> globals() 
{'pow': <built-in function pow>, 'fsum': <built-in function fsum>, 'cosh': <built-in function cosh>, 'ldexp': <built-in function ldexp>, 'hypot': <built-in function hypot>, 'acosh': <built-in function acosh>, 'tan': <built-in function tan>, 'asin': <built-in function asin>, 'isnan': <built-in function isnan>, 'log': <built-in function log>, 'fabs': <built-in function fabs>, 'floor': <built-in function floor>, 'atanh': <built-in function atanh>, 'sqrt': <built-in function sqrt>, '__package__': None, 'frexp': <built-in function frexp>, 'factorial': <built-in function factorial>, 'degrees': <built-in function degrees>, 'pi': 3.141592653589793, 'log10': <built-in function log10>, '__doc__': None, 'math': <module 'math' from '/usr/local/lib/python2.7/lib-dynload/math.so'>, 'asinh': <built-in function asinh>, 'fmod': <built-in function fmod>, 'atan': <built-in function atan>, '__builtins__': <module '__builtin__' (built-in)>, 'copysign': <built-in function copysign>, 'cos': <built-in function cos>, 'ceil': <built-in function ceil>, 'atan2': <built-in function atan2>, 'isinf': <built-in function isinf>, 'sinh': <built-in function sinh>, '__name__': '__main__', 'trunc': <built-in function trunc>, 'expm1': <built-in function expm1>, 'e': 2.718281828459045, 'tanh': <built-in function tanh>, 'radians': <built-in function radians>, 'sin': <built-in function sin>, 'lgamma': <built-in function lgamma>, 'erf': <built-in function erf>, 'erfc': <built-in function erfc>, 'modf': <built-in function modf>, 'exp': <built-in function exp>, 'acos': <built-in function acos>, 'log1p': <built-in function log1p>, 'gamma': <built-in function gamma>} 

Answer 4

Ci sono differenze, alcune semplici, altre che richiedono maggiori spiegazioni.

import X importa solo l'intero modulo (leggi: "esegue il modulo") e assegna un nome all'ambito locale. Il nome può essere alias in questo modo: import X as Y

from X import * importa tutto il attributi del modulo X in ambito locale, per impostazione predefinita. Ecco un esempio di utilizzo differenti:

# Assume that module `X` contains an `opendb` function 
import X 
X.opendb('Y') 

# VS. 
from X import * 
opendb('Y') 

Dove diventa leggermente più complicato è quando un modulo definisce __all__. Ciò cambia la semantica di from X import * per indicare "importa tutto elencato nello__all__proprietà." Ciò consente agli scrittori di moduli di avere il controllo su quali funzioni e oggetti vengono esportati dal loro modulo.

Answer 5

from X import * importa tutti gli elementi dal modulo X nello spazio dei nomi corrente. import X importa X ma non "unisce" gli spazi dei nomi. Es .:

Modulo X:

def foo(): pass 
BAR = 12 

tuo codice:

from X import * 
foo() # calls X.foo 
print BAR # prints 12 

Oppure:

import X 
X.foo() 
print X.BAR 

Answer 6

Usiamo questo come un esempio della nostra definizione del modulo

def my_func(): 
    return 1 

il dall'importazione tirerà tutto nel namespace corrente

from X import * 
print my_func() 

l'importazione normale creerà un oggetto modulo chiamato X nello spazio dei nomi corrente

import X 
print x.my_func() 

in più con da X importazione my_func può essere usato per importare solo quella funzionalità.

Answer 7

Si dovrebbe mai utilizzare from X import * a meno che non si sappia davvero cosa si sta facendo. Puoi ottenere simboli dal modulo X in conflitto con i simboli di un altro modulo o persino con il tuo programma. L'unica eccezione che ho a questa regola è a volte from math import *.

È possibile utilizzare il modulo from X import y per ottenere una singola cosa da un modulo.

Se si utilizza il modulo import X, non solo si fa a fare l'uso del modulo esplicito X.y ma ora è possibile utilizzare la funzione di reload se si apportano modifiche al modulo e la necessità di reimportarla.