Come importare altri file Python?

Come importare altri file in Python?

1. Come posso esattamente importare un file Python specifico come import file.py ?
2. Come posso importare una cartella anziché un file specifico?
3. Voglio caricare un file Python in modo dinamico in fase di esecuzione, in base all'input dell'utente.
4. Voglio sapere come caricare solo una parte specifica dal file.

Ad esempio, in main.pyho:

from extra import * 

Anche se questo mi dà tutte le definizioni extra.py, quando forse tutto ciò che voglio è una singola definizione:

def gap():
    print
    print

Quello che faccio ad aggiungere alla importdichiarazione per ottenere solo gapda extra.py?

importlibè stato aggiunto a Python 3 per importare a livello di codice un modulo. È solo un involucro in giro __import__, vedi i documenti .

import importlib

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

Nota: l' .pyestensione deve essere rimossa da moduleName. La funzione definisce anche un packageargomento per le importazioni relative.

Aggiornamento: la risposta di seguito è obsoleta . Usa l'alternativa più recente sopra.

1. Solo import filesenza l'estensione ".py".

2. È possibile contrassegnare una cartella come pacchetto, aggiungendo un file vuoto denominato __init__.py.

3. Puoi usare la __import__funzione. Prende il nome del modulo come stringa. (Ancora una volta: nome del modulo senza l'estensione ".py".)

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

   Digita help(__import__)per maggiori dettagli.

Esistono molti modi per importare un file Python, tutti con i loro pro e contro.

Non limitarti a scegliere in fretta la prima strategia di importazione che funziona per te, altrimenti dovrai riscrivere la base di codice in seguito quando scoprirai che non soddisfa le tue esigenze.

Inizierò spiegando l'esempio n. 1 più semplice, quindi mi sposterò verso l'esempio n. 7 più professionale e robusto

Esempio 1, importare un modulo Python con interprete Python:

1. Metti questo in /home/el/foo/fox.py:

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

2. Entra nell'interprete 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
   >>> 

   Hai importato fox attraverso l'interprete Python, invocato la funzione Python what_does_the_fox_say()da fox.py.

Esempio 2, Usa execfileo ( execin Python 3 ) in uno script per eseguire l'altro file python sul posto:

1. Inseriscilo in /home/el/foo2/mylib.py:

   def moobar():
     print("hi")

2. Inseriscilo in /home/el/foo2/main.py:

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

3. eseguire il file:

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

   La funzione moobar è stata importata da mylib.py e resa disponibile in main.py

Esempio 3, utilizzare dalla funzionalità ... import ...

1. Inseriscilo in /home/el/foo3/chekov.py:

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

2. Inseriscilo in /home/el/foo3/main.py:

   from chekov import question
   question()

3. Eseguilo in questo modo:

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

   Se hai definito altre funzioni in chekov.py, non sarebbero disponibili a meno che tu import *

Esempio 4, Importa riaa.py se si trova in una posizione di file diversa da quella in cui è stato importato

1. Inseriscilo in /home/el/foo4/stuff/riaa.py:

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

2. Inseriscilo in /home/el/foo4/main.py:

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

3. Eseguirlo:

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

   Ciò importa tutto nel file esterno da una directory diversa.

Esempio 5, utilizzare os.system("python yourfile.py")

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

Esempio 6, importa il tuo file tramite il piggyback dello startuphook python:

Aggiornare: questo esempio funzionava sia per python2 che per 3, ma ora funziona solo per python2. python3 si è sbarazzato di questo set di funzionalità startuphook dell'utente perché è stato abusato dagli autori di librerie python a bassa competenza, usandolo per iniettare impolitamente il loro codice nello spazio dei nomi globale, prima di tutti i programmi definiti dall'utente. Se vuoi che funzioni per python3, dovrai diventare più creativo. Se ti dico come farlo, gli sviluppatori di Python disabiliteranno anche quel set di funzionalità, quindi sei da solo.

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

Inserisci questo codice nella tua home directory in ~/.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 )

Inserisci questo codice nel tuo main.py (può essere ovunque):

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

Eseguilo, dovresti ottenere questo:

$ 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 ricevi un errore qui: ModuleNotFoundError: No module named 'user'significa che stai usando python3, startuphooks è disabilitato lì per impostazione predefinita.

Il merito di questo jist va a: https://github.com/docwhat/homedir-examples/blob/master/python-commandline/.pythonrc.py Invia lungo le tue imbarcazioni.

Esempio 7, Più robusto: importa i file in Python con il comando bare import:

1. Crea una nuova directory /home/el/foo5/
2. Crea una nuova directory /home/el/foo5/herp

3. Crea un file vuoto chiamato __init__.pysotto herp:

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

4. Crea una nuova directory / home / el / foo5 / herp / derp

5. Sotto derp, crea un altro __init__.pyfile:

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

6. Sotto / home / el / foo5 / herp / derp crea un nuovo file chiamato yolo.pyInserisci questo:

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

7. Il momento della verità, crea il nuovo file /home/el/foo5/main.py, inseriscilo;

   from herp.derp.yolo import skycake
   skycake()

8. Eseguirlo:

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

   Il __init__.pyfile vuoto comunica all'interprete python che lo sviluppatore intende che questa directory sia un pacchetto improprio.

Se vuoi vedere il mio post su come includere TUTTI i file .py in una directory vedi qui: https://stackoverflow.com/a/20753073/445131

Per importare un file Python specifico in 'runtime' con un nome noto:

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

Non hai molti metodi complessi per importare un file Python da una cartella all'altra. Basta creare un file __init__.py per dichiarare che questa cartella è un pacchetto python e quindi andare al file host dove si desidera importare semplicemente digitare

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

Import doc .. - Link per riferimento

I __init__.pyfile sono necessari per fare in modo che Python tratti le directory come pacchetti contenenti, questo per impedire alle directory con un nome comune, come stringa, di nascondere involontariamente moduli validi che si verificano successivamente nel percorso di ricerca del modulo.

__init__.pypuò essere solo un file vuoto, ma può anche eseguire il codice di inizializzazione per il pacchetto o impostare la __all__variabile.

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

Primo caso: vuoi importare file A.pyin file B.py, questi due file si trovano nella stessa cartella, in questo modo:

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

Puoi farlo nel file B.py:

import A

o

from A import *

o

from A import THINGS_YOU_WANT_TO_IMPORT_IN_A

Quindi sarai in grado di utilizzare tutte le funzioni del file A.pynel fileB.py

Secondo caso: si desidera importare file folder/A.pyin file B.py, questi due file non si trovano nella stessa cartella, in questo modo:

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

Puoi farlo nel file B:

import folder.A

o

from folder.A import *

o

from folder.A import THINGS_YOU_WANT_TO_IMPORT_IN_A

Quindi sarai in grado di utilizzare tutte le funzioni del file A.pynel fileB.py

Riepilogo: nel primo caso, file A.pyè un modulo importato in file B.py, è stata utilizzata la sintassi import module_name. Nel secondo caso, folderè il pacchetto che contiene il modulo A.py, è stata utilizzata la sintassi import package_name.module_name.

Per maggiori informazioni su pacchetti e moduli, consultare questo 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

Ecco due semplici modi in cui ho capito ormai e assicurati che il tuo file "file.py" che vuoi importare come libreria sia presente solo nella tua directory corrente.

Se la funzione definita è in un file x.py:

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

Nel file in cui stai importando la funzione, scrivi questo:

from x import greet

Ciò è utile se non si desidera importare tutte le funzioni in un file.

il modo migliore per importare file .py è tramite __init__.py. la cosa più semplice da fare è creare un file vuoto chiamato __init__.pynella stessa directory in cui si trova il tuo file .py.

questo post di Mike Grouchy è una grande spiegazione __init__.pye il suo uso per creare, importare e configurare pacchetti python.

Come importare è importare il file e usare la scorciatoia del suo nome.

import DoStuff.py as DS
DS.main()

Non dimenticare che il tuo file di importazione DEVE ESSERE nominato con estensione .py

Vorrei aggiungere questa nota che non ho chiaramente altrove; all'interno di un modulo / pacchetto, quando si carica da file, il nome del modulo / pacchetto deve essere preceduto da mymodule. Immagina di mymoduleessere in questo modo layout:

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

Quando si carica somefile.py/ otherstuff.pydal __init__.pycontenuto dovrebbe apparire come:

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

Nel caso in cui il modulo che si desidera importare non si trovi in ​​una sottodirectory , provare quanto segue ed eseguireapp.py dalla directory principale comune più profonda:

Struttura delle directory:

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

In app.py, aggiungi il percorso del client a sys.path:

import os, sys, inspect

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

Opzionale (se carichi ad es. Le configurazioni) (Inspect sembra essere il più affidabile per i miei casi d'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")

Correre

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

Questa soluzione funziona per me in cli, così come PyCharm.

Esistono due modi per includere il tuo script Python con il nome abc.py

1. ad es. se il tuo file si chiama abc.py (import abc) Il limite è che il tuo file dovrebbe essere presente nella stessa posizione in cui si trova lo script python chiamante.

import abc

2. ad es. se il tuo file python si trova nella cartella Windows. La cartella Windows è presente nella stessa posizione in cui si trova lo script python chiamante.

dalla cartella import abc

3. Lo script incase abc.py è disponibile nella cartella internal_insider presente nella cartella

da folder.internal_folder import abc

4. Come ha risposto James sopra, nel caso in cui il file si trovi in ​​una posizione fissa

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

Nel caso in cui il tuo script Python venga aggiornato e non desideri caricarlo, utilizza queste istruzioni per l'aggiornamento automatico. Bonus :)

%load_ext autoreload 
%autoreload 2

Solo per importare il file Python in un altro file Python

diciamo che ho un file python helper.py che ha una funzione di visualizzazione come,

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

Ora in app.py , puoi utilizzare la funzione di visualizzazione,

import helper
helper.display()

Il risultato,

I'm working sundar gsv

NOTA: non è necessario specificare l'estensione .py.

Questo può sembrare folle, ma puoi semplicemente creare un link simbolico al file che desideri importare se stai solo creando uno script wrapper per esso.

Puoi anche fare questo: from filename import something

esempio: si from client import Client noti che non è necessaria l' .py .pyw .pyuiestensione.

È così che ho chiamato una funzione da un file Python, che è flessibile per me chiamare qualsiasi funzione.

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)

Esistono molti modi, come elencato sopra, ma trovo che voglio solo importare il contenuto di un file e non voglio scrivere righe e righe e importare altri moduli. Quindi, ho trovato un modo per ottenere il contenuto di un file, anche con la sintassi del punto ( file.property) invece di unire il file importato con il tuo.
Prima di tutto, ecco il mio file che importerò,data.py

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

Nota: è possibile utilizzare l' .txtestensione.
In mainfile.py, inizia aprendo e ottenendo i contenuti.

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

Ora hai il contenuto come stringa, ma il tentativo di accedere data.testStringprovocherà un errore, come dataun'istanza della strclasse, e anche se ha una proprietà testStringnon farà ciò che ti aspettavi.
Quindi, crea una classe. Ad esempio (gioco di parole),ImportedFile

    class ImportedFile:

E inseriscilo (con il rientro appropriato):

    exec(data)

E infine, riassegnare in questo datamodo:

    data=ImportedFile()

E questo è tutto! Basta accedere come faresti per qualsiasi altro modulo, digitando print(data.testString)verrà stampato sulla console A string literal to import and test with.
Se, tuttavia, si desidera l'equivalente di from mod import *eliminare semplicemente la classe, l'assegnazione dell'istanza e rimuovere ilexec .

Spero che questo aiuti :)
-Benji

Una caratteristica molto sconosciuta di Python è la possibilità di importare zipfile:

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

Il file __init__.pydel pacchetto contiene quanto segue:

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

Possiamo scrivere un altro script che può importare un pacchetto dall'archivio zip. È solo necessario aggiungere il file zip a sys.path.

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

import library

def run():
    library.dummy()

run()