"आयात एक्स" और "एक्स आयात * से" के बीच अंतर?

Question

अजगर में, मैं कोड की निम्न दो पंक्तियों के बीच अंतर पर वास्तव में स्पष्ट नहीं कर रहा हूँ:

import X 

या

from X import * 

वे दोनों सिर्फ मॉड्यूल एक्स से सब कुछ आयात नहीं करते हैं? क्या फर्क पड़ता है?

Answer 1

import x के बाद, आप xजैसे x में चीजों का उल्लेख कर सकते हैं। from x import * के बाद, आप सीधे something के रूप में x में चीजों को संदर्भित कर सकते हैं। चूंकि दूसरा फॉर्म सीधे नामों को स्थानीय नामस्थान में आयात करता है, इसलिए यदि आप कई मॉड्यूल से चीजें आयात करते हैं तो यह संघर्षों की संभावना बनाता है। इसलिए, from x import * निराश है।

आप from x import something भी कर सकते हैं, जो स्थानीय नामस्थान में something आयात करता है, एक्स में सबकुछ नहीं। यह बेहतर है क्योंकि यदि आप आयात किए गए नामों को सूचीबद्ध करते हैं, तो आप जानते हैं कि आप वास्तव में क्या आयात कर रहे हैं और नाम विवादों से बचना आसान है।

Answer 2

import X 

स्थानीय नामस्थान में एक लेबल बनाता है जो मॉड्यूल ऑब्जेक्ट का संदर्भ देता है।

from X import * 

X मॉड्यूल के हर सदस्य विशेषता के लिए एक लेबल बनाता है, स्थानीय नाम स्थान में सीधे।

दोनों ऑपरेशंस Xsys.modules पर सत्य जोड़ते हैं, लेकिन स्थानीय नामस्थान पर प्रभाव अंतर है।

Answer 3

import X: इस आयात करता है सब कुछ X.var1, X.var2, के रूप में आदि

from X import *: इस आयात var1, var2 के रूप में प्रत्येक भाग को आदि, यानी यह स्थानीय नाम स्थान

दो कॉल के बाद अंतर देखना बाढ़:

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

मतभेद हैं, कुछ सरल हैं, दूसरों को और स्पष्टीकरण की आवश्यकता है।

import X बस पूरे मॉड्यूल को आयात करता है (पढ़ें: "मॉड्यूल चलाता है"), और इसे स्थानीय दायरे में एक नाम असाइन करता है। नाम तो जैसे एलियास जा सकता है: import X as Y

from X import *, के सभी गुण स्थानीय गुंजाइश में मॉड्यूल X की आयात करता है डिफ़ॉल्ट रूप से।

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

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

जहां इस थोड़ा और अधिक जटिल हो जाता है जब एक मॉड्यूल __all__ को परिभाषित करता है: यहां विभिन्न उपयोग का एक उदाहरण है। यह from X import * के अर्थशास्त्र को बदलता है जिसका मतलब है "आयात करें जो__all__संपत्ति में सूचीबद्ध है।" यह मॉड्यूल लेखकों को नियंत्रण रखने की अनुमति देता है कि कौन से कार्यों और वस्तुओं को उनके मॉड्यूल से निर्यात किया जाता है।

Answer 5

from X import * वर्तमान नामस्थान में मॉड्यूल X से सभी तत्व आयात करता है। import X एक्स आयात करता है लेकिन नामस्थानों को "विलय" नहीं करता है। उदा .:

मॉड्यूल एक्स:

def foo(): pass 
BAR = 12 

आपका कोड:

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

या:

import X 
X.foo() 
print X.BAR 

Answer 6

के हमारे मॉड्यूल परिभाषा का एक उदाहरण के रूप में उपयोग करते हैं

def my_func(): 
    return 1 

,210

आयात से वर्तमान नाम स्थान

from X import * 
print my_func() 

सामान्य आयात वर्तमान नाम स्थान

import X 
print x.my_func() 

साथ एक्स आयात my_func हो सकता है से अलावा में एक मॉड्यूल वस्तु बुलाया एक्स बनाएगा में सब कुछ खींच लेंगे केवल उस कार्यक्षमता को आयात करने के लिए प्रयोग किया जाता है।

Answer 7

आपको कभीfrom X import * का उपयोग नहीं करना चाहिए जबतक कि आप वास्तव में नहीं जानते कि आप क्या कर रहे हैं। आप मॉड्यूल एक्स से प्रतीकों को प्राप्त कर सकते हैं जो किसी अन्य मॉड्यूल या यहां तक ​​कि अपने स्वयं के प्रोग्राम से प्रतीकों के साथ संघर्ष करते हैं। मेरे पास उस नियम का एकमात्र अपवाद कभी-कभी from math import * होता है।

आप मॉड्यूल से एक चीज़ प्राप्त करने के लिए from X import y फॉर्म का उपयोग कर सकते हैं।

आप import X फार्म का उपयोग करते हैं, तो न केवल आप मॉड्यूल स्पष्ट X.y के आपके उपयोग कर सकता हूँ, लेकिन अगर आप मॉड्यूल में परिवर्तन करने और इसे फिर आयात करने की जरूरत है कि आप अब reload फ़ंक्शन का उपयोग कर सकते हैं।