Como importar outros arquivos Python?

Como importo outros arquivos no Python?

1. Como exatamente posso importar um arquivo python específico como import file.py?
2. Como posso importar uma pasta em vez de um arquivo específico?
3. Quero carregar um arquivo Python dinamicamente no tempo de execução, com base na entrada do usuário.
4. Quero saber como carregar apenas uma parte específica do arquivo.

Por exemplo, em main.pyeu tenho:

from extra import * 

Embora isso me dê todas as definições extra.py, quando talvez tudo o que eu quero é uma única definição:

def gap():
    print
    print

O que posso adicionar ao importcomunicado começar apenas gapa partir de extra.py?

importlibfoi adicionado ao Python 3 para importar programaticamente um módulo. É apenas um invólucro __import__, veja os documentos .

import importlib

moduleName = input('Enter module name:')
importlib.import_module(moduleName)

Nota: a .pyextensão deve ser removida de moduleName. A função também define um packageargumento para importações relativas.

Atualização: A resposta abaixo está desatualizada . Use a alternativa mais recente acima.

1. Apenas import filesem a extensão '.py'.

2. Você pode marcar uma pasta como um pacote, adicionando um arquivo vazio chamado __init__.py.

3. Você pode usar a __import__função Leva o nome do módulo como uma sequência. (Novamente: nome do módulo sem a extensão '.py'.)

   pmName = input('Enter module name:')
   pm = __import__(pmName)
   print(dir(pm))

   Digite help(__import__)para mais detalhes.

Existem várias maneiras de importar um arquivo python, todos com seus prós e contras.

Não escolha apressadamente a primeira estratégia de importação que funcione para você, caso contrário você terá que reescrever a base de código mais tarde, quando achar que ela não atende às suas necessidades.

Começarei explicando o exemplo mais fácil nº 1, depois passarei para o exemplo mais profissional e robusto nº 7

Exemplo 1, Importe um módulo python com intérprete python:

1. Coloque isso em /home/el/foo/fox.py:

   def what_does_the_fox_say():
     print("vixens cry")

2. Entre no interpretador python:

   el@apollo:/home/el/foo$ python
   Python 2.7.3 (default, Sep 26 2013, 20:03:06) 
   >>> import fox
   >>> fox.what_does_the_fox_say()
   vixens cry
   >>> 

   Você importou o fox através do interpretador python, invocou a função python what_does_the_fox_say()de dentro do fox.py.

Exemplo 2, use execfileou ( execno Python 3 ) em um script para executar o outro arquivo python no local:

1. Coloque isso em /home/el/foo2/mylib.py:

   def moobar():
     print("hi")

2. Coloque isso em /home/el/foo2/main.py:

   execfile("/home/el/foo2/mylib.py")
   moobar()

3. execute o arquivo:

   el@apollo:/home/el/foo$ python main.py
   hi

   A função moobar foi importada do mylib.py e disponibilizada no main.py

Exemplo 3, Usar de ... importar ... funcionalidade:

1. Coloque isso em /home/el/foo3/chekov.py:

   def question():
     print "where are the nuclear wessels?"

2. Coloque isso em /home/el/foo3/main.py:

   from chekov import question
   question()

3. Execute-o assim:

   el@apollo:/home/el/foo3$ python main.py 
   where are the nuclear wessels?

   Se você definisse outras funções no chekov.py, elas não estariam disponíveis, a menos que você import *

Exemplo 4, importe riaa.py se estiver em um local de arquivo diferente de onde foi importado

1. Coloque isso em /home/el/foo4/stuff/riaa.py:

   def watchout():
     print "computers are transforming into a noose and a yoke for humans"

2. Coloque isso em /home/el/foo4/main.py:

   import sys 
   import os
   sys.path.append(os.path.abspath("/home/el/foo4/stuff"))
   from riaa import *
   watchout()

3. Executá-lo:

   el@apollo:/home/el/foo4$ python main.py 
   computers are transforming into a noose and a yoke for humans

   Isso importa tudo no arquivo externo de um diretório diferente.

Exemplo 5, use os.system("python yourfile.py")

import os
os.system("python yourfile.py")

Exemplo 6, importe seu arquivo pegando carona o python startuphook:

Atualização: este exemplo costumava funcionar para python2 e 3, mas agora só funciona para python2. O python3 se livrou desse conjunto de recursos de inicialização do usuário por ter sido abusado por escritores de bibliotecas python de baixa habilidade, usando-o para injetar impolitariamente seu código no espaço de nome global, antes de todos os programas definidos pelo usuário. Se você quiser que isso funcione para python3, precisará ser mais criativo. Se eu lhe disser como fazê-lo, os desenvolvedores de python também desabilitarão esse conjunto de recursos, então você estará por sua conta.

Consulte: https://docs.python.org/2/library/user.html

Coloque esse código no diretório inicial em ~/.pythonrc.py

class secretclass:
    def secretmessage(cls, myarg):
        return myarg + " is if.. up in the sky, the sky"
    secretmessage = classmethod( secretmessage )

    def skycake(cls):
        return "cookie and sky pie people can't go up and "
    skycake = classmethod( skycake )

Coloque esse código no seu main.py (pode estar em qualquer lugar):

import user
msg = "The only way skycake tates good" 
msg = user.secretclass.secretmessage(msg)
msg += user.secretclass.skycake()
print(msg + " have the sky pie! SKYCAKE!")

Execute-o, você deve obter o seguinte:

$ python main.py
The only way skycake tates good is if.. up in the sky, 
the skycookie and sky pie people can't go up and  have the sky pie! 
SKYCAKE!

Se você receber um erro aqui: ModuleNotFoundError: No module named 'user'significa que você está usando python3, startuphooks são desativados por padrão.

O crédito para este jist vai para: https://github.com/docwhat/homedir-examples/blob/master/python-commandline/.pythonrc.py Envie seus up-boats.

Exemplo 7, Mais robusto: importe arquivos em python com o comando bare import:

1. Crie um novo diretório /home/el/foo5/
2. Crie um novo diretório /home/el/foo5/herp

3. Crie um arquivo vazio chamado __init__.pyherp:

   el@apollo:/home/el/foo5/herp$ touch __init__.py
   el@apollo:/home/el/foo5/herp$ ls
   __init__.py

4. Crie um novo diretório / home / el / foo5 / herp / derp

5. Sob derp, crie outro __init__.pyarquivo:

   el@apollo:/home/el/foo5/herp/derp$ touch __init__.py
   el@apollo:/home/el/foo5/herp/derp$ ls
   __init__.py

6. Em / home / el / foo5 / herp / derp, crie um novo arquivo chamado yolo.pyColoque isso aqui:

   def skycake():
     print "SkyCake evolves to stay just beyond the cognitive reach of " +
     "the bulk of men. SKYCAKE!!"

7. O momento da verdade, faça o novo arquivo /home/el/foo5/main.py, coloque isso lá;

   from herp.derp.yolo import skycake
   skycake()

8. Executá-lo:

   el@apollo:/home/el/foo5$ python main.py
   SkyCake evolves to stay just beyond the cognitive reach of the bulk 
   of men. SKYCAKE!!

   O __init__.pyarquivo vazio se comunica com o intérprete python que o desenvolvedor pretende que este diretório seja um pacote importável.

Se você quiser ver minha postagem sobre como incluir TODOS os arquivos .py em um diretório, consulte aqui: https://stackoverflow.com/a/20753073/445131

Para importar um arquivo Python específico em 'runtime' com um nome conhecido:

import os
import sys

...

scriptpath = "../Test/"

# Add the directory containing your module to the Python path (wants absolute paths)
sys.path.append(os.path.abspath(scriptpath))

# Do the import
import MyModule

Você não possui muitos métodos complexos para importar um arquivo python de uma pasta para outra. Basta criar um arquivo __init__.py para declarar que esta pasta é um pacote python e, em seguida, vá para o arquivo host para o qual deseja importar, apenas digite

from root.parent.folder.file import variable, class, whatever

Import doc .. - Link para referência

Os __init__.pyarquivos são necessários para fazer o Python tratar os diretórios como contendo pacotes; isso é feito para impedir que diretórios com um nome comum, como string, ocultem involuntariamente módulos válidos que ocorrem posteriormente no caminho de pesquisa do módulo.

__init__.pypode ser apenas um arquivo vazio, mas também pode executar o código de inicialização do pacote ou definir a __all__variável

mydir/spam/__init__.py
mydir/spam/module.py
import spam.module
or
from spam import module

Primeiro caso: você deseja importar arquivo A.pyem arquivo B.py, esses dois arquivos estão na mesma pasta, assim:

. 
├── A.py 
└── B.py

Você pode fazer isso no arquivo B.py:

import A

ou

from A import *

ou

from A import THINGS_YOU_WANT_TO_IMPORT_IN_A

Então você poderá usar todas as funções de arquivo A.pyem arquivoB.py

Segundo caso: você deseja importar arquivo folder/A.pyem arquivo B.py, esses dois arquivos não estão na mesma pasta, assim:

.
├── B.py
└── folder
     └── A.py

Você pode fazer isso no arquivo B:

import folder.A

ou

from folder.A import *

ou

from folder.A import THINGS_YOU_WANT_TO_IMPORT_IN_A

Então você poderá usar todas as funções de arquivo A.pyem arquivoB.py

Resumo: no primeiro caso, arquivo A.pyé um módulo que você importa em arquivo B.py, você usou a sintaxe import module_name. No segundo caso, folderé o pacote que contém o módulo A.py, você usou a sintaxe import package_name.module_name.

Para mais informações sobre pacotes e módulos, consulte este link .

from file import function_name  ######## Importing specific function
function_name()                 ######## Calling function

e

import file              ######## Importing whole package
file.function1_name()    ######## Calling function
file.function2_name()    ######## Calling function

Aqui estão as duas maneiras simples que entendi até agora e verifique se o arquivo "file.py" que você deseja importar como biblioteca está presente apenas no diretório atual.

Se a função definida estiver em um arquivo x.py:

def greet():
    print('Hello! How are you?')

No arquivo em que você está importando a função, escreva isto:

from x import greet

Isso é útil se você não deseja importar todas as funções em um arquivo.

a melhor maneira de importar arquivos .py é por meio de __init__.py. a coisa mais simples a fazer é criar um arquivo vazio nomeado __init__.pyno mesmo diretório em que seu arquivo.py está localizado.

este post de Mike Grouchy é uma ótima explicação __init__.pye seu uso para criar, importar e configurar pacotes python.

Como eu importo é importar o arquivo e usar uma abreviação de seu nome.

import DoStuff.py as DS
DS.main()

Não esqueça que seu arquivo de importação DEVE SER nomeado com extensão .py

Eu gostaria de adicionar esta nota que não faço muito claramente em outros lugares; dentro de um módulo / pacote, ao carregar de arquivos, o nome do módulo / pacote deve ser prefixado com o mymodule. Imagine mymoduleum layout como este:

/main.py
/mymodule
    /__init__.py
    /somefile.py
    /otherstuff.py

Ao carregar somefile.py/ otherstuff.pydo __init__.pyconteúdo, deve ser semelhante a:

from mymodule.somefile import somefunc
from mymodule.otherstuff import otherfunc

Caso o módulo que você deseja importar não esteja em um subdiretório , tente o seguinte e execute a app.pypartir do diretório pai comum mais profundo:

Estrutura de Diretórios:

/path/to/common_dir/module/file.py
/path/to/common_dir/application/app.py
/path/to/common_dir/application/subpath/config.json

Em app.py, acrescente o caminho do cliente ao sys.path:

import os, sys, inspect

sys.path.append(os.getcwd())
from module.file import MyClass
instance = MyClass()

Opcional (se você carregar, por exemplo, configurações) (o Inspecionar parece ser o mais robusto para meus casos de uso)

# Get dirname from inspect module
filename = inspect.getframeinfo(inspect.currentframe()).filename
dirname = os.path.dirname(os.path.abspath(filename))
MY_CONFIG = os.path.join(dirname, "subpath/config.json")

Corre

user@host:/path/to/common_dir$ python3 application/app.py

Esta solução funciona para mim tanto em cli quanto em PyCharm.

Existem algumas maneiras de incluir seu script python com o nome abc.py

1. por exemplo, se seu arquivo for chamado abc.py (import abc), a limitação é que seu arquivo deve estar presente no mesmo local em que o script python de chamada está.

import abc

2. por exemplo, se o seu arquivo python estiver dentro da pasta do Windows. A pasta Windows está presente no mesmo local em que está o script python de chamada.

da pasta import abc

3. Caso o script abc.py esteja disponível, insider internal_folder, presente na pasta

da pasta.internal_folder import abc

4. Como respondido por James acima, caso seu arquivo esteja em algum local fixo

import os
import sys
scriptpath = "../Test/MyModule.py"
sys.path.append (os.path.abspath (scriptpath))
importar MyModule

Caso seu script python seja atualizado e você não queira fazer o upload - use estas instruções para atualização automática. Bônus :)

%load_ext autoreload 
%autoreload 2

Apenas para importar arquivo python em outro arquivo python

digamos que eu tenho o arquivo helper.py python, que tem uma função de exibição como,

def display():
    print("I'm working sundar gsv")

Agora no app.py , você pode usar a função de exibição,

import helper
helper.display()

A saída,

I'm working sundar gsv

NOTA: Não é necessário especificar a extensão .py.

Pode parecer uma loucura, mas você pode apenas criar um link simbólico para o arquivo que deseja importar se estiver criando um script de wrapper para ele.

Você também pode fazer isso: from filename import something

exemplo: from client import Client Observe que você não precisa da .py .pyw .pyuiextensão.

Foi assim que eu chamei uma função de um arquivo python, que é flexível para chamar quaisquer funções.

import os, importlib, sys

def callfunc(myfile, myfunc, *args):
    pathname, filename = os.path.split(myfile)
    sys.path.append(os.path.abspath(pathname))
    modname = os.path.splitext(filename)[0]
    mymod = importlib.import_module(modname)
    result = getattr(mymod, myfunc)(*args)
    return result

result = callfunc("pathto/myfile.py", "myfunc", arg1, arg2)

Existem várias maneiras, conforme listado acima, mas acho que só quero importar o conteúdo de um arquivo e não quero escrever linhas e linhas e importar outros módulos. Portanto, criei uma maneira de obter o conteúdo de um arquivo, mesmo com a sintaxe do ponto ( file.property), em vez de mesclar o arquivo importado com o seu.
Primeiro de tudo, aqui está o meu arquivo que eu vou importar,data.py

    testString= "A string literal to import and test with"

Nota: Você pode usar a .txtextensão.
Em mainfile.py, comece abrindo e obtendo o conteúdo.

    #!usr/bin/env python3
    Data=open('data.txt','r+').read()

Agora você tem o conteúdo como uma sequência, mas a tentativa de acessar data.testStringcausará um erro, como dataé uma instância da strclasse, e mesmo que tenha uma propriedade testString, não fará o que você esperava.
Em seguida, crie uma classe. Por exemplo (trocadilhos),ImportedFile

    class ImportedFile:

E coloque isso nele (com o recuo apropriado):

    exec(data)

E, finalmente, redesigne da seguinte datamaneira:

    data=ImportedFile()

E é isso! Basta acessar como faria em qualquer outro módulo, digitandoprint(data.testString) será impresso no console A string literal to import and test with.
Se, no entanto, você quiser o equivalente a from mod import *apenas largar a classe, a atribuição da instância e remover o exec.

Espero que isto ajude:)
-Benji

Um recurso muito desconhecido do Python é a capacidade de importar ziparquivos:

library.zip
|-library
|--__init__.py

O arquivo __init__.pydo pacote contém o seguinte:

def dummy():
    print 'Testing things out...'

Podemos escrever outro script que pode importar um pacote do arquivo zip. Só é necessário adicionar o arquivo zip ao sys.path.

import sys
sys.path.append(r'library.zip')

import library

def run():
    library.dummy()

run()