Cree una secuencia de comandos de Python para abrir una nueva terminal y ejecutar comandos en Linux

1. Cree una secuencia de comandos de Python que abra una nueva terminal y ejecute comandos en Linux
2. Crear secuencia de comandos de Python para comprobar la versión de Python en Linux
3. Script de Python para mantener viva una terminal abierta y ejecutar comandos en ella
4. Pase comandos a la nueva terminal usando el submódulo Python subprocess() en Linux
5. Conclusión

El sistema operativo Linux es conocido por su terminal versátil que los programadores usan ampliamente. Pero hay situaciones en las que nos encontramos escribiendo el mismo conjunto de sintaxis repetidamente, lo que puede ser aburrido y consumir mucho tiempo.

¿Alguna vez se ha preguntado si existe una forma de preescribir comandos de Linux en un archivo y luego ejecutarlos de inmediato en la terminal? ¡Sí! Puede.

Puede escribir sintaxis de terminal preescrita en un archivo y ejecutarlo todo a la vez escribiendo una secuencia de comandos de Python. Este artículo explica cómo crear un script de Python para abrir una nueva terminal y ejecutar un comando para nosotros.

Cree una secuencia de comandos de Python que abra una nueva terminal y ejecute comandos en Linux

Antes de comenzar, revisemos algunos conceptos básicos. Los scripts de Python se ejecutan en las interfaces de línea de comandos localizando el archivo y luego ejecutándolo. Estos archivos se ejecutan y muestran la salida.

Hay muchas formas de crear un script de Python para abrir una nueva terminal y ejecutar un comando. El primer ejemplo muestra cómo crear un script de Python que pasa un comando de Linux para verificar la versión de Python dentro del sistema.

Crear secuencia de comandos de Python para comprobar la versión de Python en Linux

Si se necesita verificar la versión de Python escribiendo directamente el comando en la terminal, se usa esta sintaxis:

python3 --version

Que muestra la versión de Python dentro del sistema, como la siguiente:

jay@jay-virtual-machine:~$ python3 --version
Python 3.10.6

Esta es una sintaxis de línea de comando, lo que significa que solo se puede escribir en una terminal. Si se desea escribir como texto plano dentro de un archivo de texto con extensión .py (ej: test.py), dará error.

python3 --version

Producción :

jay@jay-virtual-machine:~$ python3 test.py
Traceback (most recent call last):
  File "/home/jay/test.py", line 1, in <module>
    python3 --version
NameError: name 'python3' is not defined

Se debe crear una secuencia de comandos de Python para que la sintaxis sea significativa tanto para el compilador de Python como para el terminal para resolver este problema.

Para crear un script de Python para abrir una nueva terminal y ejecutar un comando, cree un archivo de texto con la extensión .py y escriba la siguiente sintaxis:

import os

My_Cmmnd = "python3 --version"
os.system("gnome-terminal -e 'bash -c \"" + My_Cmmnd + ";bash\"'")

¿Qué hace el código?

1. El módulo Python os se importa en la primera línea de código. Este módulo ayuda a pasar comandos al sistema operativo.

2. La sintaxis de la línea de comandos que debe ejecutarse se almacena en la variable llamada My_Cmmnd. La sintaxis utilizada en este ejemplo verifica la versión de Python del sistema.

   My_Cmmnd = "python3 --version"
   

3. La tercera línea de código envía el comando al sistema.

   os.system("gnome-terminal -e 'bash -c \"" + My_Cmmnd + ";bash\"'")
   

El fragmento de código anterior hace lo siguiente:

1. El os.system() inicia una subcapa y ejecuta el comando dentro de los corchetes.
2. El comando gnome-terminal abre un nuevo gnome-terminal dentro del sistema operativo Linux.
3. El contenido de la variable My_Cmmnd se envía como un comando Bash al nuevo terminal para ejecutarlo.

El script ejecuta la sintaxis y muestra el resultado deseado.

Python 3.10.6
jay@jay-virtual-machine:~$

Script de Python para mantener viva una terminal abierta y ejecutar comandos en ella

El último ejemplo mostró cómo crear un script de Python para abrir una nueva terminal y ejecutar un comando almacenándolo dentro de una variable.

Por otro lado, si la sintaxis es un comando de una línea, se puede poner directamente sin almacenarlo dentro de una variable. Cree un archivo con la extensión .py y escriba la siguiente sintaxis:

import os

os.system("gnome-terminal -e 'bash -c \"python3 --version\" '")

La sintaxis anterior inicia una nueva terminal y ejecuta el comando. Pero el uso de este método cierra el terminal inmediatamente después de ejecutar el comando.

Resolver este problema requiere colocar un temporizador de reposo con el comando:

import os

os.system("gnome-terminal -e 'bash -c \"python3 --version; sleep 5\" '")

La sintaxis anterior mantiene abierta la nueva terminal durante 5 segundos, aunque se puede aumentar según el requisito. Si se requiere que el terminal se mantenga indefinidamente activo, use la siguiente sintaxis.

import os

os.system("gnome-terminal -e 'bash -c \"python3 --version; bash\" '")

Esto mantiene el terminal abierto y activo hasta que el usuario lo cierra.

Pase comandos a la nueva terminal usando el submódulo Python subprocess() en Linux

Aprendimos cómo crear un script de Python para abrir una nueva terminal y ejecutar un comando usando el submódulo os de Python. Aunque ya no se recomienda usar esta biblioteca integrada para pasar comandos al terminal.

Esto se debe a que os ha quedado obsoleto en las versiones más recientes de Python. Para evitar riesgos de seguridad, se debe usar el submódulo de Python subprocess en su lugar.

Para crear un script de Python para abrir una nueva terminal y ejecutar un comando usando subproceso, cree un archivo con una extensión .py similar a los ejemplos anteriores, y escriba este código dentro:

import subprocess

My_Cmmnd = "ls"

process = subprocess.Popen(
    "gnome-terminal -e 'bash -c \"" + My_Cmmnd + ";bash\"'",
    stdout=subprocess.PIPE,
    stderr=None,
    shell=True,
)

El comando UNIX ls enumera los archivos en el directorio actual. Como resultado, se muestra una lista de los archivos en el directorio actual si se ejecuta este comando.

Primero se importa el módulo subprocess(); luego, los comandos se almacenan en una variable. Dentro de la variable denominada proceso, se definen los argumentos para el subproceso().

El constructor subprocess.Popen lanza un proceso hijo dentro de un nuevo gnome-terminal cuando lee la sintaxis gnome-terminal -e. Por último, la secuencia de comandos de Python abre una nueva terminal y ejecuta el comando.

Producción :

jay@jay-virtual-machine:~$ python3 test.py
Desktop    Downloads  Pictures	snap	   test2.py  Videos
Documents  Music      Public	Templates  test.py

Para conocer otras características que proporciona el shell de Linux, exploremos el uso de subprocess() para enviar argumentos al shell. Por ejemplo, el comando en el programa a continuación, ls -la, enumera todos los metadatos y archivos ocultos.

import subprocess

My_Cmmnd = "ls -la"

process = subprocess.Popen(
    "gnome-terminal -e 'bash -c \"" + My_Cmmnd + ";bash\"'",
    stdout=subprocess.PIPE,
    stderr=None,
    shell=True,
)

Producción:

Este comando se ejecuta como una cadena cuando el argumento se pasa al shell. Como resultado, el shell interpreta la cadena como un argumento de comando al comienzo de la ejecución de nuestro subproceso().

Un inconveniente del método anterior es que cuando se llama explícitamente al shell usando shell=true, pasa todos los metacaracteres, incluidos los espacios en blanco, al proceso secundario, lo que representa una amenaza en los eventos de una inyección de shell.

Para evitar tal situación, use una lista de Python en su lugar. Cuando se usa una lista, el comando para llamar se coloca en el índice 0 de la lista y los otros argumentos lo siguen.

Llame al comando utilizado en el ejemplo anterior como una lista.

import subprocess

subprocess.run(["ls", "-la"])

Producción:

El resultado del comando también se puede almacenar dentro de una variable configurando la opción capture_output=True.

import subprocess

saved_results = subprocess.run(["ls", "-la"], capture_output=True)

print(saved_results.stdout)

Producción:

Se puede ver que la salida muestra el resultado deseado, pero no hay indexación y los nombres de archivo se distribuyen de manera desorganizada. Esto sucede porque el sistema guardó el resultado del comando ls -la en bytes.

Para obtener el resultado como una cadena, establezca la opción text=True.

import subprocess

saved_results = subprocess.run(["ls", "-la"], capture_output=True, text=True)

print(saved_results.stdout)

Producción:

Conclusión

Este artículo explica cómo crear secuencias de comandos de Python para abrir una nueva terminal y ejecutar comandos. El lector que lea el artículo podrá crear un script de Python para abrir una nueva terminal y ejecutar comandos fácilmente en Linux.