Importar un módulo desde una ruta relativa

¿Cómo importo un módulo de Python dada su ruta relativa?

Por ejemplo, si dirFoocontiene Foo.pyy dirBar, y dirBarcontiene Bar.py, ¿Cómo se importan Bar.pyen Foo.py?

Aquí hay una representación visual:

dirFoo\
    Foo.py
    dirBar\
        Bar.py

Foodesea incluir Bar, pero la reestructuración de la jerarquía de carpetas no es una opción.

Suponiendo que ambos directorios son paquetes reales de Python (sí tienen el __init__.pyarchivo dentro de ellos), aquí hay una solución segura para incluir módulos en relación con la ubicación del script.

Supongo que quiere hacer esto, porque necesita incluir un conjunto de módulos con su script. Lo uso en producción en varios productos y funciona en muchos escenarios especiales como: scripts llamados desde otro directorio o ejecutados con Python execute en lugar de abrir un nuevo intérprete.

 import os, sys, inspect
 # realpath() will make your script run, even if you symlink it :)
 cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
 if cmd_folder not in sys.path:
     sys.path.insert(0, cmd_folder)

 # Use this if you want to include modules from a subfolder
 cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"subfolder")))
 if cmd_subfolder not in sys.path:
     sys.path.insert(0, cmd_subfolder)

 # Info:
 # cmd_folder = os.path.dirname(os.path.abspath(__file__)) # DO NOT USE __file__ !!!
 # __file__ fails if the script is called in different ways on Windows.
 # __file__ fails if someone does os.chdir() before.
 # sys.argv[0] also fails, because it doesn't not always contains the path.

Como beneficio adicional, este enfoque le permite forzar a Python a usar su módulo en lugar de los instalados en el sistema.

¡Advertencia! Realmente no sé qué sucede cuando el módulo actual está dentro de un eggarchivo. Probablemente también falla.

Asegúrese de que dirBar tenga el __init__.pyarchivo; esto convierte un directorio en un paquete de Python.

También puede agregar el subdirectorio a su ruta de Python para que se importe como un script normal.

import sys
sys.path.insert(0, <path to dirFoo>)
import Bar

import os
import sys
lib_path = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'lib'))
sys.path.append(lib_path)

import mymodule

Simplemente haga cosas simples para importar el archivo .py desde una carpeta diferente.

Digamos que tiene un directorio como:

lib/abc.py

Luego, solo mantenga un archivo vacío en la carpeta lib como se llama

__init__.py

Y luego usar

from lib.abc import <Your Module name>

Mantenga el __init__.pyarchivo en cada carpeta de la jerarquía del módulo de importación.

Si estructura su proyecto de esta manera:

src\
  __init__.py
  main.py
  dirFoo\
    __init__.py
    Foo.py
  dirBar\
    __init__.py
    Bar.py

Luego, desde Foo.py deberías poder hacer:

import dirFoo.Foo

O:

from dirFoo.Foo import FooObject

Según el comentario de Tom, esto requiere que se srcpueda acceder a la carpeta a través de site_packagessu ruta de búsqueda. Además, como él menciona, __init__.pyse importa implícitamente cuando se importa por primera vez un módulo en ese paquete / directorio. Típicamente __init__.pyes simplemente un archivo vacío.

El método más fácil es usar sys.path.append ().

Sin embargo, también te puede interesar el módulo imp . Proporciona acceso a funciones de importación internas.

# mod_name is the filename without the .py/.pyc extention
py_mod = imp.load_source(mod_name,filename_path) # Loads .py file
py_mod = imp.load_compiled(mod_name,filename_path) # Loads .pyc file 

Esto se puede usar para cargar módulos dinámicamente cuando no conoce el nombre de un módulo.

Lo he usado en el pasado para crear una interfaz de tipo plugin para una aplicación, donde el usuario escribiría un script con funciones específicas de la aplicación, y simplemente colocaría su script en un directorio específico.

Además, estas funciones pueden ser útiles:

imp.find_module(name[, path])
imp.load_module(name, file, pathname, description)

Esta es la PEP relevante:

http://www.python.org/dev/peps/pep-0328/

En particular, suponiendo que dirFoo es un directorio desde dirBar ...

En dirFoo \ Foo.py:

from ..dirBar import Bar

La forma más fácil sin ninguna modificación en su script es establecer la variable de entorno PYTHONPATH. Debido a que sys.path se inicializa desde estas ubicaciones:

1. El directorio que contiene el script de entrada (o el directorio actual).
2. PYTHONPATH (una lista de nombres de directorio, con la misma sintaxis que la variable de shell PATH).
3. El valor predeterminado dependiente de la instalación.

Solo corre:

export PYTHONPATH=/absolute/path/to/your/module

Su sys.path contiene la ruta anterior, como se muestra a continuación:

print sys.path

['', '/absolute/path/to/your/module', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7', '/usr/lib/python2.7/dist-packages/ubuntu-sso-client', '/usr/lib/python2.7/dist-packages/ubuntuone-client', '/usr/lib/python2.7/dist-packages/ubuntuone-control-panel', '/usr/lib/python2.7/dist-packages/ubuntuone-couch', '/usr/lib/python2.7/dist-packages/ubuntuone-installer', '/usr/lib/python2.7/dist-packages/ubuntuone-storage-protocol']

En mi opinión, la mejor opción es poner __ init __.py en la carpeta y llamar al archivo con

from dirBar.Bar import *

No se recomienda usar sys.path.append () porque algo podría salir mal si usa el mismo nombre de archivo que el paquete python existente. No he probado eso, pero será ambiguo.

La manera rápida y sucia para los usuarios de Linux

Si solo está jugando y no le importan los problemas de implementación, puede usar un enlace simbólico (suponiendo que su sistema de archivos lo admita) para hacer que el módulo o paquete sea directamente visible en la carpeta del módulo solicitante.

ln -s (path)/module_name.py

o

ln -s (path)/package_name

Nota: Un "módulo" es cualquier archivo con una extensión .py y un "paquete" es cualquier carpeta que contiene el archivo __init__.py(que puede ser un archivo vacío). Desde el punto de vista del uso, los módulos y los paquetes son idénticos: ambos exponen sus "definiciones y declaraciones" contenidas según lo solicitado a través del importcomando.

Ver: http://docs.python.org/2/tutorial/modules.html

from .dirBar import Bar

en vez de:

from dirBar import Bar

por si acaso podría haber otro dirBar instalado y confundir a un lector foo.py.

Para este caso para importar Bar.py en Foo.py, primero convertiría estas carpetas en paquetes de Python de esta manera:

dirFoo\
    __init__.py
    Foo.py
    dirBar\
        __init__.py
        Bar.py

Entonces lo haría así en Foo.py:

from .dirBar import Bar

Si quisiera que el espacio de nombres se pareciera a Bar. lo que sea , o

from . import dirBar

Si quisiera el espacio de nombres dirBar.Bar. lo que sea . Este segundo caso es útil si tiene más módulos bajo el paquete dirBar.

Agregue un archivo __init__.py :

dirFoo\
    Foo.py
    dirBar\
        __init__.py
        Bar.py

Luego agregue este código al inicio de Foo.py:

import sys
sys.path.append('dirBar')
import Bar

Ejemplo relativo de sys.path:

# /lib/my_module.py
# /src/test.py


if __name__ == '__main__' and __package__ is None:
    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../lib')))
import my_module

Basado en esta respuesta.

Bueno, como usted menciona, generalmente desea tener acceso a una carpeta con sus módulos en relación con el lugar donde se ejecuta su script principal, por lo que solo debe importarlos.

Solución:

Tengo el script D:/Books/MyBooks.pyy algunos módulos (como oldies.py). Necesito importar desde el subdirectorio D:/Books/includes:

import sys,site
site.addsitedir(sys.path[0] + '\\includes')
print (sys.path)  # Just verify it is there
import oldies

Coloque una print('done')en oldies.py, por lo que comprobar que todo va bien. De esta manera, siempre funciona porque, según la definición de Python sys.pathinicializada al iniciar el programa, el primer elemento de esta lista,path[0] es el directorio que contiene el script que se utilizó para invocar al intérprete de Python.

Si el directorio del script no está disponible (por ejemplo, si el intérprete se invoca de forma interactiva o si el script se lee desde la entrada estándar), path[0]es la cadena vacía, que dirige a Python a buscar primero los módulos en el directorio actual. Observe que el directorio del script se inserta antes de las entradas insertadas como resultado de PYTHONPATH.

Simplemente puedes usar: from Desktop.filename import something

Ejemplo:

dado que el archivo es nombre test.pyen el directorio Users/user/Desktop, e importará todo.

el código:

from Desktop.test import *

Pero asegúrese de hacer un archivo vacío llamado " __init__.py" en ese directorio

Otra solución sería instalar el paquete py-require y luego usar lo siguiente enFoo.py

import require
Bar = require('./dirBar/Bar')

Aquí hay una manera de importar un archivo desde un nivel superior, utilizando la ruta relativa.

Básicamente, simplemente mueva el directorio de trabajo hacia arriba un nivel (o cualquier ubicación relativa), agréguelo a su ruta, luego mueva el directorio de trabajo donde comenzó.

#to import from one level above:
cwd = os.getcwd()
os.chdir("..")
below_path =  os.getcwd()
sys.path.append(below_path)
os.chdir(cwd)

No tengo experiencia con Python, así que si hay algún error en mis palabras, solo dígame. Si su jerarquía de archivos se organizó así:

project\
    module_1.py 
    module_2.py

module_1.pydefine una función llamada func_1(), module_2.py :

from module_1 import func_1

def func_2():
    func_1()

if __name__ == '__main__':
    func_2()

y ejecuta python module_2.pyen cmd, ejecutará lo que func_1()define. Así es como importamos los mismos archivos de jerarquía. Pero cuando se escribe from .module_1 import func_1en module_2.py, intérprete de python dirá No module named '__main__.module_1'; '__main__' is not a package. Entonces, para solucionar esto, simplemente conservamos el cambio que acabamos de hacer, y movemos ambos módulos a un paquete, y hacemos que se ejecute un tercer módulo como llamador module_2.py.

project\
    package_1\
        module_1.py
        module_2.py
    main.py

main.py :

from package_1.module_2 import func_2

def func_3():
    func_2()

if __name__ == '__main__':
    func_3()

Pero la razón por la que agregamos un .antes module_1en module_2.pyes que si no hacemos eso y corremos main.py, el intérprete de Python dirá No module named 'module_1', eso es un poco complicado, module_1.pyestá justo al lado module_2.py. Ahora dejo func_1()en module_1.pyalgo Do:

def func_1():
    print(__name__)

que __name__registra quién llama a func_1. Ahora guardamos el .antes module_1, corre main.py, se imprimirá package_1.module_1, no module_1. Indica que quien llama func_1()está en la misma jerarquía que main.py, lo .que implica que module_1está en la misma jerarquía que él module_2.pymismo. Entonces, si no hay un punto, main.pyreconocerá module_1en la misma jerarquía que sí mismo, puede reconocerpackage_1 , pero no qué "debajo" de él.

Ahora hagámoslo un poco complicado. Tiene un config.iniy un módulo define una función para leerlo en la misma jerarquía que 'main.py'.

project\
    package_1\
        module_1.py
        module_2.py
    config.py
    config.ini
    main.py

Y por alguna razón inevitable, debe llamarlo module_2.py, por lo que debe importar desde la jerarquía superior. module_2.py :

 import ..config
 pass

Dos puntos significa importar desde la jerarquía superior (acceso de tres puntos superior a superior, etc.). Ahora corremos main.py, el intérprete dirá: ValueError:attempted relative import beyond top-level package. El "paquete de nivel superior" aquí es main.py. Solo porque config.pyestá al lado main.py, están en la misma jerarquía, config.pyno están "debajo" main.pyo no están "guiados" main.py, por lo que está más allá main.py. Para solucionar esto, la forma más simple es:

project\
    package_1\
        module_1.py
        module_2.py
    config.py
    config.ini
main.py

Creo que eso coincide con el principio de organizar la jerarquía de archivos del proyecto, debe organizar los módulos con diferentes funciones en diferentes carpetas, y simplemente dejar una llamada superior en el exterior, y puede importar lo que quiera.

Esto también funciona, y es mucho más simple que cualquier cosa con el sysmódulo:

with open("C:/yourpath/foobar.py") as f:
    eval(f.read())

Llámame demasiado cauteloso, pero me gusta hacer que el mío sea más portátil porque no es seguro asumir que los archivos siempre estarán en el mismo lugar en cada computadora. Personalmente, el código busca primero la ruta del archivo. Yo uso Linux para que el mío se vea así:

import os, sys
from subprocess import Popen, PIPE
try:
    path = Popen("find / -name 'file' -type f", shell=True, stdout=PIPE).stdout.read().splitlines()[0]
    if not sys.path.__contains__(path):
        sys.path.append(path)
except IndexError:
    raise RuntimeError("You must have FILE to run this program!")

Eso es, por supuesto, a menos que planee agruparlos. Pero si ese es el caso, realmente no necesita dos archivos separados de todos modos.