consola - Python: Ejecutar la función desde la línea de comando

ejecutar python desde cmd

Question

Tengo código debajo de mi archivo:

def hello():
return ''Hi :)''

¿Cómo ejecutaría esto desde la línea de comandos?

Answer 1

A continuación se muestra el archivo Odd_Even_function.py que tiene la definición de la función.

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

Ahora, para llamar al mismo desde el indicador de comando de abajo, están las opciones que me funcionaron.

Opciones 1 Ruta completa de exe / python.exe -c "importar Odd_Even_function; Odd_Even_function.OE (100)"

Opción 2 Ruta completa de exe / python.exe -c "desde Odd_Even_function import OE; OE (100)"

Gracias.

Answer 2

Algo como esto: 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

Esto funciona en bash.

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

Answer 3

Con el argumento -c (comando) (asumiendo que su archivo se llama foo.py ):

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

Alternativamente, si no te importa la contaminación del espacio de nombres:

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

Y el punto medio:

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

Answer 4

Curiosamente, si el objetivo era imprimir en la consola de la línea de comandos o realizar alguna otra operación de Python por un minuto, puede canalizar la entrada al intérprete de Python de la siguiente manera:

echo print("hi:)") | python

así como archivos de tuberías.

python < foo.py

* Tenga en cuenta que la extensión no tiene que ser .py para que la segunda funcione. ** También tenga en cuenta que para bash puede que necesite escapar de los personajes

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

Answer 5

Escribí un pequeño y rápido script de Python que se puede llamar desde una línea de comandos de bash. Toma el nombre del módulo, la clase y el método que desea llamar y los parámetros que desea pasar. Lo llamo PyRun y ​​dejé la extensión .py y lo hice ejecutable con chmod + x PyRun para poder llamarlo rápidamente como sigue:

./PyRun PyTest.ClassName.Method1 Param1

Guarda esto en un archivo llamado 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)

Aquí hay un ejemplo de módulo para mostrar cómo funciona. Esto se guarda en un archivo llamado 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")

Intente ejecutar estos ejemplos:

./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/)

Tenga en cuenta el último ejemplo de cómo escapar de los paréntesis para pasar una tupla como único parámetro al segundo método.

Si pasa muy pocos parámetros para lo que necesita el método, obtendrá un error. Si pasas demasiados, ignora los extras. El módulo debe estar en la carpeta de trabajo actual, puesto que PyRun puede estar en cualquier lugar de su ruta.

Answer 6

Esta función no se puede ejecutar desde la línea de comando ya que devuelve un valor que no se procesará. Puede eliminar la devolución y utilizar imprimir en su lugar.

Answer 7

Hagamos esto un poco más fácil para nosotros y solo usemos un módulo ...

Prueba: pip install compago

A continuación, escribir:

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()

Entonces use así:

$ python test.py hello
hi there!
$ python test.py goodbye
see ya later.

Nota: hay un bug en Python 3 en este momento, pero funciona muy bien con Python 2.

Edición: una opción aún mejor, en mi opinión, es el lanzamiento del módulo de Google, que también facilita la aprobación de argumentos de función. Se instala con pip install fire . De su GitHub:

Aquí hay un ejemplo simple.

import fire
class Calculator(object):
"""A simple calculator class."""
def double(self, number):
return 2 * number
if __name__ == ''__main__'':
fire.Fire(Calculator)

Luego, desde la línea de comando, puede ejecutar:

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

Answer 8

Primero tiene que llamar a la función como le dijeron o la función no mostrará nada en la salida, después de eso, guarde el archivo y copie la ruta del archivo haciendo clic derecho en la carpeta del archivo y haga clic en "copiar archivo" y luego vaya al terminal y escriba: - cd "la ruta del archivo" - python "nombre del archivo por ejemplo (main.py)" después de eso, se mostrará la salida de su código.

Answer 9

Si instala el paquete runp con pip install runp es cuestión de ejecutar:

runp myfile.py hello

Puede encontrar el repositorio en: https://github.com/vascop/runp

Answer 10

Siempre es una opción ingresar python en la línea de comando con el comando python

luego importa tu archivo así que importa ejemplo_archivo

luego ejecute el comando con example_file.hello ()

Esto evita la extraña función de copia .pyc que surge cada vez que ejecutas python -c etc.

Quizás no sea tan conveniente como un comando único, pero es una buena solución rápida para enviar un mensaje de texto desde la línea de comandos, y le permite usar Python para llamar y ejecutar su archivo.

Answer 11

Simplemente coloca hello() algún lugar debajo de la función y se ejecutará cuando hagas python your_file.py

Para una solución más ordenada puedes usar esto:

if __name__ == ''__main__'':
hello()

De esa manera, la función solo se ejecutará si ejecuta el archivo, no cuando importe el archivo.

Answer 12

Tenía el requisito de usar varias utilidades de python (rango, cadena, etc.) en la línea de comandos y había escrito la herramienta pyfunc específicamente para eso. Puedes usarlo para enriquecer tu experiencia en el uso de la línea de comandos:

 $ 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

Answer 13

Use la herramienta python-c ( pip instale python-c ) y luego simplemente escriba:

$ python-c foo ''hello()''

o en caso de que no tenga ningún conflicto de nombres de funciones en sus archivos de python:

$ python-c ''hello()''

Answer 14

agrega este fragmento al final de tu script

def myfunction():
...
if __name__ == ''__main__'':
globals()[sys.argv[1]]()

Ahora puedes llamar a tu función ejecutando

python myscript.py myfunction

Esto funciona porque está pasando el argumento de la línea de comando (una cadena del nombre de la función) a los locals , un diccionario con una tabla de símbolos local actual. Las paréntesis al final harán que se llame la función.

Answer 15

python -c ''from myfile import hello; hello()'' python -c ''from myfile import hello; hello()'' donde myfile debe reemplazarse con el nombre base de su secuencia de comandos de Python. (Por ejemplo, myfile.py convierte en myfile.py ).

Sin embargo, si hello() es su punto de entrada principal "permanente" en su script de Python, entonces la forma habitual de hacerlo es la siguiente:

def hello():
print "Hi :)"
if __name__ == "__main__":
hello()

Esto le permite ejecutar el script simplemente ejecutando python myfile.py o python -m myfile .

Algunas explicaciones aquí: __name__ es una variable especial de Python que contiene el nombre del módulo que se está ejecutando actualmente, excepto cuando el módulo se inicia desde la línea de comando, en cuyo caso se convierte en "__main__" .