AWK comando para obtener columnas de datos de un fichero

 

ejemplos:

1) Muestra la columna nº 17 del fichero de "DatosPiezometricos.dat":

$ cat DatosPiezometricos.dat| awk '{print $17}'

2) Sacar 2 columnas, separandolas con el caracter "|":

$ cat DatosPiezometricos.dat| awk '{print $17 "|" $19}'

3)  Del fichero DATOS.csv, obtener la 1º y 2º columna, con el siguiente criterio:

-> los datos de la 2º columna tienen que ser menores de 60 y mayores de 10

-> las columnas estan separados por coma

Los datos obtenidos, vendran separados por el caracter coma.

cat 'DATOS.csv' | awk '$2<60 && $2>10  {print $1 ","  $2}' FS=","

Fuente:

https://geekland.eu/uso-del-comando-awk-en-linux-y-unix-con-ejemplos/

https://es.wikipedia.org/wiki/AWK

webscraping ¿Como extraer datos de páginas web con Python? Ejemplo con página de apuestas

webscraping 

 ¿Como extraer datos de páginas web con Python?

En python tenemos varias librerías que nos facilitan la extracción de datos de páginas web. En el ejemplo que sigue voy a usar las siguientes:

• requests (que es la que se encarga de leer la página web) 
• beatifulsoup4 ( https://www.crummy.com/software/BeautifulSoup/ ) que es la que tiene las herramientas para extraer la información.

Para instalarlas, usa los siguientes comandos.

$ pip install beautifulsoup4
$ pip install requests

Ejemplo:
Trataremos de extraer los datos de la página web www.maratonbet.es de un partido "en vivo", que nos muestre datos del tipo: tiempo, resultado, y las cuotas de los mercados más importante (resultados). En programa necesita que se le pase en la linea de comando un parámetro con la url de la pagina web a analizar.

En el siguiente enlace podéis descargar el código del programa: alojado en google drive


Análisis del código:

1) Importando librerias
from bs4 import BeautifulSoup
import requests
import sys

Importamos las librerías que vamos a usar en la aplicación. La librería "sys" es necesaria para leer los argumentos de la linea de comandos.

2) Análisis de argumentos

if len(sys.argv)>=2:

  Hacemos una comprobación sobre el numero de argumentos. Si hay 2 o más seguimos ejecutando el programa, sino escribiremos en la consola que faltan argumentos:
else:
print "Falta argumento: url de la página mbet a analizar";

3) Cuerpo principal del programa:
3.1) Leer la url del argumento de la linea de comando y cargar página web:
URL=sys.argv[1]

req = requests.get(URL)

3.2) Una vez cargada empezamos con crear un objeto BeautifulSoup con el texto extraido:

html = BeautifulSoup(req.text, "html.parser")


3.3) Extraigo el resultado y el tiempo del encuentro.

resultadoytiempo=html.find('td',{'class':'event-description'})

Nota: Anteriormente he analizado la página web de los encuentros en directo de mbet, y he visto como esta formado la página web, etiquetas tipo table, td, div, class, que usa página web para mostrar la información.

Imprimo el resultado y tiempo:

print " %s " %resultadoytiempo.getText()


3.4) Proceso entradas de resultados:
Las etiquetas "div" que usan la case "nowrap simple-price", contienen datos del mercado y cuota a la que estan referidas. Con la siguiente instrucción, consigo un array con estos datos.


entradas = html.find_all('div', {'class': 'nowrap simple-price'})


Ahora con un bucle for, voy extrayendo los datos del mercado dentro de cada elemento de "entradas"

for i, entrada in enumerate(entradas):
# Con el método "getText()" no nos devuelve el HTML
equipo1 = entrada.find('span', {'class': 'left-simple'}).getText()
cuota1= entrada.find('span', {'class': 'right-simple'}).getText()

Y los imprimo en pantalla:
# Imprimo el equipo/resultado y cuota
print "%d - %s | %s " % (i + 1, equipo1, cuota1)


Pantallazo de uso y salida del script:

Vídeo de uso de la aplicación:




Saludos


Fuentes y Documentación Extra:
https://jarroba.com/scraping-python-beautifulsoup-ejemplos/
https://www.crummy.com/software/BeautifulSoup/
https://es.slideshare.net/ecrespo/webscraping

Truco: Como Guardar (y Abrir) comprimidos los archivos de datos de nuestros programas

Truco: 

Como Guardar (y Abrir)  comprimidos 

los archivos de datos de nuestros programas

En este artículo, os comento como guardar datos de nuestros programas y luego abrirlos, comprimiendo los archivos. Aunque lo explico usando código de Gambas, es aplicable a otros lenguajes Python, Java, etc... Básicamente se trata de usar el comando del sistema tar,  y para que se entienda mejor, os haré la explicación de como lo hace el programa pintascreen.

El programa pintascreen, maneja los siguientes datos:

- Una imagen de fondo

- Un array de objetos del tipo "dibujo", que es el que contiene las diversas primitivas de dibujo, osea los objetos del tipo "marcador", "texto", "linea", "flecha", "chincheta", etc... que es lo que va dibujando el usuario.

- Una imagen miniatura de todo lo que ha dibujado, que la usa para mostrarla en el formulario de "abrir":

Os describo los pasos a seguir para Guardar los datos:

Los archivos que tenemos que guardar por cada captura son:

fondo.jpg: es la imagen del fondo

mini.jpg: es una imagen en miniatura de lo dibujado (incluyendo el fondo)

figuras.txt: es un archivo de texto plano, donde se guardan los datos de las figuras dibujadas (ancho, color, coordenada de inicio y fin, etc..)

Pasos a seguir:

0) Pedir la ruta y el nombre del archivo donde guardaremos los datos. Lo guardaremos en la variable "rutafichero"

1)  Generar los archivos, tanto la imagen de miniatura como el archivo .txt de las figuras dibujadas.

No entro en detalles, porque para cada programa será distinto, pero podeis ver como se hace en el pintascreen en el módulo: ModuleAbrirGuardar, en el método guardar().

2) Copiarlos en una ruta.

En nuestro caso, los vamos a copiarlo en el directorio /tmp/pintascreenGuarda/

3) Crear el tar.gz

Mediante el siguiente comando, vamos a crear el archivo comprimido que contenga los 3 archivos:

comando = "cd /tmp/pintascreenGuarda/;tar czvf \"" & File.Name(rutafichero) & ".tar.gz\" *"

Nota:Es muy importante que usemos "cd" para desplazarnos al directorio donde tenemos los archivos, y luego usar ";" para unir la siguiente orden (tar).

y lo ejecutamos con la orden Shell:

Shell comando Wait

4) Cambiamos la extensión .tar.gz por .pintascreen y lo movemos a la ruta seleccionada:

comando = "mv /tmp/pintascreenGuarda/" & File.Name(rutafichero) & ".tar.gz " & Rutafichero & ".pintascreen"

Shell comando Wait

5) Borrar archivos temporales.

Borraríamos los archivos que tendríamos en la carpeta "/tmp/pintascreenGuarda/":

 For Each nombrearchivo In Dir("/tmp/pintascreenGuarda/", "*.*", GB.File).Sort()

Kill "/tmp/pintascreenGuarda/" & nombrearchivo

Next

Así obtenemos un archivo con extensión .pintascreen, que realmente es un tar.gz, con los archivos de los datos comprimidos y empaquetado.

Pasos para Abrir los archivos .pintascreen

0)  Elegir el archivo que queremos abrir, lo llamaremos "rutafichero"

1) Creamos el directorio de trabajo, en nuestro caso lo llamamos "/tmp/pintascreenAbrir", y si no existe lo creamos:

If Not Exist("/tmp/pintascreenAbrir") Then

Mkdir "/tmp/pintascreenAbrir"

Endif

2) Borramos el contenido del directorio de trabajo, por si hubiésemos abierto otro archivo anteriormente.

'borrar archivos existentes

For Each nombrearchivo In Dir("/tmp/pintascreenAbrir", "*.*", GB.File).Sort()

Kill "/tmp/pintascreenAbrir/" & nombrearchivo

Next

3) Copiamos el archivo y lo descomprimirmos.

'copia el archivo y lo descomprime el archivo

Copy Rutafichero To "/tmp/pintascreenAbrir/" & File.Name(Rutafichero)

Shell "cd /tmp/pintascreenAbrir/;tar -zxvf \"/tmp/pintascreenAbrir/" & File.Name(Rutafichero) & "\"" Wait

Nota:
Es muy importante que usemos "cd" para desplazarnos al directorio donde tenemos los archivos, y luego usar ";" para unir la siguiente orden (tar).

4) Ya con los archivos descomprimidos, lo usaríamos en el programa, por ejemplo en el pintascreen, se cargaría el fondo, se leería el fichero de figuras.txt, para crear los objetos de dibujo.

Extracción de un archivo concreto:

Os dejo por ultimo, la forma de extraer un archivo en concreto, que es lo que uso para cuando estamos en el formulario de abrir, y nos muestra la miniatura. Se trata de usar el comando tag -zxvf indicándole la ruta donde queramos que se descomprima y el nombre del fichero que queramos extraer. Esto lo hago con el método "cargaImagen()", que esta en el módulo "ModuleAbrirGuardar"

Public Sub cargaImagen(Rutafichero As String) As Picture
'leer el archivo, lo descomprime, y carga la vista minuatura...Try Kill "/tmp/mini.jpg"
Shell "cd /tmp;tar -zxvf \"" & Rutafichero & "\" mini.jpg" Wait
If Exist("/tmp/mini.jpg") ThenReturn Picture.Load("/tmp/mini.jpg")ElseReturn NullEndif
End

Como veis, la función recibe el nombre (ruta incluida), del fichero que queremos ver si miniatura, y devuelve un objeto Picture.

Extrae el fichero mini.jpg (en la ruta /tmp) ,

Shell "cd /tmp;tar -zxvf \"" & Rutafichero & "\" mini.jpg" Wait

 y lo carga y devuelve

Return Picture.Load("/tmp/mini.jpg")

Si hay no lo encuentra, devuelve Null

Return Null

Por último os comento que seguramente existen otros métodos más óptimos y con mejor rendimiento para hacer esto, yo os lo comento para que veais la forma en que lo hago yo, y como lo he usado en varios de mis programas con éxito.

Nota:

El código fuente del programa pintascreen lo podéis descargar en:

http://jsbsan.blogspot.com.es/2014/12/pintascreen-0056-seguimos-con-mejoras.html