Importar o módulo não desperdiça nada ; o módulo é sempre totalmente importado (para o mapeamento sys.modules
), de modo que você use import sys
ou from sys import argv
não faz nenhuma probabilidade.
A única diferença entre as duas declarações é o nome que está vinculado; import sys
liga o nome sys
ao módulo (assim sys
- > sys.modules['sys']
), enquanto from sys import argv
liga um nome diferente, argv
, apontando diretamente para o atributo contido dentro do módulo (assim argv
- > sys.modules['sys'].argv
). O resto do módulo sys
ainda está lá, quer você use qualquer outra coisa do módulo ou não.
Também não há diferença de desempenho entre as duas abordagens. Sim, sys.argv
tem que procurar duas coisas; ele precisa procurar sys
em seu namespace global (localiza o módulo) e, em seguida, procurar o atributo argv
. E sim, usando from sys import argv
você pode ignorar a pesquisa de atributos, já que você já tem uma referência direta ao atributo. Mas a declaração import
ainda tem que fazer esse trabalho, ele procura o mesmo atributo ao importar, e você só precisará usar argv
uma vez . Se você tivesse que usar argv
milhares de vezes em um loop, talvez pudesse fazer a diferença, mas, neste caso específico, isso não acontece.
A escolha entre um ou outro deve ser baseada em estilo de codificação .
Em um módulo grande , eu certamente usaria import sys
; a documentação do código é importante, e usar sys.argv
em algum lugar em um módulo grande torna muito mais claro o que você está se referindo do que apenas argv
jamais faria.
Se o único local em que você usa argv
está em '__main__'
para chamar uma função main()
, use from sys import argv
se você se sentir mais feliz com isso:
if __name__ == '__main__':
from sys import argv
main(argv)
Eu ainda usaria import sys
lá. Todas as coisas são iguais (e são, exatamente, em termos de desempenho e número de caracteres usados para escrevê-lo), isso é mais fácil para mim.
Se você estiver importando algo mais , então talvez o desempenho entre em ação. Mas somente se você usar um nome específico em um módulo muitas vezes por , em um loop crítico, por exemplo. Mas criar um nome local (dentro de uma função) será ainda mais rápido:
import somemodule
def somefunction():
localname = somemodule.somefunctionorother
while test:
# huge, critical loop
foo = localname(bar)