Importazione di file da cartelle diverse

Ho la seguente struttura di cartelle.

application/app/folder/file.py

e voglio importare alcune funzioni da file.py in un altro file Python in cui risiede

application/app2/some_folder/some_file.py

ho provato

from application.app.folder.file import func_name

e alcuni altri vari tentativi, ma finora non sono riuscito a importare correttamente. Come posso fare questo?

Per impostazione predefinita, non puoi. Quando si importa un file, Python cerca solo la directory corrente, la directory da cui è in esecuzione lo script del punto di ingresso e sys.pathche include posizioni come la directory di installazione del pacchetto (in realtà è un po 'più complessa di questa, ma copre la maggior parte dei casi) .

Tuttavia, è possibile aggiungere al percorso Python in fase di esecuzione:

# 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

Niente di sbagliato in:

from application.app.folder.file import func_name

Assicurati solo che foldercontenga anche un __init__.py, questo consente di includerlo come pacchetto. Non sono sicuro del motivo per cui le altre risposte parlano PYTHONPATH.

Quando i moduli si trovano in posizioni parallele, come nella domanda:

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

Questa scorciatoia rende un modulo visibile all'altro:

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

Primo import sys in name-file.py

 import sys

Secondo aggiungere il percorso della cartella in name-file.py

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

Terzo Crea un file vuoto chiamato __ init __.py nella tua sottodirectory (questo dice a Python che è un pacchetto)

• name-file.py
• Nome pacchetto
  • __ init __.py
  • name-module.py

Quarto importare il modulo all'interno della cartella in name-file.py

from name-package import name-module

Penso che un modo ad hoc sarebbe usare la variabile d'ambientePYTHONPATH come descritto nella documentazione: Python2 , Python3

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

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

Le risposte qui mancano di chiarezza, questo è testato su Python 3.6

Con questa struttura di cartelle:

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

Dove myfile.pyha il contenuto:

def myfunc():
    print('hello')

La dichiarazione di importazione in main.pyè:

from myfolder.myfile import myfunc
myfunc()

e questo stamperà ciao .

Il tuo problema è che Python sta cercando nella directory Python questo file e non lo trova. Devi specificare che stai parlando della directory in cui ti trovi e non di quella di Python.

Per fare ciò, cambia questo:

from application.app.folder.file import func_name

a questo:

from .application.app.folder.file import func_name

Aggiungendo il punto che stai dicendo cerca in questa cartella la cartella dell'applicazione invece di cercare nella directory Python.

Da quello che so, aggiungere un __init__.pyfile direttamente nella cartella delle funzioni che si desidera importare farà il lavoro.

In Python 3.4 e versioni successive, è possibile importare direttamente da un file di origine (collegamento alla documentazione) . Questa non è la soluzione più semplice, ma sto includendo questa risposta per completezza.

Ecco un esempio Innanzitutto, il file da importare, denominato foo.py:

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

Il codice che importa il file sopra, fortemente ispirato all'esempio nella documentazione:

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()

Il risultato:

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

Si noti che il nome della variabile, il nome del modulo e il nome file non devono necessariamente corrispondere. Questo codice funziona ancora:

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()

Il risultato:

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

L'importazione a livello di codice dei moduli è stata introdotta in Python 3.1 e offre un maggiore controllo su come i moduli vengono importati. Fare riferimento alla documentazione per ulteriori informazioni.

Ha funzionato per me in python3 su linux

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

Prova le importazioni relative di Python:

from ...app.folder.file import func_name

Ogni punto iniziale è un altro livello superiore nella gerarchia che inizia con la directory corrente.

I problemi? Se questo non funziona per te, probabilmente stai diventando morso dalle molte importazioni relative di Gotcha. Leggi le risposte e i commenti per maggiori dettagli: Come risolvere "Tentativo di importazione relativa in non pacchetto" anche con __init__.py

Suggerimento: avere __init__.pya ogni livello di directory. Potrebbe essere necessario python -m application.app2.some_folder.some_file(tralasciando .py) che si esegue dalla directory di livello superiore o che si ha quella directory di livello superiore nel proprio PYTHONPATH. Accidenti!

Ho dovuto affrontare la stessa sfida, soprattutto durante l'importazione di più file, ecco come sono riuscito a superarlo.

import os, sys

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

from root_folder import file_name

Considerando applicationcome la directory principale per il progetto di pitone, creare un vuoto __init__.pyfile in application, appe folderle cartelle. Quindi, some_file.pyapportare le modifiche come segue per ottenere la definizione di 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'uso di sys.path.append con un percorso assoluto non è l'ideale quando si sposta l'applicazione in altri ambienti. L'uso di un percorso relativo non funzionerà sempre perché la directory di lavoro corrente dipende da come è stato invocato lo script.

Poiché la struttura delle cartelle dell'applicazione è fissa, possiamo usare os.path per ottenere il percorso completo del modulo che vogliamo importare. Ad esempio, se questa è la struttura:

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

E diciamo che vuoi importare il modulo "mango". In vanilla.py potresti fare quanto segue:

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

Ovviamente, non hai bisogno della variabile mango_dir.

Per capire come funziona questo esempio di sessione interattiva:

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

E controlla la documentazione di os.path .

Questo funziona per me su Windows

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

import some_file

Sono abbastanza speciale: uso Python con Windows!

Completo solo le informazioni: sia per Windows che per Linux, funzionano sia il percorso relativo sia quello assoluto sys.path(ho bisogno di percorsi relativi perché utilizzo i miei script sui vari PC e in diverse directory principali).

E quando si usano entrambi Windows \e /possono essere usati come separatore per i nomi dei file e ovviamente è necessario raddoppiare le \stringhe Python,
alcuni esempi validi:

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

(nota: penso che /sia più conveniente di \, evento se è meno 'nativo di Windows' perché è compatibile con Linux e più semplice da scrivere e copiare in Windows Explorer)

Se lo scopo di caricare un modulo da un percorso specifico è di aiutarti durante lo sviluppo di un modulo personalizzato, puoi creare un collegamento simbolico nella stessa cartella dello script di test che punta alla radice del modulo personalizzato. Questo riferimento al modulo avrà la precedenza su qualsiasi altro modulo installato con lo stesso nome per qualsiasi script eseguito in quella cartella.

Ho provato questo su Linux, ma dovrebbe funzionare in qualsiasi sistema operativo moderno che supporti i collegamenti simbolici.

Un vantaggio di questo approccio è che puoi indicare un modulo che si trova nella tua copia di lavoro della filiale SVC locale che può semplificare notevolmente il tempo del ciclo di sviluppo e ridurre le modalità di errore nella gestione di diverse versioni del modulo.

Nel mio caso avevo una classe da importare. Il mio file era simile al seguente:

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

Nel mio file principale ho incluso il codice tramite:

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

Ho incontrato più volte la stessa domanda, quindi vorrei condividere la mia soluzione.

Versione Python: 3.X

La seguente soluzione è per chi sviluppa la tua applicazione in Python versione 3.X perché Python 2 non è supportato dal 1 gennaio 2020 .

Struttura del progetto

In python 3, non è necessario __init__.pynella sottodirectory del progetto a causa dei pacchetti dello spazio dei nomi impliciti . See Is init non .py richiesto per i pacchetti in Python 3.3+

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

Dichiarazione problema

In file_b.py, vorrei importare una classe Ainfile_a.py cartella a.

soluzioni

# 1 Un modo rapido ma sporco

Senza installare il pacchetto come te, stai attualmente sviluppando un nuovo progetto

Utilizzando il try catchper verificare se gli errori. Esempio di codice:

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 Installa il tuo pacchetto

Una volta installata l'applicazione (in questo post, il tutorial di installazione non è incluso)

Puoi semplicemente

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

Buona programmazione!

Stavo lavorando al progetto ache volevo che gli utenti installassero pip install acon il seguente elenco di file:

.
├── 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

un / 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

Ho installato il modulo eseguendo quanto segue dalla directory con MANIFEST.in:

python setup.py install

Quindi, da una posizione totalmente diversa sul mio filesystem /moustache/armwrestlesono stato in grado di eseguire:

import a
dir(a)

Ciò ha confermato che in a.catseffetti era uguale a 0 e in a.b.dogseffetti uguale a 1, come previsto.

Invece di limitarti a fare un import ..., fai questo:

from <MySubFolder> import <MyFile>

MyFile è all'interno di MySubFolder.

Puoi aggiornare la shell di Python premendo f5 o vai su Esegui> Esegui modulo. In questo modo non è necessario modificare la directory per leggere qualcosa dal file. Python cambierà automaticamente la directory. Ma se vuoi lavorare con file diversi da directory diverse in Python Shell, puoi cambiare la directory in sys, come ha detto Cameron in precedenza.

Quindi avevo appena fatto clic con il pulsante destro del mouse sul mio IDE e ne avevo aggiunto uno nuovo foldere mi chiedevo perché non ero in grado di importarlo. Successivamente ho capito che dovevo fare clic con il tasto destro e creare un pacchetto Python e non una classica cartella del file system. Oppure un metodo post mortem che aggiunge un __init__.py(che fa in modo che Python tratti la cartella del file system come un pacchetto) come indicato in altre risposte. Aggiungendo questa risposta qui nel caso in cui qualcuno abbia seguito questa strada.

Puoi usare importlib per importare moduli in cui vuoi importare un modulo da una cartella usando una stringa in questo modo:

import importlib

scriptName = 'Snake'

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

Questo esempio ha un main.py che è il codice sopra, quindi una cartella chiamata Scripts e quindi puoi chiamare qualunque cosa ti serva da questa cartella cambiando la scriptNamevariabile. È quindi possibile utilizzare scriptper fare riferimento a questo modulo. come se avessi una funzione chiamata Hello()nel modulo Snake puoi eseguire questa funzione in questo modo:

script.Hello()

Ho provato questo in Python 3.6

Ho avuto questi problemi diverse volte. Sono venuto su questa stessa pagina molto. Nel mio ultimo problema ho dovuto eseguire il serverda una directory fissa, ma ogni volta che debug volevo eseguire da diverse sottodirectory.

import sys
sys.insert(1, /path) 

ha NON lavorare per me, perché in diversi moduli ho dovuto leggere diversi * .csv file che erano tutti nella stessa directory.

Alla fine, ciò che ha funzionato per me non era pitonico, immagino, ma:

Ho usato un if __main__ modulo in cima al quale volevo eseguire il debug , che viene eseguito da un percorso diverso dal solito.

Così:

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