Importation de fichiers à partir d'un dossier différent

J'ai la structure de dossiers suivante.

application/app/folder/file.py

et je veux importer certaines fonctions de file.py dans un autre fichier Python qui réside dans

application/app2/some_folder/some_file.py

J'ai essayé

from application.app.folder.file import func_name

et quelques autres tentatives diverses mais jusqu'à présent, je n'ai pas réussi à importer correctement. Comment puis-je faire ceci?

Par défaut, vous ne pouvez pas. Lors de l'importation d'un fichier, Python ne recherche que le répertoire en cours, le répertoire à partir sys.pathduquel le script du point d'entrée s'exécute, et qui inclut des emplacements tels que le répertoire d'installation du package (c'est en fait un peu plus complexe que cela, mais cela couvre la plupart des cas) .

Cependant, vous pouvez ajouter au chemin Python lors de l'exécution:

# some_file.py
import sys
# insert at 1, 0 is the script path (or '' in REPL)
sys.path.insert(1, '/path/to/application/app/folder')

import file

Rien de mal avec:

from application.app.folder.file import func_name

Assurez-vous simplement qu'il foldercontient également un __init__.py, cela lui permet d'être inclus en tant que package. Je ne sais pas pourquoi les autres réponses parlent PYTHONPATH.

Lorsque les modules sont dans des emplacements parallèles, comme dans la question:

application/app2/some_folder/some_file.py
application/app2/another_folder/another_file.py

Ce raccourci rend un module visible pour l'autre:

import sys
sys.path.append('../')

Premier import sys dans name-file.py

 import sys

Deuxième append le chemin du dossier dans name-file.py

sys.path.insert(0, '/the/folder/path/name-package/')

Troisièmement, créez un fichier vide appelé __ init __.py dans votre sous-répertoire (cela indique à Python qu'il s'agit d'un package)

• nom-fichier.py
• nom-package
  • __ init __.py
  • name-module.py

Quatrièmement, importez le module dans le dossier name-file.py

from name-package import name-module

Je pense qu'une manière ad-hoc serait d'utiliser la variable d'environnementPYTHONPATH comme décrit dans la documentation: Python2 , Python3

# Linux & OSX
export PYTHONPATH=$HOME/dirWithScripts/:$PYTHONPATH

# Windows
set PYTHONPATH=C:\path\to\dirWithScripts\;%PYTHONPATH%

Les réponses ici manquent de clarté, cela est testé sur Python 3.6

Avec cette structure de dossiers:

main.py
|
---- myfolder/myfile.py

Où myfile.pya le contenu:

def myfunc():
    print('hello')

L'instruction d'importation dans main.pyest:

from myfolder.myfile import myfunc
myfunc()

et cela imprimera bonjour .

Votre problème est que Python recherche ce fichier dans le répertoire Python et ne le trouve pas. Vous devez spécifier que vous parlez du répertoire dans lequel vous vous trouvez et non du répertoire Python.

Pour ce faire, vous changez ceci:

from application.app.folder.file import func_name

pour ça:

from .application.app.folder.file import func_name

En ajoutant le point, vous dites recherchez dans ce dossier le dossier d'application au lieu de chercher dans le répertoire Python.

D'après ce que je sais, ajouter un __init__.pyfichier directement dans le dossier des fonctions que vous souhaitez importer fera l'affaire.

Dans Python 3.4 et versions ultérieures, vous pouvez importer directement à partir d'un fichier source (lien vers la documentation) . Ce n'est pas la solution la plus simple, mais j'inclus cette réponse pour être complet.

Voici un exemple. Tout d'abord, le fichier à importer, nommé foo.py:

def announce():
    print("Imported!")

Le code qui importe le fichier ci-dessus, largement inspiré de l'exemple de la documentation:

import importlib.util

def module_from_file(module_name, file_path):
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module

foo = module_from_file("foo", "/path/to/foo.py")

if __name__ == "__main__":
    print(foo)
    print(dir(foo))
    foo.announce()

Le résultat:

<module 'foo' from '/path/to/foo.py'>
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'announce']
Imported!

Notez que le nom de variable, le nom de module et le nom de fichier ne doivent pas nécessairement correspondre. Ce code fonctionne toujours:

import importlib.util

def module_from_file(module_name, file_path):
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module

baz = module_from_file("bar", "/path/to/foo.py")

if __name__ == "__main__":
    print(baz)
    print(dir(baz))
    baz.announce()

Le résultat:

<module 'bar' from '/path/to/foo.py'>
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'announce']
Imported!

L'importation par programme de modules a été introduite dans Python 3.1 et vous donne plus de contrôle sur la façon dont les modules sont importés. Reportez-vous à la documentation pour plus d'informations.

A travaillé pour moi en python3 sur linux

import sys  
sys.path.append(pathToFolderContainingScripts)  
from scriptName import functionName #scriptName without .py extension  

Essayez les importations relatives de Python:

from ...app.folder.file import func_name

Chaque point de tête est un autre niveau supérieur de la hiérarchie commençant par le répertoire courant.

Problèmes? Si cela ne fonctionne pas pour vous, vous obtenez probablement peu par les nombreuses importations relatives de gotcha. Lisez les réponses et les commentaires pour plus de détails: Comment corriger «Tentative d'importation relative dans un non-package» même avec __init__.py

Astuce: avoir __init__.pyà chaque niveau de répertoire. Vous pourriez avoir besoin python -m application.app2.some_folder.some_file(en laissant .py) que vous exécutez à partir du répertoire de niveau supérieur ou avoir ce répertoire de niveau supérieur dans votre PYTHONPATH. Phew!

J'ai été confronté au même défi, en particulier lors de l'importation de plusieurs fichiers, c'est ainsi que j'ai réussi à le surmonter.

import os, sys

from os.path import dirname, join, abspath
sys.path.insert(0, abspath(join(dirname(__file__), '..')))

from root_folder import file_name

Considérant applicationque le répertoire racine de votre projet python, créer un vide __init__.pyfichier application, appet des folderdossiers. Ensuite, dans vos some_file.pymodifications, procédez comme suit pour obtenir la définition de func_name:

import sys
sys.path.insert(0, r'/from/root/directory/application')

from application.app.folder.file import func_name ## You can also use '*' wildcard to import all the functions in file.py file.
func_name()

L'utilisation de sys.path.append avec un chemin absolu n'est pas idéale lors du déplacement de l'application vers d'autres environnements. L'utilisation d'un chemin relatif ne fonctionnera pas toujours car le répertoire de travail actuel dépend de la façon dont le script a été appelé.

La structure du dossier d'application étant fixe, nous pouvons utiliser os.path pour obtenir le chemin complet du module que nous souhaitons importer. Par exemple, si c'est la structure:

/home/me/application/app2/some_folder/vanilla.py
/home/me/application/app2/another_folder/mango.py

Et disons que vous souhaitez importer le module "mango". Vous pouvez faire ce qui suit dans vanilla.py:

import sys, os.path
mango_dir = (os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+ '/another_folder/')
sys.path.append(mango_dir)
import mango

Bien sûr, vous n'avez pas besoin de la variable mango_dir.

Pour comprendre comment cela fonctionne, regardez cet exemple de session interactive:

>>> import os
>>> mydir = '/home/me/application/app2/some_folder'
>>> newdir = os.path.abspath(os.path.join(mydir, '..'))
>>> newdir
    '/home/me/application/app2'
>>> newdir = os.path.abspath(os.path.join(mydir, '..')) + '/another_folder'
>>> 
>>> newdir
'/home/me/application/app2/another_folder'
>>> 

Et consultez la documentation os.path .

Cela fonctionne pour moi sur Windows

# some_file.py on mainApp/app2 
import sys
sys.path.insert(0, sys.path[0]+'\\app2')

import some_file

Je suis assez spécial: j'utilise Python avec Windows!

Je viens de compléter les informations: pour Windows et Linux, les chemins relatifs et absolus fonctionnent sys.path(j'ai besoin de chemins relatifs car j'utilise mes scripts sur plusieurs PC et sous différents répertoires principaux).

Et lorsque vous utilisez Windows à la fois \et /pouvez être utilisé comme séparateur pour les noms de fichiers et bien sûr, vous devez doubler \en chaînes Python,
quelques exemples valides:

sys.path.append('c:\\tools\\mydir')
sys.path.append('..\\mytools')
sys.path.append('c:/tools/mydir')
sys.path.append('../mytools')

(note: je pense que /c'est plus pratique que \, événement s'il est moins «natif de Windows» car il est compatible Linux et plus simple à écrire et à copier dans l'explorateur Windows)

Si le but du chargement d'un module à partir d'un chemin spécifique est de vous aider lors du développement d'un module personnalisé, vous pouvez créer un lien symbolique dans le même dossier du script de test qui pointe vers la racine du module personnalisé. Cette référence de module aura priorité sur tous les autres modules installés du même nom pour tout script exécuté dans ce dossier.

J'ai testé cela sur Linux mais cela devrait fonctionner dans n'importe quel système d'exploitation moderne qui prend en charge les liens symboliques.

Un avantage de cette approche est que vous pouvez pointer vers un module qui se trouve dans votre propre copie de travail de branche SVC locale, ce qui peut considérablement simplifier le temps de cycle de développement et réduire les modes de défaillance de la gestion des différentes versions du module.

Dans mon cas, j'avais une classe à importer. Mon fichier ressemblait à ceci:

# /opt/path/to/code/log_helper.py
class LogHelper:
    # stuff here

Dans mon fichier principal, j'ai inclus le code via:

import sys
sys.path.append("/opt/path/to/code/")
from log_helper import LogHelper

Je suis tombé sur la même question plusieurs fois, alors je voudrais partager ma solution.

Version Python: 3.X

La solution suivante est destinée à quelqu'un qui développe votre application dans Python version 3.X car Python 2 n'est pas pris en charge depuis le 1er janvier 2020 .

Structure du projet

En python 3, vous n'avez pas besoin __init__.pydans votre sous-répertoire de projet en raison des packages d'espace de noms implicites . Voir Is init .py n'est pas requis pour les packages en Python 3.3+

Project 
├── main.py
├── .gitignore
|
├── a
|   └── file_a.py
|
└── b
    └── file_b.py

Énoncé du problème

Dans file_b.py, je voudrais importer une classe Adans file_a.pyle dossier a.

Solutions

# 1 Un moyen rapide mais sale

Sans installer le package comme vous développez actuellement un nouveau projet

Utiliser le try catchpour vérifier si les erreurs. Exemple de code:

import sys
try:
    # The insertion index should be 1 because index 0 is this file
    sys.path.insert(1, '/absolute/path/to/folder/a')  # the type of path is string
    # because the system path already have the absolute path to folder a
    # so it can recognize file_a.py while searching 
    from file_a import A
except (ModuleNotFoundError, ImportError) as e:
    print("{} fileure".format(type(e)))
else:
    print("Import succeeded")

# 2 Installez votre package

Une fois que vous avez installé votre application (dans cet article, le tutoriel d'installation n'est pas inclus)

Vous pouvez simplement

try:
    from __future__ import absolute_import
    # now it can reach class A of file_a.py in folder a 
    # by relative import
    from ..a.file_a import A  
except (ModuleNotFoundError, ImportError) as e:
    print("{} fileure".format(type(e)))
else:
    print("Import succeeded")

Bon codage!

Je travaillais sur un projet aque je voulais que les utilisateurs installent via pip install aavec la liste de fichiers suivante:

.
├── setup.py
├── MANIFEST.in
└── a
    ├── __init__.py
    ├── a.py
    └── b
        ├── __init__.py
        └── b.py

setup.py

from setuptools import setup

setup (
  name='a',
  version='0.0.1',
  packages=['a'],
  package_data={
    'a': ['b/*'],
  },
)

MANIFEST.in

recursive-include b *.*

a / init .py

from __future__ import absolute_import

from a.a import cats
import a.b

a / a.py

cats = 0

a / b / init .py

from __future__ import absolute_import

from a.b.b import dogs

a / b / b.py

dogs = 1

J'ai installé le module en exécutant ce qui suit à partir du répertoire avec MANIFEST.in:

python setup.py install

Ensuite, à partir d'un emplacement totalement différent sur mon système de fichiers, /moustache/armwrestlej'ai pu exécuter:

import a
dir(a)

Ce qui a confirmé a.catsqu'effectivement égal à 0 et a.b.dogseffectivement égal à 1, comme prévu.

Au lieu de simplement faire un import ..., faites ceci:

from <MySubFolder> import <MyFile>

MyFile est à l'intérieur de MySubFolder.

Vous pouvez actualiser le shell Python en appuyant sur f5, ou allez dans Exécuter-> Exécuter le module. De cette façon, vous n'avez pas à modifier le répertoire pour lire quelque chose dans le fichier. Python changera automatiquement le répertoire. Mais si vous souhaitez travailler avec différents fichiers d'un répertoire différent dans le shell Python, vous pouvez modifier le répertoire dans sys, comme Cameron l'a dit plus tôt.

Je venais donc de cliquer avec le bouton droit de la souris sur mon IDE et d'en ajouter un nouveau folderet je me demandais pourquoi je ne pouvais pas importer à partir de celui-ci. Plus tard, j'ai réalisé que je devais faire un clic droit et créer un package Python, et non un dossier de système de fichiers classique. Ou une méthode post-mortem consistant à ajouter un __init__.py(ce qui fait que python traite le dossier du système de fichiers comme un package) comme mentionné dans d'autres réponses. Ajouter cette réponse ici juste au cas où quelqu'un emprunterait cette voie.

Vous pouvez utiliser importlib pour importer des modules où vous souhaitez importer un module à partir d'un dossier à l'aide d'une chaîne comme ceci:

import importlib

scriptName = 'Snake'

script = importlib.import_module('Scripts\\.%s' % scriptName)

Cet exemple a un main.py qui est le code ci-dessus puis un dossier appelé Scripts et vous pouvez ensuite appeler ce dont vous avez besoin à partir de ce dossier en changeant la scriptNamevariable. Vous pouvez ensuite utiliser scriptpour faire référence à ce module. comme si j'ai une fonction appelée Hello()dans le module Snake, vous pouvez exécuter cette fonction en le faisant:

script.Hello()

J'ai testé cela en Python 3.6

J'ai eu ces problèmes plusieurs fois. Je suis souvent venu sur cette même page. Dans mon dernier problème, j'ai dû exécuter le à serverpartir d'un répertoire fixe, mais chaque fois que le débogage je voulais exécuter à partir de différents sous-répertoires.

import sys
sys.insert(1, /path) 

n'a PAS fonctionné pour moi car à différents modules j'ai dû lire différents fichiers * .csv qui étaient tous dans le même répertoire.

En fin de compte, ce qui a fonctionné pour moi n'était pas pythonique, je suppose, mais:

J'ai utilisé un if __main__ sur le module que je voulais déboguer , qui est exécuté à partir d'un chemin différent de celui habituel.

Donc:

# On top of the module, instead of on the bottom
import os
if __name__ == '__main__':
    os.chdir('/path/for/the/regularly/run/directory')