Bash scripting

01 of february of 2023

Bash scripting

Folder with scripts

This notebook has been automatically translated to make it accessible to more people, please let me know if you see any typos.

To make this post we are going to create a folder where we are going to save all the scripts

	
		!mkdir scripts_bash

First script

Specification of the execution binary

In linux you can indicate with which program to execute a file by putting in the first line #!<binary path>, for example, if we create a .py we can indicate that it has to be executed with python by putting in the first line #!/usr/bin/python3. In our case, as we are making a terminal script we put in the first line #!/bin/bash.

Now if the file is given execute permissions, it can be executed directly without specifying the program with which it has to be executed. That is, the .py no longer needs to be executed via python script.py, but can be executed via .script.py. In our case, instead of running the file via bash script.sh we can run it via ./script.sh.

Comments in bash scripts

If we want to enter a comment it would be enough to start the line with #.

# This is a one-line comment

If we want to enter several lines of comments we have to start with : ' and end with '.

: '
      This is a multi-line commentary
      which extends across several lines.

Print on the screen with the command `echo`.

If we want to print on the screen we use the command echo followed by what we want to print.

	
		!mkdir scripts_bash
%%writefile scripts_bash/01_primerScript.sh
#!/bin/bash
# Comentario de una sola linea
: '
Comentario de varias
lineas
'
echo "Hola mundo"

	
		Writing scripts_bash/01_primerScript.sh

We give execution permissions and run the script

	
		!chmod +x scripts_bash/01_primerScript.sh && ./scripts_bash/01_primerScript.sh

	
		Hola mundo

Variable declaration

There are two types of variables, user variables and environment variables.

To create a variable just declare it by entering the name you want, followed by = and the value

To print the value of a variable with echo, you have to reference it by `$.

echo "Variable = $<variable name>" echo "Variable = $<variable name>

	
		%%writefile scripts_bash/02_variables.sh
#!/bin/bash
opcion=1
nombre="Juan"
echo "Opcion: $opcion"
echo "Nombre: $nombre"

	
		Writing scripts_bash/02_variables.sh

	
		!chmod +x scripts_bash/02_variables.sh && ./scripts_bash/02_variables.sh

	
		Opcion: 1
Nombre: Juan

Scope of variables

The variables created are only accessible from within the script, i.e., their scope is within the script.

Export of variables

We can export variables so that they can be accessed by other scripts, to do this we first export the variable using the export command and execute call, inside the script, the second script to which we want to pass the variable to

	
		%%writefile scripts_bash/02_variables.sh
#!/bin/bash
opcion=1
nombre="Juan"
echo "Opcion: $opcion"
echo "Nombre: $nombre"
# Exportar variable nombre
echo "export nombre=$nombre"
export nombre
# Ejecutar script de importacion
echo ""
echo "Ejecutando script de importacion"
./scripts_bash/02_variables_importacion.sh

	
		Overwriting scripts_bash/02_variables.sh

	
		%%writefile scripts_bash/02_variables_importacion.sh
#!/bin/bash
echo "Nombre importado: $nombre"

	
		Writing scripts_bash/02_variables_importacion.sh

	
		!chmod +x scripts_bash/02_variables.sh && chmod +x scripts_bash/02_variables_importacion.sh && ./scripts_bash/02_variables.sh

	
		Opcion: 1
Nombre: Juan
export nombre=Juan
Ejecutando script de importacion
Nombre importado: Juan

The second script has to be executed inside the first script. If we now execute the second script we do not have the variable

	
		!chmod +x scripts_bash/02_variables_importacion.sh && ./scripts_bash/02_variables_importacion.sh

	
		Nombre importado:

If we want it to be accessible from any second script, without having to run it inside the first scritp, we have to export the variable to an environment variable

Types of operators

All possible operators are shown below

	
		%%writefile scripts_bash/03_operadores.sh
#!/bin/bash
# Asignación de variables
x=10
y=20
echo "x = $x"
echo "y = $y"
# Operadores aritméticos
echo ""
echo "Operadores aritméticos"
echo "x + y = $((x + y))"
echo "x - y = $((x - y))"
echo "x * y = $((x * y))"
echo "x / y = $((x / y))"
echo "x % y = $((x % y))"
# Operadores de comparación
echo ""
echo "Operadores de comparación"
if [ "$x" -eq "$y" ]; then
  echo "x es igual a y"
else
  echo "x no es igual a y"
fi
if [ "$x" -ne "$y" ]; then
  echo "x no es igual a y"
else
  echo "x es igual a y"
fi
if [ "$x" -lt "$y" ]; then
  echo "x es menor que y"
else
  echo "x no es menor que y"
fi
if [ "$x" -gt "$y" ]; then
  echo "x es mayor que y"
else
  echo "x no es mayor que y"
fi
# Operadores de cadena
echo ""
echo "Operadores de cadena"
if [ "$a" = "$b" ]; then
  echo "a es igual a b"
else
  echo "a no es igual a b"
fi
if [ "$a" != "$b" ]; then
  echo "a no es igual a b"
else
  echo "a es igual a b"
fi
if [ -z "$a" ]; then
  echo "a es una cadena vacía"
else
  echo "a no es una cadena vacía"
fi
if [ -n "$a" ]; then
  echo "a no es una cadena vacía"
else
  echo "a es una cadena vacía"
fi
# Operadores de archivo
echo ""
echo "Operadores de archivo"
if [ -e "/path/to/file" ]; then
  echo "El archivo existe"
else
  echo "El archivo no existe"
fi
if [ -f "/path/to/file" ]; then
  echo "Es un archivo regular"
else
  echo "No es un archivo regular"
fi
if [ -d "/path/to/dir" ]; then
  echo "Es un directorio"
else
  echo "No es un directorio"
fi

	
		Overwriting scripts_bash/03_operadores.sh

	
		!chmod +x scripts_bash/03_operadores.sh && ./scripts_bash/03_operadores.sh

	
		x = 10
y = 20
Operadores aritméticos
x + y = 30
x - y = -10
x * y = 200
x / y = 0
x % y = 10
Operadores de comparación
x no es igual a y
x no es igual a y
x es menor que y
x no es mayor que y
Operadores de cadena
a es igual a b
a es igual a b
a es una cadena vacía
a es una cadena vacía
Operadores de archivo
El archivo no existe
No es un archivo regular
No es un directorio

Arguments step

Arguments can be passed to the scripts, once inside the script we can make use of them as follows

By argument number: in this case they will be named as $1, $2, etc. But in case the number of arguments is greater than 9, that is to say that more than 2 digits are needed to name it, in this case the number will be identified between braces, $1, $2, ..., $10, $11, etc.
If the $0 argument is called, we are getting the file name.
If we want all the arguments we do it with $*.
If what we want is the number of arguments we have, we obtain it by means of $#.
If we want to saner the output of the last command, we can know it by $?.
If we want to know the PID of the script, we can know it through $$.
We can replace the value of a string in an argument by ${<argument index>/string to be replaced/new string}, i.e. if we have ${1/hello/hello} it will replace the word hello with the word hello in argument 1.
However, if we use ${<argument index>/#string to be replaced/new string}, it will only replace the string in the argument if this argument starts with that string.

	
		%%writefile scripts_bash/04_argumentos.sh
#!/bin/bash
# Pasos de argumentos simples
echo "Primer argumento: $1"
echo "Segundo argumento: $2"
echo "Tercer argumento: $3"
# Accediendo a todos los argumentos
echo "Todos los argumentos: $*"
# Accediendo al número de argumentos
echo "Número de argumentos: $#"
# Accediendo al nombre del script
echo "Nombre del script: $0"
# Accediendo al código de salida del último comando ejecutado
echo "Código de salida del último comando: $?"
# Accediendo al PID del script
echo "PID del script: $$"
# Accediendo a los argumentos con índices
echo "Argumento 3: ${3}"
echo "Argumento 2: ${2}"
# Accediendo a los argumentos con índices y longitud máxima
echo "Argumento 3 con longitud máxima de 2 caracteres: ${3:0:2}"
echo "Argumento 2 con longitud máxima de 3 caracteres: ${2:0:3}"
# Reemplazando argumentos con índices y longitud máxima
echo "Reemplazando argumento 3: ${3/arg/ARG}"
echo "Reemplazando argumento 2: $                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   {2/arg/ARG}"
# Accediendo a los argumentos con índices y patrones de reemplazo
echo "Reemplazando patrón en argumento 3: ${3/#tercer/TERCER}"
echo "Reemplazando patrón en argumento 2: ${2/#arg/ARG}"

	
		Overwriting scripts_bash/04_argumentos.sh

	
		!arg1="primer argumento" && arg2="segundo argumento" && arg3="tercer argumento" && chmod +x scripts_bash/04_argumentos.sh && ./scripts_bash/04_argumentos.sh "$arg1" "$arg2" "$arg3"

	
		Primer argumento: primer argumento
Segundo argumento: segundo argumento
Tercer argumento: tercer argumento
Todos los argumentos: primer argumento segundo argumento tercer argumento
Número de argumentos: 3
Nombre del script: ./scripts_bash/04_argumentos.sh
Código de salida del último comando: 0
PID del script: 11644
Argumento 3: tercer argumento
Argumento 2: segundo argumento
Argumento 3 con longitud máxima de 2 caracteres: te
Argumento 2 con longitud máxima de 3 caracteres: seg
Reemplazando argumento 3: tercer ARGumento
Reemplazando argumento 2: segundo ARGumento
Reemplazando patrón en argumento 3: tercer argumento
Reemplazando patrón en argumento 2: segundo argumento

Execute commands and save them in a variable

We have two ways of executing a command and saving its output in a variable

Through variable=command
Through variable=$$(command).

	
		%%writefile scripts_bash/05_variables_comandos.sh
#!/bin/bash
path=$(pwd)
infokernel=`uname -a`
echo "El directorio actual es: $path"
echo "La información del kernel es: $infokernel"

	
		Overwriting scripts_bash/05_variables_comandos.sh

	
		!chmod +x scripts_bash/05_variables_comandos.sh && ./scripts_bash/05_variables_comandos.sh

	
		El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts
La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

Debugging

There are two ways to be able to debug in bash scripting

Using -v: Detailed line-by-line script execution
Using -x: Display of script information

	
		!bash -v scripts_bash/05_variables_comandos.sh

	
		#!/bin/bash
path=$(pwd)
infokernel=`uname -a`
echo "El directorio actual es: $path"
El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts
echo "La información del kernel es: $infokernel"
La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

	
		!bash -x scripts_bash/05_variables_comandos.sh

	
		++ pwd
+ path=/home/wallabot/Documentos/web/portafolio/posts
++ uname -a
+ infokernel='Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux'
+ echo 'El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts'
El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts
+ echo 'La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux'
La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

Obtain user information

Get information using the `echo` and `read` commands

We have two ways to obtain user information

With the command echo -n. With the flag -n we indicate that we do not want a line break to be printed at the end of the echo. For example, echo -n "Enter data:", with this command we ask for a data and the cursor will stay on the same line, there will be no line break.

Using the read command. With this command the program will wait for the user to enter data ending with a line break. What has been entered will be stored in the variable REPLY. If you want the variable where the data entered by the user is saved to have another name, you must enter read [variable], for example the command read myVariable, will save the user's data in the variable myVariable. Using the command $REPLY or $[variable] we access the data entered by the user.

	
		%%writefile scripts_bash/06_leer_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read
option=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read backupName
echo ""
echo "Opción: $option, backupName: $backupName"

	
		Overwriting scripts_bash/06_leer_informacion.sh

As in a jupyter notebook I can't enter the data as it is requested, I enter it first in a | pipe.

	
		!chmod +x scripts_bash/06_leer_informacion.sh && echo "1
nombreprueba" | ./scripts_bash/06_leer_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1, backupName: nombreprueba

Get information only by `read` command

Another way to obtain information is to use only the read command, the syntax would be

read -p "Prompt message:" [variable].

The -p flag indicates that the Hint prompt: message will be displayed before waiting for the user to enter the data. If no variable name is specified, the data will be stored in the REPLY variable.

	
		%%writefile scripts_bash/06_leer_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read
option1=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read backupName
echo ""
read -p "Ingresar otra opción: " option2
echo ""
echo "Opción: $option1-$option2, backupName: $backupName"

	
		Overwriting scripts_bash/06_leer_informacion.sh

	
		!chmod +x scripts_bash/06_leer_informacion.sh && echo "1
nombreprueba
2" | ./scripts_bash/06_leer_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1-2, backupName: nombreprueba

Validate user information

To validate the user's information it would be best to use regular expressions, here is a post where I explain them

We can also specify the number of characters we want the user to enter when using read, for this we use the -n flag, which, if not followed by a number, will wait until the user enters a line break, and if followed by a number, will wait until the user enters that number of characters.

	
		%%writefile scripts_bash/07_validar_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read -n1
option1=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read -n4 backupName
echo ""
read -p "Ingresar otra opción: " option2
echo ""
echo "Opción: $option1-$option2, backupName: $backupName"

	
		Writing scripts_bash/07_validar_informacion.sh

	
		!chmod +x scripts_bash/07_validar_informacion.sh && echo "1back2" | ./scripts_bash/07_validar_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1-2, backupName: back

If we want to enter a confidential value, such as a key, we set the -s (security) flag. This way, when the user enters the data, it will not be printed in the console.

	
		%%writefile scripts_bash/07_validar_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read -n1
option1=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read -n4 backupName
echo ""
read -p "Ingresar otra opción: " option2
echo ""
read -s -p "Password: " password
echo ""
echo "Opción: $option1-$option2, backupName: $backupName, password: $password"

	
		Overwriting scripts_bash/07_validar_informacion.sh

	
		!chmod +x scripts_bash/07_validar_informacion.sh && echo "1back2
1234" | ./scripts_bash/07_validar_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1-2, backupName: back, password: 1234

If else

The way to write if-else conditionals is:

if [[condition]]; then
          statement
      elif [[condition]]; then
          statement
      else
          statement
      fi

It is important to emphasize that the conditions must be enclosed in two square brackets [[]].

	
		%%writefile scripts_bash/08_if_else.sh
#!/bin/bash
if [[ 1 > 2 ]]; then
    echo "Verdadero"
elif [[ 1 > 3 ]]; then
    echo "Verdadero"
else
    echo "Falso"
fi

	
		Overwriting scripts_bash/08_if_else.sh

	
		!chmod +x scripts_bash/08_if_else.sh && ./scripts_bash/08_if_else.sh

	
		Falso

Let's see how to create nested ifs

	
		%%writefile scripts_bash/08_if_else.sh
#!/bin/bash
if [[ 1 > 2 ]]; then
    echo "Verdadero"
elif [[ 1 > 3 ]]; then
    echo "Verdadero"
else
    if [[ 1 > 4 ]]; then
        echo "Verdadero pero falso"
    else
        echo "Totalmente falso"
    fi
fi

	
		Overwriting scripts_bash/08_if_else.sh

	
		!chmod +x scripts_bash/08_if_else.sh && ./scripts_bash/08_if_else.sh

	
		Totalmente falso

Conditional expressions

We have already seen how to create ifs, but it is necessary to explain how to create conditional expressions.

If we are going to make comparisons between strings or strings

operation	command	example
greater than	`>>``		`[[[ string1 > string2 ]]`
less than	`<`				[[[ string1 < string2 ]]`
same as	`==`			[[[ string1 == string2 ]]`
same as	`=``	`[[[[ string1 = string2 ]]`

empty string|-z||[[ -z string ]]| |non-empty string|-n|[[ -n string ]]|| |||[[[ string ]]||||

If what we are going to do is to make comparisons between numbers

operation	command	example
greater than	`-gt`		`[[[ number1 -gt number2 ]]`

greater than or equal to|-ge||[[[ numero1 -ge numero2 ]]|| |less than|-lt||[[[ number1 -lt number2 ]]|| |less than or equal to|-le||[[[ number1 -le number2 ]]|| |equal to|-eq|[[[ number1 -eq number2 ]]|| |different than|``-ne|[[[ number1 -ne number2 ]]`||

If we want to check files or directories

operation	command	example
is a directory?	`-d`		`[[ -d <dir> ]]`
is a file?	`-f`		`[[[ -f <file> ]]`
exists?	`-e`		`[[ -e <file> ]]` or `[[ -e <dir> ]]`
is it readable?	`-r`	`[[ -r <file> ]]`
is it writable?	`-w`		`[[[ -w <file> ]]`
							is executable?	`-x`	[[[ -x ]]`
is a link?	`-L`		`[[[ -L <file> ]]`
es has content?	`-s`		`[[ -s <file> ]]`
				[[[ -O ]]`
				is owned by the group?	`-G`	`[[[ -G <file> ]]`
was modified?	`-N`		`[[[ -N <file> ]]`
file1 is newer than file2?	``-nt`		`[[[ <file1> -nt <file2> ]]`
file1 is older than file2?	``-ot`		`[[[ <file1> -ot <file2> ]]`
file1 is the same file as file2?	`-ef`		`[[[ <file1> -ef <file2> ]]`
file1 is the same file as file2?	`-ef`		`[[[ <file1> -ef <file2> ]]`

If we want to compare joint conditions with and, or and not, we need to use and, or and not.

operation	command	example
and	`&&&``	``[[[ && ]]`
or		`			`		``[[[		]]`

If we want to deny conditions

operation	command	example
not	`!`		`[[ ! <condition> ]]`

	
		%%writefile scripts_bash/09_condicionales.sh
#!/bin/bash
echo "Comparando strings"
string1="hola"
string2="hola"
string3="chao"
string4=""
if [[ $string1 > $string3 ]]; then
    echo "$string1 es mayor que $string3"
fi
if [[ $string3 < $string1 ]]; then
    echo "$string3 es menor que $string1"
fi
if [[ $string1 == $string2 ]]; then
    echo "$string1 es igual que $string2"
fi
if [[ $string1 != $string3 ]]; then
    echo "$string1 es diferente que $string3"
fi
if [[ -z $string4 ]]; then
    echo "$string4 es una cadena vacía"
fi
if [[ -n $string3 ]]; then
    echo "$string3 es una cadena no vacía"
fi
if [[ $string3 ]]; then
    echo "$string3 es una cadena no vacía"
fi
echo -e "\nComparando números"
number1=10
number2=10
number3=20
if [[ $number3 -gt $number1 ]]; then
    echo "$number3 es mayor que $number1"
fi
if [[ $number3 -ge $number2 ]]; then
    echo "$number3 es mayor o igual que $number2"
fi
if [[ $number1 -lt $number3 ]]; then
    echo "$number1 es menor que $number3"
fi
if [[ $number1 -le $number2 ]]; then
    echo "$number1 es menor o igual que $number2"
fi
if [[ $number1 -eq $number2 ]]; then
    echo "$number1 es igual que $number2"
fi
if [[ $number1 -ne $number3 ]]; then
    echo "$number1 es diferente que $number3"
fi
echo -e "\nComparando archivos"
file1="$PWD/2021-02-11-Introduccion-a-Python.ipynb"
file2="$PWD/scripts_bash"
file3="$PWD/mi_paquete_de_python"
if [[ -d $file2 ]]; then
    echo "$file2 es un directorio"
fi
if [[ -f $file1 ]]; then
    echo "$file1 es un archivo"
fi
if [[ -e $file1 ]]; then
    echo "$file1 existe"
fi
if [[ -r $file1 ]]; then
    echo "$file1 es legible"
fi
if [[ -w $file1 ]]; then
    echo "$file1 es escribible"
fi
if [[ -x $file1 ]]; then
    echo "$file1 es ejecutable"
fi
if [[ -L $file1 ]]; then
    echo "$file1 es un link"
fi
if [[ -s $file1 ]]; then
    echo "$file1 tiene contenido"
fi
if [[ -O $file1 ]]; then
    echo "$file1 es propiedad del usuario"
fi
if [[ -G $file1 ]]; then
    echo "$file1 es propiedad del grupo"
fi
if [[ -N $file1 ]]; then
    echo "$file1 fue modificado"
fi
if [[ $file1 -nt $file2 ]]; then
    echo "$file1 es más nuevo que $file2"
fi
if [[ $file1 -ot $file2 ]]; then
    echo "$file1 es más viejo que $file2"
fi
if [[ $file1 -ef $file1 ]]; then
    echo "$file1 es el mismo archivo que $file2"
fi
echo -e "\nComparando expresiones con AND"
if [[ 2 > 1 && 3 > 1 ]]; then
    echo "2 > 1 y 3 > 1"
fi
echo -e "\nComparando expresiones con OR"
if [[ 2 > 1 || 1 > 2 ]]; then
    echo "2 > 1 o 1 > 2"
fi
echo -e "\nComparando expresiones con NOT"
if [[ ! 1 > 2 ]]; then
    echo "1 > 2 no es cierto"
fi

	
		Overwriting scripts_bash/09_condicionales.sh

	
		!chmod +x scripts_bash/09_condicionales.sh && ./scripts_bash/09_condicionales.sh

	
		Comparando strings
hola es mayor que chao
chao es menor que hola
hola es igual que hola
hola es diferente que chao
 es una cadena vacía
chao es una cadena no vacía
chao es una cadena no vacía
Comparando números
20 es mayor que 10
20 es mayor o igual que 10
10 es menor que 20
10 es menor o igual que 10
10 es igual que 10
10 es diferente que 20
Comparando archivos
/home/wallabot/Documentos/web/portafolio/posts/scripts_bash es un directorio
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es un archivo
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb existe
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es legible
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es escribible
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb tiene contenido
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es propiedad del usuario
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es propiedad del grupo
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es más viejo que /home/wallabot/Documentos/web/portafolio/posts/scripts_bash
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es el mismo archivo que /home/wallabot/Documentos/web/portafolio/posts/scripts_bash
Comparando expresiones con AND
2 > 1 y 3 > 1
Comparando expresiones con OR
2 > 1 o 1 > 2
Comparando expresiones con NOT
1 > 2 no es cierto

`case` statement

Next we are going to see how to write the typical switch-case, but in this case we only use case.

case $variable in
          <value1>) <sentence1>;;
          <value2>) <sentence2>;;
          <value3>) <sentence3>;;
          ...
          *) <sentence that does not meet any of the above>.
      esac

	
		%%writefile scripts_bash/10_case.sh
#!/bin/bash
variable="amarillo"
case $variable in
    "rojo") echo "Color rojo";;
    "verde") echo "Color verde";;
    "azul") echo "Color azul";;
    *) echo "Color desconocido";;
esac

	
		Writing scripts_bash/10_case.sh

	
		!chmod +x scripts_bash/10_case.sh && ./scripts_bash/10_case.sh

	
		Color desconocido

Arrays

Let's see how arrays behave in bash scripting

	
		%%writefile scripts_bash/11_arrays.sh
#!/bin/bash
arrayNumeros=(1 2 3 4 5)
arrayStrings=("hola" "chao" "adios")
arrayMixto=(1 "hola" 2 "chao" 3 "adios")
arrayVacio=()
arrayRango=({A..Z})
echo "Arrays"
echo "Array de números: ${arrayNumeros[*]}"
echo "Array de strings: ${arrayStrings[*]}"
echo "Array mixto: ${arrayMixto[*]}"
echo "Array vacío: ${arrayVacio[*]}"
echo "Array de rango: ${arrayRango[*]}"
echo -e "\nAccediendo a elementos"
echo "Primer elemento del array de números: ${arrayNumeros[0]}"
echo "Segundo elemento del array de strings: ${arrayStrings[1]}"
echo "Último elemento del array de números: ${arrayNumeros[-1]}"
echo "Penúltimo elemento del array de strings: ${arrayStrings[-2]}"
echo -e "\nLongitud de arrays"
echo "Longitud del array de números: ${#arrayNumeros[*]}"
echo "Longitud del array de strings: ${#arrayStrings[*]}"
echo "Longitud del array mixto: ${#arrayMixto[*]}"
echo "Longitud del array vacío: ${#arrayVacio[*]}"
echo "Longitud del array de rango: ${#arrayRango[*]}"
echo -e "\nAñadiendo y eliminando elementos"
arrayNumeros[5]=6
echo "Añadiendo elemento al array de números: ${arrayNumeros[*]}"
unset arrayStrings[1]
echo "Eliminando elemento del array de strings: ${arrayStrings[*]}"

	
		Overwriting scripts_bash/11_arrays.sh

	
		!chmod +x scripts_bash/11_arrays.sh && ./scripts_bash/11_arrays.sh

	
		Arrays
Array de números: 1 2 3 4 5
Array de strings: hola chao adios
Array mixto: 1 hola 2 chao 3 adios
Array vacío: 
Array de rango: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Accediendo a elementos
Primer elemento del array de números: 1
Segundo elemento del array de strings: chao
Último elemento del array de números: 5
Penúltimo elemento del array de strings: chao
Longitud de arrays
Longitud del array de números: 5
Longitud del array de strings: 3
Longitud del array mixto: 6
Longitud del array vacío: 0
Longitud del array de rango: 26
Añadiendo y eliminando elementos
Añadiendo elemento al array de números: 1 2 3 4 5 6
Eliminando elemento del array de strings: hola adios

Loop `for`

To use the for loop use the following syntax

for <variable> in <array>
      do
          sentence
      done

Let's see an example

	
		%%writefile scripts_bash/12_for.sh
#!/bin/bash
arrayNumeros=(1 2 3 4 5)
arrayStrings=("hola" "chao" "adios")
echo "Iterar a través de un array de numeros"
for numero in ${arrayNumeros[*]}
do
    echo "Número: $numero"
done
echo -e "\nIterar a través de un array de strings"
for string in ${arrayStrings[*]}
do
    echo "String: $string"
done
echo -e "\nIterar a través de un array no declarado"
for string in "Manolo" "Juan" "Pedro"
do
    echo "String: $string"
done
echo -e "\nIterar a través de un rango"
for i in {1..10}
do
    echo "Número: $i"
done
echo -e "\nIterar a través de un rango de manera clásica"
for (( i=1; i<=10; i++ ))
do
    echo "Número: $i"
done
echo -e "\nIterar a través de un comando"
for file in $(ls)
do
    echo "Archivo: $file"
done
echo -e "\nIterar a través de un directorio"
for file in *
do
    echo "Archivo: $file"
done

	
		Overwriting scripts_bash/12_for.sh

	
		!chmod +x scripts_bash/12_for.sh && ./scripts_bash/12_for.sh

	
		Iterar a través de un array de numeros
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Iterar a través de un array de strings
String: hola
String: chao
String: adios
Iterar a través de un array no declarado
String: Manolo
String: Juan
String: Pedro
Iterar a través de un rango
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Número: 6
Número: 7
Número: 8
Número: 9
Número: 10
Iterar a través de un rango de manera clásica
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Número: 6
Número: 7
Número: 8
Número: 9
Número: 10
Iterar a través de un comando
Archivo: 2021-02-11-Introduccion-a-Python.ipynb
Archivo: 2021-04-23-Calculo-matricial-con-Numpy.ipynb
Archivo: 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
Archivo: 2022-09-12-Introduccion-a-la-terminal.ipynb
Archivo: 2023-01-22-Docker.ipynb
Archivo: 2023-XX-XX-Bash-scripting.ipynb
Archivo: california_housing_train.csv
Archivo: command-line-cheat-sheet.pdf
Archivo: CSS.ipynb
Archivo: Expresiones
Archivo: regulares.ipynb
Archivo: html_files
Archivo: html.ipynb
Archivo: introduccion_python
Archivo: mi_paquete_de_python
Archivo: movies.csv
Archivo: movies.dat
Archivo: notebooks_translated
Archivo: __pycache__
Archivo: scripts_bash
Archivo: ssh.ipynb
Archivo: test.ipynb
Iterar a través de un directorio
Archivo: 2021-02-11-Introduccion-a-Python.ipynb
Archivo: 2021-04-23-Calculo-matricial-con-Numpy.ipynb
Archivo: 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
Archivo: 2022-09-12-Introduccion-a-la-terminal.ipynb
Archivo: 2023-01-22-Docker.ipynb
Archivo: 2023-XX-XX-Bash-scripting.ipynb
Archivo: california_housing_train.csv
Archivo: command-line-cheat-sheet.pdf
Archivo: CSS.ipynb
Archivo: Expresiones regulares.ipynb
Archivo: html_files
Archivo: html.ipynb
Archivo: introduccion_python
Archivo: mi_paquete_de_python
Archivo: movies.csv
Archivo: movies.dat
Archivo: notebooks_translated
Archivo: __pycache__
Archivo: scripts_bash
Archivo: ssh.ipynb
Archivo: test.ipynb

`while` loop

To use the while loop use the following syntax

while <condition>
      do
          sentence
      done

Let's see an example

	
		%%writefile scripts_bash/13_while.sh
#!/bin/bash
numero=1
while [ $numero -ne 5 ]
do
    echo "Número: $numero"
    numero=$(( numero + 1 ))
done

	
		Overwriting scripts_bash/13_while.sh

	
		!chmod +x scripts_bash/13_while.sh && ./scripts_bash/13_while.sh

	
		Número: 1
Número: 2
Número: 3
Número: 4

Flow control with `break` and `continue

We can control the flow of a loop by using the words break and continue, let's see an example

	
		%%writefile scripts_bash/14_control_de_flujo.sh
#!/bin/bash
numero=1
while [ $numero -ne 10 ]
do
    if [ $numero -eq 5 ]; then
        numero=$(( numero + 1 ))
        echo "Saltando el número 5"
        continue
    elif
        [ $numero -eq 8 ]; then
        echo "Terminando el bucle"
        break
    fi 
    echo "Número: $numero"
    numero=$(( numero + 1 ))
done

	
		Overwriting scripts_bash/14_control_de_flujo.sh

	
		!chmod +x scripts_bash/14_control_de_flujo.sh && ./scripts_bash/14_control_de_flujo.sh

	
		Número: 1
Número: 2
Número: 3
Número: 4
Saltando el número 5
Número: 6
Número: 7
Terminando el bucle

Functions

The syntax for writing functions is

<function name> (){
          sentences
      }

Here is an example

	
		%%writefile scripts_bash/15_funciones.sh
#!/bin/bash
funcion () {
    echo "Soy una función"
}
funcoionConParametros () {
    echo "Soy una función con parámetros"
    echo "Parámetro 1: $1"
    echo "Parámetro 2: $2"
}
funcion
funcoionConParametros "Hola" "Adiós"

	
		Writing scripts_bash/15_funciones.sh

	
		!chmod +x scripts_bash/15_funciones.sh && ./scripts_bash/15_funciones.sh

	
		Soy una función
Soy una función con parámetros
Parámetro 1: Hola
Parámetro 2: Adiós

Continue reading

Agents patterns

Are your agents falling short? Elevate your AI projects with advanced patterns: ReAct, planning, multi-agents, and more. Practical guide with code!

LangGraph: Revolutionize your AI agents

🚀 Revolutionize your AI agents! 🧠 LangGraph is not just another library, it's the orchestration framework that gives you total control to build complex agents, with long-term memory and even human intervention! Say goodbye to basic chatbots, it's time to create true intelligence. Dive into this post and discover it!

Create virtual environments with uv

Learn how to create virtual environments with uv, a package manager and environment for Python written in Rust, which makes it very fast. If you have had problems with the waiting times using conda, or want a faster and easier alternative to venv, enter and see how to use uv.

Last posts -->

Have you seen these projects?

Horeca chatbot

Naviground

Subtify

View all projects -->

Do you want to apply AI in your project? Contact me!

Do you want to improve with these tips?

Memory profiler

See the memory usage of a script

DataLoader with pin_memory and num_workers

Increase DataLoader performance with pin_memory and num_workers

py-smi

Python library to get GPU data like `nvidia-smi`

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.

Flow edit

FLUX.1-RealismLora

token_hmr

View all containers -->

Do you want to apply AI in your project? Contact me!

Do you want to train your model with these datasets?

short-jokes-dataset

Dataset with jokes in English

opus100

Dataset with translations from English to Spanish

netflix_titles

Dataset with Netflix movies and series

View more datasets -->

Bash scripting

Folder with scripts

First script

Specification of the execution binary

Comments in bash scripts

Print on the screen with the command echo.

Variable declaration

Scope of variables

Export of variables

Types of operators

Arguments step

Execute commands and save them in a variable

Debugging

Obtain user information

Get information using the echo and read commands

Get information only by read command

Validate user information

If else

Conditional expressions

case statement

Arrays

Loop for

while loop

Flow control with break and `continue

Functions

Continue reading

Agents patterns

LangGraph: Revolutionize your AI agents

Create virtual environments with uv

Have you seen these projects?

Do you want to apply AI in your project? Contact me!

Do you want to improve with these tips?

Memory profiler

DataLoader with pin_memory and num_workers

py-smi

Use this locally

Do you want to apply AI in your project? Contact me!

Do you want to train your model with these datasets?

short-jokes-dataset

opus100

netflix_titles

Print on the screen with the command `echo`.

Get information using the `echo` and `read` commands

Get information only by `read` command

`case` statement

Loop `for`

`while` loop

Flow control with `break` and `continue