Différence entre " import X "et" from x import*"? [dupliquer]

import X: il importe tout ce que X.var1,X.var2, etc

from X import * : il importe tout ce que var1,var2 etc, I. e il inonde l'espace de noms local

voir la différence après deux appels:

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

import X

crée une étiquette dans l'espace de noms local qui renvoie à l'objet module.

from X import *

crée une étiquette pour chaque attribut membre du X module, directement dans l'espace de noms local.

les deux opérations ajoutent Xsys.modules, c'est vrai, mais l'effet sur l'espace de noms local est la différence.

il y a des différences, certaines simples, d'autres nécessitant plus d'explications.

import X importe simplement le module entier (lire: "exécute le module"), et lui assigne un nom dans la portée locale. Le nom d'alias peuvent être attribués comme suit: import X as Y

from X import * importe tout le attributs du module X dans la portée locale, par défaut. Voici un exemple d'utilisation différents:

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

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

devient un peu plus compliqué est quand un module définit __all__. Cela modifie la sémantique de l' from X import * pour dire "tout importer qui est répertorié dans le__all__propriété."Cela permet aux rédacteurs de modules d'avoir le contrôle sur les fonctions et les objets exportés de leur module.

vous devriez jamais utiliser from X import * sauf si vous savez vraiment ce que vous faites. Vous pouvez obtenir des symboles du module X qui entrent en conflit avec des symboles d'un autre module ou même de votre propre programme. La seule exception que j'ai à cette règle est parfois from math import *.

Vous pouvez utiliser le formulaire from X import y pour obtenir une seule chose à partir d'un module.

Si vous utilisez le import X former, non seulement vous faire votre utilisation du module explicite X.y mais vous pouvez maintenant utiliser le reload fonction si vous apportez des modifications au module et avez besoin de le réimporter.

from X import * importe tous les éléments du module X dans l'espace de noms courant. import X importe X mais ne "fusionne" pas les espaces de noms. E. g.:

Module X:

def foo(): pass
BAR = 12

votre code:

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

Ou:

import X
X.foo()
print X.BAR

utilisons ceci comme exemple de notre définition de module

def my_func():
    return 1

à partir de l'importation de tirer tout en l'espace de noms courant

from X import *
print my_func()

l'import normal va créer un objet module appelé X dans l'espace de noms actuel

import X
print x.my_func()

de plus, avec l'import DE X, my_func ne peut être utilisé que pour importer cette fonctionnalité.