Importer un module à partir d'un chemin relatif

Comment importer un module Python compte tenu de son chemin d'accès relatif?

Par exemple, si dirFoocontient Foo.pyet dirBar, et dirBarcontient Bar.py, comment importer Bar.pydans Foo.py?

Voici une représentation visuelle:

dirFoo\
    Foo.py
    dirBar\
        Bar.py

Foosouhaite inclure Bar, mais la restructuration de la hiérarchie des dossiers n'est pas une option.

En supposant que vos deux répertoires sont de vrais packages Python (ils contiennent le __init__.pyfichier), voici une solution sûre pour l'inclusion de modules relativement à l'emplacement du script.

Je suppose que vous voulez le faire, car vous devez inclure un ensemble de modules avec votre script. Je l'utilise en production dans plusieurs produits et fonctionne dans de nombreux scénarios spéciaux comme: des scripts appelés à partir d'un autre répertoire ou exécutés avec python execute au lieu d'ouvrir un nouvel interpréteur.

 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.

En prime, cette approche vous permet de forcer Python à utiliser votre module au lieu de ceux installés sur le système.

Attention! Je ne sais pas vraiment ce qui se passe lorsque le module actuel se trouve dans un eggfichier. Il échoue probablement aussi.

Assurez-vous que dirBar a le __init__.pyfichier - cela fait un répertoire dans un package Python.

Vous pouvez également ajouter le sous-répertoire à votre chemin Python afin qu'il soit importé en tant que 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

Faites simplement des choses simples pour importer le fichier .py à partir d'un dossier différent.

Disons que vous avez un répertoire comme:

lib/abc.py

Ensuite, gardez simplement un fichier vide dans le dossier lib comme nommé

__init__.py

Et puis utilisez

from lib.abc import <Your Module name>

Conservez le __init__.pyfichier dans chaque dossier de la hiérarchie du module d'importation.

Si vous structurez votre projet de cette façon:

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

Ensuite, à partir de Foo.py, vous devriez pouvoir faire:

import dirFoo.Foo

Ou:

from dirFoo.Foo import FooObject

Selon le commentaire de Tom, cela nécessite que le srcdossier soit accessible via site_packagesou votre chemin de recherche. De plus, comme il le mentionne, __init__.pyest implicitement importé lorsque vous importez un module dans ce package / répertoire pour la première fois. Il __init__.pys'agit généralement d' un fichier vide.

La méthode la plus simple consiste à utiliser sys.path.append ().

Cependant, vous pouvez également être intéressé par le module imp . Il donne accès aux fonctions d'importation internes.

# 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 

Cela peut être utilisé pour charger des modules dynamiquement lorsque vous ne connaissez pas le nom d'un module.

J'ai utilisé cela dans le passé pour créer une interface de type plugin pour une application, où l'utilisateur écrirait un script avec des fonctions spécifiques à l'application, et déposerait simplement son script dans un répertoire spécifique.

De plus, ces fonctions peuvent être utiles:

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

C'est le PEP pertinent:

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

En particulier, en supposant que dirFoo est un répertoire à partir de dirBar ...

Dans dirFoo \ Foo.py:

from ..dirBar import Bar

Le moyen le plus simple sans aucune modification de votre script est de définir la variable d'environnement PYTHONPATH. Parce que sys.path est initialisé à partir de ces emplacements:

1. Le répertoire contenant le script d'entrée (ou le répertoire courant).
2. PYTHONPATH (une liste de noms de répertoires, avec la même syntaxe que la variable shell PATH).
3. Valeur par défaut dépendante de l'installation.

Exécutez simplement:

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

Votre sys.path contiendra le chemin ci-dessus, comme indiqué ci-dessous:

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']

À mon avis, le meilleur choix est de mettre __ init __.py dans le dossier et d'appeler le fichier avec

from dirBar.Bar import *

Il n'est pas recommandé d'utiliser sys.path.append () car quelque chose pourrait mal tourner si vous utilisez le même nom de fichier que le package python existant. Je n'ai pas testé cela, mais ce sera ambigu.

Le moyen rapide et sale pour les utilisateurs de Linux

Si vous ne faites que bricoler et que vous ne vous souciez pas des problèmes de déploiement, vous pouvez utiliser un lien symbolique (en supposant que votre système de fichiers le prend en charge) pour rendre le module ou le package directement visible dans le dossier du module demandeur.

ln -s (path)/module_name.py

ou

ln -s (path)/package_name

Remarque: Un "module" est n'importe quel fichier avec une extension .py et un "package" est n'importe quel dossier qui contient le fichier __init__.py(qui peut être un fichier vide). Du point de vue de l'utilisation, les modules et les packages sont identiques - les deux exposent leurs "définitions et instructions" contenues comme demandé via la importcommande.

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

from .dirBar import Bar

au lieu de:

from dirBar import Bar

juste au cas où il pourrait y avoir un autre dirBar installé et confondre un lecteur foo.py.

Pour que ce cas importe Bar.py dans Foo.py, je transformerais d'abord ces dossiers en packages Python comme ceci:

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

Ensuite, je le ferais comme ça dans Foo.py:

from .dirBar import Bar

Si je voulais que l'espace de noms ressemble à Bar. quoi que ce soit , ou

from . import dirBar

Si je voulais le dirBar.Bar d'espacement de noms. peu importe . Ce deuxième cas est utile si vous avez plus de modules sous le package dirBar.

Ajoutez un fichier __init__.py :

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

Ajoutez ensuite ce code au début de Foo.py:

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

Exemple relatif 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

Basé sur cette réponse.

Eh bien, comme vous le mentionnez, vous souhaitez généralement avoir accès à un dossier contenant vos modules par rapport à l'emplacement d'exécution de votre script principal, il vous suffit donc de les importer.

Solution:

J'ai le script D:/Books/MyBooks.pyet quelques modules (comme oldies.py). Je dois importer du sous D:/Books/includes- répertoire :

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

Placez un print('done')in oldies.pypour vérifier que tout se passe bien. Cette méthode fonctionne toujours car, selon la définition Python sys.pathtelle qu'initialisée au démarrage du programme, le premier élément de cette liste,path[0] est le répertoire contenant le script qui a été utilisé pour appeler l'interpréteur Python.

Si le répertoire de script n'est pas disponible (par exemple, si l'interpréteur est appelé de manière interactive ou si le script est lu à partir d'une entrée standard), path[0]est la chaîne vide, qui dirige Python pour rechercher les modules dans le répertoire actuel en premier. Notez que le répertoire de script est inséré avant les entrées insérées à la suite de PYTHONPATH.

Vous pouvez simplement utiliser: from Desktop.filename import something

Exemple:

étant donné que le fichier est nom test.pydans le répertoire Users/user/Desktop, et importera tout.

le code:

from Desktop.test import *

Mais assurez-vous de créer un fichier vide appelé " __init__.py" dans ce répertoire

Une autre solution consisterait à installer le package py-require , puis à utiliser ce qui suit dansFoo.py

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

Voici un moyen d'importer un fichier d'un niveau supérieur, en utilisant le chemin relatif.

Fondamentalement, il suffit de déplacer le répertoire de travail d'un niveau (ou de n'importe quel emplacement relatif), d'ajouter cela à votre chemin, puis de déplacer le répertoire de travail là où il a commencé.

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

Je ne connais pas le python, donc s'il y a un problème dans mes mots, dites-le moi. Si votre hiérarchie de fichiers est organisée comme ceci:

project\
    module_1.py 
    module_2.py

module_1.pydéfinit une fonction appelée func_1(), module_2.py :

from module_1 import func_1

def func_2():
    func_1()

if __name__ == '__main__':
    func_2()

et vous exécutez python module_2.pyen cmd, il exécutera ce qui func_1()définit. C'est généralement ainsi que nous importons les mêmes fichiers de hiérarchie. Mais quand vous écrivez from .module_1 import func_1dans module_2.py, interpréteur Python dira No module named '__main__.module_1'; '__main__' is not a package. Donc, pour résoudre ce problème, nous conservons simplement les modifications que nous venons d'apporter, et déplaçons les deux modules dans un package, et créons un troisième module en tant qu'appelant à exécuter 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()

Mais la raison pour laquelle nous ajoutons un .avant module_1en module_2.pyest que si nous ne le faisons pas et exécuter main.py, l' interpréteur python va dire No module named 'module_1', c'est un peu délicat, qui module_1.pyest juste à côté module_2.py. Maintenant , je laisse func_1()en module_1.pydo quelque chose:

def func_1():
    print(__name__)

qui __name__enregistre qui appelle func_1. Maintenant, nous gardons l' .avant module_1, exécutons main.py, il imprimera package_1.module_1, non module_1. Cela indique que celui qui appelle func_1()est dans la même hiérarchie que main.py, .cela implique qu'il module_1est dans la même hiérarchie que module_2.pylui. Donc, s'il n'y a pas de point, main.pyreconnaîtra module_1la même hiérarchie que lui, il peut reconnaîtrepackage_1 , mais pas ce qui est "sous".

Maintenant, faisons un peu compliqué. Vous avez un config.iniet un module définit une fonction pour le lire dans la même hiérarchie que 'main.py'.

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

Et pour une raison inévitable, vous devez l'appeler avec module_2.py, il doit donc importer de la hiérarchie supérieure. module_2.py :

 import ..config
 pass

Deux points signifie l'importation à partir de la hiérarchie supérieure (trois points d'accès supérieur à supérieur, etc.). Maintenant , nous courons main.py, l'interprète dira: ValueError:attempted relative import beyond top-level package. Le "package de niveau supérieur" ici est main.py. Tout simplement parce qu'ils sont à config.pycôté main.py, ils sont dans la même hiérarchie, config.pyne sont pas "sous" main.py, ou ils ne sont pas "dirigés" par main.py, donc c'est au-delà main.py. Pour résoudre ce problème, le moyen le plus simple est:

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

Je pense que cela coïncide avec le principe de l'organisation de la hiérarchie des fichiers de projet, vous devez organiser les modules avec différentes fonctions dans différents dossiers, et laisser simplement un appelant supérieur à l'extérieur, et vous pouvez importer comme vous le souhaitez.

Cela fonctionne également, et est beaucoup plus simple que tout avec le sysmodule:

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

Appelez-moi trop prudent, mais j'aime rendre le mien plus portable car il n'est pas sûr de supposer que les fichiers seront toujours au même endroit sur chaque ordinateur. Personnellement, le code recherche d'abord le chemin du fichier. J'utilise Linux donc le mien ressemblerait à ceci:

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!")

C'est bien sûr à moins que vous ne prévoyiez de les regrouper. Mais si c'est le cas, vous n'avez pas vraiment besoin de deux fichiers distincts de toute façon.