모듈을 가져 오는 것은 아무 것도 낭비하지 않습니다 . 모듈은 항상 ( 매핑으로) 완전히 가져 sys.modules오기 때문에 사용 import sys하거나 from sys import argv승산하지 않습니다.

두 문장의 유일한 차이점은 이름이 바인드 된 것입니다. import sys이름 결합 sys모듈로 (그래서 sys-> sys.modules['sys'])가 동시에 from sys import argv서로 다른 이름을 바인딩 argv모듈의 내부에 포함되는 속성에 셔널 (그래서 argv-> sys.modules['sys'].argv). sys모듈의 다른 것을 사용하든 아니든, 나머지 모듈은 여전히 ​​존재합니다.

또한 두 접근 방식간에 성능 차이는 없습니다. 예, sys.argv두 가지를 찾아야합니다. sys전역 네임 스페이스에서 찾아보고 (모듈을 찾음) 속성을 찾아야합니다 argv. 그리고 예, from sys import argv이미 속성에 대한 직접적인 참조가 있으므로 속성 검색을 건너 뛸 수 있습니다. 그러나 import진술은 여전히 ​​그 일을해야하며 가져 오기 할 때 동일한 속성을 찾고 argv 한 번만 사용해야 합니다 . argv루프에서 수천 번 사용해야한다면 아마도 차이가 생길 수 있지만이 경우에는 실제로 그렇지 않습니다.

그러면 둘 중 하나를 선택하는 것이 코딩 스타일을 기반으로해야합니다 .

A의 대형 모듈, 나는 확실히 사용하십시오 import sys; 코드 문서가 중요 sys.argv하고 큰 모듈에서 어딘가에 사용 하면 이전보다 훨씬 명확하게 참조 할 argv수 있습니다.

당신이 사용하는 유일한 장소 가 함수 를 호출하기 argv위해 '__main__'블록 안에 있다면, 그것에 대해 더 행복하다고 느끼면 반드시 main()사용 from sys import argv하십시오 :

if __name__ == '__main__':
    from sys import argv
    main(argv)

나는 여전히 import sys저 자신을 사용 합니다. 모든 것이 평등하고 (그리고 정확하게 쓰는 데 사용되는 문자 수 와 성능면에서 ), 그것은 나에게 더 쉽습니다.

다른 것을 모두 가져 오는 경우 성능이 향상 될 수 있습니다. 그러나 예를 들어 중요한 루프 와 같이 모듈에서 특정 이름을 여러 번 사용하는 경우에만 가능합니다 . 그러나 함수 내에서 로컬 이름을 만드는 것이 여전히 더 빠릅니다.

 import somemodule

 def somefunction():
      localname = somemodule.somefunctionorother
      while test:
          # huge, critical loop
          foo = localname(bar)

답변

from module import func
...
reload(module)
# func still points to the old code

import module
...
reload(module)
# module.func points to the new code

from collections import defaultdict
from foomodule import FooBar, FooBaz
from twisted.internet.protocol import Factory
defaultdict(); FooBar(); FooBaz(); Factory()

import collections
import foomodule
import twisted.internet.protocol
collections.defaultdict(); foomodule.FooBar(); foomodule.FooBaz()
twisted.internet.protocol.Factory()

import sys
sys.argv; sys.stderr; sys.exit()

import json
json.loads(foo)

from json import loads
loads(foo)  # potentially confusing

import collections as col
import foomodule as foo
import twisted.internet.protocol as twip

my_dict = col.defaultdict()
foo.FooBar()
twip_fac = twip.Factory()

from __future__ import unicode_literals
from __future__ import print_function

def r():
    import requests
    return 'hello'
timeit r() # output: 1000000 loops, best of 3: 1.55 µs per loop

def rg():
    from requests import get
    return 'hello'
timeit rg() # output: 100000 loops, best of 3: 2.53 µs per loop

def bs():
    import bs4
    return 'hello'
timeit bs() # output: 1000000 loops, best of 3: 1.53 µs per loop

def be():
    from bs4 import BeautifulSoup
    return 'hello'
timeit be() # output: 100000 loops, best of 3: 2.59 µs per loop

def js():
    import json
    return 'hello'
timeit js() # output: 1000000 loops, best of 3: 1.53 µs per loop

def jl():
    from json import loads
    return 'hello'
timeit jl() # output: 100000 loops, best of 3: 2.56 µs per loop

def s():
    import sys
    return 'hello'
timeit s() # output: 1000000 loops, best of 3: 1.55 µs per loop

def ar():
    from sys import argv
    return 'hello'
timeit ar() # output: 100000 loops, best of 3: 2.87 µs per loop

from datetime import datetime, timedelta

argv = sys.argv