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!

Demasiado Largo; Para Leer

 Add passwordless user experiences to your app

HackerNoon Mobile

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

Demasiado Largo; Para Leer

People Mentioned

Company Mentioned

@marcosdelcueto

HISTORIAS RELACIONADAS