¿Cómo puedo hacer importaciones relativas en Python?

Question 1

Imagina esta estructura de directorios:

app/
   __init__.py
   sub1/
      __init__.py
      mod1.py
   sub2/
      __init__.py
      mod2.py

estoy codificando mod1y necesito importar algo de mod2. ¿Cómo debería hacerlo?

Lo intenté from ..sub2 import mod2pero obtengo un “Intento de importación relativa sin paquete”.

Busqué en Google, pero solo encontré “sys.path trucos de manipulación. ¿No hay una manera limpia?

Toda mi __init__.pyestán actualmente vacíos

Estoy tratando de hacer esto porque sub2 contiene clases que se comparten entre subpaquetes (sub1, subXetc.).

El comportamiento que estoy buscando es el mismo que se describe en PEP 366 (gracias Juan B).

Question 2

El problema es que está ejecutando el módulo como ‘__main__’ al pasar mod1.py como argumento al intérprete.

De PEP 328:

Las importaciones relativas usan el atributo __name__ de un módulo para determinar la posición de ese módulo en la jerarquía del paquete. Si el nombre del módulo no contiene ninguna información del paquete (por ejemplo, está configurado como ‘__main__’), las importaciones relativas se resuelven como si el módulo fuera un módulo de nivel superior, independientemente de dónde se encuentre realmente el módulo en el sistema de archivos.

En Python 2.6, están agregando la capacidad de hacer referencia a módulos en relación con el módulo principal. PEP 366 describe el cambio.

Según Nick Coghlan, la alternativa recomendada es ejecutar el módulo dentro del paquete usando el modificador -m.

Question 3

Aquí está la solución que funciona para mí:

Hago las importaciones relativas como from ..sub2 import mod2
y luego, si quiero correr mod1.py luego voy al directorio principal de app y ejecute el módulo usando el interruptor python -m como python -m app.sub1.mod1.

La verdadera razón por la que ocurre este problema con las importaciones relativas es que las importaciones relativas funcionan tomando el __name__ propiedad del módulo. Si el módulo se está ejecutando directamente, entonces __name__ se establece en __main__ y no contiene ninguna información sobre la estructura del paquete. Y, es por eso que Python se queja de la relative import in non-package error.

Entonces, al usar el interruptor -m, proporciona la información de la estructura del paquete a python, a través de la cual puede resolver las importaciones relativas con éxito.

Me he encontrado con este problema muchas veces al hacer importaciones relativas. Y, después de leer todas las respuestas anteriores, todavía no pude descubrir cómo resolverlo, de una manera limpia, sin necesidad de poner el código repetitivo en todos los archivos. (Aunque algunos de los comentarios fueron realmente útiles, gracias a @ncoghlan y @XiongChiamiov)

Espero que esto ayude a alguien que está luchando con un problema de importaciones relativas, porque pasar por PEP realmente no es divertido.

Question 4

main.py
setup.py
app/ ->
    __init__.py
    package_a/ ->
       __init__.py
       module_a.py
    package_b/ ->
       __init__.py
       module_b.py

Tu corres python main.py.
main.py hace: import app.package_a.module_a
module_a.py hace import app.package_b.module_b

Alternativamente, 2 o 3 podrían usar: from app.package_a import module_a

Eso funcionará mientras tengas app en tu PYTHONPATH. main.py podría estar en cualquier lugar entonces.

Así que escribes un setup.py para copiar (instalar) todo el paquete de la aplicación y los subpaquetes en las carpetas de python del sistema de destino, y main.py a las carpetas de secuencias de comandos del sistema de destino.

Question 5

“Guido ve los scripts en ejecución dentro de un paquete como un antipatrón” (rechazado
PEP-3122)

Pasé mucho tiempo tratando de encontrar una solución, leyendo publicaciones relacionadas aquí en Stack Overflow y diciéndome a mí mismo “¡debe haber una mejor manera!”. Parece que no hay.

Question 6

Esto está resuelto al 100%:

aplicación/
- principal.py
ajustes/
- escenarios_locales.py

Importe settings/local_setting.py en app/main.py:

principal.py:

import sys
sys.path.insert(0, "../settings")


try:
    from local_settings import *
except ImportError:
    print('No Import')

Question 7

Explicación de la respuesta de nosklo con ejemplos:

Nota: todo __init__.py los archivos están vacíos.

main.py
app/ ->
    __init__.py
    package_a/ ->
       __init__.py
       fun_a.py
    package_b/ ->
       __init__.py
       fun_b.py

app/paquete_a/fun_a.py

def print_a():
    print 'This is a function in dir package_a'

app/paquete_b/fun_b.py

from app.package_a.fun_a import print_a
def print_b():
    print 'This is a function in dir package_b'
    print 'going to call a function in dir package_a'
    print '-'*30
    print_a()

principal.py

from app.package_b import fun_b
fun_b.print_b()

Si tu corres python main.py vuelve:

This is a function in dir package_b
going to call a function in dir package_a
------------------------------
This is a function in dir package_a

main.py hace: from app.package_b import fun_b
fun_b.py hace from app.package_a.fun_a import print_a

así que archivo en la carpeta package_b archivo usado en la carpeta package_a, que es lo que quieres. ¿¿Bien??

Question 8

Usar:

def import_path(fullpath):
    """ 
    Import a file with full path specification. Allows one to
    import from anywhere, something __import__ does not do. 
    """
    path, filename = os.path.split(fullpath)
    filename, ext = os.path.splitext(filename)
    sys.path.append(path)
    module = __import__(filename)
    reload(module) # Might be out of date
    del sys.path[-1]
    return module

Estoy usando este fragmento para importar módulos desde rutas.

app/paquete_a/fun_a.py

app/paquete_b/fun_b.py

principal.py

¿Ha sido útil esta solución?