Come eseguire le importazioni relative in Python?

Immagina questa struttura di directory:

app/
   __init__.py
   sub1/
      __init__.py
      mod1.py
   sub2/
      __init__.py
      mod2.py

Sto codificando mod1e devo importare qualcosa da mod2. Come dovrei farlo?

Ho provato from ..sub2 import mod2ma sto ottenendo un "Tentativo di importazione relativa in non pacchetto".

Ho cercato su Google ma ho trovato solo sys.pathhack di " manipolazione". Non c'è un modo pulito?

Modifica: tutti i miei __init__.pysono attualmente vuoti

Edit2: Sto cercando di fare questo perché sub2 contiene classi che sono condivisi tra i pacchetti di sub ( sub1, subX, ecc).

Edit3: il comportamento che sto cercando è lo stesso descritto in PEP 366 (grazie John B)

Tutti sembrano voler dirti cosa dovresti fare invece di rispondere alla domanda.

Il problema è che stai eseguendo il modulo come '__main__' passando il mod1.py come argomento all'interprete.

Da PEP 328 :

Le importazioni relative utilizzano l'attributo __name__ di un modulo per determinare la posizione di quel modulo nella gerarchia dei pacchetti. Se il nome del modulo non contiene informazioni sul pacchetto (ad es. È impostato su '__main__'), le importazioni relative vengono risolte come se il modulo fosse un modulo di livello superiore, indipendentemente da dove si trova effettivamente il modulo sul file system.

In Python 2.6, stanno aggiungendo la possibilità di fare riferimento ai moduli relativi al modulo principale. PEP 366 descrive la modifica.

Aggiornamento : Secondo Nick Coghlan, l'alternativa consigliata è far funzionare il modulo all'interno del pacchetto usando l'opzione -m.

Ecco la soluzione che funziona per me:

Faccio le importazioni relative come from ..sub2 import mod2 e poi, se voglio correre, mod1.pyvado nella directory padre apped eseguo il modulo usando l'opzione python -m come python -m app.sub1.mod1.

Il vero motivo per cui questo problema si verifica con le importazioni relative è che le importazioni relative funzionano prendendo la __name__proprietà del modulo. Se il modulo viene eseguito direttamente, __name__è impostato su __main__e non contiene alcuna informazione sulla struttura del pacchetto. Ed è per questo che Python si lamenta relative import in non-packagedell'errore.

Quindi, usando l'opzione -m fornisci le informazioni sulla struttura del pacchetto a Python, attraverso le quali può risolvere con successo le relative importazioni.

Ho riscontrato questo problema molte volte durante le importazioni relative. E, dopo aver letto tutte le risposte precedenti, non ero ancora in grado di capire come risolverlo, in modo pulito, senza la necessità di inserire il codice boilerplate in tutti i file. (Sebbene alcuni dei commenti siano stati davvero utili, grazie a @ncoghlan e @XiongChiamiov)

Spero che questo aiuti qualcuno che sta lottando con il problema delle importazioni relative, perché passare attraverso PEP non è davvero divertente.

main.py
setup.py
app/ ->
    __init__.py
    package_a/ ->
       __init__.py
       module_a.py
    package_b/ ->
       __init__.py
       module_b.py

1. Tu corri python main.py.
2. main.py fa: import app.package_a.module_a
3. module_a.py fa import app.package_b.module_b

In alternativa 2 o 3 potrebbero usare: from app.package_a import module_a

Funzionerà per tutto il tempo che hai appnel tuo PYTHONPATH. main.pypotrebbe essere ovunque allora.

Quindi scrivi a setup.pyper copiare (installare) l'intero pacchetto dell'app e i pacchetti secondari nelle cartelle Python del sistema di main.pydestinazione e nelle cartelle degli script del sistema di destinazione.

"Guido vede gli script in esecuzione all'interno di un pacchetto come anti-pattern" (rifiutato PEP-3122 )

Ho trascorso così tanto tempo a cercare una soluzione, leggendo i post correlati qui su Stack Overflow e dicendo a me stesso "deve esserci un modo migliore!". Sembra che non ci sia.

Questo è risolto al 100%:

• app /
  • main.py
• impostazioni/
  • local_setings.py

Importa impostazioni / local_setting.py in app / main.py:

main.py:

import sys
sys.path.insert(0, "../settings")


try:
    from local_settings import *
except ImportError:
    print('No Import')

def import_path(fullpath):
    """ 
    Import a file with full path specification. Allows one to
    import from anywhere, something __import__ does not do. 
    """
    path, filename = os.path.split(fullpath)
    filename, ext = os.path.splitext(filename)
    sys.path.append(path)
    module = __import__(filename)
    reload(module) # Might be out of date
    del sys.path[-1]
    return module

Sto usando questo frammento per importare moduli da percorsi, spero che sia d'aiuto

spiegazione della nosklo'srisposta con esempi

nota: tutti i __init__.pyfile sono vuoti.

main.py
app/ ->
    __init__.py
    package_a/ ->
       __init__.py
       fun_a.py
    package_b/ ->
       __init__.py
       fun_b.py

app / package_a / fun_a.py

def print_a():
    print 'This is a function in dir package_a'

app / package_b / fun_b.py

from app.package_a.fun_a import print_a
def print_b():
    print 'This is a function in dir package_b'
    print 'going to call a function in dir package_a'
    print '-'*30
    print_a()

main.py

from app.package_b import fun_b
fun_b.print_b()

se lo esegui $ python main.pyrestituisce:

This is a function in dir package_b
going to call a function in dir package_a
------------------------------
This is a function in dir package_a

• main.py fa: from app.package_b import fun_b
• fun_b.py lo fa from app.package_a.fun_a import print_a

quindi file nella cartella package_butilizzato file nella cartella package_a, che è quello che vuoi. Giusto??

Questo è purtroppo un hack sys.path, ma funziona abbastanza bene.

Ho riscontrato questo problema con un altro livello: avevo già un modulo con il nome specificato, ma era il modulo sbagliato.

quello che volevo fare era il seguente (il modulo da cui lavoravo era module3):

mymodule\
   __init__.py
   mymodule1\
      __init__.py
      mymodule1_1
   mymodule2\
      __init__.py
      mymodule2_1


import mymodule.mymodule1.mymodule1_1  

Nota che ho già installato mymodule, ma nella mia installazione non ho "mymodule1"

e otterrei un ImportError perché stava cercando di importare dai miei moduli installati.

Ho provato a fare un sys.path.append e non ha funzionato. Ciò che ha funzionato è stato un sys.path.insert

if __name__ == '__main__':
    sys.path.insert(0, '../..')

È una specie di hack, ma ha funzionato tutto! Quindi tieni a mente, se vuoi che la tua decisione abbia la precedenza su altri percorsi, allora devi usare sys.path.insert (0, nome percorso) per farlo funzionare! Questo è stato un punto critico molto frustrante per me, molte persone dicono di usare la funzione "append" a sys.path, ma non funziona se hai già un modulo definito (lo trovo un comportamento molto strano)

Lascia che lo metta qui per mio riferimento. So che non è un buon codice Python, ma avevo bisogno di uno script per un progetto su cui stavo lavorando e volevo mettere lo script in una scriptsdirectory.

import os.path
import sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))

Come dice @EvgeniSergeev nei commenti all'OP, è possibile importare il codice da un .pyfile in una posizione arbitraria con:

import imp

foo = imp.load_source('module.name', '/path/to/file.py')
foo.MyClass()

Questo è tratto da questa risposta SO .

Dai un'occhiata a http://docs.python.org/whatsnew/2.5.html#pep-328-absolute-and-relative-imports . Si potrebbe fare

from .mod1 import stuff

Dal documento Python ,

In Python 2.5, puoi cambiare il comportamento dell'importazione in importazioni assolute usando una from __future__ import absolute_importdirettiva. Questo comportamento di importazione assoluta diventerà l'impostazione predefinita in una versione futura (probabilmente Python 2.7). Una volta che le importazioni assolute sono predefinite, import stringtroverà sempre la versione della libreria standard. Si suggerisce agli utenti di iniziare a utilizzare il più possibile le importazioni assolute, quindi è preferibile iniziare a scrivere from pkg import stringnel codice

Ho trovato più facile impostare la variabile di ambiente "PYTHONPATH" sulla cartella principale:

bash$ export PYTHONPATH=/PATH/TO/APP

poi:

import sub1.func1
#...more import

ovviamente PYTHONPATH è "globale", ma non ha ancora sollevato problemi per me.

Oltre a ciò che ha detto John B, sembra che l'impostazione della __package__variabile dovrebbe aiutare, invece di cambiare__main__ che potrebbe rovinare altre cose. Ma per quanto ho potuto testare, non funziona completamente come dovrebbe.

Ho lo stesso problema e né PEP 328 o 366 risolvono completamente il problema, poiché entrambi, alla fine della giornata, hanno bisogno che il capo del pacchetto sia incluso in sys.path , per quanto ho potuto capire.

Dovrei anche menzionare che non ho trovato il modo di formattare la stringa che dovrebbe andare in quelle variabili. È "package_head.subfolder.module_name"o cosa?

Devi aggiungere il percorso del modulo a PYTHONPATH:

export PYTHONPATH="${PYTHONPATH}:/path/to/your/module/"