Si es un programador de Python, es muy probable que tenga experiencia en secuencias de comandos de shell. No es raro enfrentarse a una tarea que parece trivial de resolver con un comando de shell. Por lo tanto, es útil familiarizarse con cómo llamar a estos comandos de manera eficiente desde su código Python y conocer sus limitaciones.  En este breve artículo, discuto cómo usar el antiguo (aunque aún relativamente común)  comando y el más nuevo  dominio. Mostraré algunos de sus riesgos potenciales, limitaciones y proporcionaré ejemplos completos de su uso.   os.system   subprocess  Los comandos externos pueden ser una opción atractiva para tareas pequeñas si está familiarizado con ellos y la alternativa de Python implicaría más tiempo de aprendizaje/implementación. Sin embargo, las funciones de Python le ahorrarán tiempo y problemas a largo plazo.  Opción 1: OS.system (obsoleto)  Muestro a continuación un ejemplo sencillo de  para imprimir la primera línea de un archivo proporcionado por el usuario, usando  .    os.system   head -n 1      os   command =     filename = input(   )   return_value = os.system(command+filename) print(   ) print(   , return_value) #!/usr/bin/env python3 import # Define command and options wanted "head -n 1 " # Ask user for file name(s) - SECURITY RISK: susceptible to shell injection "Please introduce name of file of interest:\n" # Run os.system and save return_value '###############' 'Return Value:'  los  La función es fácil de usar e interpretar: simplemente use como entrada de la función el mismo comando que usaría en un shell. Sin embargo, está en desuso y   ahora.   os.system se recomienda su uso   subprocess  Tenga en cuenta que esta función simplemente ejecutará el comando de shell y el resultado se imprimirá en la salida estándar, pero la salida que devuelve la función es el   (0 si se ejecutó correctamente y diferente de 0 en caso contrario). valor de retorno   1.1: Susceptibilidad a la inyección de caparazón  Entre otros inconvenientes,  ejecuta directamente el comando en un shell, lo que significa que es susceptible a   (también conocida como inyección de comando). Puede leer más sobre esto en   por Anthony Shaw).   os.system la inyección de shell 10 problemas de seguridad comunes en Python y cómo evitarlos  La inyección de Shell es un problema cada vez que  está recibiendo una entrada sin formato, como por ejemplo cuando un usuario puede introducir un nombre de archivo, como en el ejemplo anterior. Puede intentar ejecutar el script anterior y dar la siguiente entrada:   os.system   dummy; touch harmful_file  Esto dará como resultado que el shell haga:   head -n 1 dummy; touch harmful_file  Como resultado, el programa ejecutará primero  , como se esperaba, pero luego ejecutará el comando  para crear un archivo llamado 'archivo_dañino'.   head -n 1 dummy   touch harmful_file  De acuerdo, este archivo vacío no es una gran amenaza, pero puede imaginar a un usuario agregando comandos adicionales para crear un archivo con propósitos nefastos reales. Esta inyección de shell también se puede usar para simplemente transferir o eliminar información. Por ejemplo, uno podría usar  ,  o cualquier otro comando potencialmente peligroso (¡por favor   los intente!).   ;rm -rf ~   ;rm -rf / , no  Opción 2: subprocess.call  (recomendado para Python<3.5)   2.1: forma no segura de ejecutar comandos de shell externos  Una alternativa preferible es  . Como os.sys, la función subprocess.call devuelve el   como salida. Un primer enfoque ingenuo para el subproceso es usar el  opción. De esta forma, el comando deseado también se ejecutará en una subcapa. Tenga en cuenta que esto   se recomienda, ya que tiene los mismos riesgos de seguridad potenciales que  . Por ejemplo, el siguiente código sería equivalente al anterior  ejemplo.    subprocess.call valor devuelto   shell=True no   os.system   os.system      subprocess   command =     filename = input(   )   return_value = subprocess.call(command+filename, shell=   ) print(   ) print(   , return_value) #!/usr/bin/env python3 import # Define command and options wanted "head -n 1 " # Ask user for file name(s) - SECURITY RISK: susceptible to shell injection "Please introduce name of file of interest:\n" # Run subprocess.call and save return_value True '###############' 'Return value:'   2.2: Forma preferida de ejecutar comandos externos  Una forma preferible de correr  es usando  (es la opción por defecto, por lo que no es necesario especificarla). Entonces, simplemente podemos llamar  , dónde  contiene el comando, y  contiene todas las opciones adicionales al comando.    subprocess.call   shell=False   subprocess.call(args)   agrs[0]   args[1:]      subprocess   command =   options =     filename = input(   )   args=[] args.append(command) args.append(options)   i   filename.split(): args.append(i)   return_value = subprocess.call(args) print(   ) print(   , return_value) #!/usr/bin/env python3 import # Define command and options wanted "head" "-n 1" # Ask user for file name(s) - now it's safe from shell injection "Please introduce name(s) of file(s) of interest:\n" # Create list with arguments for subprocess.call for in # Run subprocess.call and save return_value '###############' 'Return value:'   2.3: Obtener salida estándar:   subprocess.check_output  Como se mencionó antes,  devuelve el   . Sin embargo, a veces nos puede interesar la salida estándar devuelta por el comando de shell. En este caso, podemos hacer uso de  .   subprocess.call valor devuelto   subprocess.check_output  Para hacer que nuestro script sea más sólido, podemos agregar una declaración de prueba/exclusión para tratar situaciones en las que  genera un error (en este caso, por ejemplo, cuando no se encuentra ningún archivo).   check_output  Como se muestra a continuación, podemos usar  en la cláusula de excepción para tratar el error de forma controlada y obtener información al respecto.    subprocess.CalledProcessError      subprocess   command =   options =     filename = input(   )   args=[] args.append(command) args.append(options)   i   filename.split(): args.append(i)     : output = subprocess.check_output(args)   print(   ) print(   , output.decode(   ))     subprocess.CalledProcessError   error: print(   , error.returncode,   , error.output.decode(   )) #!/usr/bin/env python3 import # Define command and options wanted "head" "-n 1" # Ask user for file name(s) - now it's safe from shell injection "Please introduce name(s) of file(s) of interest:\n" # Create list with arguments for subprocess.check_output for in # Run subprocess.check_output and save command output try # use decode function to convert to string '###############' 'Output:' "utf-8" # If check_output returns an error: except as 'Error code:' '. Output:' "utf-8"  Opción 3: subprocess.run  (recomendado desde Python 3.5)  La   , desde Python 3.5, es con el  función. Es más seguro y fácil de usar que las opciones anteriores discutidas. forma recomendada de ejecutar comandos de shell externos   subprocess.run  De forma predeterminada, esta función devuelve un objeto con el comando de entrada y el código de retorno. También se puede obtener fácilmente la salida estándar usando la opción  y finalmente recuperar el código de retorno y la salida del comando usando:  y  , respectivamente.    capture_output=True   output.returncode   output.stdout      subprocess   command =   options =     filename = input(   )   args=[] args.append(command) args.append(options)   i   filename.split(): args.append(i)   output = subprocess.run(args,capture_output=   ) print(   ) print(   , output.returncode)   print(   ,output.stdout.decode(   )) #!/usr/bin/env python3 import # Define command and options wanted "head" "-n 1" # Ask user for file name(s) - now it's safe from shell injection "Please introduce name(s) of file(s) of interest:\n" # Create list with arguments for subprocess.run for in # Run subprocess.run and save output object True '###############' 'Return code:' # use decode function to convert to string 'Output:' "utf-8"  Nota final sobre los comandos de Shell en Python  Si está pensando en usar cualquiera de los métodos discutidos aquí para llamar a un comando externo, podría valer la pena considerar si existe una función estándar de Python que le permita realizar la misma tarea y evitará la creación de un nuevo proceso. Tenga en cuenta que el uso de comandos externos también hace que su programa sea menos compatible con varias plataformas.  Los comandos externos pueden ser una opción atractiva para tareas pequeñas si está familiarizado con ellos y la alternativa de Python implicaría más tiempo de aprendizaje/implementación.  Sin embargo, apegarse a las funciones de Python le ahorrará tiempo de cálculo y problemas a largo plazo, por lo que los comandos externos deben guardarse para tareas que no se pueden lograr con las bibliotecas estándar de Python.  ¡Espero que este artículo te haya ayudado a llamar comandos externos desde tu código python!  Imagen destacada de   en   , usada con permiso. JPucket Design Instagram

Instagram

Visit my science and programming blog

Read My Stories

Este audio es producido en el idioma original de la historia!

Llamar a los comandos de Shell desde Python: OS.system vs Subprocess

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

El modelo Bitcoin UTXO, impulsando un ecosistema único

Telegram: el puente de Crypto Island hacia el continente

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

El modelo Bitcoin UTXO, impulsando un ecosistema único

Telegram: el puente de Crypto Island hacia el continente

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps