'from X import a' versus 'import X; X.a '

Question

He visto que algunos programadores de Python usan el siguiente estilo de manera bastante consistente (lo llamaremos estilo 1):

import some_module
# Use some_module.some_identifier in various places.

Para admitir este estilo, puede citar el " explícito es mejor que implícito " maxim. He visto a otros programadores usar este estilo (estilo 2):

from some_module import some_identifier
# Use some_identifier in various places.

El principal beneficio que veo en el estilo 2 es la mantenibilidad, especialmente con escritura de pato ideales Es posible que desee intercambiar some_module por some_other_module. También siento que el estilo 2 gana puntos con la " legibilidad cuenta " maxim . Aunque tiendo a estar en desacuerdo, siempre se puede argumentar que buscar y reemplazar es una opción tan buena cuando se usa el primer estilo.

Anexo: Se observó que podría usar como para resolver el cambio de some_module a some_other_module en estilo 1. Olvidé mencionar que también es común decidir implementar some_identifier en su módulo current , lo que hace que la creación de un some_module equivalente contenedor un poco incómodo.

Answer 1

Hay usos para ambos casos, así que no creo que este sea un problema. Consideraría usar desde el módulo import x, y, z cuando:

• Hay un número bastante pequeño de cosas para importar

• El propósito de las funciones importadas es obvio cuando se divorcia del nombre del módulo. Si los nombres son bastante genéricos, pueden chocar con otros y decirte poco. p.ej. ver remove le dice poco, pero os.remove probablemente le indicará que está tratando con archivos.

• Los nombres no chocan. Similar a lo anterior, pero más importante. Nunca haga algo como:

   from os import open
  

import module [as renamed_module] tiene la ventaja de que proporciona un poco más de contexto sobre lo que se llama cuando lo usa. Tiene la desventaja de que esto está un poco más abarrotado cuando el módulo realmente no proporciona más información y tiene un rendimiento ligeramente menor (2 búsquedas en lugar de 1).

Sin embargo, también tiene ventajas al realizar pruebas (por ejemplo, reemplazar os.open con un objeto simulado, sin tener que cambiar cada módulo), y debe usarse cuando se usan módulos mutables, por ejemplo

import config
config.dburl = 'sqlite:///test.db'

En caso de duda, siempre usaría el estilo import module .

Answer 2

Con la existencia de la siguiente sintaxis:

import some_other_module as some_module

el argumento de mantenibilidad del estilo 2 ya no es relevante.

Tiendo a usar el estilo 1. Normalmente, encuentro que hago referencia explícita al nombre del paquete importado solo unas pocas veces en un programa típico de Python. Todo lo demás son métodos en el objeto, que por supuesto no necesitan hacer referencia al paquete importado.

Answer 3

Usualmente uso un umbral para decidir esto. Si quiero usar muchas cosas dentro de some_module , usaré:

import some_module as sm
x = sm.whatever

Si solo necesito una o dos cosas:

from some_module import whatever
x = whatever

Eso supone que no necesito un lo que sea de some_other_module , por supuesto.

Tiendo a usar la cláusula como en las importaciones para poder reducir mi escritura y sustituir fácilmente a otro módulo en el futuro.

Answer 4

Prefiero importar X y luego usar X.a tanto como sea posible.

Mi excepción se centra en los módulos profundamente anidados en un gran marco como Django. Los nombres de sus módulos tienden a ser largos, y todos sus ejemplos dicen de la configuración de importación de django.conf para evitar que escriba django.conf.settings.DEBUG en todas partes.

Si el nombre del módulo está profundamente anidado, entonces la excepción es usar de X.Y.Z import a .

Answer 5

Encuentro que la notación

from some_module import some_symbol

funciona mejor en la mayoría de los casos. Además, en caso de conflicto de nombres para el símbolo, puede usar:

from some_module import some_symbol as other_symbol

Como dice la pregunta, evita reescribir el nombre del módulo todo el tiempo, cada vez con el riesgo de escribirlo mal. Yo uso la sintaxis:

import  module [as other_module]

Solo en dos casos:

1. Uso demasiadas funciones / objetos del módulo para importarlos todos
2. El módulo define algún símbolo que puede cambiar durante la ejecución

Answer 6

Personalmente trato de no meterme demasiado con mi espacio de nombres, así que en la mayoría de las situaciones simplemente lo hago

import module  

o     importar módulo como mod

Solo la diferencia real es cuando tengo un módulo con una sola clase que se usa mucho. Si hubiera subclasificado un tipo list para agregar alguna funcionalidad allí, usaría

from SuperImprovedListOverloadedWithFeatures import NewLIst
nl = NewList()

etc.

Answer 7

Tiendo a usar solo unos pocos miembros de cada módulo, por lo que hay muchos

from john import cleese
from terry import jones, gilliam

en mi código. Importaré módulos completos (como os o wx ) si espero utilizar la mayor parte del módulo y el nombre del módulo es corto. También importaré módulos completos si hay un conflicto de nombres o quiero recordarle al lector a qué se asocia esa función.

import michael
import sarah

import wave

gov_speech = wave.open(sarah.palin.speechfile)
parrot_sketch = wave.open(michael.palin.justresting)

(Podría usar desde wave import open como wave_open , pero creo que wave.open será más familiar para el lector.

Answer 8

Puede que le interese la pregunta de desbordamiento de pila ¿Por qué 'import x; xy' se comporta de forma diferente a 'desde x import y', y el primero falla cuando el paquete x. init no se completa? .

Answer 9

Creo en las versiones más recientes de Python (2.5+? debe verificar mis datos ...) incluso puede hacer:

import some_other_module as some_module

Así que aún podría seguir con el estilo 1 e intercambiar en un módulo diferente más adelante.

Creo que generalmente se asigna a la cantidad que desea saturar su espacio de nombres. ¿Utilizará uno o dos nombres en el módulo? ¿O todos ellos ( de x import * no siempre son malos, solo en general)?