Python 使用'；导入模块&x27；或'；从模块导入'；？

我试图找到一个关于使用

import module

还是从module import使用

的全面指南。我刚刚开始学习Python，我正试图从最佳实践开始

基本上，我希望任何人都能分享他们的经验，其他开发人员有哪些偏好，以及避免出现问题的最佳方法是什么？
支持这两种方法的原因是：有时一种方法比另一种更合适


导入模块
：当您使用模块中的许多位时，效果很好。缺点是您需要用模块名限定每个引用

来自模块导入…
：导入的项目可以直接使用，而无需模块名称前缀。缺点是您必须列出您使用的每一件东西，并且代码中不清楚这些东西是从哪里来的


使用哪种方法取决于哪种方法使代码清晰易读，并且与个人偏好有很大关系。我倾向于导入模块，因为在代码中，对象或函数的来源非常清楚。当我在代码中大量使用某些对象/函数时，我使用模块导入的
。
导入模块
和模块导入foo的
之间的区别主要是主观的。选择一个你最喜欢的，并在使用中保持一致。这里有一些要点可以帮助您做出决定

导入模块


优点：

减少对
import
语句的维护。无需添加任何其他导入即可开始使用模块中的其他项

缺点：

在您的代码中键入
module.foo
可能会非常繁琐和冗余（通过使用
将模块导入为mo
然后键入
mo.foo
，可以最大限度地减少繁琐）


从模块导入foo


优点：

使用
foo
对可访问模块的哪些项进行更多控制

缺点：

要使用模块中的新项，必须更新
import
语句
您失去了有关
foo
的上下文。例如，与
math.ceil（）


这两种方法都可以接受，但不要使用模块导入中的
*

对于任何合理的大型代码集，如果
导入*
，则可能会将其固定到模块中，无法删除。这是因为很难确定代码中使用的项目来自“模块”，从而很容易达到您认为不再使用
import
的程度，但很难确定

import module

最好使用模块中的许多功能

from module import function

当您只需要
函数
我个人经常使用的函数时，如果您希望避免使用模块中的所有函数和类型污染全局名称空间，那么这是最好的选择

from package.subpackage.subsubpackage import module

然后访问所有内容

module.function
module.modulevar

原因是，在进行短调用的同时，您清楚地定义了每个例程的模块名称空间，如果您必须在源代码中搜索给定模块的用法，这是非常有用的

不用说，不要使用import*，因为它会污染您的名称空间，并且不会告诉您给定函数的来源（来自哪个模块）

当然，如果两个不同包中的两个不同模块具有相同的模块名，则可能会遇到麻烦，如

from package1.subpackage import module
from package2.subpackage import module

在这种情况下，您当然会遇到麻烦，但有一个强烈的迹象表明，您的包布局有缺陷，您必须重新思考。
要补充人们对x导入的
*
：除了让您更难辨别名称来自何处之外，这还抛出了类似Pylint的代码检查器。他们会将这些名称报告为未定义的变量。
我自己的答案主要取决于首先，我将使用多少不同的模块。如果我只打算使用一个或两个，我会经常使用
中的
import因为它可以减少文件其余部分的击键次数，但是如果我要使用许多不同的模块，我更喜欢导入，因为这意味着每个模块引用都是自文档化的。我不必四处寻找，就能看到每个符号的来源

通常我更喜欢纯导入的自文档风格，只更改为from。。当我必须输入模块名的次数增加到10到20次以上时导入，即使只导入一个模块。
我刚刚发现这两种方法之间还有一个细微的区别

如果模块
foo
使用以下导入：

from itertools import count

然后模块
bar
可能会错误地使用
count
，就好像它是在
foo
中定义的，而不是在
itertools
中定义的一样：

import foo
foo.count()

>>> del locals()['path']
>>> path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'path' is not defined
>>>

如果
foo
使用：

import itertools

这个错误仍然有可能发生，但不太可能发生<代码>条形图
需要：

import foo
foo.itertools.count()

这给我带来了一些麻烦。我有一个模块，它错误地从一个没有定义异常的模块导入了一个异常，只是从其他模块导入了它（使用
from module import SomeException
）。当导入不再需要并被删除时，有问题的模块被破坏。
这里还有另一个未提及的与写入模块相关的细节。虽然这可能不是很常见，但我时常需要它

由于Python中引用和名称绑定的工作方式，如果您想从模块外部更新模块中的某些符号，比如foo.bar
import foo
foo.bar = "oranges"   # update bar inside foo module object

import foo           
print foo.bar        # if executed after a's "foo.bar" assignment, will print "oranges"

from foo import bar
bar = "oranges"

from package import item

import item.subitem.subsubitem

>>> import sys
>>> import os.path

>>> sys.modules['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> sys.modules['os.path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

>>> globals()['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> locals()['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> globals()['os.path']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'os.path'
>>>

>>> os
<module 'os' from
  '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> os.path
<module 'posixpath' from
 '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>>

>>> path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'path' is not defined
>>>

>>> del locals()['os']
>>> os
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined
>>> os.path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined
>>>

>>> import sys
>>> from os import path

>>> sys.modules['os']
<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>
>>> sys.modules['os.path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

>>> globals()['path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> locals()['path']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> globals()['os']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'os'
>>>

>>> path
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> os.path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined
>>>

>>> del locals()['path']
>>> path
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'path' is not defined
>>>

>>> from os import path as HELL_BOY
>>> locals()['HELL_BOY']
<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>> globals()['HELL_BOY']
<module 'posixpath' from /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>
>>>

>>> globals()['path']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'path'
>>>

import package
import module

import package1.package2.package
import package1.package2.module

from package1.package2 import package
from package1.package2 import module

a = big_package_name.subpackage.even_longer_subpackage_name.function

from package3.module import some_function

import package3.module.some_function 

import math

math.sqrt(4)

import math as m

from math import sqrt

from math import * 

public_variable = 42
_private_variable = 141
def public_function():
    print("I'm a public function! yay!")
def _private_function():
    print("Ain't nobody accessing me from another module...usually")

import settings
print (settings._private_variable)
print (settings.public_variable)
settings.public_function()
settings._private_function()

# Prints:
# 141
# 42
# I'm a public function! yay!
# Ain't nobody accessing me from another module...usually

from settings import *
#print (_private_variable) #doesn't work
print (public_variable)
public_function()
#_private_function()   #doesn't work

mod/
    __init__.py
    main.py
    a.py
    b.py
    c.py
    d.py

import mod.a
import mod.b as b
from mod import c
import d

  1           0 LOAD_CONST               0 (-1)
              3 LOAD_CONST               1 (None)
              6 IMPORT_NAME              0 (mod.a)
              9 STORE_NAME               1 (mod)

  2          12 LOAD_CONST               0 (-1)
             15 LOAD_CONST               1 (None)
             18 IMPORT_NAME              2 (b)
             21 STORE_NAME               2 (b)

  3          24 LOAD_CONST               0 (-1)
             27 LOAD_CONST               2 (('c',))
             30 IMPORT_NAME              1 (mod)
             33 IMPORT_FROM              3 (c)
             36 STORE_NAME               3 (c)
             39 POP_TOP

  4          40 LOAD_CONST               0 (-1)
             43 LOAD_CONST               1 (None)
             46 IMPORT_NAME              4 (mod.d)
             49 LOAD_ATTR                5 (d)
             52 STORE_NAME               5 (d)
             55 LOAD_CONST               1 (None)

foo/
   __init__.py
   a.py
   b.py

a.py:
import foo.b 

b.py:
import foo.a

>>> import foo.a
>>>

bar/
   __init__.py
   a.py
   b.py

a.py:
import bar.b as b

b.py:
import bar.a as a

>>> import bar.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "bar\a.py", line 1, in <module>
    import bar.b as b
  File "bar\b.py", line 1, in <module>
    import bar.a as a
AttributeError: 'module' object has no attribute 'a'

baz/
   __init__.py
   a.py
   b.py

a.py:
from baz import b

b.py:
from baz import a

>>> import baz.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "baz\a.py", line 1, in <module>
    from baz import b
  File "baz\b.py", line 1, in <module>
    from baz import a
ImportError: cannot import name a

qux/
   __init__.py
   a.py
   b.py

a.py:
import b 

b.py:
import a

>>> import qux.a
>>>

.  
└─a  
   └─b  
     └─c

In[1]: import a.b.c

In[2]: a
Out[2]: <module 'a' (namespace)>

In[3]: a.b
Out[3]: <module 'a.b' (namespace)>

In[4]: a.b.c
Out[4]: <module 'a.b.c' (namespace)>

In[1]: from a.b import c

In[2]: a
NameError: name 'a' is not defined

In[2]: a.b
NameError: name 'a' is not defined

In[3]: a.b.c
NameError: name 'a' is not defined

In[4]: c
Out[4]: <module 'a.b.c' (namespace)>

import mymath
mymath.gcd(30, 42)  # will work though maybe not expected

# for instance...
from math import gcd as _gcd
# or...
import math as _math

package1
  |-- __init__.py

package2
  |-- __init__.py
  |-- module1.py
  |-- module2.py

import package1

package1.func1()

import package1 as my

my.func1()

from package1 import func1

func1()

from package1 import *

func1()

import package2.module2

package2.module2.foo()

import package2.module2 as mod2

mod2.foo()

from package2 import module2

module2.foo()

from package2 import module2 as mod2

mod2.foo()

from package2.module2 import *

foo()