Python: exécuter la fonction à partir de la ligne de commande

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

Pour une solution plus propre, 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ù 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, alors 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.py ou 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 quand le module est démarré à partir de la ligne de commande, auquel cas il 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, la classe et la méthode que vous souhaitez appeler et les paramètres que vous souhaitez passer. Je l'appelle PyRun et j'ai laissé l'extension. py et l'ai rendu 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 __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 passez trop, il ignore les extras. Le module doit être dans le dossier de travail actuel, mettre PyRun peut être n'importe où dans votre chemin.

Fait intéressant, si le but était d'imprimer sur la console de ligne de commande ou d'effectuer une autre opération Python minute, Vous pouvez acheminer l'entrée dans l'interpréteur python comme suit:

echo print("hi:)") | python

Ainsi que les 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 caractères

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

Si vous installez le runp paquet avec pip install runp c'est une question de course:

runp myfile.py hello

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

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

Essayez: pip install compago

Alors écrivez:

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.

Note: il y a un bug dans Python 3 en ce moment, mais fonctionne très bien avec Python 2.

Edit: une option encore meilleure, à mon avis, est le module fire de Google qui permet de passer facilement 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 __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

J'avais besoin d'utiliser divers utilitaires python (range, string, etc.) sur la ligne de commande et avait écrit l'outil pyfunc spécialement 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

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

Il est toujours possible d'entrer python sur la ligne de commande avec la commande python

, Puis importer votre fichier afin de importation example_file

Ensuite, exécutez la commande avec example_file.bonjour()

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

Peut-être pas aussi pratique qu'une seule commande, mais une bonne correction rapide de texte d'un fichier à 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 dans bash.

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

Ci-dessous est le Odd_Even_function.py fichier 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 sont les options ont fonctionné pour moi.

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

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

Merci.

Utilisez le python-c Outil ( pip installer python-C ) et ensuite simplement écrire:

$ python-c foo 'hello()'

Ou au cas où vous n'auriez 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 founction n'affichera rien dans la sortie, après cela enregistrez le fichier et copiez le chemin du fichier par un clic droit dans le dossier du fichier et cliquez sur "Copier le fichier" puis allez au terminal et écrivez: - cd "le chemin d'accès du fichier" - python "nom du fichier par exemple (main.py)" après cela, il affichera la sortie de votre code.