Sto eseguendo Python 2.5.

Questo è il mio albero delle cartelle:

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

(Ho anche __init__.pyin ogni cartella, omesso qui per leggibilità)

Come importare il nibmodulo dall'interno del lifemodulo? Spero sia possibile fare a meno di armeggiare con sys.path.

Nota: il modulo principale in esecuzione si trova nella ptdraftcartella.

Sembra che il problema non sia correlato al fatto che il modulo si trova in una directory padre o qualcosa del genere.

Devi aggiungere la directory che contiene ptdrafta PYTHONPATH

Hai detto che ha import nibfunzionato con te, probabilmente significa che hai aggiunto ptdraftse stesso (non il suo genitore) a PYTHONPATH.

È possibile utilizzare le importazioni relative (python> = 2.5):

from ... import nib

(Novità di Python 2.5) PEP 328: importazioni assolute e relative

EDIT : aggiunto un altro punto '.' per salire due pacchi

Le importazioni relative (come in from .. import mymodule) funzionano solo in un pacchetto. Per importare "mymodule" che si trova nella directory principale del modulo corrente:

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

modifica : l' __file__attributo non viene sempre assegnato. Invece di utilizzare os.path.abspath(__file__)ora ho suggerito di utilizzare il modulo inspect per recuperare il nome file (e il percorso) del file corrente

Ho pubblicato una risposta simile anche alla domanda relativa alle importazioni da pacchetti di pari livello. Puoi vederlo qui .

Soluzione senza sys.pathhack

Sommario

• Avvolgere il codice in una cartella (ad es. packaged_stuff)
• Usa lo setup.pyscript di creazione in cui usi setuptools.setup () .
• Pip installa il pacchetto in stato modificabile con pip install -e <myproject_folder>
• Importa utilizzando from packaged_stuff.modulename import function_name

Impostare

Presumo la stessa struttura di cartelle della domanda

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

Chiamo la .cartella principale e nel mio caso si trova in C:\tmp\test_imports.

passi

1) Aggiungi setup.pya alla cartella principale

Il contenuto di setup.pypuò essere semplicemente

from setuptools import setup, find_packages

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

Fondamentalmente "qualsiasi" setup.pyavrebbe funzionato. Questo è solo un esempio minimo di lavoro.

2) Utilizzare un ambiente virtuale

Se hai familiarità con gli ambienti virtuali, attivane uno e vai al passaggio successivo. L'uso di ambienti virtuali non è assolutamente necessario, ma ti aiuteranno davvero a lungo termine (quando hai in corso più di 1 progetto ...). I passaggi più basilari sono (esegui nella cartella principale)

• Crea un ambiente virtuale
  • python -m venv venv
• Attiva env virtuale
  • . /venv/bin/activate(Linux) o ./venv/Scripts/activate(Win)

Per saperne di più su questo, basta Google "tutorial Python virtualenv" o simili. Probabilmente non avrai mai bisogno di altri comandi oltre a creare, attivare e disattivare.

Dopo aver creato e attivato un ambiente virtuale, la console dovrebbe fornire il nome dell'ambiente virtuale tra parentesi

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 installa il tuo progetto in stato modificabile

Installa il tuo pacchetto di livello superiore myprojectutilizzando pip. Il trucco è usare la -ebandiera durante l'installazione. In questo modo viene installato in uno stato modificabile e tutte le modifiche apportate ai file .py verranno automaticamente incluse nel pacchetto installato.

Nella directory principale, eseguire

pip install -e . (notare il punto, sta per "directory corrente")

Puoi anche vedere che è installato usando 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) Importa anteponendo mainfolderad ogni importazione

In questo esempio, mainfoldersarebbe ptdraft. Ciò ha il vantaggio di non incorrere in collisioni di nomi con altri nomi di moduli (dalla libreria standard di Python o da moduli di terze parti).

Esempio di utilizzo

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!

È possibile utilizzare il sistema operativo in base al percorso nel "percorso di ricerca del modulo" che è elencato in sys.path . Quindi puoi facilmente aggiungere la directory principale come segue

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

Se vuoi aggiungere la directory genitore-genitore,

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

Funziona sia in Python 2 che 3.

Se l'aggiunta della cartella del modulo a PYTHONPATH non ha funzionato, è possibile modificare l' elenco sys.path nel programma in cui l'interprete Python cerca i moduli da importare, la documentazione di Python dice:

Quando viene importato un modulo chiamato spam , l'interprete cerca prima un modulo integrato con quel nome. Se non lo trova, cerca un file chiamato spam.py in un elenco di directory fornito dalla variabile sys.path. sys.path è inizializzato da queste posizioni:

• la directory contenente lo script di input (o la directory corrente).
• PYTHONPATH (un elenco di nomi di directory, con la stessa sintassi della variabile shell PATH).
• l'impostazione predefinita dipendente dall'installazione.

Dopo l'inizializzazione, i programmi Python possono modificare sys.path . La directory contenente lo script in esecuzione viene posizionata all'inizio del percorso di ricerca, davanti al percorso della libreria standard. Ciò significa che verranno caricati gli script in quella directory anziché i moduli con lo stesso nome nella directory della libreria. Questo è un errore a meno che non sia prevista la sostituzione.

Sapendo questo, puoi fare quanto segue nel tuo programma:

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

Non so molto di Python 2.
In Python 3, la cartella padre può essere aggiunta come segue:

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

... e quindi si è in grado di importare moduli da esso

Ecco una risposta semplice in modo da poter vedere come funziona, piccola e multipiattaforma.
Esso utilizza solo incorporato moduli ( os, syse inspect) così dovrebbe funzionare
su qualsiasi sistema operativo (OS) perché Python è progettato per questo.

Codice più breve per la risposta: meno righe e variabili

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)

Per meno righe di questa, sostituire la seconda riga con import os.path as path, sys, inspect,
aggiungere inspect.all'inizio di getsourcefile(riga 3) e rimuovere la prima riga.
- tuttavia, questo importa tutto il modulo, quindi potrebbe essere necessario più tempo, memoria e risorse.

Il codice per la mia risposta ( versione più lunga )

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.

Usa un esempio da una risposta Stack Overflow Come posso ottenere il percorso del
file attualmente eseguito in Python? per trovare l'origine (nome file) del codice in esecuzione con uno strumento integrato.

from inspect import getsourcefile  
from os.path import abspath  

Quindi, ovunque tu voglia trovare il file sorgente da te, basta usare:

abspath(getsourcefile(lambda:0))

Il mio codice aggiunge un percorso di file a sys.path, l' elenco dei percorsi di Python
, perché questo permette Python per i moduli di importazione da quella cartella.

Dopo aver importato un modulo nel codice, è una buona idea eseguire sys.path.pop(0)su una nuova riga
quando quella cartella aggiunta ha un modulo con lo stesso nome di un altro modulo che viene importato
successivamente nel programma. È necessario rimuovere l'elemento dell'elenco aggiunto prima dell'importazione, non altri percorsi.
Se il tuo programma non importa altri moduli, è sicuro non eliminare il percorso del file perché
dopo la fine di un programma (o il riavvio della shell Python), tutte le modifiche apportate asys.path scompaiono.

Note su una variabile di nome file

La mia risposta non usa la __file__variabile per ottenere il percorso del file / nome file del
codice in esecuzione perché gli utenti qui lo hanno spesso descritto come inaffidabile . Non dovresti usarlo
per importare moduli dalla cartella genitore nei programmi usati da altre persone.

Alcuni esempi in cui non funziona (citazione da questa domanda Stack Overflow):

• non può essere trovato su alcune piattaforme • a volte non è il percorso completo del file

• py2exenon ha un __file__attributo, ma esiste una soluzione alternativa
• Quando si esegue da IDLE con execute()non esiste alcun __file__attributo
• OS X 10.6 dove ottengo NameError: global name '__file__' is not defined

Ecco una soluzione più generica che include la directory principale in sys.path (funziona per me):

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

Ho trovato il seguente modo funziona per importare un pacchetto dalla directory padre dello script. Nell'esempio, vorrei importare le funzioni env.pydal app.dbpacchetto.

.
└── 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)

Anche le soluzioni sopra menzionate vanno bene. Un'altra soluzione a questo problema è

Se vuoi importare qualcosa dalla directory di livello superiore. Poi,

from ...module_name import *

Inoltre, se si desidera importare qualsiasi modulo dalla directory principale. Poi,

from ..module_name import *

Inoltre, se si desidera importare qualsiasi modulo dalla directory principale. Poi,

from ...module_name.another_module import *

In questo modo è possibile importare qualsiasi metodo particolare se lo si desidera.

Per me il più breve e il mio oneliner preferito per accedere alla directory principale è:

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

o:

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

os.getcwd () restituisce il nome della directory di lavoro corrente, os.path.dirname (directory_name) restituisce il nome della directory per quella passata.

In realtà, a mio avviso, l'architettura del progetto Python dovrebbe essere eseguita nel modo in cui nessun modulo dalla directory figlio utilizzerà alcun modulo dalla directory padre. Se succede qualcosa del genere, vale la pena ripensare all'albero del progetto.

Un altro modo è aggiungere la directory principale alla variabile di ambiente di sistema PYTHONPATH.

In un quaderno Jupyter

Finché lavori in un notebook Jupyter, questa breve soluzione potrebbe essere utile:

%cd ..
import nib

Funziona anche senza __init__.py file.

L'ho provato con Anaconda3 su Linux e Windows 7.

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

Quando non ci si trova in un ambiente pacchetto con __init__.pyfile, la libreria pathlib (inclusa con> = Python 3.4) rende molto conciso e intuitivo aggiungere il percorso della directory padre al PYTHONPATH:

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

stesso tipo di stile della risposta passata, ma in meno righe: P

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

il file restituisce la posizione in cui si sta lavorando

Lavora con le biblioteche. Crea una libreria chiamata pennino, installala usando setup.py, lascia che risieda nei pacchetti del sito e i tuoi problemi sono risolti. Non devi riempire tutto ciò che fai in un unico pacchetto. Spezzalo in pezzi.

In un sistema Linux, è possibile creare un collegamento software dalla cartella "life" al file nib.py. Quindi, puoi semplicemente importarlo come:

import nib