‘from X import a’ versus ‘import X; Xa ‘

He visto a algunos progtwigdores de Python usar el siguiente estilo de manera bastante consistente (lo llamaremos estilo 1):

import some_module # Use some_module.some_identifier in various places. 

Para el soporte de este estilo, puede citar la máxima “explícito es mejor que implícito” . He visto a otros progtwigdores 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 capacidad de mantenimiento, especialmente con los ideales de tipeo de pato , es posible que desee intercambiar some_module por some_other_module. También siento que el estilo 2 gana puntos con la máxima de “cuentas de legibilidad” . 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.

Addendum: se señaló que podría usarlo para resolver el cambio de some_module a some_other_module en el estilo 1. Olvidé mencionar que también es común decidir implementar some_identifier en su módulo actual , lo que hace que la creación de un contenedor equivalente de some_module un poco más torpe.

    Hay usos para ambos casos, por lo que no creo que esto sea un problema de uno u otro. 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 está divorciado del nombre del módulo. Si los nombres son bastante generics, pueden chocar con otros y decirle poco. p.ej. Ver remove te dice poco, pero os.remove probablemente insinuará que estás tratando con archivos.

    • Los nombres no chocan. Similar a lo anterior, pero más importante. Nunca hagas 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 está llamando cuando lo usas. Tiene la desventaja de que esto está un poco más desordenado 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 se debe usar cuando se usan módulos mutables, por ejemplo

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

    En caso de duda, siempre me quedo con el estilo de import module .

    Con la existencia de la siguiente syntax:

     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 una referencia explícita al nombre del paquete importado solo unas pocas veces en un progtwig típico de Python. Todo lo demás son métodos en el objeto, que por supuesto no necesitan hacer referencia al paquete importado.

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

     import some_module as sm x = sm.whatever 

    Si solo hay una o dos cosas que necesito:

     from some_module import whatever x = whatever 

    Eso es asumiendo que no necesito nada de algún whatever some_other_module , por supuesto.

    Tiendo a usar la cláusula as en las importaciones para poder reducir mi escritura y sustituir otro módulo con bastante facilidad en el futuro.

    Prefiero import X y luego usar Xa tanto como sea posible.

    Mi excepción se centra en los módulos profundamente nesteds en un gran marco como Django. Sus nombres de módulos tienden a ser largos, y todos sus ejemplos dicen que from django.conf import settings ahorran escribir django.conf.settings.DEBUG todas partes.

    Si el nombre del módulo está profundamente nested, la excepción es usar from XYZ import a .

    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 utilizar:

     from some_module import some_symbol as other_symbol 

    Como indica la pregunta, evita volver a escribir el nombre del módulo todo el tiempo, cada vez con el riesgo de escribirlo incorrectamente. Yo uso la syntax:

     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.

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

     import module 

    o importar modulo como mod

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

     from SuperImprovedListOverloadedWithFeatures import NewLIst nl = NewList() 

    etc.

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

     from john import cleese from terry import jones, gilliam 

    en mi codigo Importaré módulos enteros (como os o wx ) si espero usar la mayor parte del módulo y el nombre del módulo es corto. También importaré módulos enteros si hay un conflicto de nombres o quiero recordarle al lector con qué está asociada 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 from wave import open as wave_open , pero creo que wave.open será más familiar para el lector.

    Puede estar interesado en la pregunta de desbordamiento de stack. ¿Por qué ‘importar x; xy’ se comporta diferente de ‘desde x import y’ y la primera falla cuando el paquete x. init no se ha completado? .

    Creo que en las versiones más recientes de Python (2.5+? Debo verificar mis datos …) incluso puedes hacer:

     import some_other_module as some_module 

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

    Pienso que generalmente se asigna a cuánto deseas desordenar tu espacio de nombres. ¿Estará usando uno o dos nombres en el módulo? ¿O todos ellos ( from x import * no siempre son malos, solo en general)?