Estou executando o Python 2.5.

Esta é a minha árvore de pastas:

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

(Eu também tenho __init__.pyem cada pasta, omitido aqui para facilitar a leitura)

Como importo o nibmódulo de dentro do lifemódulo? Espero que seja possível fazer sem mexer com sys.path.

Nota: O módulo principal em execução está na ptdraftpasta.

Parece que o problema não está relacionado ao fato de o módulo estar em um diretório pai ou algo assim.

Você precisa adicionar o diretório que contém ptdraftao PYTHONPATH

Você disse que import nibtrabalhou com você, o que provavelmente significa que você se adicionou ptdraft(e não o pai) ao PITONONA.

Você pode usar importações relativas (python> = 2.5):

from ... import nib

(O que há de novo no Python 2.5) PEP 328: importações absolutas e relativas

EDIT : adicionado outro ponto '.' subir dois pacotes

As importações relativas (como em from .. import mymodule) funcionam apenas em um pacote. Para importar 'mymodule' que está no diretório pai do seu módulo atual:

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

editar : o __file__atributo nem sempre é fornecido. Em vez de usar os.path.abspath(__file__), agora sugeri o uso do módulo inspecionar para recuperar o nome do arquivo (e o caminho) do arquivo atual

Também postei uma resposta semelhante à pergunta sobre importações de pacotes de irmãos. Você pode vê-lo aqui .

Solução sem sys.pathhacks

Sumário

• Coloque o código em uma pasta (por exemplo packaged_stuff)
• Use o setup.pyscript create onde você usa setuptools.setup () .
• O Pip instala o pacote no estado editável com pip install -e <myproject_folder>
• Importar usando from packaged_stuff.modulename import function_name

Configuração

Eu assumo a mesma estrutura de pastas da pergunta

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

Eu chamo a .pasta raiz e, no meu caso, está localizada em C:\tmp\test_imports.

Passos

1) Adicione um setup.pyà pasta raiz

O conteúdo do setup.pypode ser simplesmente

from setuptools import setup, find_packages

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

Basicamente "qualquer" setup.pyfuncionaria. Este é apenas um exemplo de trabalho mínimo.

2) Use um ambiente virtual

Se você estiver familiarizado com ambientes virtuais, ative um e pule para a próxima etapa. O uso de ambientes virtuais não é absolutamente necessário, mas eles realmente o ajudarão a longo prazo (quando você tiver mais de um projeto em andamento ..). As etapas mais básicas são (executadas na pasta raiz)

• Criar ambiente virtual
  • python -m venv venv
• Ativar env virtual
  • . /venv/bin/activate(Linux) ou ./venv/Scripts/activate(Win)

Para saber mais sobre isso, basta pesquisar no Google "python virtualenv tutorial" ou similar. Você provavelmente nunca precisará de outros comandos além de criar, ativar e desativar.

Depois de criar e ativar um ambiente virtual, seu console deve fornecer o nome do ambiente virtual entre parênteses.

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 instala seu projeto em estado editável

Instale seu pacote de nível superior myprojectusando pip. O truque é usar a -ebandeira ao fazer a instalação. Dessa forma, ele é instalado em um estado editável e todas as edições feitas nos arquivos .py serão automaticamente incluídas no pacote instalado.

No diretório raiz, execute

pip install -e . (observe o ponto, significa "diretório atual")

Você também pode ver que ele está instalado 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) Importe anexando anteriormente mainfoldera cada importação

Neste exemplo, o mainfolderseria ptdraft. Isso tem a vantagem de não ocorrer colisões de nomes com outros nomes de módulos (da biblioteca padrão do python ou de módulos de terceiros).

Exemplo de uso

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

Executando life.py

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

Você pode usar o caminho dependente do SO no "caminho de pesquisa do módulo", listado em sys.path . Assim, você pode adicionar facilmente o diretório pai como segue

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

Se você deseja adicionar o diretório pai-pai,

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

Isso funciona no python 2 e 3.

Se a adição da pasta do módulo ao PYTHONPATH não funcionou, você pode modificar a lista sys.path no seu programa em que o interpretador Python procura os módulos a serem importados, a documentação do python diz:

Quando um módulo chamado spam é importado, o intérprete primeiro procura um módulo interno com esse nome. Se não for encontrado, ele procurará um arquivo chamado spam.py em uma lista de diretórios fornecida pela variável sys.path. sys.path é inicializado a partir desses locais:

• o diretório que contém o script de entrada (ou o diretório atual).
• PYTHONPATH (uma lista de nomes de diretório, com a mesma sintaxe que a variável de shell PATH).
• o padrão dependente da instalação.

Após a inicialização, os programas Python podem modificar o sys.path . O diretório que contém o script que está sendo executado é colocado no início do caminho de pesquisa, à frente do caminho da biblioteca padrão. Isso significa que os scripts nesse diretório serão carregados em vez de módulos com o mesmo nome no diretório da biblioteca. Este é um erro, a menos que a substituição seja intencional.

Sabendo disso, você pode fazer o seguinte em seu programa:

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

Não sabe muito sobre o python 2.
No python 3, a pasta pai pode ser adicionada da seguinte maneira:

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

... e então é possível importar módulos dele

Aqui está uma resposta simples, para que você possa ver como funciona, pequeno e multiplataforma.
Ele usa apenas módulos internos ( os, syse inspect), portanto, deve funcionar
em qualquer sistema operacional (SO) porque o Python foi projetado para isso.

Código mais curto para resposta - menos linhas e variáveis

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)

Por menos linhas que isso, substitua a segunda linha por import os.path as path, sys, inspect,
adicione inspect.no início de getsourcefile(linha 3) e remova a primeira linha.
- no entanto, isso importa todo o módulo, portanto, pode precisar de mais tempo, memória e recursos.

O código da minha resposta ( versão mais longa )

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.

Ele usa um exemplo de uma resposta de estouro de pilha. Como obtenho o caminho do
arquivo executado atualmente no Python? para encontrar a fonte (nome do arquivo) do código em execução com uma ferramenta interna.

from inspect import getsourcefile  
from os.path import abspath  

Em seguida, onde você quiser encontrar o arquivo de origem, basta usar:

abspath(getsourcefile(lambda:0))

Meu código adiciona um caminho de arquivo à lista de caminhossys.path do python,
porque isso permite que o Python importe módulos dessa pasta.

Depois de importar um módulo no código, é uma boa ideia executar sys.path.pop(0)uma nova linha
quando a pasta adicionada tiver um módulo com o mesmo nome que outro módulo importado
posteriormente no programa. Você precisa remover o item da lista adicionado antes da importação, e não outros caminhos.
Se o seu programa não importar outros módulos, é seguro não excluir o caminho do arquivo, porque
após o término de um programa (ou a reinicialização do shell do Python), as edições são feitas para sys.pathdesaparecer.

Notas sobre uma variável de nome de arquivo

Minha resposta não usa a __file__variável para obter o caminho do arquivo / nome do arquivo em execução
, porque os usuários aqui a descrevem como não confiável . Você não deve usá-lo
para importar módulos da pasta pai em programas usados ​​por outras pessoas.

Alguns exemplos em que não funciona (cite esta questão do Stack Overflow):

• não pode ser encontrado em algumas plataformas • às vezes não é o caminho completo do arquivo

• py2exenão tem um __file__atributo, mas há uma solução alternativa
• Quando você executa a partir do IDLE com execute()nenhum __file__atributo
• OS X 10.6 onde eu recebo NameError: global name '__file__' is not defined

Aqui está uma solução mais genérica que inclui o diretório pai no sys.path (funciona para mim):

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

Eu achei a seguinte maneira para importar um pacote do diretório pai do script. No exemplo, eu gostaria de importar funções env.pydo app.dbpacote.

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

As soluções acima mencionadas também são boas. Outra solução para esse problema é

Se você deseja importar algo do diretório de nível superior. Então,

from ...module_name import *

Além disso, se você deseja importar qualquer módulo do diretório pai. Então,

from ..module_name import *

Além disso, se você deseja importar qualquer módulo do diretório pai. Então,

from ...module_name.another_module import *

Dessa forma, você pode importar qualquer método específico, se desejar.

Para mim, o mais curto e meu oneliner favorito para acessar o diretório pai é:

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

ou:

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

os.getcwd () retorna o nome do diretório ativo atual, os.path.dirname (directory_name) retorna o nome do diretório para o passado.

Na verdade, na minha opinião, a arquitetura do projeto Python deve ser feita da maneira que nenhum módulo do diretório filho usará nenhum módulo do diretório pai. Se algo assim acontecer, vale a pena repensar sobre a árvore do projeto.

Outra maneira é adicionar o diretório pai à variável de ambiente do sistema PYTHONPATH.

Em um caderno Jupyter

Desde que você esteja trabalhando em um notebook Jupyter, esta solução curta pode ser útil:

%cd ..
import nib

Funciona mesmo sem um __init__.py arquivo.

Eu testei com o Anaconda3 no Linux e Windows 7.

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

Quando não está em um ambiente de pacote com __init__.pyarquivos, a biblioteca pathlib (incluída em> = Python 3.4) torna muito conciso e intuitivo anexar o caminho do diretório pai ao PYTHONPATH:

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

mesmo tipo de estilo que a resposta anterior - mas em menos linhas: P

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

O arquivo retorna o local em que você está trabalhando

Trabalhar com bibliotecas. Crie uma biblioteca chamada nib, instale-a usando setup.py, deixe-a residir nos pacotes do site e seus problemas serão resolvidos. Você não precisa encher tudo o que faz em um único pacote. Quebrá-lo em pedaços.

Em um sistema Linux, você pode criar um link virtual da pasta "life" para o arquivo nib.py. Em seguida, você pode simplesmente importá-lo como:

import nib