Quelle est la meilleure façon d'appeler un script à partir d'un autre script?

J'ai un script nommé test1.py qui n'est pas dans un module. Il a juste du code qui devrait s'exécuter lorsque le script lui-même est exécuté. Il n'y a pas de fonctions, classes, méthodes, etc. J'ai un autre script qui fonctionne comme un service. Je veux appeler test1.py à partir du script exécuté en tant que service.

Par exemple:

Fichier test1.py

print "I am a test"
print "see! I do nothing productive."

File service.py

# Lots of stuff here
test1.py # do whatever is in test1.py

Je connais une méthode qui ouvre le fichier, lit le contenu et l'évalue. Je suppose qu'il existe une meilleure façon de procéder. Ou du moins je l'espère.

La façon habituelle de procéder est quelque chose comme ce qui suit.

test1.py

def some_func():
    print 'in test 1, unproductive'

if __name__ == '__main__':
    # test1.py executed as script
    # do something
    some_func()

service.py

import test1

def service_func():
    print 'service func'

if __name__ == '__main__':
    # service.py executed as script
    # do something
    service_func()
    test1.some_func()

Ceci est possible dans Python 2 en utilisant

execfile("test2.py")

Consultez la documentation pour la gestion des espaces de noms, si cela est important dans votre cas.

En Python 3, cela est possible en utilisant (grâce à @fantastory)

exec(open("test2.py").read())

Cependant, vous devriez envisager d'utiliser une approche différente; votre idée (d'après ce que je peux voir) ne semble pas très propre.

Autrement:

Fichier test1.py:

print "test1.py"

Fichier service.py:

import subprocess

subprocess.call("test1.py", shell=True)

L'avantage de cette méthode est que vous n'avez pas à modifier un script Python existant pour mettre tout son code dans un sous-programme.

Documentation: Python 2 , Python 3

Si vous voulez que test1.py reste exécutable avec les mêmes fonctionnalités que lorsqu'il est appelé dans service.py, faites quelque chose comme:

test1.py

def main():
    print "I am a test"
    print "see! I do nothing productive."

if __name__ == "__main__":
    main()

service.py

import test1
# lots of stuff here
test1.main() # do whatever is in test1.py

import os

os.system("python myOtherScript.py arg1 arg2 arg3")  

En utilisant os, vous pouvez appeler directement votre terminal. Si vous voulez être encore plus précis, vous pouvez concaténer votre chaîne d'entrée avec des variables locales, c'est-à-dire.

command = 'python myOtherScript.py ' + sys.argv[1] + ' ' + sys.argv[2]
os.system(command)

Vous ne devriez pas faire ça. Au lieu de cela, faites:

test1.py:

 def print_test():
      print "I am a test"
      print "see! I do nothing productive."

service.py

#near the top
from test1 import print_test
#lots of stuff here
print_test()

Utilisation import test1 pour la 1ère utilisation - il exécutera le script. Pour les appels ultérieurs, traitez le script comme un module importé et appelez la reload(test1)méthode.

Quand reload(module)est exécuté:

• Le code des modules Python est recompilé et le code au niveau du module réexécuté , définissant un nouvel ensemble d'objets qui sont liés aux noms dans le dictionnaire du module. La fonction init des modules d'extension n'est pas appelée

Une simple vérification de sys.modulespeut être utilisée pour appeler l'action appropriée. Pour continuer à faire référence au nom du script sous forme de chaîne ( 'test1'), utilisez le module intégré ' import ()' .

import sys
if sys.modules.has_key['test1']:
    reload(sys.modules['test1'])
else:
    __import__('test1')

Je préfère runpy :

#!/usr/bin/env python
# coding: utf-8

import runpy

runpy.run_path(path_name='script-01.py')
runpy.run_path(path_name='script-02.py')
runpy.run_path(path_name='script-03.py')

Pourquoi ne pas simplement importer test1? Chaque script python est un module. Une meilleure façon serait d'avoir une fonction par exemple main / run dans test1.py, import test1 et run test1.main (). Ou vous pouvez exécuter test1.py en tant que sous-processus.

Comme cela a déjà été mentionné, runpyest un bon moyen d'exécuter d'autres scripts ou modules à partir du script actuel.

Soit dit en passant, il est assez courant qu'un traceur ou un débogueur le fasse, et dans de telles circonstances, des méthodes telles que l'importation directe du fichier ou l'exécution du fichier dans un sous-processus ne fonctionnent généralement pas.

Il doit également être utilisé execpour exécuter le code. Vous devez fournir correctement run_globalspour éviter une erreur d'importation ou d'autres problèmes. Reportez-vous à runpy._run_codepour plus de détails.

Ceci est un exemple avec la subprocessbibliothèque:

import subprocess

python_version = '3'
path_to_run = './'
py_name = '__main__.py'

# args = [f"python{python_version}", f"{path_to_run}{py_name}"]  # Avaible in python3
args = ["python{}".format(python_version), "{}{}".format(path_to_run, py_name)]

res = subprocess.Popen(args, stdout=subprocess.PIPE)
output, error_ = res.communicate()

if not error_:
    print(output)
else:
    print(error_)

Ce processus est quelque peu anti-orthodoxe, mais fonctionnerait dans toutes les versions de python,

Supposons que vous vouliez exécuter un script nommé 'recommend.py' à l'intérieur d'une condition 'if', puis utilisez,

if condition:
       import recommend

La technique est différente, mais fonctionne!