Exécuter la fonction à partir de 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?

Avec l' argument -c (commande) (en supposant que votre fichier est nommé foo.py):

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

Alternativement, si vous ne vous souciez pas de la pollution de l'espace de noms:

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

Et le juste milieu:

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

Mettez juste hello()quelque part en dessous de la fonction et elle s'exécutera lorsque vous le ferezpython your_file.py

Pour une solution plus nette, vous pouvez utiliser ceci:

if __name__ == '__main__':
    hello()

De cette façon, la fonction ne sera exécutée que si vous exécutez le fichier, pas lorsque vous importez le fichier.

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

Cependant, si hello()est votre point d'entrée principal "permanent" dans votre script Python, la façon habituelle de le faire est la suivante:

def hello():
    print "Hi :)"

if __name__ == "__main__":
    hello()

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

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

J'ai écrit un petit script Python rapide qui peut ê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 souhaitez appeler et les paramètres que vous souhaitez transmettre. Je l'appelle PyRun et ai laissé l'extension .py et l'ai rendue exécutable avec chmod + x PyRun afin que je puisse l'appeler rapidement comme suit:

./PyRun PyTest.ClassName.Method1 Param1

Enregistrez-le 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 __name__ == "__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 appelé 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 d'exécuter 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'échappement des parenthèses pour passer dans un tuple comme seul paramètre à la deuxième méthode.

Si vous passez trop peu de paramètres pour ce dont la méthode a besoin, vous obtenez une erreur. Si vous en passez trop, il ignore les extras. Le module doit être dans le dossier de travail actuel, mis PyRun peut être n'importe où sur votre chemin.

ajoutez cet extrait au bas de votre script

def myfunction():
    ...


if __name__ == '__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 localsun dictionnaire avec une table de symboles locale actuelle. Les parenthèses à la fin feront appeler la fonction.

mise à jour: 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 __name__ == '__main__':
    globals()[sys.argv[1]](sys.argv[2])

De cette façon, l'exécution python myscript.py myfunction "hello"sortira hello.

Rendons cela un peu plus facile pour nous et utilisons simplement un module ...

Essayer: 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 __name__ == "__main__":
    app.run()

Ensuite, utilisez comme ceci:

$ python test.py hello
hi there!

$ python test.py goodbye
see ya later.

Remarque: Il existe actuellement un bogue dans Python 3, mais fonctionne très bien avec Python 2.

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

Voici un exemple simple.

import fire

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

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

if __name__ == '__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

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

echo print("hi:)") | python

ainsi que des fichiers de tuyaux ..

python < foo.py

* Notez que l'extension n'a pas besoin d'être .py pour que la seconde fonctionne. ** Notez également que pour bash, vous devrez peut-être échapper aux personnages

echo print\(\"hi:\)\"\) | python

Si vous installez le package runp avec pip install runpune question de fonctionnement:

runp myfile.py hello

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

J'avais besoin d'utiliser divers utilitaires python (plage, chaîne, 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

C'est toujours une option pour entrer python sur la ligne de commande avec la commande python

puis importez votre fichier afin d' importer exemple_fichier

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

Cela évite la fonction de copie .pyc bizarre 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 fichier texte à partir de la ligne de commande, et vous permet d'utiliser python pour appeler et exécuter votre fichier.

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 en bash.

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

Ci-dessous se trouve le fichier Odd_Even_function.py qui a 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 fonctionnent 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 "d'Odd_Even_function import OE; OE (100)"

Merci.

Cette fonction ne peut pas être exécutée à partir de la ligne de commande car elle renvoie une valeur qui ne sera pas manipulée. Vous pouvez supprimer le retour et utiliser plutôt print

Utilisez l' outil python-c ( pip install python-c ) puis écrivez simplement:

$ python-c foo 'hello()'

ou si vous n'avez aucun conflit de nom de fonction dans vos fichiers python:

$ python-c 'hello()'

Vous devez d'abord appeler la fonction comme ils vous l'ont dit ou la fonction n'affichera rien dans la sortie, après cela enregistrez le fichier et copiez le chemin du fichier par un clic droit sur le dossier du fichier et cliquez sur "copier le fichier" puis allez dans le terminal et écrivez: - cd "le chemin du fichier" - python "nom du fichier par exemple (main.py)" après cela il affichera la sortie de votre code.

Simplifiez-vous la vie, installez Spyder. Ouvrez votre fichier puis exécutez-le (cliquez sur la flèche verte). Ensuite, votre hello()méthode est définie et connue de la console IPython, vous pouvez donc l'appeler à partir de la console.