Aprende web Scraping - Web ESPN - Parte 2 👀

2. Web Scraping de la página ESPN

•  En este capítulo del curso de programación en c# con visual studio 2017 continuamos con la técnica conocida como web scraping.  A grandes rasgos podemos decir que se trata de una técnica para extraer información de sitios web, se trata de un proceso para  recopilar información de forma automática de páginas que encontremos publicadas en la red.

• En esta entrada comenzaremos ha obtener los datos referentes a las estadísticas de los jugadores. Para ello, utilizando la herramienta para desarrolladores que traen integrada los diferentes navegadores vemos como se llaman los componentes html de la paginas que queremos descargarnos a nuestra máquina. En nuestro caso las páginas que tienen una  estructura de url similar a:  http://www.espn.com/nba/player/_/id/1/  tienen un div   con  un  class que se llama   'player-bio':  div[@class='player-bio'] . Basándonos en esto podemos empezar  nuestro bot.

• Os dejo el vídeo donde podemos ver lo que acabo de contar:

• Os dejo el código visto en el vídeo:

        static void Main(string[] args)

        {

            WebClient client = new WebClient();

            HtmlDocument doc = new HtmlDocument();

            HtmlNode.ElementsFlags["br"] = HtmlElementFlag.Empty;

            doc.OptionWriteEmptyNodes = true;

            var web = HttpWebRequest.Create("http://www.espn.com/nba/player/_/id/1/");

            Stream stream = web.GetResponse().GetResponseStream();

            doc.Load(stream);

            foreach (HtmlNode node in doc.DocumentNode.SelectNodes("//div[@class='player-bio']"))

            {

                Console.WriteLine(node.InnerHtml);

            }

            Console.ReadLine();

                

       }

    }

Aprende web Scraping - Web ESPN - Parte 1

1. Web Scraping de la página ESPN

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos ha empezar con la técnica conocida como web scraping.  A grandes rasgos podemos decir que se trata de una técnica para extraer información de sitios web, se trata de un proceso para  recopilar información de forma automática de páginas que encontremos publicadas en la red. 

• Os dejo un enlace  con una definición más amplia: https://es.wikipedia.org/wiki/Web_scraping

• Antes de continuar  con la entrada del blog comentaros que en España el web scraping en sí, es legal. Es importante que entendamos que el problema no está en el uso de los crawlers o bots  para rastrear la red, sino en el uso que damos de los datos conseguidos. Como en nuestro caso el objetivo es simplemente aprender ha construir un bot para realizar esta tarea, y no le vamos a dar ningún uso comercial no creo que haya ningún problema. 

• Una vez aclaradas estás cuestiones paso a comentaros lo que nos espera en las siguientes semanas en nuestro blog :

1. Crearemos un programa que rastree la web  ESPN para obtener estadísticas de los jugadores.
2. Una vez hecho esto guardaremos en nuestro disco duro un fichero por cada jugador encontrado. Como esto se trata de un ejemplo sólo me bajaré la información de unos 5000 jugadores.
3.  Una vez tengamos almacenada la información en disco definir tablas en una base de datos para guardar la información.
4. Volcar la información de los ficheros a nuestras base de datos.
5. Crear un página web o aplicación de escritorio donde consultar las estadísticas.

• Os dejo un enlace al vídeo donde os cuento la película:

Creando bot monitorización en c# - Capítulo 4

4. Creando bot monitorización en c# 

•  En este capítulo del curso de programación en c# con visual studio 2017 finalizamos  la construcción de nuestro bot para monitorizar los cambios que se produzcan en un página determinada. Básicamente queremos saber cuando cambia un texto en una zona determinada de una página. 

• En este capítulo veremos como hacer que una aplicación se ejecute con la periodicidad que nosotros le indiquemos.Para ello hacemos uso de las tareas programadas.Las tareas programadas son aquellas que usted puede configurar para que cualquier proceso, programa o archivo se ejecute el tiempo o fecha que usted desee. Los pasos a seguir son los siguientes:

• Abrimos el programador de tareas:

• Nos encontraremos con algo similar a esto:

• Ahora pulsamos el botón derecho para crear una nueva tarea:

• Nos aparecerá una ventana similar a la siguiente  donde configuraremos las características de la tarea:

• Seleccionamos el archivos que queremos que se ejecute en la pestaña acciones:

• Una vez hecho esto sólo nos queda configurar la periocidad. Tenéis la información al completo en el vídeo.

Creando bot monitorización en c# - Capítulo 3

Este resumen no está disponible. Haz clic en este enlace para ver la entrada.

Creando bot monitorización en c# - Capítulo 2

2. Creando bot monitorización en c# 

•  En este capítulo del curso de programación en c# con visual studio 2017 continuamos con la construcción de nuestro bot para monitorizar los cambios que se produzcan en un página determinada. Básicamente queremos saber cuando cambia un texto en una zona determinada de una página. Cuando el bot detecta un cambio desencadenara la acción que elijamos.

• Como sólo queremos detectar el cambio que se produce en una sección determinada de la página, vamos a navegar en el documento cuando lo tengamos cargado en memoria, antes de guardar en disco, para seleccionar y guardar únicamente la parte de la página que queremos monitorizar.

• Para ello utilizamos la libreria HTML Agility pack que nos facilita el trabajo.Os dejo un enlace a stackoverflow donde se explica como utilizar esta libreria: https://stackoverflow.com/questions/846994/how-to-use-html-agility-pack

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código que hemos visto en el vídeo:

//Parte que guardo pagina en disco solo lo que me interesa de la página

  try

            {

                //Video  utilizar y guardar en disco

                WebClient cliente = new WebClient();

                String pagina = String.Empty;

                pagina = cliente.DownloadString("https://www.taiestado.com/");

                    

                StreamWriter sw = new StreamWriter("D:\\Temporal.html",false);

                sw.Write(pagina);

                sw.Close();

                sw.Dispose();

                //Video 2 guardar en disco solo la parte del fichero que me interesa

                var doc = new HtmlAgilityPack.HtmlDocument();

                HtmlAgilityPack.HtmlNode.ElementsFlags["br"] = HtmlAgilityPack.HtmlElementFlag.Empty;

                doc.OptionWriteEmptyNodes = true;

                var webRequest = HttpWebRequest.Create("https://www.taiestado.com/");

                Stream stream = webRequest.GetResponse().GetResponseStream();

                doc.Load(stream);

                stream.Close();

                string testDivSelector = "//div[@id='subcomentarios']";

                var divString = doc.DocumentNode.SelectSingleNode(testDivSelector).InnerHtml.ToString();

                Console.ReadLine();

            }

            catch (Exception ex)

            {

                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine(ex.ToString());

                Console.ReadLine();

            }

        }

Creando bot monitorización en c# - Capítulo 1

1. Creando bot monitorización en c# 

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos ha empezar a construir un bot para monitorizar los cambios que se produzcan en un página determinada. Básicamente queremos saber cuando cambia un texto en una zona determinada de una página. Cuando el bot detecte un cambio desencadenara la acción que elijamos.

• Un bot  es un programa informático que efectúa automáticamente tareas repetitivas a través de Internet.Un ejemplo de bots son los rastreadores web de los motores de búsqueda de Internet, que recorren los sitios web de forma automática y recopilan información de los mismos de manera mucho más rápida y efectiva de lo que lo haría una persona.

• Os dejo un enlace  a  información más detallada sobre los diferentes tipos de bots:https://computerhoy.com/noticias/software/que-es-bot-44366

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código visto en el video, en el que guardo la página a chequear en disco:

static void Main(string[] args)

{

try

{

WebClient cliente = new WebClient();

String pagina = String.Empty;

pagina = cliente.DownloadString("https://www.taiestado.com/");

StreamWriter sw = new StreamWriter("D:\\Temporal.html", false);

sw.Write(pagina);

sw.Close();

sw.Dispose();

Console.WriteLine(pagina);

Console.ReadLine();

}

catch (Exception ex)

{

Console.ForegroundColor = ConsoleColor.Red;

Console.WriteLine(ex.ToString());

Console.ReadLine();

}

}

Algoritmos de ordenación en c# - Algoritmo Shell Sort

6. Algoritmo de ordenación Shell Sort 

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de de ordenación Shell Sort.

• El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta que  el ordenamiento por inserción es eficiente si la entrada está "casi ordenada". El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez. El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones

• Os dejo un enlace  a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Ordenamiento_Shell

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código del algoritmo visto en el vídeo:

      public static void ShellShort()

        {

            int[] array = { 15,50, 17, 72, 12, 23, 54, 76, 75, 43, 8654, 87, 654, 9 };

            mostrar(array);

            Console.WriteLine("");

            ShellShort(array);

            Console.ReadLine();

            mostrar(array);

            Console.ReadLine();

        }

        public static void ShellShort(int[] array)

        {

            int mitad = 0;

            bool ejecutar = false;

            int aux = 0;

            int x = 0;

            mitad = array.Length / 2;

            while (mitad > 0)

            {

                ejecutar = true;

                while (ejecutar)

                {

                    ejecutar = false;

                    x = 1;

                    while (x <= (array.Length - mitad))

                    {

                        if (array[x - 1] > array[(x - 1) + mitad])

                        {

                            aux = array[(x - 1) + mitad];

                            array[(x - 1) + mitad] = array[x - 1];

                            array[(x - 1)] = aux;

                            ejecutar = true;

                        }

                        x++;

                    }

                }

                mitad = mitad / 2;

            }

        }

• También os dejo el  código del proyecto con todos los algoritmos de ordenación vistos hasta ahora para descargar

Algoritmos de ordenación en c# - Algoritmo de ordenamiento por insercion

5. Algoritmo de ordenamiento por inserción

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de de ordenamiento por insercion.

•  La idea de este algoritmo de ordenación consiste en ir insertando un elemento del array en la parte ordenado del mismo, asumiendo que el primer elemento es la parte ordenada, el algoritmo ira comparando un elemento de la parte desordenada del array con los elementos de la parte ordenada, insertando el elemento en la posición correcta dentro de la parte ordenada, y así sucesivamente hasta obtener el array ordenado.

• Os dejo un enlace  a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Ordenamiento_por_inserci%C3%B3n

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código del ejemplo visto en el vídeo:

  public static void OrdenaciónDirecta()

        {

            int[] array = { 50, 17, 72, 12, 23, 54, 76,75,43 ,8654,87,654,9};

            mostrar(array);

            Console.WriteLine("");

            OrdenaciónDirecta(array);

            Console.ReadLine();

            mostrar(array);

            Console.ReadLine();

        }

        public static void OrdenaciónDirecta(int[] array)

        {

            int aux;

            int j;

            for (int i = 0; i < array.Length; i++)

            {

                aux = array[i];

                j = i - 1;

                while (j >= 0 && array[j] > aux)

                {

                    array[j + 1] = array[j];

                    j--;

                }

                array[j + 1] = aux;

            }

        }

:

Algoritmos de ordenación en c# - Algoritmo HeapShort

4. Algoritmo HeapSort

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de ordenación HeapSort.

•  Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un montículo y posteriormente  extraer el nodo que queda como nodo raíz del montículo en sucesivas iteraciones obteniendo el conjunto ordenado.

• Os dejo un enlace al pseudocódigo y a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Heapsort

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código visto en el vídeo:

   public static void  HeapSort()

        {

            

                int[] array = { 50, 17, 72, 12, 23, 54, 76 };

                mostrar(array);

                Console.WriteLine("");

                HeapSort(array);

                Console.ReadLine();

                mostrar(array);

                Console.ReadLine();

            

        }

        static private void HeapSort(int[] array)

        {

           

            int tamanioArray = array.Length;

            for (int p = (tamanioArray - 1) / 2; p >= 0; p--)

                Maximos(array, tamanioArray, p);

            for (int i = array.Length - 1; i > 0; i--)

            {

                int temp = array[i];

                array[i] = array[0];

                array[0] = temp;

                tamanioArray--;

                Maximos(array, tamanioArray, 0);

                Console.WriteLine("");

                mostrar(array);

            }

          

        }

        private static void Maximos(int[] array, int tamanyo, int posicion)

        {

            int izquierda = (posicion + 1) * 2 - 1;

            int derecha = (posicion + 1) * 2;

            int mayor = 0;

            if (izquierda < tamanyo && array[izquierda] > array[posicion])

                mayor = izquierda;

            else

                mayor = posicion;

            if (derecha < tamanyo && array[derecha] > array[mayor])

                mayor = derecha;

            if (mayor != posicion)

            {

                int temp = array[posicion];

                array[posicion] = array[mayor];

                array[mayor] = temp;

                Maximos(array, tamanyo, mayor);

            }

        }

Algoritmos de ordenación en c# - Algoritmo Quick Sort

3. Algoritmo Quick Sort

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de ordenación Quick Sort.

• En este algoritmo se toma un elemento x de una posición del array. Se trata de ubicar a x en la posición correcta del array, de tal forma que todos los elementos que se encuentran a su izquierda sean menores o iguales a x y todos los elementos que se encuentren a su derecha sean mayores o iguales a x.

• Os dejo un enlace al pseudocódigo y a  información más detallada sobre este algoritmo:https://es.wikipedia.org/wiki/Quicksort

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el codigo visto en el vídeo:

  public static void Quicksort()

        {

            int[] array = { 12, 17, 16, 8, 67, 1, 4, 876,21,6789, 99, 77, 6, 10, 88, 45 };

            mostrar(array);

            Console.WriteLine("");

            Quicksort(array, 0, array.Length - 1);

            Console.ReadLine();

            mostrar(array);

            Console.ReadLine();

        }

        static private void Quicksort(int[] array, int inicio, int fin)

        {

            int x, y, central;

            double pivote;

            central = (inicio + fin) / 2;

            pivote = array[central];

            x = inicio;

            y = fin;

            do

            {   

                while (array[x] < pivote) x++;

                while (array[y] > pivote) y--;

                if (x <= y)

                {

                    int aux;

                    aux = array[x];

                    array[x] = array[y];

                    array[y] = aux;

                    x++;

                    y--;

                }

            } while (x <= y);

            if (inicio < y)

            {

                Console.WriteLine();

                mostrar(array);

                Quicksort(array, inicio, y);

            }

            if (x < fin)

            {

                Console.WriteLine();

                mostrar(array);

                Quicksort(array, x, fin);

            }

          

        }

Algoritmos de ordenación en c# - Algoritmo Merge Sort

2. Algoritmo Merge Sort

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de ordenación por mezcla o Merge Sort.

• Este algoritmo  se basa en la técnica divide y vencerás.Esta técnica consiste en dividir el problema a resolver en  problemas más pequeños del mismo tipo que a su vez se  volverán a dividir en problemas todavía mas pequeños hasta que sean  triviales.

• Os dejo un enlace al pseudocódigo y a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Ordenamiento_por_mezcla

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• También os dejo el código correspondiente al algoritmo explicado en el vídeo:

 public static void Mergesort()
        {
            int[] array = { 12, 17, 16, 8, 67, 1, 4, 1000, 99, 77, 6, 10 ,88, 45 };
            mostrar(array);
            Console.WriteLine("");
            MergeSort(array, 0, array.Length - 1);
            Console.ReadLine();
            mostrar(array);
            Console.ReadLine();

        }


        static private void MergeSort(int[] array, int inicio, int fin)
        {

            if (inicio == fin)
                return;

             int mitad = (inicio + fin) / 2;

            MergeSort(array, inicio, mitad);
            MergeSort(array, mitad + 1, fin);

             int[] aux = juntarArrays(array, inicio, mitad, mitad + 1, fin);

            Array.Copy(aux, 0, array, inicio, aux.Length);

            Console.WriteLine("");

            mostrar(array);

        }

    static private int[] juntarArrays(int[] x, int inicio, int fin, int inicio2, int fin2)
        {

            int aux1 = inicio;
            int aux2 = inicio2;
            int[] resultado = new int[fin - inicio + fin2 - inicio2 + 2];

            for (int i = 0; i < resultado.Length; i++)
            {

                if (aux2 != x.Length)
                {

                    if (aux1 > fin && aux2 <= fin2)
                    {
                        resultado[i] = x[aux2];
                        aux2++;
                    }

                    if (aux2 > fin2 && aux1 <= fin)
                    {
                        resultado[i] = x[aux1];
                        aux1++;
                    }

                    if (aux1 <= fin && aux2 <= fin2)
                    {
                        if (x[aux2] <= x[aux1])
                        {
                            resultado[i] = x[aux2];
                            aux2++;
                        }
                        else
                        {
                            resultado[i] = x[aux1];
                            aux1++;

                        }

                    }

                }
                else
                {
                    if (aux1 <= fin)
                    {
                       resultado[i] = x[aux1];
                        aux1++;
                    }

                }

            }
            return resultado;

        }