La importación del módulo no desperdicia nada ; el módulo siempre se importa completamente (en la asignación sys.modules
), por lo tanto, si utiliza import sys
o from sys import argv
no hay probabilidades.
La única diferencia entre las dos declaraciones es qué nombre está enlazado; import sys
une el nombre sys
al módulo (entonces sys
- > sys.modules['sys']
), mientras que from sys import argv
une un nombre diferente, argv
, apuntando directamente al atributo contenido dentro del módulo (así que argv
- > sys.modules['sys'].argv
). El resto del módulo sys
todavía está allí, ya sea que uses algo más del módulo o no.
Tampoco hay diferencia de rendimiento entre los dos enfoques. Sí, sys.argv
tiene que buscar dos cosas; tiene que buscar sys
en su espacio de nombres global (encuentra el módulo), luego buscar el atributo argv
. Y sí, al utilizar from sys import argv
puede omitir la búsqueda de atributos, ya que ya tiene una referencia directa al atributo. Pero la declaración import
todavía tiene que hacer ese trabajo, busca el mismo atributo al importar, y solo tendrá que usar argv
una vez . Si tuviera que usar argv
miles de veces en un bucle, tal vez podría hacer una diferencia, pero en este caso específico realmente no lo hace.
La elección entre uno u otro entonces, debe basarse en estilo de codificación en su lugar.
En un módulo grande , ciertamente usaría import sys
; la documentación del código es importante, y el uso de sys.argv
en algún lugar en un módulo grande hace que sea mucho más claro a qué se refiere usted que solo argv
alguna vez.
Si el único lugar donde usas argv
está en un bloque '__main__'
para llamar a una función main()
, por supuesto usa from sys import argv
si te sientes más feliz con eso:
if __name__ == '__main__':
from sys import argv
main(argv)
Yo todavía usaría import sys
allí mismo. En igualdad de condiciones (y son, exactamente, en términos de rendimiento y el número de caracteres utilizados para escribirlo), eso es más fácil para mí.
Si está importando algo else por completo, tal vez el rendimiento entra en juego. Pero solo si usa un nombre específico en un módulo varias veces más , en un ciclo crítico, por ejemplo. Pero luego, crear un nombre local (dentro de una función) será más rápido aún:
import somemodule
def somefunction():
localname = somemodule.somefunctionorother
while test:
# huge, critical loop
foo = localname(bar)