Saltar a contenido

2021

Curso de Python - Introducir datos, control de excepciones, trabajar con archivos

Bienvenidos al nuevo post del curso de Python, al terminar este post ya sabrás como introducir datos por el teclado, cómo gestionar el control de excepciones y mostrar lo que te interesa según el error y sobre todo, trabajar con archivos de texto.

Obtener datos introducidos por el usuario

Tenemos una función que es input() y podemos solicitar al usuario que introduzca un dato y que este se almacene en una variable, esto nos puede ayudar a dinamizar los programas interactuando con los usuarios:

input('Aquí va un mensaje')

NOTA: Los datos introducidos se almacenan como un str, por lo que si quieres almacenar datos tipo float, int tendrás que usar la función de conversión que hemos hablado en el apartado de Tipos de datos en Python. Vamos hacer este ejemplo:

nombre = input("¿Cómo te llamas? ")
edad = int(input("¿Qué edad tienes? "))
print("Me llamo %s y tengo %i años." % (nombre,edad))

Imprimirá un resultado como:

¿Cómo te llamas? Alvaro
¿Qué edad tienes? 26
Me llamo Álvaro y tengo 26 años.

Control de excepciones

¿Qué ocurre si queremos ejecutar un código y depende de una serie de datos que no se han inicializado? No pasa nada, tenemos un mecanismo que controla las excepciones.

try-except

try:
  # Bloque de código que se probará antes de ejecutar
except:
  # Bloque de código que se ejecutará si ocurre algún error.

Por ejemplo:

try:
    print(a)
except:
    print("Hubo un problema.")

Esto nos imprimirá Hubo un problema. pero no nos dice en ningún momento dónde está el error. Evidentemente, el error es que la variable a no contiene ningún tipo de valor. Pero, ¿Qué ocurre si quiero personalizar estos errores y mostrar información según convenga?

No pasa nada, podemos añadir excepciones por error, por ejemplo, si la variable a no existía, podemos crear una excepción que permita decir que no existe porque no está creada de la siguiente forma.

  1. Primero identificamos como se llama el error en Python:
print(A)
Traceback (most recent call last):

  File "/tmp/untitled0.py", line 9, in <module>
    print(a)

NameError: name 'a' is not defined

El nombre del error que tenemos que utilizar es NameError.

  1. Definimos el try-except de la siguiente manera:
try:
  print(a)
except NameError:
  print("La variable no se ha asignao, por favor, revisa el programa.")
except:
  print("Hubo un problema, contacte con el desarrollador de la aplicación.")

¿Se pueden definir múltiples errores y que impiman un mensaje? Sí que se puede, esto además nos permite ahorrar mucho código.

try:
  pass
except(NameError, TypeError, ValueError):
  pass
except:
  pass

También podemos usar un alias e imprimir solo el mensaje de error:

try:
  print(a)
except(NameError, TypeError, ValueError) as EstoEsUnError:
  print(EstoEsUnError)
except:
  pass

¿Para qué nos sirve esto? Para tener un mayor control en la validación e impresión de nuestro código. EstoEsUnError imprimirá: NameError: name 'a' is not defined, con este str podemos iniciar una validación on if-elif-else.

with

with es un método que permite realizar acciones que posteriormente necesitan limpiarse para que no queden restos en memoria, un ejemplo muy común y extendido es cuando se trabaja con archivos.

with open('nombreArchivo.ext', modo') as fichero:
  # Bloque de código

Cuando abrimos el archivo de esta forma, aunque hayan problemas con el archivo, este termina cerrándose y dejando de existir en la memoria. Sin embargo, si trabajamos con el archivo de la siguiente forma, el archivo quedará en la memoria de forma casi indefinida en el tiempo generando datos basura:

fichero = open('nombreArchivo.ext','modo')

Además, de que hay que cerrarlo debidamente:

fichero.close()

En el siguiente punto trabajaremos más con los archivos, no nos alarmemos.

Puedes consultar más información sobre este apartado en este hilo de la documentación.

Trabajando con archivos en Python

¿Qué podemos hacer en Python con los archivos? ¿Podemos trabajar con ellos? La cuestión es que sí, podemos abrir, leer, escribir o crear y eliminar archivos, las operaciones básicas que nos deja hacer un SO si estuvieramos en una shell como bash o zsh.

Abriendo un archivo

La sintaxis que se utiliza es:

fichero = open("ruta del archivo", modo)

La sintaxis correcta,que debe usarse y que utilizaremos en estos ejemplos es:

with open("ruta del archivo", modo) as nombreFichero:
  # Bloque de código
Modo Descripción
r Lectura, es el valor por defecto, abre el archivo para que se pueda leer y da un error si el archivo no existe.
a Abre un archivo para agregarle información al final, si no existe el archivo lo crea.
w Sobreescribe cualquier contendio que haya en el archivo que esté abierto y/o crea el archivo si no existe.
x Crea el archivo, si devuelve error quiere decir que ya existe.

Leer archivo

Creamos este archivo:

$ cd /home/$USER/
$ cat << EOF >> hola.txt
> Hola Mundo
> EOF

Si hacemos un cat hola.txt nos mostrará Hola Mundo. Bien, abrimos el archivo con Python

>>> with open("hola.txt","r") as fichero:
>>>   fichero.read()
Hola Mundo

Este método también permite decirle que nos imprima los n caracteres del principio del texto con .read(4).

Devuelve una línea

Si tenemos un archivo con más líneas, podemos imprimirlas con .readline() en vez de .read(). Sin embargo, si queremos imprimir mas líneas, tenemos que llamar varias veces al método.

>>> fichero.readline()
>>> fichero.readline()

Leer el archivo completo

Con ayuda de un bucle for lo hacemos:

>>> with open("ejemplo.txt", "r") as fichero:
>>> for linea in fichero:
>>>   print(linea)

Creando un archivo nuevo

Si el archivo existe, dará error.

>>> with open("ejemplo.txt", "x") as fichero:

Cuando terminemos de escribir en un archivo, lo cerramos para que no quede en memoria.

fichero.close()

Añadir información al archivo

En esta línea añadimos el siguiente texto.

>>> with open("hola.txt","a") as fichero:
>>> fichero.write("Esta es una línea de ejemplo")

Cuando terminemos de escribir en un archivo, lo cerramos para que no quede en memoria.

fichero.close()

Sobreescribir en el archivo

Sobreescribimos el archivo si lo abrimos con el modo w:

>>> with open("hola.txt","w") as fichero:
>>> fichero.write("Te he sobreescrito el contenido con esta línea")

Cuando terminemos de escribir en un archivo, lo cerramos para que no quede en memoria.

fichero.close()

Eliminar un archivo

Hay que importar un módulo llamado os:

import os

os.remove("hola.txt")

Curso de Python - Introducción y preparación del entorno

Historia

Python es un lenguaje de programación interpretado, de alto nivel y de interés general. Este lenguaje tiene una filosofía de programación que se centra en la legibilidad del código, para ello implementa una serie de declaraciones y estándares que ha de respetarse para que el código funcione como es la indentación. Python es un lenguaje orientado a objetos que facilitan a los desarrolladores escribir un código limpio, eficaz, lógico y pequeño que sirve tanto para pequeños, como medianos y grandes proyectos.

La primera versión de Python se publicó en el año 1991 por Guido van Rossum un programador holandés graduado en matemáticas y ciencias computacionales en la universidad de Amsterdam en 1982. Posteriormente se publicó la versión 2.0 el día 16 de octubre del año 2000 y la versión 3.0 que se liberó el 3 de diciembre de 2008. Actualmente las versiones 1.0 y 2.0 ya no están soportadas, esta última dejó de tener soporte el día 31 de diciembre de 2019.

Notas importantes

Antes de seguir con este artículo es muy importante que sepamos que la versión con la que trabajaremos en las siguientes entragas es Python 3. Python 2.7 no tiene más soporte desde el 31 de diciembre del 2019.

A parte de la versión, conviene saber que tenemos que leer mucho la documentación oficial (inglés) si no queremos perder horas y horas con las clásicas pruebas de Error/Acierto (pruebo cosas al azar y lo que salga salió).

También tenemos muchos recursos en línea como Real Python (inglés) que contienen muchos recursos bastante bien explicados; Full Stack Python (inglés) tiene tambień muchos recursos, ayudas...

Instalación

Python por norma general está instalado por defecto en el 99% de distribuciones de Linux por lo que no te hará falta tener que instalar nada. Sin embargo, hay distribuciones que a pesar de que Python 2. se encuentre obsoleto, la mayor parte de librerías y programas que contienen en su sistema operativo hacen uso de la versión 2.7. que fue la última en mantenerse. Por lo que, quizás necesites realizar unos pasos adicionales para tener Python 3.* instalado en tu Linux.

Algunas distribuciones pueden ser: * CentOS 6/7, hay que hacer uso de Software Collections puedes hacer uso de esta guía que elaboré. * Debian Stable * RHEL 6/7 * Gentoo

En FreeBSD y OpenBSD hay que instalarlo con su respectiva paquería, puedes utilizar estas guía oficial de Python para hacerlo.

En Windows tenemos dos formas de hacerlo, una es utilizando el subsistema de Linux para Windows haciendo uso de un sistema Linux ejecutándose en un Windows, o bien, la forma oficial que es utilizar el instalador oficial elaborado por la comunidad de Python. Para descarganos el instalador hay que dirigirse a la página de descargas pulsando aquí.

Una vez descargado, ejecutamos el instalador y seguimos los pasos como tenemos en las imágenes:

Desmarcamos la opción de instalar para todos y marcamos la opción de añadir a la variable PATH, después "Install Now":

Vemos como se está instalando:

En este paso, deshabilitamos el path lenght limit:

Y desde PowerShell podemos abrir el ejecutable directamente, veremos la versión que estamos utilizando.

IDEs

Hay una gran selección de IDEs bastante buenos que podemos utilizar para aprender, hay tanto de pago, gratuitos, libres y no libres... hay un gran abanico para decidir.

IDLE

Un IDE que viene integrado con Python (incluyendo en la instalación de Windows en la que hemos hablado más arriba). Permite ejecutar código directamente, depurarlo y tiene un pequeño editor dónde realizar nuestras modificaciones.

Spyder

Es un IDE gratuito y libre que contiene multitud de funciones desde depuración, ejecución y redacción de un archivo en Python todo en una misma ventana. Pues ver más info aquí.

Jupyter Notebook

Es un servidor web que mediante estilos, javascripts y html5 genera un IDE web con el que poder interactuar, al igual que todos permite depurar, crear archivos, navegar por los directorios del sistema operativo...etc Más info

Navegando por los directorios del SO desde su interfaz web

Ejecutando comandos de Python en un archivo nuevo

Abriendo una sesión de SO desde Web

Jupyter labs

Basado en Jupyter Notebook y Arquitecture contiene más características, como especificar qué versión de Python lanzar, ejecutar una consola directamente de Python o de SO... Más info.

Anaconda

Anaconda es un software que contiene todo lo necesario para desplegar un entorno de desarrollo de Python tanto en Linux como en Windows. No solo contiene el intérprete, si no que también tienen varios editores que puedes seleccionar desde su panel "Anaconda Navitator". Más info.

PyCharm

PyCharm es un software elaborado por la empresa JetBrains, es bastante conocido porque tiene un potente interfaz de desarrollo que permite hacer carga de espacios de nombres, módulos, referencias... y es muy potente. Aunque es de pago, si eres estudiante y tienes la ISIC puedes obtener una licencia anual gratuita para todos los productos de la empresa como DataGrid, PhpStorm, CLion... y poder hacer tus desarrollos (siempre personales y no comerciales) con él. No obstante, si no eres estudiante, y no quieres comprar la licencia, puedes hacer uso de la versión comunitaria.Más info.

Editores

Si no te gusta utilizar un IDE, siempre puedes hacer uso de editores como vim, Sublime Text, VSCode con sus correspondientes plugins. Algunas de estas personalizaciones las hablaremos en otros posts.

Siguiente entrega

En el próxmo artículo, hablaremos de los principales conceptos básicos como son los identificadores, palabras reservadas, variables, funciones, tipos de datos, módulos... cada apartado que veamos tendrá un ejemplo de uso por lo que será más fácil aprender la lógica de los mismos.

¡Os espero en la siguiente entrega, y espero que os haya gustado este post!

Curso de Python - Tipos de operadores e introducción con módulos

En esta entrega vamos a ver cómo trabajar con los diferentes operadores que tenemos disponibles en Python, ¡que no son pocos! y además lo justo para trabajar con módulos.

Tipos de operadores

En Python tenemos varios tipos de oepradores para hacer comparaciones, cálculos, valorar expresiones lógicas.... * Aritmético * Asignación * Comparación * Lógico * Bit a bit (bitwise) * Identidad * Membresía

Aritméticos

Se utiliza para realizar operaciones matemáticas y se utilizando dos operandos para llevarlas a cabo.

Operador Descripción
+ Se utiliza para realizar operaciones de adicción (suma)
- Operaciones de sustracción (resta)
* Multiplicación
/ División (cociente)
% Módulo (resto de una división)

Adicción

>>> 2 + 3
5

Sustracción

>>> 1 - 2
-1

Multiplicación

>>> 2 * 1
2

División (cociente)

>>> 4 / 2
0

Módulo, (resto de una división)

>>> 4 % 2
2.0

Operadores de asignación

Estos operadores permiten asignar valores, por norma general a variables, pero no olvidemos que podemos involucrar otros tipos de identificadores como pueden ser listas, tuplas...

Operador Descripción
= Asigna un valor
+= Suma un valor al valor actual y guardar el nuevo valor
-= Resta un valor al valor actual y guardar el nuevo valor
*= Multiplica un valor al valor actual y guardar el nuevo valor

Igual (=)

>>> variable = 10
>>> print(variable)
10

Más e igual (+=)

>>> variable = 1
>>> variable += 2
>>> print(variable)
3

Menos e igual (-=)

>>> variable = 1
>>> variable -= 2
>>> print(variable)
-1

Multiplicar e igual (*=)

>>> variable = 2
>>> variable *= 2
>>> print(variable)
4

Operadores de comparación

Estos operadores te permiten realizar una comparación entre dos valores, son muy utilizados en los condicionales o en validaciones como pueden ser bucles...etc. Además, los valores comparados devuelven un True o un False (booleano) si la comparación se cumple o no.

Operador Descripción
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que
!= Distinto de

Menor que

>>> 1 < 2
True

Mayor que

>>> 1 > 2
False

Menor igual que

>>> 1 <= 2
True

Mayor igual que

>>> 1 >= 2
False

Distinto de

>>> 1 != 2
True

Operadores lógicos

Estos permiten realizar operaciones lógicas y devuelven True o False según el resultado.

Operador Descripción
and Deben cumplirse las condiciones sí o sí
or Debe cumplir al menos una de las condiciones evaluadas
not Devuelve False si el resultado es verdadero

and

>>> 1<2 and 2<3
True
>>> x = 100 < 20 and 2>3
>>>print(x)
False

or

>>> 1<2 and 100>100
True

not

>>> not(2 != 100 and 90<200)
False

Operadores bitwise

Operadores Descripción
& Convierte el primer y segundo nº decimal en nº binarios, compara ambos nº. Cuando se encuentra 1 bit en el primer nº, y en el segundo también, se establece 1. Cuando se encuentra 1 bit en el primer nº y un 0 en el segundo también se establece un 0.
| Convierte el primer y segundo nº decimal en nº binarios, compara ambos nº. Cuando se encuentra 1 bit en el primer nº, y en el segundo también, se establece 1. Cuando se encuentra 1 bit en el primer nº y un 0 en el segundo también se establece un 1.
>> Convierte el primer y segundo nº decimal en nº binarios, compara ambos nº. Cuando se encuentra 1 bit en el segundo nº, y se desplaza el bit en el segundo también, se establece 1. Cuando se encuentra 1 bit en el primer nº y un 0 en el segundo también se establece un 1.
<< Lo anterior pero desde la izquierda
~ Devuelve el complemento del nº menos el nº que obtenemos cambiado cada 1 por un 0 y un 0 por un 1. Es lo mismo que -nº-1

Ampersan (&)

>>> 7 & 2
2

¿Por qué nos devuelve 2? Si nosotros pasamos a binario ambos números:

7 = 0 0 0 0 0 1 1 1
2 = 0 0 0 0 0 0 1 0

Cuando coincida el 1 del primer valor, con el 1 del segundo quedará como 1. Si el primer valor hay un 0 y en el segundo hay 1, se quedará el 0 por encima del 1 quedando tal que así:

0 0 0 0 0 1 1 1
0 0 0 0 0 0 1 0
---------------------
0 0 0 0 0 0 1 0

Si conviertes este número binario a decimal te dará 2.

Tubería o pipe

>>> 190 | 9
191

¿Por qué nos devuelve 191? Si nosotros pasamos a binario ambos números:

190 = 1 0 1 1 1 1 1 0
9 = 0 0 0 0 1 0 0 1

Cuando coincida el 1 del primer valor, con el 1 del segundo quedará como 1. Si el primer valor hay un 0 y en el segundo hay 1, se quedará el 1 por encima del 0 quedando tal que así:

1 0 1 1 1 1 1 0
0 0 0 1 0 0 0 1
---------------------
1 0 1 1 1 1 1 1

Si conviertes este número binario a decimal te dará 191. PENDIENTE DE REVISAR

Desplazamiento hacia la derecha o (shift-to-right)

>>> 10 >> 2
2

¿Por qué nos devuelve 2?

Si pasas el nº 10 a binario:

10 = 0 0 0 0 1 0 1 0

Desplazas 2 posiciones añadiendo dos ceros hacia la derecha, y te quedaría:

0 0 0 0 0 0 1 0

Si conviertes este número binario a decimal te dará 2.

Desplazamiento hacia la izquierda o (shift-to-left)

Este procedimiento es el mismo que el anterior, pero hacia el otro lado.

>>> 10 << 2
40

¿Por qué devuelve 2?

Si pasas a binario el nº 10:

10 = 0 0 0 0 1 0 1 0

Desplazas 2 posiciones añadiendo dos ceros hacia la izquierda, y te quedaría:

0 0 1 0 1 0 0 0

Si conviertes este número binario a decimal te dará 40.

Inversión bitwise

>>> ~100
-101

¿Por qué devuelve -101?

Devuelve el complemento del nº menos el nº que obtenemos cambiado cada 1 por un 0 y un 0 por un 1. Es lo mismo que -nº-1

Operador de identidad

Prueba si dos operandos comparten una identidad. Aquí hay dos tipos de operadores is e is not.

is

Por ejemplo, comparamos si un valor almacenado en x es igual a su valor.

>>> x = 10
>>> x is 10
True

is not

Aquí utilizamos el ejemplo anterior pero a la inversa.

>>> x = 10
>>> x is not 10
False

Operadores de membresía

Estos operadores permiten verificar si hay un str en otro str, lista, diccionario, tupla... (estos 3 últimos los verás más adelante). Se utiliza in para buscar y devolver True si encuentra dicho str, o, not in para verificar que no está.

in

>>> "echemos" in "echemos un bitstazo"
True

not in

>>> ".es" not in "echemos un bitstazo"
True

Módulos

¿Qué son los módulos? Los módulos son fragmentos de código que contienen librerías... que elaboran otros usuarios o que ya vienen integradas con Python. Hay muchos módulos que vienen ya pre-instalados en el sistema como pueden ser os que permite interactuar con el sistema operativo; subprocess que permite ejecutar comandos de shell; json con el que podremos trabajar con archivos o salidas JSON...

¿Cómo cargar este código?

El código de los módulos puede cargarse utilizando la palabra import, como en el siguiente ejemplo:

>>> import json

También podemos cargar parte del código de los módulos como por ejemplo random es un módulo que contiene métodos y propiedades. Podemos cargar solo uno de los métodos que tienes como es .random() y asignarle un alias para trabajar con él como en le siguiente ejemplo:

>>> from random import random as GenerarAleatorio
>>> GenerarAleatorio()
0.9037083824066462

¿Qué pasa si no me sé las propiedades o métodos de un módulo?

No pasa nada, puedes revisar siempre la documentación de Python pulsando aquí.

Espero que os haya gustado esta entrega, para la próxima, trabajaremos con listas, tuplas, sets y diccionarios.

Curso de Python - Tuplas, listas, diccionarios y sets

A continuación vamos a ver algunos de los tipos de datos clave en Python junto con alguno de sus métodos, de los cuáles nos serán útiles para empezar.

Tuplas tuple

Conjunto de valores que no cambian dentro del flujo de la ejecución del programa. Pueden contener como valor todo tipo de dato incluyendo otra tupla.

Más info en la doc oficial de Python

>>> nacionalidad = ( 'Español', 'Turco', 'Italiano')
>>> paises = ( 'España', nacionalidad, 'Turquía', 'Italia' )
>>> print(paises)
('España', ('Español', 'Turco', 'Italiano'), 'Turquía', 'Italia')

Añadir elementos a la tupla:

>>> nacionalidad = ( 'Español', 'Turco', 'Italiano')
>>> paises = ( 'España', nacionalidad, 'Turquía', 'Italia' )
>>> paises += ('Francia', 'Munich')
>>> print(paises)
('España', ('Español', 'Turco', 'Italiano'), 'Turquía', 'Italia', 'Francia', 'Munich')

Duplicar el str o caracter que obtengamos por un nº de veces:

>>> nacionalidad = ( 'Español', 'Turco', 'Italiano')
>>> nacionalidad * 2
('Español', 'Turco', 'Italiano', 'Español', 'Turco', 'Italiano')

Muestra el str que esté ubicada en una posición:

>>> nacionalidad = ( 'Español', 'Turco', 'Italiano')
>>> print(nacionalidad[2])
'Italiano'

Mostrar un conjunto de valores específicos de la tupla haciendo uso de su posición:

>>> paises = ( 'España', nacionalidad, 'Turquía', 'Italia','Francia', 'Munich')
>>> print(paises[3:5])
('Italia', 'Francia')

Listas

Grupo de valores representados dentro de unos [], se pueden cambiar de forma simple y sencilla. Más info en la doc oficial de Python

Declarando una lista:

>>> animales = [ 'gato', 'perro', 'búho' ]

Añadir valores en la última posición de la lista, (similar a la tupla):

>>> animales = [ 'gato', 'perro', 'búho' ]
>>> animales += [ 'lagartija', 'pez' ]
>>> print(animales)
['gato', 'perro', 'búho', 'lagartija', 'pez']

También podemos utilizar .extend():

>>> animales = [ 'gato', 'perro', 'búho' ]
>>> animales.extend([ 'lagartija', 'pez' ])
>>> print(animales)
['gato', 'perro', 'búho', 'lagartija', 'pez']

Por otro lado podemos añadir un valor a partir de una posición específica dentro de la lista .insert()

>>> animales = [ 'gato', 'perro', 'búho' ]
>>> animales.insert(0, 'lagartija')
>>> print(animales)
['lagartija', 'gato', 'perro', 'búho']

Eliminar un valor de la lista:

>>> animales = [ 'gato', 'perro', 'búho' ]
>>> animales.remove('gato')
>>> print(animales)
[ 'perro', 'búho' ]

Multiplicar el nº veces los valores de la lista:

>>> animales = [ 'gato', 'perro', 'búho' ]
>>> animales * 2
['gato', 'perro', 'búho', 'gato', 'perro', 'búho']

Mostrar valores específicos utilizando la posición de dichos valores en la lista:

>>> animales = [ 'gato', 'perro', 'búho' ]
>>> print(animales[0:2])
['gato', 'perro']

Diccionarios

Son un conjunto de valores que se almacenan en modo clave:valor, separados los valores por comas, y todas las claves y sus valores van encerrados en {} como JSON. Las claves no pueden contener tuplas, diccionarios, sets... solo str o int. Más info en la doc oficial de Python

>>> ciudades = { 'Andalucía': 'Sevilla', 'País Vasco': 'Bilbao', 'Baleares':'Palma' }

Accediendo a un valor del diccionario:

>>> ciudades = { 'Andalucía': 'Sevilla', 'País Vasco': 'Bilbao', 'Baleares':'Palma' }
>>> print(ciudades['Andalucía'])
Sevilla

Obtener el nº de posiciones de una lista:

>>> ciudades = { 'Andalucía': 'Sevilla', 'País Vasco': 'Bilbao', 'Baleares':'Palma' }
>>> len(ciudades)
3

Obtener las claves de un diccionario:

>>> ciudades = { 'Andalucía': 'Sevilla', 'País Vasco': 'Bilbao', 'Baleares':'Palma' }
>>> ciudades.keys()
dict_keys(['Andalucía', 'País Vasco', 'Baleares'])

Obtener los valores de un diccionario:

>>> ciudades = { 'Andalucía': 'Sevilla', 'País Vasco': 'Bilbao', 'Baleares':'Palma' }
>>> ciudades.values()
dict_values(['Sevilla', 'Bilbao', 'Palma'])

Obtener un valor de una clave del diccionario:

>>> print(ciudades.get('Baleares'))

Eliminar un valor de una clave del diccionario:

del ciudades['Baleares']

# Esto de volverá None.
print(ciudades.get('Baleares'))

Cambiar el valor de una clave del diccionario:

ciudades['Baleares'] = 'Menorca'

# Esto de volverá Menorca.
print(ciudades.get('Baleares'))

Sets

Son un conjunto sin orden de valores encerrados en {} que se ordenan cuando se imprimen: Más info en la doc oficial de Python

>>> marcas_coche = { 'Opel', 'Citröen', 'Tesla' }
>>> print(marcas_coche)
{'Citröen', 'Opel', 'Tesla'}

Comparar 2 sets y mostrar los valores no duplicados de ambas listas

>>> marcas_coche = { 'Opel', 'Citröen', 'Tesla' }
>>> marcas_moto = { 'Suzuki', 'Citröen', 'Tesla', 'Yamaha' }
>>> marcas_coche | marcas_moto
{'Citröen', 'Opel', 'Suzuki', 'Tesla', 'Yamaha'}

Comparar 2 sets y mostrar los valores duplicados de ambas listas como sin repetirlos.

>>> marcas_coche = { 'Opel', 'Citröen', 'Tesla' }
>>> marcas_moto = { 'Suzuki', 'Citröen', 'Tesla', 'Yamaha' }
>>> marcas_coche & marcas_moto
{'Citröen', 'Tesla'}

Comparar 2 sets y mostrar diferencias:

>>> marcas_coche = { 'Opel', 'Citröen', 'Tesla' }
>>> marcas_moto = { 'Suzuki', 'Citröen', 'Tesla', 'Yamaha' }
>>> marcas_coche - marcas_moto
{'Opel'}
>>> marcas_moto - marcas_coche
{'Suzuki', 'Yamaha'}

Añadir un conjunto de valores a un set y que queden en primer lugar.

marcas_coche.update([["2","3","4"])
print(marcas_coche)
{2, 3, 4, 'Opel', 'Citröen', 'Tesla'}

Añadir un valor al set

marcas_coche.add("Valor")
print(marcas_coche)
{2, 3, 4, 'Opel', 'Citröen', 'Tesla', 'Valor'}

Eliminar un valor del set

marcas_coche.remove("Opel")
print(marcas_coche)
{2, 3, 4, 'Citröen', 'Tesla', 'Valor'}

Imprimir dos sets en uno:

setA = {1,2,3,4,5}
setB = {6,7,8,9,10}
print(setA|setB)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

¡Ya sabemos trabajar mínimamente con estos tipos de datos en Python! En los próximos cursos veremos como trabajar con el control de flujo, es decir, añadiendo condicionales para encausar las decisiones imperativas de nuestro script o programa, y también como iterar diferentes tipos de valores mediante el uso de los bucles.

Detecta cambios en tus archivos con AIDE

Aide es un sistema avanzado de detección de intrusión que nos permite visualizar cambios en los archivos. Si una persona accede de forma ilegal a nuestro servidor y modifica un archivo que no tiene que tocar, este sistema de intrusión te lo detecta mediante el hash del archivo.

También permite revisar nuevos archivos creados, eliminados o modificados. Al realizar un escaneo a los archivos puede devolver diversos códigos de salida como errores de escritura, argumentos inválidos, funciones incompletas...etc El software no ocupa más que 200kb de espacio, y tiene un gran potencial, algo similar a mlocate.

Instalación en Fedora

sudo dnf install aide

Ejemplos de uso

En el siguiente apartado veremos los usos que podemos darle: * Comprobar versión * Generar la base de datos * Instalar la DB en el directorio estipulado en /etc/aide * Comprobando la integridad sin cambios * Comprobando la integridad con una modificación

Comprobar versión:

Podemos ver todas las opciones con las que se compiló y de dónde obtiene la configuración.

sudo aide --version
Aide 0.16

Compiled with the following options:

WITH_MMAP
WITH_PCRE
WITH_POSIX_ACL
WITH_SELINUX
WITH_XATTR
WITH_E2FSATTRS
WITH_LSTAT64
WITH_READDIR64
WITH_ZLIB
WITH_CURL
WITH_GCRYPT
WITH_AUDIT
CONFIG_FILE = "/etc/aide.conf"

Generar la base de datos

Depende del volumen de información que tengamos puede que tarde más o menos, hay que tener un poco de cuidado si estamos trabajando con elementos críticos en el sistema y tengamos un sistema no muy potente.

sudo aide --init
AIDE initialized database at /var/lib/aide/aide.db.new.gz

Number of entries:  11284

---------------------------------------------------
The attributes of the (uncompressed) database(s):
---------------------------------------------------

/var/lib/aide/aide.db.new.gz
  MD5      : dwWdkE+qrFulxJf6iEWJTQ==
  SHA1     : aK4Ao0mbmSmtCueAhyJnoJ4mdwI=
  RMD160   : TDxnNq5kYr1fmXXi8lAgCdsnfeA=
  TIGER    : nqgmBwvdbU4BrDrBS0pFdn9MIYPwd2q5
  SHA256   : QT3fev2WCQ+rDzvPMFU8ZgRgEXAd1pzd
             WLf95un9zeg=
  SHA512   : wCjWTKbQuKfNN/Y2Jytuq71waZrm24sr
             aQMShVvuYDS2DBRiT0G0WP146SuAkFV6
             lGqBitUYo+AgqvEPLuNXAQ==


End timestamp: 2019-01-16 18:56:44 +0000 (run time: 0m 7s)

Moviendo la base de datos

Este proceso es esencial a menos que modifiquemos la línea de dónde leerá la base de datos en el fichero de configuración o bien se lo indiquemos mediante parámetro.

sudo mv mv /var/lib/aide/aide.db.new.gz /var/lib/aide/aide.db.gz

Comprobar la integridad de los archivos

Permite visualizar si hay o no cambios en la integridad de los archivos.

sudo aide --check
AIDE found NO differences between database and filesystem. Looks okay!!

Number of entries:  11284

---------------------------------------------------
The attributes of the (uncompressed) database(s):
---------------------------------------------------

/var/lib/aide/aide.db.gz
  MD5      : rK2m9AmpajAl1ft5hBUMNQ==
  SHA1     : 0gB7cMLYLFHjRs52/7EBp3+NeS4=
  RMD160   : AcDvvoKGwNGBJe4xN+GpQVjFF2k=
  TIGER    : VOjFoPFMk6Q6zuRZcPNkaHPPYOT5yG7F
  SHA256   : xCptxDZF+uw36xUP1F0pRgc+iQtAtCbO
             aJqaD2EzhHs=
  SHA512   : SEoScwAVxVPvCfC1ZSVLR+iTP2H/ZV1d
             hi+FZm1MzVQhrsL5yqTOPxLuitdzYnn6
             aZpV9FSangKVytif0MM2vQ==


End timestamp: 2019-01-16 19:02:40 +0000 (run time: 0m 5s)

Como puedes ver, no se observan cambios.

Prueba modificando uno de ellos

Si toqueteamos el fichero de /etc/krb5.conf que pertenece a una cosa rara llamada Kerberos, te devolverá una salida como esta indicando que ha habido un cambio en el archivo de configuración.

AIDE found differences between database and filesystem!!

Summary:
  Total number of entries:  11284
  Added entries:    0
  Removed entries:    0
  Changed entries:    1

---------------------------------------------------
Changed entries:
---------------------------------------------------

f   ...   i  . . : /etc/krb5.conf

---------------------------------------------------
Detailed information about changes:
---------------------------------------------------

File: /etc/krb5.conf
  Inode    : 12452018                         | 12717139


---------------------------------------------------
The attributes of the (uncompressed) database(s):
---------------------------------------------------

/var/lib/aide/aide.db.gz
  MD5      : rK2m9AmpajAl1ft5hBUMNQ==
  SHA1     : 0gB7cMLYLFHjRs52/7EBp3+NeS4=
  RMD160   : AcDvvoKGwNGBJe4xN+GpQVjFF2k=
  TIGER    : VOjFoPFMk6Q6zuRZcPNkaHPPYOT5yG7F
  SHA256   : xCptxDZF+uw36xUP1F0pRgc+iQtAtCbO
             aJqaD2EzhHs=
  SHA512   : SEoScwAVxVPvCfC1ZSVLR+iTP2H/ZV1d
             hi+FZm1MzVQhrsL5yqTOPxLuitdzYnn6
             aZpV9FSangKVytif0MM2vQ==


End timestamp: 2019-01-16 19:05:15 +0000 (run time: 0m 2s)

Como vemos, no es un software muy "moderno", pero cumple su función.

¡Espero que le saquéis utilidad!

Distrochooser, descarga fácilmente distros de Linux desde CLI

Distrochooser es un pequeño script que he elaborado para descargar cualquier distribución popular pulsando un par de teclas evitando ir a los mirrors o páginas oficiales para descargarlos. Se puede obtener desde GitHub

git clone https://github.com/sincorchetes/distrochooser
chmod +x distrochooser/run.sh
./distrochooser/run.sh

Este script crea un directorio iso en la ruta de trabajo actual dónde descargar la imagen, para su descarga hace uso del comando wget utilizando el modificador -c que permite renaudar la descarga en caso de fallo, por lo que deberemos tenerlo instalado en nuestro sistema.

En la próxima versión soportará verificación de firma, más distribuciones. Espero que os guste.

Un saludo.

Entornos de escritorio y gestores de ventanas

Hoy en día es indispensable hacer uso de un servidor gráfico que nos permita visualizar páginas Web, escuchar música y ver películas o series entre otras cosas. Eso de estar con terminales y reproducción de contenido multimedia en formato ASCII como que no nos va mucho. Queremos visualizar el contenido cuánto más nítido y con calidad, se vive mejor.

Sin embargo, hasta hace relativamente poco, solo disponíamos de terminales de texto y programas elaborados en una interfaz MS-DOS como suelen comentar las personas más veteranas (ya que por mi edad, no pude vivirlo ni sentirlo). La historia fue que hasta que Xerox PARC (el centro de investigación del futuro para Xerox Corp.), no sacó su primer Xerox Alto en 1973, no se utilizaba ningún tipo de interfaz gráfica y mucho menos, existía el concepto del cursor del ratón. Posteriormente, hubo una guerra entre Apple y Microsoft que se disputaron a ver quién copiaba mejor la interfaz gráfica y el ratón inventado de Xerox.

Entornos de escritorio

Se denominan entornos de escritorio a un conjunto de software que contiene interfaz gráfica y que permita realizar múltiples tareas de una forma sencilla, fácil y productiva debido a su interacción amigable de cara al usuario.

Por ejemplo, ver los eventos de nuestro calendario sin tener que hacer uso de comandos o terminales de texto; visualizar el correo electrónico solo haciendo dos clics en el programa...

Haremos un breve repaso de los entornos de escritorio que existen en Linux y en BSD que podemos instalar, y en qué se diferencian principalmente.

CDE

Common Desktop Environment, fue un entorno gráfico para UNIX que fue desarrollado por empresas de gran hincampié tecnológico como HP, IBM, Novell y Sun (comprada por Oracle) viendo su primera versión en junio de 1993 de la mano de HP, IBM, SunSoft y USL(Unix System Laboratories). Estos elaboraron un proyecto en común repartiéndose las tareas para llevar a cabo diferentes objetivos hasta llegar a su primera versión del escritorio. Posteriormente, se fueron involucrando más empresas en su desarrollo. No obstante, estuvo unos años en el mercado hasta que GNOME y KDE les arrebató su posicionamiento.

GNOME

GNOME (GNU Network Object Model Environment) traducido al español como Entorno de Modelo de Objeto de Red GNU, un nombre no tan amigable como sus siglas fue desarrollado por Miguel de Icaza y Federico Mena el 15 de agosto de 1997 como alternativa a KDE (ahora Plasma) para sistemas operativos UNIX-like tipo BSD, Linux, o UNIX como esSolaris (antes SunOS).

Una de las características de GNOME es que hace uso de GTK+. Es un conjunto de bibliotecas multiplataforma para desarrollar interfaces gráficas para el usuario. Básicamente, define entre otras cosas el diseño de la ventana, los botones, introduce eventos, disparadores... como Qt en Plasma o Motif en CDE pero cada cual tiene sus diferencias.

Por otro lado, pretende ser un entorno de escritorio de fácil uso con poca personalización (sobre todo en la última versión 3.x) con el que se pueda trabajar desde el minuto 0.

Instalación

Desde los repositorios oficiales de cada distribución o sistema, hay distribuciones que requieren de pasos adicionales e incluso, configuraciones que no permitan la instalación de GNOME con el gestor de servicios systemd como es el caso de Gentoo, o también contemplan la instalación más básica de GNOME que sucede tanto en Gentoo como en Archlinux. Por ende, os recomendamos la documentación.: * Fedora: sudo dnf install @gnome-desktop * CentOS: sudo yum install @gnome-desktop * Archlinux: sudo pacman -S gnome gnome-extra * Gentoo (systemd): USE="-qt4 -qt5 -kde X gtk gnome systemd" sudo emerge --ask gnome-base/gnome" * Ubuntu: sudo apt-get install ubuntu-gnome-desktop * Debian: Se utiliza una herramienta llamada taskel(8) con interfaz ncurses que permite la instalación de un entorno. sudo apt-get install tasksel && sudo tasksel * openSUSE Leap 42.3: sudo zypper -n in patterns-openSUSE-gnome * FreeBSD: sudo pkg install gnome3

KDE (aka Plasma)

KDE fue el primer entorno de escritorio para sistemas UNIX-like que nació en octubre de 1996 de la mano de un programador alemán llamado Matthias Ettrich que buscaba básicamente una interfaz gráfica que unificáse todos los sistemas UNIX imitando el entorno de escritorio CDE.

Plasma se caracteriza a parte de hacer uso de la suite Qt de bibliotecas gráficas, de hacer un entorno muy completo y muy personalizado, en el se puede configurar todo lo que un usuario jamás pudo haber imaginado que podía llegar a configurar en un entorno, y sobre todo, haciendo uso de sus propias herramientas para hacerlo sin utilizar software a terceros tipo GNOME TweakTool, o teniendo conocimientos de JavaScript o CSS para modificar estilos y comportamientos como hacen las últimas versiones de GNOME.

Hoy en día, el software de Plasma es tan portable, que se puede hasta ejecutar en Windows y en dispositivos móviles.

Instalación

Desde los repositorios oficiales de cada distribución o sistema, hay distribuciones que requieren de pasos adicionales e incluso, configuraciones que no permitan la instalación de GNOME con el gestor de servicios systemd como es el caso de Gentoo, o también contemplan la instalación más básica de Plasma (KDE) que sucede tanto en Gentoo como en Archlinux. Por ende, os recomendamos la documentación: * Fedora: sudo dnf install @kde-desktop * CentOS: sudo yum install @kde-desktop * Archlinux: sudo pacman -S plasma * Gentoo (systemd): sudo emerge --ask kde-plasma/plasma-meta" * Ubuntu: sudo apt-get install kde-plasma-desktop * Debian: Se utiliza una herramienta llamada taskel(8) con interfaz ncurses que permite la instalación de un entorno. sudo apt-get install tasksel && sudo tasksel * openSUSE Leap 42.3: sudo zypper -n in patterns-openSUSE-kde * FreeBSD: sudo pkg install gnome3

MATE

MATE es un fork de GNOME que salió el 19 de agosto de 2011 como muestra del descontento de la nueva versión de GNOME 3 debido a que reducía muchísimo la personalización del entorno de escritorio, consumía mucho más, y tenía otro tipo de funcionalidades y características no muy transigentes. Este proyecto fue desarrollado por un desarrollador argenito de Archlinux llamado Germán Perugorría conocido en la comunidad del software libre como Perberos para continuar el desarrollo de este entorno de escritorio. Que por cierto, es el que nosotros utilizamos. El nombre proviene de la hierba Mate muy común en Argentina para tomar.

Este entorno liberó su última versión el 7 de febrero de 2018, con la satisfacción de haberse portado plenamente a la nueva suite de bibliotecas de GTK+ 3 y añadiendo más funcionalidades que no tenía sobre todo en Caja que en GNOME 3 se llama Nautilus.

Instalación

  • Fedora: sudo dnf install @mate-desktop
  • CentOS: sudo yum install epel-release && sudo yum install @mate-desktop
  • Archlinux: sudo pacman -S mate-desktop
  • Gentoo (systemd): sudo emerge --ask mate-base/mate"
  • Ubuntu: sudo apt-get install mate-desktop
  • Debian: Se utiliza una herramienta llamada taskel(8) con interfaz ncurses que permite la instalación de un entorno. sudo apt-get install tasksel && sudo tasksel
  • openSUSE Leap 42.3: sudo zypper -n in patterns-openSUSE-kde
  • FreeBSD: sudo pkg install gnome3

XFCE

XFCE se caracteriza por ser un entorno de escritorio muy liviano y ligero ya que ese eran sus dos objetivos cuando se desarrolló. La primera versión se liberó en 1996 de la mano de Olivier Fourdan. Este utiliza las bibliotecas de GTK+ para el desarrollo de sus programas gráficos.

Actualmente está comenzando a portar su software a GTK+ 3 llegando un poco tarde, ya que actualmente ya se está desarrollando GTK+ 4.

Instalación

Desde los repositorios oficiales de cada distribución o sistema, hay distribuciones que requieren de pasos adicionales e incluso, configuraciones que no permitan la instalación de XFCE con el gestor de servicios systemd como es el caso de Gentoo, o también contemplan la instalación más básica de XFCE que sucede tanto en Gentoo como en Archlinux. Por ende, os recomendamos la documentación: * Fedora: sudo dnf install @xfce-desktop * CentOS (require tener activado epel): sudo yum install epel-release && sudo yum install @xfce-desktop * Archlinux: sudo pacman -S plasma * Gentoo (systemd): sudo emerge --ask " * Ubuntu: sudo apt-get install xfce-desktop * Debian: Se utiliza una herramienta llamada taskel(8) con interfaz ncurses que permite la instalación de un entorno. sudo apt-get install tasksel && sudo tasksel * openSUSE: Hay que habilitarlo desde Factory * FreeBSD: sudo pkg install xfce

LXDE

Este fue un entorno de escritorio también como el anterior, cuyo objetivo era proveer a un PC de una suite de herramientas gráficas que permitieran trabajar consumiendo lo más mínimo de un ordenador. Su primera versión fue liberada en 2006 por Hong Jen Yee. Actualmente tiene su desarrollo parado, ya que se sustituyó por LXQt.

LXQt

Es la continuación del proyecto LXDE como entorno de escritorio. El anterior hacia uso de librerías GTK+, LXQT hace uso de Qt ya que al parecer al creador de LXDE no le terminó de convencer GTK+. Su objetivo y finalidad son el mismo que en LXDE.

Instalación

Desde los repositorios oficiales de cada distribución o sistema, hay distribuciones que requieren de pasos adicionales e incluso, configuraciones que no permitan la instalación de LXQt con el gestor de servicios systemd como es el caso de Gentoo, o también contemplan la instalación más básica de LXQt que sucede tanto en Gentoo como en Archlinux. Por ende, os recomendamos la documentación: * Fedora: sudo dnf install @lxqt-desktop * CentOS (require tener activado epel): sudo yum install epel-release && sudo yum install lxqt-* * Archlinux: sudo pacman -S lxqt * Gentoo (Requiere pasos adicionales): sudo emerge --ask lxqt-meta * Ubuntu: No disponible * Debian: Se utiliza una herramienta llamada taskel(8) con interfaz ncurses que permite la instalación de un entorno. sudo apt-get install tasksel && sudo tasksel * openSUSE Leap 42.3: sudo zypper in -y pattern lxqt * FreeBSD (Requiere pasos adicionales): sudo pkg install lxqt

Razor-Qt

Fue un entorno de escritorio desarrollado con las bibiliotecas Qt en 2010, no obstante, el equipo de Razor-Qt empezó a colaborar con el creador de LXDE originando el entorno anteriori dando origen a la primera versión en julio del 2014.

Sugar Desktop

Sugar es un entorno de escritorio que nació con el objetivo de crear una interfaz muy intuitiva para aquell@s niñ@s que no podían acceder a la tecnología puntera de países del primer mundo. Creada por Sugar Labs en mayo del 2016, como entorno para el proyecto OLPC (One Laptop Per Child) un proyecto en el que se le permite a los niños mediante un portátil de bajo costo enseñarles a incorporarse a la tecnología sin necesidad de tener grandes recursos pudo crecer y seguir manteníendose como una alternativa educativa también para l@s más peques de la casa.

Instalación

Desde los repositorios oficiales de cada distribución o sistema, hay distribuciones que requieren de pasos adicionales e incluso, configuraciones que no permitan la instalación de Sugar con el gestor de servicios systemd como es el caso de Gentoo, o también contemplan la instalación más básica de Sugar que sucede tanto en Gentoo como en Archlinux. Por ende, os recomendamos la documentación: * Fedora: sudo dnf install @sugar-desktop * CentOS: No disponible, al menos de manera oficial. * Archlinux: sudo pacman -S sugar * Gentoo: No disponible de manera oficial. * Ubuntu: sudo apt-get install sucrose * Debian: sudo apt-get install sucrose * openSUSE Leap 42.3: zypper ar http://download.opensuse.org/repositories/X11:/Sugar/openSUSE_13.1/ X11:Sugar && zypper refresh && zypper in sugar sugar-activities * FreeBSD: No disponible de forma oficial ni extra oficial.

Gestores de ventanas

Los gestores de ventanas es un conjunto mínimo de software que nos permite establecer una sesión gráfica con la que poder interactuar con elementos gráficos. Su consumo es muy pequeño al igual que sus prestaciones, pero, se puede llegar a ser muy productivo con ellos si se saben configurar y utilizar.

TWM

Tab Window Manager, es el gestor de ventanas más común en todo Linux. Fue desarrollado por Tom LaStrange desde 1987, el nombre original estaba basado en la siglas de su nombre Tom's Window Manager, pero el X Consortium lo adoptó y lo renombró en 1989. En TWM se pueden apilar las ventanas, las cuáles contienen título, e iconos para interactuar. Este gestor de ventana suele utilizarse con programas como un reloj analógico xclock(1), y también un emulador de terminal llamado xterm(1) entre otros.

Instalación

  • Fedora: sudo dnf install xorg-x11-twm
  • CentOS: No disponible, al menos de manera oficial.
  • Archlinux: sudo pacman -S xorg-twm
  • Gentoo: No disponible de manera oficial.
  • Ubuntu: sudo apt-get install twm
  • Debian: sudo apt-get install twm
  • openSUSE Leap 42.3:sudo zypper in twm
  • FreeBSD: pkg install twm

i3wm

i3wm o también conocido como i3, es un gestor de ventanas que no se superposiciona, simplemente se adapta una ventana con la otra sin superponerse. i3 nos permite gestionar ventanas en modo stack es decir, apiladas, o bien en modo de pestañas tab entre más características. En suma, soporta modo multi-pantalla, está reescrita desde 0 estando todo su código licenciado bajo términos BSD. Hay que destacar que tiene soporte UTF-8 y es muy fácil de configurar. Su primera versión fue escrita en C por Michael Stapelberg el 15 de marzo del 2009.

Instalación

  • Fedora: sudo dnf install i3
  • CentOS: sudo yum install epel-release && sudo yum install i3
  • Archlinux: sudo pacman -S i3-wm
  • Gentoo: sudo emerge --ask x11-wm/i3
  • Ubuntu: sudo apt-get install i3
  • Debian: sudo apt-get install i3
  • openSUSE Leap 42.3:sudo zypper in twm
  • FreeBSD: sudo pkg install x11-wm/i3

Fluxbox

Fluxbox es un gestor de ventanas creado por Henrik Kinnunen el 12 de septiembre de 2001. Es un wm muy sencillo y fácil de usar, bastante ligero en cuanto consumo y rendimiento. Está basado en un gestor de ventanas llamado Blackbox ya desmantenido. La última versión liberada es la 1.3.7 publicada el 8 de febrero de 2015.

Instalación

  • Fedora: sudo dnf install fluxbox
  • CentOS: sudo yum install epel-release && sudo yum install fluxbox
  • Archlinux: sudo pacman -S fluxbox
  • Gentoo: sudo emerge --ask x11-wm/fluxbox
  • Ubuntu: sudo apt-get install fluxbox
  • Debian: sudo apt-get install fluxbox
  • openSUSE Leap 42.3:sudo zypper in fluxbox
  • FreeBSD: sudo pkg install x11-wm/fluxbox

Openbox

Openbox es otro gestor de ventanas creado por Dana Jansens y Mikael Magnusson el 18 de septiembre de 2002. Este también derivó de sus inicios de Blackbox, sin embargo, ha sido reescrito totalmente desde la versión 3.0. Este gestor sacrifica entre otras cosas algunas funciones típicas como la barra de menú, lista de apps en ejecución o bordes redondeados en las ventanas. No obstante, posee herramientas de configuración del entorno bastane útiles para cambiar el fondo de pantalla, tema del gestor...etc, no obstante, el gestor de ventanas lleva sin desarrollarse desde el 1 de julio del 2015.

Instalación

  • Fedora: sudo dnf install openbox
  • CentOS: sudo yum install epel-release && sudo yum install openbox
  • Archlinux: sudo pacman -S openbox
  • Gentoo: sudo emerge --ask x11-wm/fluxbox
  • Ubuntu: sudo apt-get install openbox
  • Debian: sudo apt-get install openbox
  • openSUSE Leap 42.3:sudo zypper in openbox
  • FreeBSD: sudo pkg install x11-wm/openbox

Enlightenment

Es un gestor de ventanas con una gran cantidad de applets, módulos y aplicaciones que lo intentan convertir en un entorno de escritorio completo, la primera versión liberada fue en 1997 por Rasterman (Carsten Haitzler), mientras que la última versión liberada fue el 15 de marzo de 2018. Enlightenment lleva un desarrollo lento y denso que hace que el entorno sea un poco menos novedoso y no todos sus módulos y applets están bien recibidos según que distribuciones. Suelen faltar muchos de ellos, y algunas veces las compilaciones de los mismos no suelen llevar a resultados favorables. No obstante es una buena alternativa para aquellas personas que busquen un estado intermedio entre gestor y entorno, y resulta muy liviano y con una imagen un tanto futurista.

Instalación

  • Fedora: sudo dnf install enlightenment
  • CentOS: No disponible de forma oficial.
  • Archlinux: sudo pacman -S enlightenment
  • Gentoo: sudo emerge --ask enlightenment:0
  • Ubuntu: sudo apt-get install e17
  • Debian: sudo apt-get install e17
  • openSUSE Leap 42.3:sudo zypper in enlightenment
  • FreeBSD: sudo pkg install x11-wm/enlightenment

Awesome

Otro gestor de ventanas elaborado en C y en Lua, también es parecido a i3 en el que no es necesario hacer uso de ningún tipo de ratón y permite acoplar fácilmente las ventanas entre sí. La primera versión fue liberada el 18 de septiembre del 2007 por Julien Danjou, siendo un fork de dwm. En algunas distribuciones se encuentra disponible, pero desde el 25 de septiembre del 2016 se encuentra desmantenido.

wmii

Windows Manager Improved 2, es un gestor de ventanas que soporta el manejo de ventanas con ratón o teclado elaborado por Anselm R. Garbe y Kris Maglione y viendo la luz por primera vez el 1 de junio de 2005, tiene una filosofía minimalista de no ir más allá de 10,000 líneas de código. La última versión estable fue liberada el 1 de julio del 2017.

dwm

Es otro gestor de ventanas desarrollado por Anselm R. Garbe y liberándolo el 14 de julio de 2006. Es un wm muy minimalista pareciéndose a wmii, sin embargo, es mucho más simple que este último y está escrito en puro C para tener un rendimiento mucho más elevado además de añadir seguridad al código, pero este muy conocido gestor de ventanas se quedó en desarrollo al igual que wmii, el 1 de julio de 2017.

Fuentes

Escuchando música con MPD y ncmpcpp

¿Cuántos de nosotr@s nos hemos hecho esta pregunta? ¿Qué sería de la vida sin música? ¿Qué sería de la vida sin letras de canciones que denuncien, que estimen, que compartan dolor, amor, qué irradien ira o revolución? ¿Qué solo contenga ritmo para hacer ejercicio físico sin problemas? ¿Cuándo estamos solos y afligidos, cuándo queremos compartir momentos de celebración? Parece mentira pero la música nos despierta y nos anima. Pero más nos anima si la escuchamos haciendo uso del mínimo de recursos posibles sin perder calidad. Entonces, eso es amor.

Después de esta reflexión que parece sacada de un capítulo de Anatomía de Gray, vamos a proceder instalar el servidor de audio MPD, conocido como Music Player Daemon junto con el cliente ncmpcp(1) con el que interactuaremos cuando queramos escuchar música.

MPD es un servidor de audio que permite no solo escuchar música en local soportando multitud de códecs de audio como Ogg Vorbis, FLAC, Opus, WavPack, MP2, MP3, MP4/AAC, Mod..., si no que también puede transmitirla via streamming por el protocolo HTTP capaz de reproducir ficheros MP3 y OGG Vorbis. En suma, se puede gestionar el servidor a través de la red tanto por IPv4 como por redes IPv6, lee meta-información como las etiquetas ID3v1 y ID3v2, comentarios en Vorbis, MP4...; soporta reprodución contínua, una vez para de reproducirse una, se añaden unos segunos para "hacer creer" que sigue siendo un solo archivo (crossfading) y un millar de características más que si las seguimos mencionando no acabamos.

Instalación

Aquí añadimos varias formas de instalarlo en diferentes distribuciones, vamos a llevarlo a cabo en todas que utilicen systemd(1) junto con pulseaudio(1).

NOTA: Hay distribuciones que por licencias privativas, no se incluye software privativo de manera oficial como es el caso de Fedora, así que revisen que códecs son necesarios para nuestro sistema después de instalar el servidor y posteriormente el cliente con el que nos conectaremos.

Fedora

Para instalar en Fedora con ejecutar el siguiente comando se nos instalará pero no olvidemos instalar posteriormente los códecs para formatos MP3 desde los repositorios RPM Fusion:

sudo dnf install mpd

Ubuntu

En Ubuntu, vale tanto aptitude como la suite apt(1), hay que tener habilitado los repositorios Universe.

sudo apt-get install mpd

Debian

Como en Ubuntu, pero se encuentra en repositorio stable:

sudo apt-get install mpd

Archlinux

Tenemos que tener habilitado el repositorio extra:

sudo pacman -S mpd

Gentoo

No nos olvidemos de aplicar las USE que queramos para que se instale con los códecs y características que queramos. Puedes ver la lista pulsando aquí

sudo emerge -av media-sound/mpd

openSUSE Leap 42.3

La instalación en openSUSE requiere que se habilite el repositorio multimedia:apps porque no se encuentra soportado en los repositorios principales.

CentOS 7

Es necesario habilitar los repositorios nux

sudo yum install mpd

Configuración

La configuración como hemos dicho, haremos uso de pulseaudio(1) y lo ejecutaremos mediante nuestro usuario para evitar utilizar el usuario root que explicaremos en siguientes post que es este usuario y por qué se encuentra en el sistema.

  1. Creamos los directorios para albergar las configuraciones, playlists...etc mkdir ~/.mpd/{database,playlists,logs}
  2. Copiamos el fichero de configuración de ejemplo que nos proporciona mpd. cp /etc/mpd.conf ~/.mpd/
  3. Editamos el fichero de configuración y tienen que estar descomentadas y editadas las siguientes líneas: music_directory "~/Music" playlist_directory "~/.mpd/playlists" db_file "~/.mpd/database/mpd.db" log_file "~/.mpd/logs/mpd.log" user "sincorchetes" auto_update "yes" audio_output { type "pulse" name "My Pulse Output" } filesystem_charset "UTF-8"$

Explicaremos qué quiere decir cada línea: 1. Es el directorio dónde tengamos almacenada la música que queramos escuchar. 2. El directorio dónde se almacenarán las listas de reproducción personalizadas. 3. Fichero en el cuál se alojará los registros de cada archivo de reproducción. 4. Fichero de registro 5. Nuestro usuario 6. Se actualizará MPD de forma automática cuando MPD detecte cambios en el directorio 7. Habilitando PulseAudio en MPD (líneas 7,8 y 9) 8. Soporte UTF-8

Ahora para probar esta configuración, bastará con correr el servidor apuntando al fichero.

mpd ~/.mpd/mpd.conf

Puede que nos aparezca un mensaje como este:

exception: bind to '0.0.0.0:6600' failed (continuing anyway, because binding to '[::]:6600' succeeded): Failed to bind socket: Address already in use

Comunicándonos que se está utilizando el puerto que usa MPD, no pasa nada, lo omitimos y listo.

ncmpcpp

En este apartado, instalaremos y explicaremos como utilizar el cliente.

Instalando el cliente

Hay varios clientes para utilizar MPD, incluyendo clientes gráficos, pero a nosotros personalmente nos agrada utilizar ncmpcpp(1) más que nada por gustos.

Fedora

Para añadirlo a este SO:

sudo dnf install ncmpcpp
CentOS 7

Hay que tener habilitado el repositorio de nux como hemos mencionado anteriormente:

sudo yum install ncmpcpp
Ubuntu

Hay que tener habilitado el repositorio universe

sudo apt-get install ncmpcpp
Debian

Con un solo comando:

sudo apt-get install ncmpcpp
Archlinux

Tenemos que tener habilitado el repositorio Community

sudo pacman -S ncmpcpp
Gentoo

No nos olvidemos de que tenemos que declarar las variables USE para soportar determinadas características.

sudo emerge -av media-sound/ncmpcpp
openSUSE

Desafortunadamente no hay cliente para openSUSE, hay que compilarlo.

Probando

Para probarlo tan solo tenemos que ejecutar ncmpcpp(1)

¿Cómo manejarnos?

Bueno ncmpcpp(1) se utiliza mediante las flechas de dirección y algunas teclas preconfiguradas como las que recogemos en la siguiente tabla.

Combinación de teclas Descripción
a Añade un tema a una lista de reproducción, ya puede ser nueva o actual
Sube por los elementos
Desciende por los elementos
Shift + Selecciona elementos hacia arriba
Shift + Selecciona elementos hacia abajo
[ Desciende por el álbum
] Asciende por el álbum
{ Asciende según el artista
} Desciende según el artista
Page Up Asciende muchos ítems
Pade Down Desciende muchos ítems
Insert Selecciona ítem
Enter Según en la vista, puede reproduci, ingresar en un directorio...etc
Espacio Según la vista, puede añadir un elemento a la lista de reproducción, actualizar las letras según cambie la canción, cambiar el tipo de visualización...
Delete Borra ítems de la lista, del buscador...
Bajar el volumen, columna anterior, pantalla máster
Subir el volumen, siguiente columna...
TAB Siguiente vista
Shift + TAB Vista anterior
F1 Muestra la ayuda
1 Vista: Lista de reproducción
2 Vista: Buscador
3 Vista: Modo navegador de archivos
4 Vista: Interactuar con la biblioteca
5 Vista: Editor de listas de reproducción
6 Vista: Editor de etiquetas
7 Vista: Muestra los métodos de salida
8 Vista: Visualizador de música (no lo hemos incluído en este post)
= Vista: Muestra un reloj digital
@ Vista: Muestra la información del servidor
s Para la reproducción
p Pausa la reproducción
> Siguiente tema
< Tema anterior
Ctrl + h En el modo navegador de archivos, vuelve un directorio hacia atrás
Ctrl + h Repite la canción en modo reproducción
Backspace En modo navegador sube un directorio
Backspace En modo reproductor repite la canción
f Reproduce más rápido
b Rebovina
r Modo repetición
z Reproducción aleatoria
y Tiene múltiples funciones, buscador de canciones, detecto de cambios en etiquetas, comenzar a buscar...
Y Modo reproducción de una única canción
u Actualizar la DB

En fin hemos comentado medio archivo de atajos de teclado que viene por defecto. Puedes crearte uno propio creando el directorio ~/.ncmpcpp/bindings.

Fuentes

  • Archlinux ~ MPD
  • man packages
    • mpd.conf(5)
    • mpd(1)
    • ncmpcpp(1)

Fedora 28 liberada

Fedora como tal, vio la luz por primera vez el 6 de noviembre de 2003 por parte del Proyecto Fedora, ya que, al principio solo era un repositorio de software adicional retestado para el viejo sistema operativo de la multinacional líder en opensource y software libre Red Hat. Este repositorio fue creado por Warren Togami en el 2002 en la universidad de Hawaii como un proyecto universitario. Sin embargo, se hizo tan popular que lleguó a convertirse en un sistema operativo comunitario llamado Fedora Core y que, en 2007 pasó a llamarse Fedora.

Este utilizaba como logo un sombrero azul, ya que, la empresa Red Hat utiliza un sombrero de color rojo para su representación.

Características de Fedora

El Proyecto Fedora es una comunidad muy amplia que se encuentra alrededor de todo el mundo como muchas de las demás comunidades en el software libre. Esta difunde una serie de valores como colaborar activamente con los proyectos de software como por ejemplo GIMP, GNOME, Plasma (antes KDE) reportando errores via upstream facilitando sus correciones y adheriendo el código nuevo en los proyectos. De tal forma, que toda persona que utilice estos software que hemos mencionado acabe utilizando código de Fedora. También premia la introducción de las nuevas tecnologías tanto a nivel de desarrollo como el software GCC, Binutils, Go, Python... hasta pasar por Devops y administradores de sistemas incluyendo soporte para arquitecturas en auge como ARM64 (AArch64) para server, imágenes para s390x...etc. La tercera es tener una comunidad fuerte y amistosa en la que apoyarse, un buen compañerismo es clave no solo para el PF, si no para cualquier tipo de proyecto comunitario. Y por último, premian mucho la libertad y difunden software libre y de open source frente al software privativo ya que si se utiliza el privativo y no se da pie al conocimiento de las demás alternativas libres obligan al usuario al final a depender de software registrado en licencias restrictivas.

También es una de las comunidades que no suelen perderse eventos alrededor de todo el mundo sobre software libre como FOSDEM en Bélgica, LinuxCon en Barcelona (2012), DevCon... etc. Incluso, organizan macroeventos llamados Flock (antes FUDCon) dónde todos los colaboradores pueden tener un punto de encuentro y conocerse cara a cara.

Novedades

Fedora 28 contiene multitud de novedades que no nos podemos perder, ¡es un disparate! abarca todos los perfiles, usuarios finales, desarrolladores, DevOps, administradores de sistemas...

Arquitectura AArch64 para servidores

En esta nueva versión se facilitan imágenes de Fedora Server para esta arquitectura como DVDs para instalar, imágenes cloud en formato qcow2 (muy utilizado por el software emulador, Qemu) e imágenes Docker para gestionar contenedores.

Más info

Modularización de Anaconda

Anaconda es el instalador por excelencia de Fedora, hace unos pocos años que se reescribió completamente dando un aire de frescura haciéndolo más fácil e intuitivo que hace años atrás. Muchos de los módulos se dividirán en varias partes que se comunicarán con DBus mediante una API. El objetivo es proveer de un instalador que permita personalizarse, potenciarse añadiendo plugins, extensiones... y sobre todo más formas de probar que funciona.

Más info

Binarios anotados

Añade información extra a los binarios que hayan sido compilados con GCC. Esta información se puede utilizar por los scripts para comprobar varias características de ficheros como las opciones de refuerzo de seguridad (hardering) o posibles conflictos con ABI

Más info

Imágenes cloud y/o contenedores para s390x

Se facilitarán imágenes para esta arquitectura incluyendo las variantes de Fedora. Éstas estarán disponibles en formato qcow2 y raw.

Más info

Software modular

Fedora proveerá de una serie de repositorios de software y actualizaciones con versiones alternativas a las suministradas por los repositorios oficiales.

Más info

Ahorro de batería en portátiles

Se mejora la versión de Fedora Workstation para el consumo de la batería en ordenadores portátiles por defecto.

Más info

En cuánto a desarrollador

Tenemos una lista de software que se ha actualizado como:

  • Binutils 2.29.1
  • Boost 1.66
  • GCC 8.0.1
  • GHC 8.2.2
  • GNU C Lib 2.27
  • Ruby 2.5
  • Golang 1.10.1
  • Django 2.0.4
  • Java-openjdk-10.0.46
  • Erlang 20.3.2
  • PHP 7.2.4

Para usuarios finales

Fedora Mate personalizado{.size-full}

No nos olvidemos que tenemos una lista de novedades para aquellas personas que utilicen entornos de escritorio, entre ellas:

  • Sugar 0.112
  • GNOME 3.28.1
  • Plasma 5.12.4
  • MATE 1.20.0
  • Cinnamon 3.8.0
  • Enlightenment 0.22.3
  • XFCE 4.12.1
  • LXQt 3.1.0

Y un sin fin de más novedades que puedes revisar en el siguiente enlace

¿A qué esperas para probarlo?

Enlaces

Descarga Fedora de forma directa a través de los siguientes enlaces:

Accede a los enlaces de torrent desde aquí

¡A disfrutar!

Nota: La imagen de cabecera fue extraída del artículo "Announcing Fedora 28 en FedoraMagazine.org"

Flask - Creando una mini aplicación

En este tutorial aprenderás a utilizar Flask. Flask es un web framework elaborado en Python que te permite crear aplicaciones web bastante sencillas, pero potentes ya que el potencial se lo das tu elaborando tu propio sistema de validación, tus propios métodos de conexión a bases de datos... etc porque no olvidemos que es un microframework y no tiene muchas cosas como quizás tendría un framework como Django que contiene muchas más herramientas y desarrrollo.

Este tutorial lo he hecho basándome en la documentación oficial, pero con toques personales, así evito reproducir contenido una y otra vez.

¿Qué necesito?

  • Tener Python 3.5 o superior instalado y PyPy
  • Aunque soporte 2.7, no es recomendable utilizar esta versión porque el 31 de diciembre del año pasado se dejó de mantener la rama 2.x
  • Una o varias tazas de café

¿Cómo empezar?

A mi modo de ver las cosas y para no mezclar, siempre es mejor que utilices un entorno virtual que no el propio entorno del sistema, es decir, para instalar Flask hay que descargar una serie de códigos que se instalarán en tu sistema. Sin embargo, con un entorno virtual, puedes instalar, eliminar... o lo que quieras hacer sin dañar la instalación de Python del sistema base, ya sea Fedora, CentOS...etc

Creando un entorno virtual

$ python3 -m venv proyecto_flask

Cuando se haya creado, entonces ejecutamos:

$ flask/bin/activate

Este script carga variables de entorno y rutas para que puedas trabajar con tu proyecto, si te fijas, en el prompt de la terminal ya no está mostrándose como "$", si no, "(proyecto_flask) $"

Instalando Flask

Para instalar Flask, con el entorno virtual activo:

(proyecto_flask) $ pip install flask

Esto es todo, ya lo tendremos instalado.

Creando la mini aplicación

Utilizamos de ejemplo este directorio: /home/sincorchetes/proyecto_flask, si utilizas otro, que me imagino que sí, adáptalo al que utilices, y crea un subdirectorio llamado app.

Crea un archivo vacio y llámalo core.py (puedes llamarlo como quieras si luego defines que cargue el nombre correcto) y añades el siguiente contenido.

app/core.py
from flask import Flask
proyecto = Flask(_name_)

@proyecto.route('/')
def hola_mundo():
  return 'Hola Mundo'
  • La primera línea, importará el módulo Flask.
  • La segunda, inicializamos un objeto llamado proyecto que tiene una clase Flask y que hace referencia a sí mismo.
  • En la tercera línea, @proyecto.route('/') estamos diciendo que cuando el visitante acceda a: http://pepitodelospalotes.es verá lo que se haya definido en la función de abajo.
  • En las últimas líneas, desarrollamos la lógica de la aplicación, con la función hola_mundo(), le decimos que cuando el visitante acceda a la página verá lo que hay dentro del return, que en este caso es Hola Mundo.

Guarda el archivo, abre una terminal y sitúate en el directorio de la aplicación.

export FLASK_APP=/home/sincorchetes/proyecto_flask/app/core.py && \
export FLASK_DEBUG=1 && \
flask run 

La variables FLASK_APP, defines el core de la aplicación, FLASK_DEBUG permite activar el modo depuración que viene con ayuda para que nos muestre de dónde puede provenir los errores...etc y flask run levanta un servidor de desarrollo para que puedas ver los cambios sin tener que utilizar un servidor web como Nginx o Apache.

Una vez levantada la aplicación, si accedemos a http://localhost:5000 verás el Hola Mundo que has definido en el archivo core.py.

¿Cómo creo una página?

Como he dicho anteriormente, Flask permite crear aplicaciones web, esto no solo incluye la parte de backend que es dónde definimos la lógica de la aplicación, si no que también puedes crear la parte frontend, la parte de visible con la que el usuario interactuará.

Hay que crear el directoriotemplates para añadir las páginas .html

Una vez hecho esto, creas el archivo app/templates/index.html y le añades el siguiente contenido:

index.html
<!DOCTYPE html>
<html lang="es">
  <head>
    <title>Ejemplo de aplicación hecha en Flask</title>
  </head>
  <body>
    <div class="contenedor">
      <div class="titulo">
        <h1>¡Bienvenidos a mi página Web!</h1>
      </div>
      <div class="tareas">
        <p>¿Te gustan los perros y los coches? Esta es tú página ideal.</p>
      </div>
    </div>
  </body>
</html>

Actualiza el fichero core.py de tal modo que se quede así:

app/core.py
from flask import Flask, render_template
proyecto = Flask(_name_)

@proyecto.route('/')
def hola_mundo():
  return render_template('index.html')

He añadido render_template que permite renderizar contenido .html en el proceso de importar módulos y en la última línea llamamos al método cuyo valor es el archivo que has creado.

Verás una página como esta:

¿Cómo añado hojas de estilo o código JavaScript?

Hay crear un directorio llamado static tal que así:

(proyecto_flask) $ mkdir /home/sincorchetes/proyecto_flask/app/static

Dentro de él, añade todo el contenido CSS o JS que cargará la página, lo que suelo hacer, es crear un subdirectorio css y para las hojas de estilo y js para la lógica de eventos para el usuario.

Para llamarlo, bastará con importar el módulo url_for y luego referenciarlo en el index.html. core.py

from flask import Flask,render_template,url_for
app/templates/index.html
<head>
  <link rel="stylesheet" href="{{ url_for('static',filename='css/nombre_archivo.css) }}">
</head>
<body>
  <script src="url_for('static',filename='js/nombre_archivo.js) }}></script>
</body>

Con esto bastará, creamos un archivo en app/static/css/ejemplo.css y añade el siguiente código:

app/static/css/ejemplo.css
.body{
  font-family: Arial;
}
.contenedor {
  border-radius: 30px;
  padding:20px;
  background-color: #D3D7CF;
}
.titulo {
  text-align:center;
}
.tareas {
  background-color: white;
  border-radius: 30px;
  padding:10px;
}
.date {
    font-size: 0.4em;
    text-align: right;
    padding-left:40%;
}

Creamos un archivo llamado ejemplo.js que mostrará un cuadro de diálogo:

app/static/js/ejemplo.js
alert("Bienvenido usuario")
index.html
<!DOCTYPE html>
<html lang="es">
  <head>
    <title>Ejemplo de aplicación hecha en Flask</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/ejemplo.css') }}">
  </head>
  <body>
    <div class="contenedor">
      <div class="titulo">
        <h1>¡Bienvenidos a mi página Web!</h1>
        <hr>
      </div>
      <div class="tareas">
        <h2>Flask es un microframework web - <span class="date">Editado 19-09-2020 09:20:00 am</span></h2> 
        <p>En el siguiente artículo hablaré de las maravillas de Flask....</p>
      </div>
    </div>
    <script src="{{ url_for('static', filename='js/ejemplo.js') }}"></script>
  </body>
</html>

Cuando accedas a http://localhost:5000 vas a ver una página como esta:

No es que digas ¡como mola esta página!, simplemente es para que veas cómo se pueden crear rutas, cómo renderizar contenido .html desde el backend y cargar archivos css y js para la parte frontend de la aplicación.

En las próximas entregas, verás como trabajar con variables, listas...etc que se renderizarán en la página y con un toque más profesional en el diseño con Bootstrap.