Notebooks_Ejercicios/Audiencias/Audiencias.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio: Análisis de audiencias televisivas\n",
    "**Autor**: José A. Troyano.   **Revisores**: Mariano González, Carlos G. Vallejo, José C. Riquelme, Beatriz Pontes, Toñi Reina.   **Última modificación:** 29/10/2018"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este notebook se proporcionan soluciones a\n",
    "la mayoría de las funciones propuestas. Nos servirá para ilustrar, sobre un proyecto sencillo, los pasos más comunes de la mayor parte de los ejercicios que\n",
    "haremos a lo largo del curso:\n",
    "\n",
    "- Funciones de carga de datos\n",
    "- Funciones de transformación y filtrado\n",
    "- Funciones de visualización\n",
    "\n",
    "Trabajaremos con datos de audiencia televisiva, en concreto con los datos de audiencia de diferentes ediciones del programa _Gran Hermano_. Como resultado del proyecto, obtendremos una serie de indicadores y gráficas que nos permitirán analizar la evolución de la audiencia de un programa televisivo a lo largo del tiempo.\n",
    "\n",
    "Usaremos módulos de la librería estandar, y un único paquete externo (<code>matplotlib</code> para la generación de gráficas). Estas son las correspondientes instrucciones de importación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import statistics\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Carga de datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tomaremos los datos de un fichero de entrada llamado <code>GH.csv</code>  en el que se encuentran las\n",
    "audiencias de las distintas ediciones del programa televisivo \"Gran Hermano\"\n",
    "desde la primera edición hasta la número 17.\n",
    "\n",
    "Cada línea del fichero de entrada se corresponde con la audiencia de un\n",
    "programa, y contiene dos informaciones: \n",
    "- La edición a la que pertenece el programa\n",
    "- El _share_ (porcentaje de la audiencia que vio ese programa\n",
    "concreto) \n",
    "\n",
    "No hay información de fecha, pero las líneas del fichero mantienen\n",
    "el orden cronológico en el que fueron emitidos los correspondientes programas.\n",
    "Estas son las primeras líneas del fichero de entrada:\n",
    "\n",
    "<pre>\n",
    "    1,0.37\n",
    "    1,0.33\n",
    "    1,0.47\n",
    "    1,0.46\n",
    "    1,0.54\n",
    "    1,0.43\n",
    "    1,0.59\n",
    "    1,0.58\n",
    "</pre>\n",
    "\n",
    "La primera función que implementaremos será la de lectura. Será la encargada de leer los datos del fichero de entrada y cargarlos en una estructura en memoria. La estructra más apropiada para los datos será una _lista de tuplas_. Una lista porque tenemos como entrada una secuencia de audiencias, y _de tuplas_ porque cada audiencia tiene dos informaciones (edición y _share_).\n",
    "\n",
    "Las siguientes celdas contienen la implementación y el test, respectivamente, de la función de lectura:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lee_audiencias(fichero):\n",
    "    ''' Lee el fichero de entrada y devuelve una lista de audiencias\n",
    "    \n",
    "    ENTRADA: \n",
    "       - fichero: nombre del fichero -> str\n",
    "    SALIDA: \n",
    "       - lista de audiencias -> [(int, float)] \n",
    "\n",
    "    Cada línea del fichero se corresponde con la audiencia de un programa,\n",
    "    y se representa con una tupla con los siguientes valores:\n",
    "        - edición\n",
    "        - audiencia\n",
    "    Hay que transformar la entrada (cadenas de caracteres) en valores numéricos\n",
    "    para que puedan ser procesados posteriormente.\n",
    "    '''\n",
    "    audiencias = []\n",
    "    with open(fichero, encoding='utf-8') as f:\n",
    "        for linea in f:\n",
    "            # Separamos la línea en dos usando ',' como delimitador\n",
    "            edicion, share = linea.split(',')\n",
    "            # Transformamos los valores str a int y float\n",
    "            edicion = int(edicion)\n",
    "            share = float(share)\n",
    "            # Creamos una tupla\n",
    "            tupla = (edicion, share)\n",
    "            # Añadimos la tupla a la lista\n",
    "            audiencias.append(tupla)\n",
    "    return audiencias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función lee_audiencias\n",
    "AUDIENCIAS_GH = lee_audiencias('./data/GH.csv')\n",
    "print(AUDIENCIAS_GH[:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la siguiente celda hay otra implementación, bastante más simple, de la función <code>lee_audiencias</code> que hace uso del módulo <code>csv</code> de la librería estándar de Python y de las listas por comprensión: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lee_audiencias(fichero):\n",
    "    ''' Lee el fichero de entrada y devuelve una lista de audiencias\n",
    "    \n",
    "    ENTRADA: \n",
    "       - fichero: nombre del fichero -> str\n",
    "    SALIDA: \n",
    "       - lista de audiencias -> [(int, float)] \n",
    "\n",
    "    Cada línea del fichero se corresponde con la audiencia de un programa,\n",
    "    y se representa con una tupla con los siguientes valores:\n",
    "        - edición\n",
    "        - audiencia\n",
    "    Hay que transformar la entrada (cadenas de caracteres) en valores numéricos\n",
    "    para que puedan ser procesados posteriormente.\n",
    "    '''\n",
    "    with open(fichero, encoding='utf-8') as f:\n",
    "        # Se crea un objeto lector (un iterator) que separará los valores por comas \n",
    "        lector = csv.reader(f)\n",
    "        # Lista por comprensión sobre el objeto lector\n",
    "        audiencias = [(int(edicion), float(share)) for edicion, share in lector]\n",
    "    return audiencias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2. Funciones de transformación y filtrado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez que hemos cargado los datos en una estructura en memoria ya podemos empezar a trabajar con ellos. Lo haremos con funciones que denominaremos de _transformación_ y _filtrado_. Con estas funciones podremos obtener información derivada de los datos originales _en crudo_, extraer un subconjunto de los datos en base a una _consulta_, y también podremos transformar los datos originales para obtener nuevas estructuras de datos que nos sirvan para resolver los problemas que nos plantee cada proyecto.\n",
    "\n",
    "En este ejercicio implementaremos tres funciones de este tipo que nos permitirán:\n",
    "- Calcular una lista con las distintas ediciones del programa presentes en los datos de entrada\n",
    "- Seleccionar los datos de audiencia de unas ediciones determinadas\n",
    "- Calcular las medias de _share_ por cada edición\n",
    "\n",
    "La primera de las funciones se llama <code>calcula_ediciones</code> y obtendrá, a partir de los datos de entrada, una lista ordenada de las diferentes ediciones para las que hay algún registro en ellos. Las siguientes celdas contienen la implementación y el test, respectivamente, de esta función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcula_ediciones(audiencias):\n",
    "    ''' Calcula el conjunto de ediciones presentes en una lista de audiencias\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "    SALIDA: \n",
    "       - lista de ediciones -> [int] \n",
    "\n",
    "    Toma como entrada una lista de tuplas (edición, share) y produce como\n",
    "    salida una lista ordenada con aquellas ediciones para las que haya al menos\n",
    "    una tupla. La lista de salida no contendrá elementos repetidos.\n",
    "    '''\n",
    "    # Calculamos el conjunto de ediciones presentes\n",
    "    ediciones = {e for e, _ in audiencias}\n",
    "    # Convertimos el conjunto en lista para poder ordenarlo\n",
    "    ediciones = list(ediciones)\n",
    "    # Ordenamos las ediciones\n",
    "    ediciones.sort()\n",
    "    return ediciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función calcula_ediciones\n",
    "ediciones = calcula_ediciones(AUDIENCIAS_GH)\n",
    "print(ediciones)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La segunda de las funciones será _de filtrado_. Este tipo de funciones recuperan un subconjunto de los datos de entrada que cumplen una determinada condición. En concreto, la función <code>filtra_por_ediciones</code> recupera solo aquellos registros de audiencia en los que la edición es una de las que recibe como parámetro. Las siguientes celdas contienen la implementación y el test, respectivamente, de esta función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filtra_por_ediciones(audiencias, ediciones):\n",
    "    ''' Selecciona las tuplas correspondientes a unas determinadas ediciones\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "       - ediciones: lista de ediciones a seleccionar -> [int]\n",
    "    SALIDA:\n",
    "       - lista de audiencias seleccionadas -> [(int, float)]\n",
    "\n",
    "    Toma como entrada una lista de tuplas (edición, share) y un conjunto de \n",
    "    ediciones. Produce como salida otra lista de tuplas en la que solo se\n",
    "    incluyen aquellas cuya edición sea una de las que se recibe como parámetro.\n",
    "    '''\n",
    "    filtradas = [(e, s) for e, s in audiencias if e in ediciones]\n",
    "    return filtradas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función filtra_por_ediciones\n",
    "audiencias_123 = filtra_por_ediciones(AUDIENCIAS_GH, [1, 2, 3])\n",
    "print(audiencias_123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La tercera de las funciones de esta sección es una función _de transformación_. Con este tipo de funciones construiremos nuevas estructuras de datos a partir de los datos de entrada, que nos darán otras perspectivas de los mismos (aplicando, por ejemplo, algún tipo de función de resumen o agregación). En este ejercicio, en concreto, la función <code>medias_por_ediciones</code> realizará la siguiente transformación:\n",
    "- Entrada: una lista de tuplas (edición, _share_)\n",
    "- Salida: un diccionario en el que las claves son ediciones y los valores son las medias de _share_ de cada edición\n",
    "\n",
    "Las siguientes celdas contienen la implementación y el test, respectivamente, de la función <code>medias_por_ediciones</code> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def medias_por_ediciones(audiencias):\n",
    "    ''' Calcula la media de audiencia para cada edición\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "    SALIDA:\n",
    "       - medias de audiencia por cada edición -> {int : float}\n",
    "\n",
    "    Toma como entrada una lista de tuplas (edición, share) y produce como\n",
    "    salida un diccionario en el que las claves son las ediciones y los\n",
    "    valores son las medias de audiencia de cada edición.\n",
    "    '''\n",
    "    medias = dict()\n",
    "    ediciones = calcula_ediciones(audiencias)\n",
    "    for edicion in ediciones:\n",
    "        # Calculamos la lista de shares de cada edición\n",
    "        shares = [s for e, s in audiencias if edicion == e]\n",
    "        # Usamos la lista de shares para calcular la media\n",
    "        medias[edicion] = sum(shares)/len(shares)\n",
    "    return medias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función medias_por_ediciones\n",
    "medias = medias_por_ediciones(AUDIENCIAS_GH)\n",
    "print(medias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Funciones de visualización"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con las funciones de visualización obtendremos salidas gráficas que nos ayudarán a interpretar mejor los resultados del proyecto. En Python el paquete más usado para generar este tipo de gráficas es <code>matplotlib</code>. Es un paquete muy completo y complejo, y su manejo se escapa un poco del alcance de un curso de introducción a la programación. Por esa razón, siempre que lo usemos, en el enunciado de los ejercicios se indicarán exactamente las instrucciones _matplotlib_ necesarias para generar las gráficas, quedando solo como trabajo del ejercicio la construcción de las estructuras de datos que requieren estas instrucciones (casi siempre, estas estructuras serán listas).\n",
    "\n",
    "La primera función de visualización que implementaremos será <code>muestra_evolucion_audiencias</code>. Esta función toma como entrada una lista de tuplas (edición, _share_) y genera una gráfica con la evolución de los _shares_ a lo largo del tiempo.\n",
    "Las siguientes celdas contienen la implementación y el test, respectivamente, de esta función. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def muestra_evolucion_audiencias(audiencias):\n",
    "    ''' Genera una curva con la evolución de las audiencias\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "    SALIDA EN PANTALLA:\n",
    "       - gráfica con la evolución de los shares a lo largo del tiempo\n",
    "\n",
    "    Toma como entrada una lista de tuplas (edición, share) y muestra una\n",
    "    curva con la evolución de los shares a lo largo del tiempo.\n",
    "    \n",
    "    Para generar la gráfica usaremos elementos del paquete matplotlib. Estas\n",
    "    son las instrucciones que permiten trazar una curva a partir de la lista de\n",
    "    shares:\n",
    "        plt.plot(shares, label='audiencia')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "    '''\n",
    "    # Calculamos la lista de shares\n",
    "    shares = [s for _, s in audiencias]\n",
    "    # Componemos y visualizamos la gráfica\n",
    "    plt.plot(shares, label='audiencia')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función muestra_evolucion_audiencias\n",
    "muestra_evolucion_audiencias(AUDIENCIAS_GH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La otra funcion de visualización que implementaremos será <code>muestra_medias_por_ediciones</code>. Esta función, que también toma como entrada una lista de tuplas (edición, _share_), se apoyará en la función <code>medias_por_ediciones</code> para calcular un diccionario con las medias de _share_ de cada edición. Los valores de este diccionario se mostrarán en un diagrama de barras en el que en el eje _X_ se representarán las ediciones, y la media de los _shares_ se corresponderá con la altura de las barras.  Las siguientes celdas contienen la implementación y el test, respectivamente, de esta función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def muestra_medias_por_ediciones(audiencias):\n",
    "    ''' Genera un diagrama de barras con la media de audiencia de cada edición\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "    SALIDA EN PANTALLA:\n",
    "       - gráfica con las medias por cada edición\n",
    "\n",
    "    Toma como entrada una lista de tuplas (edición, share) y muestra un diagrama\n",
    "    de barras. Habrá una barra por cada edición presente en la lista de audiencias.\n",
    "    Se mostrará la media de shares de cada edición.\n",
    "    \n",
    "    Estas son las instrucciones 'matplotlib' para trazar el diagrama de barras\n",
    "    a partir de una lista de ediciones y otra lista (con el mismo orden) de\n",
    "    medias de shares:\n",
    "        plt.bar(ediciones, lista_medias)\n",
    "        plt.xticks(ediciones, ediciones, fontsize=8)\n",
    "        plt.show()\n",
    "    '''\n",
    "    # Calculamos la lista de ediciones\n",
    "    ediciones = calcula_ediciones(audiencias)\n",
    "    # Calculamos las medias por cada edición\n",
    "    dicc_medias = medias_por_ediciones(audiencias)\n",
    "    # Generamos una lista de medias con el mismo orden que las ediciones\n",
    "    lista_medias = [dicc_medias[e] for e in ediciones]\n",
    "    # Componemos y visualizamos la gráfica\n",
    "    plt.bar(ediciones, lista_medias)\n",
    "    plt.xticks(ediciones, ediciones, fontsize=8)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función muestra_medias_por_ediciones\n",
    "muestra_medias_por_ediciones(AUDIENCIAS_GH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Un par de ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cerramos este notebook con un par de ejercicios sin implementar. Se trata de dos funciones que calculan _informaciones derivadas_ a partir de los datos de entrada. Son dos funciones simples de pocas LDCs (Líneas De Código) cada una, con tratamientos muy comunes sobre secuencias de datos numéricos. Con una búsqueda simple en _stackoverflow_ se pueden encontrar fragmentos de código que, con pocos cambios, pueden ayudarnos a obtener la solución.\n",
    "\n",
    "La primera de las funciones se llama <code>calcula_estadisticos</code>, toma como entrada una lista de tuplas (edición, _share_) y calcula diversos estadísticos de la serie de _shares_ (media, mediana, máximo y mínimo). Para nuestros datos de entrada, por ejemplo, podríamos obtener una salida como esta:\n",
    "\n",
    "<pre>\n",
    "        Media:   0.265\n",
    "        Mediana: 0.25\n",
    "        Máximo:  0.71\n",
    "        Mínimo:  0.14\n",
    "</pre>\n",
    "\n",
    "Las siguientes celdas contienen la cabecera y el test, respectivamente, de la función <code>calcula_estadisticos</code> y de la función de apoyo <code>mediana</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mediana(lista):\n",
    "    ''' Calcula la mediana de una serie\n",
    "    \n",
    "    ENTRADA: \n",
    "       - lista: serie de valores numéricos -> [float]\n",
    "    SALIDA:\n",
    "       - mediana de los valores de entrada -> float\n",
    "    '''\n",
    "    pass\n",
    "\n",
    "\n",
    "def calcula_estadisticos(audiencias):\n",
    "    ''' Calcula la media, mediana, máximo y mínimo de una lista de audiencias\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "    SALIDA:\n",
    "       - media, mediana, máximo y mínimo -> (float, float, float, float)\n",
    "    '''\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función calcula_estadisticos\n",
    "media, mediana, maximo, minimo = calcula_estadisticos(AUDIENCIAS_GH)\n",
    "print('Media: ', media)\n",
    "print('Mediana:', mediana)\n",
    "print('Máximo:', maximo)\n",
    "print('Mínimo:', minimo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La segunda función se llama <code>lista_medias_shares</code>, toma como entrada una lista de tuplas (edición, _share_) y produce como salida una lista de tuplas (_media-shares_, edición) ordenada de mayor a menor por la media de _shares_. Esta función hace uso de la función <code>medias_por_ediciones</code> para calcular la media de _share_ de cada edición. Para nuestros datos de entrada, por ejemplo, podríamos obtener una salida como esta:\n",
    "\n",
    "<pre>\n",
    "        1 ->  0.512\n",
    "        2 ->  0.422\n",
    "        3 ->  0.341\n",
    "        6 ->  0.298\n",
    "        4 ->  0.294\n",
    "        9 ->  0.283\n",
    "        7 ->  0.277\n",
    "        5 ->  0.272\n",
    "       10 ->  0.261\n",
    "        8 ->  0.235\n",
    "       11 ->  0.232\n",
    "       16 ->  0.232\n",
    "       15 ->  0.214\n",
    "       13 ->  0.204\n",
    "       17 ->  0.197\n",
    "       14 ->  0.186\n",
    "       12 ->  0.185\n",
    "</pre>\n",
    "\n",
    "\n",
    "Las siguientes celdas contienen la cabecera y el test, respectivamente, de la función <code>lista_medias_shares</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lista_medias_shares(audiencias):\n",
    "    ''' Calcula una lista ordenada de ediciones según su media de shares\n",
    "    \n",
    "    ENTRADA: \n",
    "       - audiencias: lista de audiencias -> [(int, float)]\n",
    "    SALIDA:\n",
    "       - pares (medias de audiencia, edición) ordenados de mayor a menor media -> [(float, int)]\n",
    "    '''\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la función lista_medias_shares\n",
    "shares_eds = lista_medias_shares(AUDIENCIAS_GH)\n",
    "for s, e in shares_eds:\n",
    "    print(\"{:3d} -> {:6.3f}\".format(e, s))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}