¿Cómo importar otros archivos de Python?

¿Cómo importo otros archivos en Python?

1. ¿Cómo puedo importar exactamente un archivo Python específico import file.py?
2. ¿Cómo puedo importar una carpeta en lugar de un archivo específico?
3. Quiero cargar un archivo Python dinámicamente en tiempo de ejecución, basado en la entrada del usuario.
4. Quiero saber cómo cargar solo una parte específica del archivo.

Por ejemplo, en main.pytengo:

from extra import * 

Aunque esto me da todas las definiciones extra.py, cuando quizás todo lo que quiero es una sola definición:

def gap():
    print
    print

Lo agrego a la importdeclaración para obtener sólo gapa partir extra.py?

importlibse agregó a Python 3 para importar mediante programación un módulo. Es solo una envoltura __import__, vea los documentos .

import importlib

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

Nota: la .pyextensión debe eliminarse de moduleName. La función también define un packageargumento para las importaciones relativas.

Actualización: la respuesta a continuación está desactualizada . Use la alternativa más reciente arriba.

1. Solo import filesin la extensión '.py'.

2. Puede marcar una carpeta como un paquete, agregando un archivo vacío llamado __init__.py.

3. Puedes usar la __import__función. Toma el nombre del módulo como una cadena. (Nuevamente: nombre del módulo sin la extensión '.py').

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

   Escriba help(__import__)para más detalles.

Hay muchas formas de importar un archivo de Python, todas con sus ventajas y desventajas.

No solo elijas apresuradamente la primera estrategia de importación que funcione para ti o de lo contrario tendrás que reescribir la base de código más adelante cuando descubras que no satisface tus necesidades.

Comenzaré explicando el ejemplo más fácil # 1, luego avanzaré hacia el ejemplo más profesional y robusto # 7

Ejemplo 1, Importe un módulo de Python con el intérprete de Python:

1. Ponga esto en /home/el/foo/fox.py:

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

2. Entra en el intérprete de 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
   >>> 

   Importó Fox a través del intérprete de Python, invocó la función Python what_does_the_fox_say()desde fox.py.

Ejemplo 2, Use execfileo ( execen Python 3 ) en un script para ejecutar el otro archivo de Python en su lugar:

1. Ponga esto en /home/el/foo2/mylib.py:

   def moobar():
     print("hi")

2. Ponga esto en /home/el/foo2/main.py:

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

3. ejecuta el archivo:

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

   La función moobar se importó de mylib.py y se puso a disposición en main.py

Ejemplo 3, Uso de ... importar ... funcionalidad:

1. Ponga esto en /home/el/foo3/chekov.py:

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

2. Ponga esto en /home/el/foo3/main.py:

   from chekov import question
   question()

3. Ejecútelo así:

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

   Si definió otras funciones en chekov.py, no estarán disponibles a menos que usted import *

Ejemplo 4, Importar riaa.py si está en una ubicación de archivo diferente de donde se importa

1. Ponga esto en /home/el/foo4/stuff/riaa.py:

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

2. Ponga esto en /home/el/foo4/main.py:

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

3. Ejecutarlo:

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

   Eso importa todo en el archivo externo desde un directorio diferente.

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

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

Ejemplo 6, importe su archivo mediante piggybacking del python startuphook:

Actualización: este ejemplo solía funcionar para python2 y 3, pero ahora solo funciona para python2. python3 se deshizo de este conjunto de características de gancho de inicio de usuario porque fue abusado por escritores de bibliotecas de python de baja habilidad, que lo usaron para inyectar su código en el espacio de nombres global, antes de todos los programas definidos por el usuario. Si quieres que esto funcione para python3, tendrás que ser más creativo. Si le digo cómo hacerlo, los desarrolladores de Python también deshabilitarán ese conjunto de características, por lo que estará solo.

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

Ponga este código en su directorio de inicio en ~/.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 )

Pon este código en tu main.py (puede estar en cualquier 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!")

Ejecútelo, debería obtener esto:

$ 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!

Si recibe un error aquí: ModuleNotFoundError: No module named 'user'significa que está usando python3, los ganchos de inicio están deshabilitados allí de forma predeterminada.

El crédito para este jist va a: https://github.com/docwhat/homedir-examples/blob/master/python-commandline/.pythonrc.py Envíe sus botes.

Ejemplo 7, más robusto: importe archivos en python con el comando de importación simple:

1. Hacer un nuevo directorio /home/el/foo5/
2. Hacer un nuevo directorio /home/el/foo5/herp

3. Haga un archivo vacío nombrado __init__.pybajo herp:

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

4. Haga un nuevo directorio / home / el / foo5 / herp / derp

5. En derp, crea otro __init__.pyarchivo:

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

6. En / home / el / foo5 / herp / derp crea un nuevo archivo llamado yolo.pyPonga esto allí:

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

7. El momento de la verdad, crea el nuevo archivo /home/el/foo5/main.py, pon esto allí;

   from herp.derp.yolo import skycake
   skycake()

8. Ejecutarlo:

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

   El __init__.pyarchivo vacío comunica al intérprete de Python que el desarrollador pretende que este directorio sea un paquete importable.

Si desea ver mi publicación sobre cómo incluir TODOS los archivos .py en un directorio, consulte aquí: https://stackoverflow.com/a/20753073/445131

Para importar un archivo Python específico en 'tiempo de ejecución' con un nombre conocido:

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

No tiene muchos métodos complejos para importar un archivo de Python de una carpeta a otra. Simplemente cree un archivo __init__.py para declarar que esta carpeta es un paquete de Python y luego vaya a su archivo host donde desea importar simplemente escriba

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

Importar documento .. - Enlace para referencia

Los __init__.pyarchivos son necesarios para hacer que Python trate los directorios como paquetes que contienen paquetes, esto se hace para evitar que los directorios con un nombre común, como cadena, oculten involuntariamente módulos válidos que ocurren más adelante en la ruta de búsqueda del módulo.

__init__.pypuede ser un archivo vacío, pero también puede ejecutar el código de inicialización del paquete o establecer la __all__variable.

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

Primer caso: desea importar el archivo A.pyen el archivo B.py, estos dos archivos están en la misma carpeta, así:

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

Puedes hacer esto en el archivo B.py:

import A

o

from A import *

o

from A import THINGS_YOU_WANT_TO_IMPORT_IN_A

Entonces podrá utilizar todas las funciones de archivo A.pyen archivoB.py

Segundo caso: desea importar un archivo folder/A.pyen un archivo B.py, estos dos archivos no están en la misma carpeta, de esta manera:

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

Puede hacer esto en el archivo B:

import folder.A

o

from folder.A import *

o

from folder.A import THINGS_YOU_WANT_TO_IMPORT_IN_A

Entonces podrá utilizar todas las funciones de archivo A.pyen archivoB.py

Resumen: en el primer caso, el archivo A.pyes un módulo que importa en el archivo B.py, utilizó la sintaxis import module_name. En el segundo caso, folderes el paquete que contiene el módulo A.py, utilizó la sintaxis import package_name.module_name.

Para obtener más información sobre paquetes y módulos, consulte este enlace .

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

y

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

Estas son las dos formas simples que he entendido hasta ahora y asegúrese de que su archivo "file.py" que desea importar como biblioteca esté presente solo en su directorio actual.

Si la función definida está en un archivo x.py:

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

En el archivo donde está importando la función, escriba esto:

from x import greet

Esto es útil si no desea importar todas las funciones en un archivo.

la mejor manera de importar archivos .py es a través de __init__.py. Lo más sencillo es crear un archivo vacío nombrado __init__.pyen el mismo directorio en el que se encuentra su archivo .py.

Esta publicación de Mike Grouchy es una gran explicación __init__.pyy su uso para hacer, importar y configurar paquetes de Python.

Lo que importo es importar el archivo y usar la abreviatura de su nombre.

import DoStuff.py as DS
DS.main()

No olvide que su archivo de importación DEBE SER nombrado con la extensión .py

Me gustaría agregar esta nota que no veo muy claramente en otra parte dentro de un módulo / paquete, al cargar desde archivos, el nombre del módulo / paquete debe tener el prefijo mymodule. Imagina mymoduleser un diseño como este:

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

Al cargar somefile.py/ otherstuff.pydesde __init__.pyel contenido debe verse así:

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

En caso de que el módulo que desea importar no esté en un subdirectorio , intente lo siguiente y ejecute app.pydesde el directorio principal común más profundo:

Estructura de directorios:

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

En app.py, agregue la ruta del cliente a sys.path:

import os, sys, inspect

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

Opcional (si carga, por ejemplo, configuraciones) (Inspeccionar parece ser el más robusto para mis 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")

correr

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

Esta solución me funciona en cli, así como en PyCharm.

Hay un par de formas de incluir su script de Python con el nombre abc.py

1. por ejemplo, si su archivo se llama abc.py (import abc) La limitación es que su archivo debe estar presente en la misma ubicación donde está su script de python de llamada.

importar abc

2. por ejemplo, si su archivo de Python está dentro de la carpeta de Windows. La carpeta de Windows está presente en la misma ubicación donde está el script de Python que realiza la llamada.

de la carpeta importar abc

3. La secuencia de comandos abc.py de Incase está disponible dentro de la carpeta interna que está presente dentro de la carpeta

from folder.internal_folder import abc

4. Como respondió James anteriormente, en caso de que su archivo se encuentre en una ubicación fija

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

En caso de que su script de Python se actualice y no quiera cargarlo, use estas declaraciones para la actualización automática. Bonus :)

%load_ext autoreload 
%autoreload 2

Solo para importar un archivo de Python en otro archivo de Python

digamos que tengo un archivo python helper.py que tiene una función de visualización como,

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

Ahora en app.py , puede usar la función de visualización,

import helper
helper.display()

La salida,

I'm working sundar gsv

NOTA: No es necesario especificar la extensión .py.

Esto puede parecer una locura, pero puede crear un enlace simbólico al archivo que desea importar si solo está creando un script de envoltura.

También puedes hacer esto: from filename import something

ejemplo: from client import Client tenga en cuenta que no necesita la .py .pyw .pyuiextensión.

Así es como hice para llamar a una función desde un archivo de Python, que es flexible para que llame a cualquier función.

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)

Hay muchas formas, como se enumeró anteriormente, pero encuentro que solo quiero importar el contenido de un archivo, y no quiero tener que escribir líneas y líneas y tener que importar otros módulos. Entonces, se me ocurrió una forma de obtener el contenido de un archivo, incluso con la sintaxis de puntos ( file.property) en lugar de fusionar el archivo importado con el suyo.
En primer lugar, aquí está mi archivo que importaré,data.py

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

Nota: Puede usar la .txtextensión en su lugar.
En mainfile.py, comience abriendo y obteniendo los contenidos.

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

Ahora tiene el contenido como una cadena, pero intentar acceder data.testStringprovocará un error, como dataes una instancia de la strclase, e incluso si tiene una propiedad testString, no hará lo que esperaba.
Luego, crea una clase. Por ejemplo (juego de palabras),ImportedFile

    class ImportedFile:

Y poner esto en ello (con la sangría adecuada):

    exec(data)

Y finalmente, reasignar dataasí:

    data=ImportedFile()

¡Y eso es! Simplemente acceda como lo haría para cualquier otro módulo, la escritura print(data.testString)se imprimirá en la consola A string literal to import and test with.
Sin embargo, si desea el equivalente de from mod import *simplemente abandonar la clase, la asignación de instancia y eliminar la exec.

Espero que esto ayude :)
-Benji

Una característica muy desconocida de Python es la capacidad de importar ziparchivos:

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

El archivo __init__.pydel paquete contiene lo siguiente:

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

Podemos escribir otro script que pueda importar un paquete desde el archivo zip. Solo es necesario agregar el archivo zip a sys.path.

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

import library

def run():
    library.dummy()

run()