web-dev-qa-db-fra.com

Exécuter la fonction depuis la ligne de commande

J'ai ce code:

def hello():
    return 'Hi :)'

Comment pourrais-je l'exécuter directement à partir de la ligne de commande?

pythonfunctioncommand-line
305
Steven

Avec l'argument -c(commande) (en supposant que votre fichier s'appelle foo.py):

$ python -c 'import foo; print foo.hello()'

Sinon, si vous ne vous souciez pas de la pollution des espaces de noms:

$ python -c 'from foo import *; print hello()'

Et le juste milieu:

$ python -c 'from foo import hello; print hello()'
480
Frédéric Hamidi

Il suffit de mettre hello() quelque part en dessous de la fonction et elle s'exécutera lorsque vous ferez python your_file.py

Pour une solution plus simple, vous pouvez utiliser ceci:

if __== '__main__':
    hello()

Ainsi, la fonction ne sera exécutée que si vous exécutez le fichier, pas lorsque vous importez le fichier.

117
Wolph

python -c 'from myfile import hello; hello()' où myfile doit être remplacé par le nom de base de votre script Python. (Par exemple, myfile.py devient myfile).

Cependant, si hello() est votre point d’entrée principal "permanent" dans votre script Python, la manière habituelle de procéder est la suivante:

def hello():
    print "Hi :)"

if __== "__main__":
    hello()

Cela vous permet d'exécuter le script simplement en exécutant python myfile.py ou python -m myfile.

Quelques explications ici: __name__ est une variable spéciale Python contenant le nom du module en cours d'exécution, sauf lorsque le module est démarré à partir de la ligne de commande, dans Dans ce cas, il devient "__main__".

52
Tamás

J'ai écrit un petit script rapide Python pouvant être appelé à partir d'une ligne de commande bash. Il prend le nom du module, de la classe et de la méthode que vous voulez appeler et les paramètres que vous voulez transmettre. Je l'appelle PyRun et ai laissé l'extension .py et je l'ai rendue exécutable avec chmod + x PyRun afin que je puisse l'appeler rapidement comme suit:

./PyRun PyTest.ClassName.Method1 Param1

Enregistrez ceci dans un fichier appelé PyRun

#!/usr/bin/env python
#make executable in bash chmod +x PyRun

import sys
import inspect
import importlib
import os

if __== "__main__":
    cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
    if cmd_folder not in sys.path:
        sys.path.insert(0, cmd_folder)

    # get the second argument from the command line      
    methodname = sys.argv[1]

    # split this into module, class and function name
    modulename, classname, funcname = methodname.split(".")

    # get pointers to the objects based on the string names
    themodule = importlib.import_module(modulename)
    theclass = getattr(themodule, classname)
    thefunc = getattr(theclass, funcname)

    # pass all the parameters from the third until the end of 
    # what the function needs & ignore the rest
    args = inspect.getargspec(thefunc)
    z = len(args[0]) + 2
    params=sys.argv[2:z]
    thefunc(*params)

Voici un exemple de module pour montrer comment cela fonctionne. Ceci est enregistré dans un fichier nommé PyTest.py:

class SomeClass:
 @staticmethod
 def First():
     print "First"

 @staticmethod
 def Second(x):
    print(x)
    # for x1 in x:
    #     print x1

 @staticmethod
 def Third(x, y):
     print x
     print y

class OtherClass:
    @staticmethod
    def Uno():
        print("Uno")

Essayez de lancer ces exemples:

./PyRun PyTest.SomeClass.First
./PyRun PyTest.SomeClass.Second Hello
./PyRun PyTest.SomeClass.Third Hello World
./PyRun PyTest.OtherClass.Uno
./PyRun PyTest.SomeClass.Second "Hello"
./PyRun PyTest.SomeClass.Second \(Hello, World\)

Notez le dernier exemple d'échapper les parenthèses pour transmettre un Tuple en tant que paramètre unique de la méthode Second.

Si vous transmettez trop peu de paramètres pour les besoins de la méthode, vous obtenez une erreur. Si vous en passez trop, les extras sont ignorés. Le module doit être dans le dossier de travail en cours, PyRun peut être n'importe où dans votre chemin.

24
Joseph Gagliardo

ajoutez cet extrait au bas de votre script

def myfunction():
    ...


if __== '__main__':
    globals()[sys.argv[1]]()

Vous pouvez maintenant appeler votre fonction en exécutant

python myscript.py myfunction

Cela fonctionne parce que vous passez l'argument de ligne de commande (une chaîne du nom de la fonction) dans locals, un dictionnaire avec une table de symboles locale en cours. Les parenthèses à la fin feront que la fonction sera appelée.

pdate: Si vous souhaitez que la fonction accepte un paramètre de la ligne de commande, vous pouvez passer sys.argv[2] comme ceci:

def myfunction(mystring):
    print mystring


if __== '__main__':
    globals()[sys.argv[1]](sys.argv[2])

De cette façon, exécuter python myscript.py myfunction "hello" produira hello.

13
Noam Hacker

Rendons cela un peu plus facile avec nous-mêmes et utilisons simplement un module ...

Essayez: pip install compago

Puis écrire:

import compago
app = compago.Application()

@app.command
def hello():
    print "hi there!"

@app.command
def goodbye():
    print "see ya later."

if __== "__main__":
    app.run()

Alors utilisez comme ceci:

$ python test.py hello
hi there!

$ python test.py goodbye
see ya later.

Remarque: Il y a un bug dans Python 3 pour le moment, mais fonctionne très bien avec Python 2.

Edit: Une option encore meilleure, à mon avis, est le module fire de Google, qui facilite également le passage des arguments de fonction . Il est installé avec pip install fire. De leur GitHub:

Voici un exemple simple.

import fire

class Calculator(object):
  """A simple calculator class."""

  def double(self, number):
    return 2 * number

if __== '__main__':
  fire.Fire(Calculator)

Ensuite, à partir de la ligne de commande, vous pouvez exécuter:

python calculator.py double 10  # 20
python calculator.py double --number=15  # 30
5
Charles Clayton

Fait intéressant, si l'objectif était d'imprimer sur la console de ligne de commande ou d'effectuer une autre opération minute python, vous pouvez diriger l'entrée vers l'interpréteur python comme suit:

echo print("hi:)") | python

ainsi que des fichiers de pipe ..

python < foo.py

* Notez que l'extension ne doit pas nécessairement être .py pour que la seconde fonctionne. ** Notez également que pour bash, vous devrez peut-être échapper aux caractères

echo print\(\"hi:\)\"\) | python
5
Torie J

Si vous installez le paquet runp avec pip install runp, vous devez exécuter:

runp myfile.py hello

Vous pouvez trouver le référentiel sur: https://github.com/vascop/runp

5
vascop

J'avais besoin d'utiliser divers utilitaires python (plage, chaîne de caractères, etc.) sur la ligne de commande et j'avais écrit l'outil pyfunc spécifiquement pour cela. Vous pouvez l'utiliser pour enrichir votre expérience d'utilisation de la ligne de commande:

 $ pyfunc -m range -a 1 7 2
 1
 3
 5

 $ pyfunc -m string.upper -a test
 TEST

 $ pyfunc -m string.replace -a 'analyze what' 'what' 'this'
 analyze this
4
Saurabh Hirani

Quelque chose comme ça: call_from_terminal.py

# call_from_terminal.py
# Ex to run from terminal
# ip='"hi"'
# python -c "import call_from_terminal as cft; cft.test_term_fun(${ip})"
# or
# fun_name='call_from_terminal'
# python -c "import ${fun_name} as cft; cft.test_term_fun(${ip})"
def test_term_fun(ip):
    print ip

Cela fonctionne à bash.

$ ip='"hi"' ; fun_name='call_from_terminal' 
$ python -c "import ${fun_name} as cft; cft.test_term_fun(${ip})"
hi
1
Al Conrad

Il est toujours possible d'entrer python sur la ligne de commande à l'aide de la commande python

puis importez votre fichier afin import example_file

puis exécutez la commande avec example_file.hello ()

Cela évite la fonction bizarre de copie .pyc qui apparaît chaque fois que vous exécutez python -c etc.

Peut-être pas aussi pratique qu'une commande unique, mais une bonne solution rapide pour envoyer un texte à un fichier à partir de la ligne de commande et vous permet d'utiliser python pour appeler et exécuter votre fichier.

1
user2495144

Ci-dessous se trouve le fichier Odd_Even_function.py qui contient la définition de la fonction.

def OE(n):
    for a in range(n):
        if a % 2 == 0:
            print(a)
        else:
            print(a, "ODD")

Maintenant, pour appeler la même chose à partir de l'invite de commande ci-dessous, les options ont fonctionné pour moi.

Options 1 Chemin complet de l'exe\python.exe -c "import Odd_Even_function; Odd_Even_function.OE (100)"

Option 2 Chemin complet de l'exe\python.exe -c "à partir de Odd_Even_function import OE; OE (100)"

Merci.

1
moxit mehta

Cette fonction ne peut pas être exécutée à partir de la ligne de commande car elle retourne une valeur qui restera non gérée. Vous pouvez supprimer le retour et utiliser print à la place

0
Shubham