J'utilise Python 2.5.

Voici mon arborescence de dossiers:

ptdraft/
  nib.py
  simulations/
    life/
      life.py

(J'ai également __init__.pydans chaque dossier, omis ici pour plus de lisibilité)

Comment importer le nibmodule depuis l'intérieur du lifemodule? J'espère qu'il est possible de le faire sans bricoler avec sys.path.

Remarque: Le module principal en cours d'exécution se trouve dans le ptdraftdossier.

Il semble que le problème ne soit pas lié au fait que le module se trouve dans un répertoire parent ou quelque chose comme ça.

Vous devez ajouter le répertoire contenant ptdraftPYTHONPATH

Vous avez dit que cela import nibfonctionnait avec vous, cela signifie probablement que vous vous êtes ajouté ptdraft(pas son parent) à PYTHONPATH.

Vous pouvez utiliser des importations relatives (python> = 2.5):

from ... import nib

(Quoi de neuf dans Python 2.5) PEP 328: Importations absolues et relatives

EDIT : ajouté un autre point '.' monter deux packages

Les importations relatives (comme dans from .. import mymodule) ne fonctionnent que dans un package. Pour importer 'mymodule' qui se trouve dans le répertoire parent de votre module actuel:

import os,sys,inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir) 

import mymodule

edit : l' __file__attribut n'est pas toujours donné. Au lieu d'utiliser, os.path.abspath(__file__)j'ai maintenant suggéré d'utiliser le module d'inspection pour récupérer le nom de fichier (et le chemin) du fichier actuel

J'ai également publié une réponse similaire à la question concernant les importations à partir de paquets frères. Vous pouvez le voir ici .

Solution sans sys.pathhacks

Sommaire

• Enveloppez le code dans un dossier (par exemple packaged_stuff)
• Utilisez le setup.pyscript de création dans lequel vous utilisez setuptools.setup () .
• Pip installe le package dans un état modifiable avec pip install -e <myproject_folder>
• Importer à l'aide from packaged_stuff.modulename import function_name

Installer

Je suppose que la même structure de dossiers que dans la question

.
└── ptdraft
    ├── __init__.py
    ├── nib.py
    └── simulations
        ├── __init__.py
        └── life
            ├── __init__.py
            └── life.py

J'appelle le .dossier racine, et dans mon cas, il se trouve dans C:\tmp\test_imports.

Pas

1) Ajoutez un setup.pyau dossier racine

Le contenu de la setup.pypeut être simplement

from setuptools import setup, find_packages

setup(name='myproject', version='1.0', packages=find_packages())

Fondamentalement, «tout» setup.pyfonctionnerait. Ceci est juste un exemple de travail minimal.

2) Utilisez un environnement virtuel

Si vous connaissez les environnements virtuels, activez-en un et passez à l'étape suivante. L'utilisation d'environnements virtuels n'est pas absolument requise, mais ils vous aideront vraiment à long terme (lorsque vous avez plus d'un projet en cours ..). Les étapes les plus élémentaires sont (exécutées dans le dossier racine)

• Créer un env virtuel
  • python -m venv venv
• Activer env virtuel
  • . /venv/bin/activate(Linux) ou ./venv/Scripts/activate(Win)

Pour en savoir plus à ce sujet, il suffit de Google sur "tutoriel python virtualenv" ou similaire. Vous n'avez probablement jamais besoin d'autres commandes que la création, l'activation et la désactivation.

Une fois que vous avez créé et activé un environnement virtuel, votre console doit donner le nom de l'environnement virtuel entre parenthèses

PS C:\tmp\test_imports> python -m venv venv
PS C:\tmp\test_imports> .\venv\Scripts\activate
(venv) PS C:\tmp\test_imports>

3) Pip installez votre projet dans un état modifiable

Installez votre package de niveau supérieur à l' myprojectaide de pip. L'astuce consiste à utiliser l' -eindicateur lors de l'installation. De cette façon, il est installé dans un état modifiable et toutes les modifications apportées aux fichiers .py seront automatiquement incluses dans le package installé.

Dans le répertoire racine, exécutez

pip install -e . (notez le point, il signifie "répertoire courant")

Vous pouvez également voir qu'il est installé à l'aide de pip freeze

(venv) PS C:\tmp\test_imports> pip install -e .
Obtaining file:///C:/tmp/test_imports
Installing collected packages: myproject
  Running setup.py develop for myproject
Successfully installed myproject
(venv) PS C:\tmp\test_imports> pip freeze
myproject==1.0

4) Importer en ajoutant mainfolderà chaque importation

Dans cet exemple, le mainfolderserait ptdraft. Cela présente l'avantage que vous ne rencontrerez pas de collisions de noms avec d'autres noms de module (à partir de la bibliothèque standard python ou de modules tiers).

Exemple d'utilisation

nib.py

def function_from_nib():
    print('I am the return value from function_from_nib!')

life.py

from ptdraft.nib import function_from_nib

if __name__ == '__main__':
    function_from_nib()

Running life.py

(venv) PS C:\tmp\test_imports> python .\ptdraft\simulations\life\life.py
I am the return value from function_from_nib!

Vous pouvez utiliser le chemin d'accès dépendant du système d'exploitation dans le "chemin de recherche de module" qui est répertorié dans sys.path . Ainsi, vous pouvez facilement ajouter un répertoire parent comme suit

import sys
sys.path.insert(0,'..')

Si vous souhaitez ajouter un répertoire parent-parent,

sys.path.insert(0,'../..')

Cela fonctionne à la fois en python 2 et 3.

Si l'ajout de votre dossier de modules au PYTHONPATH n'a pas fonctionné, vous pouvez modifier la liste sys.path dans votre programme où l'interpréteur Python recherche les modules à importer, la documentation de python indique:

Lorsqu'un module nommé spam est importé, l'interpréteur recherche d'abord un module intégré portant ce nom. S'il n'est pas trouvé, il recherche ensuite un fichier nommé spam.py dans une liste de répertoires donnée par la variable sys.path. sys.path est initialisé à partir de ces emplacements:

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

Après l'initialisation, les programmes Python peuvent modifier sys.path . Le répertoire contenant le script en cours d'exécution est placé au début du chemin de recherche, avant le chemin de bibliothèque standard. Cela signifie que les scripts de ce répertoire seront chargés à la place des modules du même nom dans le répertoire de la bibliothèque. Il s'agit d'une erreur, sauf si le remplacement est prévu.

Sachant cela, vous pouvez effectuer les opérations suivantes dans votre programme:

import sys
# Add the ptdraft folder path to the sys.path list
sys.path.append('/path/to/ptdraft/')

# Now you can import your module
from ptdraft import nib
# Or just
import ptdraft

Je ne sais pas grand-chose sur python 2.
En python 3, le dossier parent peut être ajouté comme suit:

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

... et puis on peut en importer des modules

Voici une réponse simple pour que vous puissiez voir comment cela fonctionne, petit et multiplateforme.
Il n'utilise que des modules intégrés ( os, syset inspect) et devrait donc fonctionner
sur n'importe quel système d'exploitation (OS) car Python est conçu pour cela.

Code de réponse plus court - moins de lignes et de variables

from inspect import getsourcefile
import os.path as path, sys
current_dir = path.dirname(path.abspath(getsourcefile(lambda:0)))
sys.path.insert(0, current_dir[:current_dir.rfind(path.sep)])
import my_module  # Replace "my_module" here with the module name.
sys.path.pop(0)

Pour moins de lignes que cela, remplacez la deuxième ligne par import os.path as path, sys, inspect,
ajoutez inspect.au début de getsourcefile(ligne 3) et supprimez la première ligne.
- cependant, cela importe tout le module et pourrait donc nécessiter plus de temps, de mémoire et de ressources.

Le code de ma réponse ( version longue )

from inspect import getsourcefile
import os.path
import sys

current_path = os.path.abspath(getsourcefile(lambda:0))
current_dir = os.path.dirname(current_path)
parent_dir = current_dir[:current_dir.rfind(os.path.sep)]

sys.path.insert(0, parent_dir)

import my_module  # Replace "my_module" here with the module name.

Il utilise un exemple d'une réponse Stack Overflow Comment puis-je obtenir le chemin du
fichier en cours d' exécution en Python? pour trouver la source (nom de fichier) du code en cours d'exécution avec un outil intégré.

from inspect import getsourcefile  
from os.path import abspath  

Ensuite, où que vous souhaitiez trouver le fichier source, utilisez simplement:

abspath(getsourcefile(lambda:0))

Mon code ajoute un chemin de fichier à sys.path, la liste des chemins de python
car cela permet à Python d'importer des modules de ce dossier.

Après avoir importé un module dans le code, c'est une bonne idée de s'exécuter sys.path.pop(0)sur une nouvelle ligne
lorsque ce dossier ajouté a un module portant le même nom qu'un autre module importé
plus tard dans le programme. Vous devez supprimer l'élément de liste ajouté avant l'importation, pas les autres chemins.
Si votre programme n'importe pas d'autres modules, il est prudent de ne pas supprimer le chemin du fichier car
après la fin d'un programme (ou le redémarrage du shell Python), toutes les modifications apportées sys.pathdisparaissent.

Remarques sur une variable de nom de fichier

Ma réponse n'utilise pas la __file__variable pour obtenir le chemin d'accès / nom de fichier du
code en cours d'exécution car les utilisateurs ici l'ont souvent décrit comme peu fiable . Vous ne devez pas l'utiliser
pour importer des modules du dossier parent dans des programmes utilisés par d'autres personnes.

Quelques exemples où cela ne fonctionne pas (citation de cette question Stack Overflow):

• il ne peut pas être trouvé sur certaines plates-formes • ce n'est parfois pas le chemin complet du fichier

• py2exen'a pas d' __file__attribut, mais il existe une solution de contournement
• Lorsque vous exécutez depuis IDLE avec execute()aucun __file__attribut
• OS X 10.6 où je reçois NameError: global name '__file__' is not defined

Voici une solution plus générique qui inclut le répertoire parent dans sys.path (fonctionne pour moi):

import os.path, sys
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))

J'ai trouvé que la méthode suivante fonctionne pour importer un package à partir du répertoire parent du script. Dans l'exemple, je voudrais importer des fonctions env.pydepuis le app.dbpackage.

.
└── my_application
    └── alembic
        └── env.py
    └── app
        ├── __init__.py
        └── db

import os
import sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)

Les solutions mentionnées ci-dessus conviennent également. Une autre solution à ce problème est

Si vous souhaitez importer quoi que ce soit à partir du répertoire de niveau supérieur. Alors,

from ...module_name import *

En outre, si vous souhaitez importer un module du répertoire parent. Alors,

from ..module_name import *

En outre, si vous souhaitez importer un module du répertoire parent. Alors,

from ...module_name.another_module import *

De cette façon, vous pouvez importer n'importe quelle méthode particulière si vous le souhaitez.

Pour moi, le plus court et mon oneliner préféré pour accéder au répertoire parent est:

sys.path.append(os.path.dirname(os.getcwd()))

ou:

sys.path.insert(1, os.path.dirname(os.getcwd()))

os.getcwd () renvoie le nom du répertoire de travail en cours, os.path.dirname (nom_répertoire) renvoie le nom du répertoire de celui qui a été transmis.

En fait, à mon avis, l'architecture de projet Python devrait être effectuée de la manière où aucun module du répertoire enfant n'utilisera de module du répertoire parent. Si quelque chose comme cela se produit, il vaut la peine de repenser l'arborescence du projet.

Une autre façon consiste à ajouter le répertoire parent à la variable d'environnement système PYTHONPATH.

Dans un cahier Jupyter

Tant que vous travaillez dans un bloc-notes Jupyter, cette courte solution peut être utile:

%cd ..
import nib

Cela fonctionne même sans __init__.py fichier.

Je l'ai testé avec Anaconda3 sur Linux et Windows 7.

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

Lorsqu'elle n'est pas dans un environnement de package avec des __init__.pyfichiers, la bibliothèque pathlib (incluse avec> = Python 3.4) rend très concis et intuitif l'ajout du chemin du répertoire parent au PYTHONPATH:

import sys
from pathlib import Path
sys.path.append(str(Path('.').absolute().parent))

même style que la réponse précédente - mais en moins de lignes: P

import os,sys
parentdir = os.path.dirname(__file__)
sys.path.insert(0,parentdir)

le fichier renvoie l'emplacement dans lequel vous travaillez

Travaillez avec les bibliothèques. Créez une bibliothèque appelée nib, installez-la à l'aide de setup.py, laissez-la résider dans des packages de site et vos problèmes sont résolus. Vous n'avez pas à fourrer tout ce que vous faites dans un seul paquet. Brisez-le en morceaux.

Dans un système Linux, vous pouvez créer un lien logiciel du dossier "life" vers le fichier nib.py. Ensuite, vous pouvez simplement l'importer comme:

import nib