Diferencia entre "importar X" y "de X import *"?

Question

En Python, no estoy muy claro en la diferencia entre las siguientes dos líneas de código:

import X 

o

from X import * 

¿No se dan ambos a la importación de todo, desde el módulo X? ¿Cual es la diferencia?

Answer 1

Después de import x, puede consultar las cosas en x como x.something. Después de from x import *, puede consultar las cosas en x directamente como something. Como la segunda forma importa los nombres directamente en el espacio de nombres local, crea el potencial de conflictos si importa cosas de muchos módulos. Por lo tanto, se desaconseja el from x import *.

También puede hacer from x import something, que importa solo el something en el espacio de nombres local, no todo en x. Esto es mejor porque si enumera los nombres que importa, sabe exactamente lo que está importando y es más fácil evitar los conflictos de nombres.

Answer 2

import X 

Crea una etiqueta en el espacio de nombres local que hace referencia al objeto del módulo.

from X import * 

Crea una etiqueta para cada atributo de miembro del módulo X, directamente en el espacio de nombres local.

Ambas operaciones agregan X a sys.modules, cierto, pero el efecto en el espacio de nombres local es la diferencia.

Answer 3

import X: Esto importa todo como X.var1, X.var2, etc

from X import *: Esto importa Everthing como var1, var2 etc, es decir, que inunda el espacio de nombres local de

ver la diferencia después de dos llamadas:

>>> 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

Existen diferencias, algunas simples, otras que requieren más explicaciones.

import X acaba de importar todo el módulo (léase: "ejecuta el módulo"), y le asigna un nombre en el ámbito local. El nombre puede tener un alias de esta manera: import X as Y

from X import * importa todos los atributos de la del módulo X en el ámbito local, de manera predeterminada. Aquí está un ejemplo de uso diferentes:

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

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

Cuando esto se pone ligeramente más complicado es cuando un módulo define __all__. Esto cambia la semántica de from X import * para significar "importar todo que se enumera en la__all__propiedad." Esto permite a los escritores de módulos tener control sobre qué funciones y objetos se exportan desde su módulo.

Answer 5

from X import * importa todos los elementos del módulo X en el espacio de nombres actual. import X importa X pero no "fusiona" los espacios de nombres. Ej .:

Módulo X:

def foo(): pass 
BAR = 12 

Su código:

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

O:

import X 
X.foo() 
print X.BAR 

Answer 6

Vamos a usar esto como un ejemplo de nuestra definición de módulo

def my_func(): 
    return 1 

la de importación se tire todo en el espacio de nombres actual

from X import * 
print my_func() 

la importación normales creará un objeto de módulo llamado X en el espacio de nombres actual

import X 
print x.my_func() 

además con entre X mi_func importación puede ser solía importar solo esa funcionalidad.

Answer 7

Usted debe nunca use from X import * a menos que realmente sepa lo que está haciendo. Puede obtener símbolos del módulo X que entren en conflicto con símbolos de otro módulo o incluso de su propio programa. La única excepción que tengo a esa regla es a veces from math import *.

Puede usar el formulario from X import y para obtener una sola cosa de un módulo.

Si utiliza la forma import X, no sólo hacer que su uso del módulo explícita X.y pero ahora se puede utilizar la función de reload si se realizan cambios en el módulo y la necesidad de volver a importar ella.