<jupyter_start><jupyter_text>Visualización con Matplotlib Vamos a ver una introducción a la visualización con el pquete Matplotlib, que nos permitirá crear gráficos con Python.Pese a que sea nuestro primer contacto con él, veremos gran parte de su funcionalidad para poder sacar el máximo partido a las siguientes secciones, como el Feature Engineering, y poder realizar un EDA (Analisis Expooloratorio de Datos) muy completo.Cabe destacar que este primer contacto con la visualización está pensado para empezar a ver todo lo que podemos hacer con Python en el tema visual, pero al final del bloque volveremos sobre él, ya que es un tema muy interesante y con mucho que decir a la hora de analizar los datos. En ese momento será cuando entremos de lleno en el DataViz (visualización de datos, básicamente), y lo haremos viendo otras librerías de Python que nos ayudarán a completar un gran set de herramientas para ejercer nuestra labor de Data Scientists. ¿Qué es Matplotlib?Matplotlib es una biblioteca de visualización de datos multiplataforma construida sobre matrices NumPy y diseñada para funcionar con SciPy (una librería matemática de Python).Fue creado por <NAME> en 2002 como un parche para IPython, ya que quería añadir el trazado interactivo estilo MATLAB a través de gnuplot (programa de generación de gráficas a partir de línea de comandos) desde la línea de comandos de IPython.El creador de IPython, <NAME>, estaba en ese momento luchando por terminar su doctorado y hacerle saber a John que no tendría tiempo de revisar el parche durante varios meses.John tomó esto como una señal para comenzar por su cuenta, y así nació el paquete Matplotlib, cuya primera versión, la versión 0.1, fue lanzada en 2003.Recibió un impulso inicial cuando se adoptó como el paquete de trazado elegido por el Space Telescope Science Institute (que están detrás del Telescopio Hubble), que apoyó financieramente el desarrollo de Matplotlib y amplió enormemente sus capacidades. CaracterísticasUna de las características más importantes de Matplotlib es su capacidad para integrarse con muchos sistemas operativos y backends gráficos.Matplotlib admite docenas de backends y tipos de salida, lo que significa que puede funcionar independientemente del sistema operativo que esté utilizando o del formato de salida que se desee, siendo esta una de las grandes fortalezas de Matplotlib.Además, gracias a su potencial, ha generado una gran base de usuarios, que a su vez ha generado una comunidad activa de desarrolladores, que ha llevado a Matplotlib a convertirse en una de las mayores herramientas de visualización dentro del mundo científico de Python. Matplotlib hoyEn los últimos años, sin embargo, la interfaz y el estilo de Matplotlib han envejecido mal, dándole un aspecto torpe y anticuado en comparación con nuevas herramientas como ggplot y ggvis (R), o los kits de herramientas de visualización web basados en D3JS y HTML5.Pese a ello, lo que se ha quedado anticuado es únicamente la carcasa, pues el núcleo de Matplotlib sigue siendo un motor gráfico multiplataforma excelente. Por ello, muchos desarrolladores han trabajado para traernos nuevos paquetes que se basan en sus potentes componentes internos, permitiéndonos manejar Matplotlib a través de API más limpias y modernas, como es el caso de Seaborn (que veremos en clases futuras) o el mismísimo Pandas (en el pasado, hemos visto de refilón cómo generar histogramas, pues para ello se basa en este motor gráfico).Con esto en la mente, podrías pensar que, si está anticuado y ya hay otros paquetes que nos ofrecen un interfaz más amigable, ¿por qué deberíamos aprender los conceptos básicos? Bueno, incluso con "envoltorios" como estos, es útil conocer en la sintaxis de Matplotlib para ajustar la salida final del gráfico, ya que veremos sus principios básicos y cómo utilizarlos.  Principios generales de MatplotlibPara meternos de lleno en la visualización, deberemos introducir ciertos conceptos que necesitaremos para utilizar nuestro paquete:  Importando MatplotlibAsí como para importar ``NumPy`` o ``Pandas`` utilizábamos los alias ``np`` o ``pd``, respectivamente, para importar ``Matplotlib`` utilizaremos lo siguiente:<jupyter_code>import matplotlib as mpl
import matplotlib.pyplot as plt<jupyter_output><empty_output><jupyter_text>Donde ``plt`` es la interfaz que utilizaremos prácticamente en todas las ocasiones a lo largo de todo el notebook, ya que es la interfaz principal.  Estableciendo el estiloUsaremos la sentencia `` plt.style `` para elegir el estilo más apropiados para nuestras figuras.En este caso, estableceremos el estilo ``classic``, que asegura que las gráficas que creemos utilicen el estilo clásico de Matplotlib:<jupyter_code>plt.style.use('classic')<jupyter_output><empty_output><jupyter_text>A lo largo de esta sección, ajustaremos este estilo según sea necesario. Se hace necesario destacar que los estilos se han implementado con la versión 1.5 de Matplotlib, por lo que en versiones anteriores no funcionarán y solo tendrán disponible el estilo predeterminado. Por lo tanto, asegúrate de que tengas instalada una versión adecuada de este paquete:<jupyter_code>mpl.__version__<jupyter_output><empty_output><jupyter_text>¿Cómo mostrar nuestras gráficas? Una visualización que no podemos ver no nos será de mucha utilidad, pero cómo reptesentar nuestros gráficos de Matplotlib dependerá del contexto: mediante un script, en una terminal IPython o en un cuaderno IPython.  Graficando desde un scriptPara usar Matplotlib desde un script, utilizaremos la función `` plt.show () ``.`` plt.show () `` busca todos los objetos de figura actualmente activos y abre una o más ventanas interactivas que muestran la/s figura/s.De este modo, por ejemplo, podríamos tener un archivo llamado * myplot.py * que contenga lo siguiente:```python ------- file: myplot.py ------import matplotlib.pyplot as pltimport numpy as npx = np.linspace(0, 10, 100)plt.plot(x, np.sin(x))plt.plot(x, np.cos(x))plt.show()```Para ello, podemos hacerlo desde un IDE como Spyder. Y una vez lo tengamos, podríamos ejecutarlo directamente, con el botón de play, o a través de la consola (que podemos abrir con Jupyterlab), donde deberemos situarnos en la carpeta donde tengamos el fichero y ejecutar el siguiente comando:```$ python myplot.py```El comando ``plt.show () `` hace muchas cosas por debajo, ya que debe interactuar con el backend gráfico interactivo de nuestro sistema.El cómo lo hace puede variar mucho de un sistema a otro, e incluso de una instalación a otra, pero Matplotlib hace todo lo posible para que todo esto nos resulte transparente y no tengamos que saber las diferentes operaciones que se realizan por debajo.Una cosa que hay que tener en cuenta es que **el comando `` plt.show () `` debe usarse solo una vez por sesión de Python**, y se suele utilizar con mayor frecuencia al final del script.Múltiples comandos `` show () `` pueden conducir a un comportamiento dependiente del backend impredecible, y deberían evitarse.  Para practicar...Créate el script que hemos comentado y prueba a ejecutarlo de las 2 formas que hemos visto: mediante el propio Spyder y a través de la consola.(Recuerda que para situarte en una carpeta en la consola, podemos usar el comando ``cd`` seguido de un espacio y la carpeta relativa a la que queramos acceder. Si usamos el tabulador nos irá sugiriendo o autorrellenando lo que vayamos poniendo).  Graficando desde el terminal IPythonTambién podría ser conveniente usar Matplotlib de forma interactiva desde la shell (consola o terminal) de IPython, el cual está diseñado para trabajar perfectamente con Matplotlib si así se lo especificamos:```ipythonIn [1]: %matplotlibUsing matplotlib backend: TkAggIn [2]: import matplotlib.pyplot as plt```Para ejecutar esto, podemos usar el comando ``%matplotlib`` después de iniciar ``ipython``, el cual puede ser iniciado si nos dirigimos a ``File -> New Launcher`` y seleccionamos el ``Python 3`` de ``Console``.En este punto, cualquier comando de representación `` plt `` hará que se abra una ventana de figura, pudiéndose pueden ejecutar más comandos para actualizar el trazado.Algunos cambios (como modificar las propiedades de las líneas que ya están dibujadas) no se dibujarán automáticamente. Para forzar su actualización, podemos usar `` plt.draw () ``.No será necesario utilizar `` plt.show () `` en el modo Matplotlib.  Para practicar...Ya que hemos visto cómo se puede hacer directamente desde la terminal de IPython, ponlo en práctica.  Graficando en un notebookComo hemos visto, un notebook (esto) es una herramienta de análisis de datos interactiva basada en navegador que puede combinar texto, código, gráficos, elementos HTML y mucho más en un solo documento ejecutable.Podemos realizar gráficos interactivos en un notebook mediante el comando ``% matplotlib ``, y funciona de manera similar al que hemos visto para el temrinal de IPython.En el notebook, también tenemos la opción de incrustar gráficos directamente. Tenemos 2 opciones:- ``%matplotlib notebook `` dará lugar a gráficos interactivos integrados en el cuaderno- ``%matplotlib inline `` dará lugar a imágenes estáticas de su trazado incrustadas en el cuadernoPara este notebook, generalmente optaremos por ``%matplotlib inline ``:<jupyter_code>%matplotlib inline<jupyter_output><empty_output><jupyter_text>Después de ejecutar este comando (debe hacerse solo una vez por kernel / sesión), cualquier celda dentro del cuaderno que cree un gráfico incrustará una imagen PNG del gráfico resultante:<jupyter_code>import numpy as np
x = np.linspace(0, 10, 100)

fig = plt.figure()
plt.plot(x, np.sin(x), '-')
plt.plot(x, np.cos(x), '--');<jupyter_output><empty_output><jupyter_text>Guardando figuras en un archivoUna característica interesante de Matplotlib es la capacidad de guardar figuras en una amplia variedad de formatos.Se puede guardar una figura usando su método `` savefig () ``.Por ejemplo, para guardar la figura anterior como un archivo PNG, podemos ejecutar esto:<jupyter_code>fig.savefig("my_figure.png") # png, jpg...<jupyter_output><empty_output><jupyter_text>Ahora tendremos un nuevo fichero llamado ``my_figure.png`` en nuestro directorio actual (actualiza si no lo ves). Para comprobarlo, ejecuta el siguiente comando (recuerda que si utilizamos un ``!`` delante del texto, se interpretará como un comando de unix, gracias Jupyterlab.¡OJO! Por defecto, se ejecutan estos comandos en la carpeta en la que estemos actualmente.<jupyter_code>!dir<jupyter_output>El volumen de la unidad C no tiene etiqueta.
 El número de serie del volumen es: FE19-043D

 Directorio de C:\Users\TheBridge\Desktop\prueba_git\DS-part-time-sep2020\semana_9\dia_2

12/11/2020  00:59    <DIR>          .
12/11/2020  00:59    <DIR>          ..
12/11/2020  00:55    <DIR>          .ipynb_checkpoints
12/11/2020  00:59           114.651 1-Matplotlib general.ipynb
06/11/2020  08:50           362.274 2-Line plots.ipynb
06/11/2020  08:50           205.118 3-Scatter plots.ipynb
11/11/2020  23:46         6.300.434 EDA_Intro_MatplotLib.ipynb
12/11/2020  00:09               148 myplot.py
12/11/2020  00:55            26.294 my_figure.png
               6 archivos      7.008.919 bytes
               3 dirs  129.198.702.592 bytes libres<jupyter_text>Esto ya se nos sale un poco del guion pero, para confirmar que realmente contiene lo que creemos que contiene, podemos usar el objeto ``Image`` de IPython para mostrar el contenido de este archivo:<jupyter_code>from IPython.display import Image
Image("my_figure.png")<jupyter_output><empty_output><jupyter_text>En el método `` savefig () ``, el formato de archivo se infiere de la extensión del nombre de archivo dado.Dependiendo de los backends que tengamos, tendremos muchos formatos de archivo diferentes disponibles.Si quisiéramos, podríamos mostrar la lista de tipos de archivos admitidos para nuestro sistema utilizando el siguiente método del objeto de la figura:<jupyter_code>fig.canvas.get_supported_filetypes()<jupyter_output><empty_output><jupyter_text>Es importante destacar que, al guardar nuestra figura, no será necesario usar `` plt.show () `` o los comandos relacionados discutidos anteriormente.  Oferta en interfaces: 2x1Una característica potencialmente confusa de Matplotlib es la dualidad de interfaces que presenta: una basada en MATLAB, y otra más potente orientada a objetos.A continuación, veremos rápidamente sus diferencias:  Interfaz al estilo de MATLABComo se ha comentado al comienzo del notebook, Matplotlib se escribió originalmente como una alternativa de Python para los usuarios de MATLAB, y gran parte de su sintaxis refleja ese hecho.Las herramientas de estilo MATLAB están contenidas en la interfaz pyplot (`` plt ``).Por ejemplo, el siguiente código probablemente les resultará bastante familiar a los usuarios de MATLAB:<jupyter_code>plt.figure()

plt.subplot(2, 1, 1) # (row, column, panel number)
plt.plot(x, np.sin(x))
plt.plot(x, np.cos(x))

plt.subplot(2, 1, 2)
plt.plot(x, np.cos(x));<jupyter_output><empty_output><jupyter_text>Es importante tener en cuenta que esta interfaz tiene estado: realiza un seguimiento de la figura y los ejes "actuales", que es donde se aplican todos los comandos "plt".Podemos obtener una referencia a estos usando las rutinas `` plt.gcf () `` (obtener la figura actual) y `` plt.gca () `` (obtener los ejes actuales).Si bien esta interfaz con estado es rápida y conveniente para gráficos simples, también presenta más problemas.Por ejemplo, una vez que se crea el segundo panel, ¿cómo podemos retroceder y agregar algo al primero?Esto es posible dentro de la interfaz de estilo MATLAB, pero un poco confuso.Afortunadamente, hay una mejor manera.  Interfaz orientada a objetosLa interfaz orientada a objetos está disponible para estas situaciones más complicadas, así como para tener más control sobre nuestra figura.En lugar de depender del estado de una figura o sus ejes "activos", en la interfaz orientada a objetos las funciones de representación son métodos de objetos explícitos "Figura" y "Ejes".Para volver a crear el gráfico anterior con esta interfaz, podemos hacer lo siguiente:<jupyter_code>fig, ax = plt.subplots(2)

ax[0].plot(x, np.sin(x))
ax[0].plot(x, np.cos(x), 'g') # podemos especificar el color

ax[1].plot(x, np.cos(x));<jupyter_output><empty_output><jupyter_text>Para gráficos más simples, la elección de qué estilo usar es en gran medida una cuestión de preferencia, pero el enfoque orientado a objetos puede convertirse en una necesidad a medida que los gráficos se vuelven más complicados.A lo largo de este tema, cambiaremos entre las interfaces de estilo MATLAB y las orientadas a objetos, según lo que sea más conveniente.En la mayoría de los casos, la diferencia es tan pequeña como cambiar `` plt.plot () `` a `` ax.plot () ``, pero hay algunas trampas que revelaremos a medida que surjan en las siguientes secciones.  Ejercicio 11. ¿Recuerdas las funciones geométricas de de numpy? ¿No? Pues puedes consultarlo para esto si quieres, ya que deberás generarte un vector de 1000 puntos. que vaya de -1 a 1, para representar la función arcoseno frente a la tangente, ambas en la misma gráfica. Utiliza el enfoque de MATLAB.2. Repite el ejercicio 1 con el enfoque orientado a objetos.<jupyter_code>import numpy as np

def f(x):
    return x*2

f(np.array([1, 2, 3]))<jupyter_output><empty_output><jupyter_text>Ejercicio 2Ahora vamos a pensar un poco:1. Créate un vector que vaya de 0 a 10, con paso 0.01 (revisa las funciones que vimos en su día para generar este tipo de vectores, con la librería NumPy)2. Créate una función que reciba una lista e itere por cada uno de los elementos que reciba y defina una función a trozos, devolviendo otra lista que cumpla:  1. Si los decimales del punto están entre .000 y .500, la salida será los decimales * 10  2. Si los decimales del punto están entre .500 y .750, la salida será 5 menos los decimales de ese punto * 10  3. En el resto de los casos, la salida será la constante 23. Representa esa función4. Créate otra función para representar lo siguiente o, si se te ocurre alguna forma de hacerlo directamente, represéntalo sin crearte una función aparte:![image.png](attachment:74e96565-3f2c-41b5-a8c2-7de1d98e31d1.png)5. Representa ambas gráficas en la misma figura pero en 2 axes distintos.<jupyter_code>import numpy as np
x = np.arange(0, 10, 0.01)

def funcion_por_trozos(x):
    lista_aux = []
    for punto in x:
        decimales = abs(punto)%1
        if decimales <= 0.5:
            lista_aux.append(decimales*10)
        elif decimales <= 0.750:
            lista_aux.append(5 - decimales*10)
        else:
            lista_aux.append(2)
    return lista_aux

fig, ax = plt.subplots(1)

ax.plot(x, funcion_por_trozos(x))

fig, ax = plt.subplots(1)

ax.plot(x, x%3)
fig, ax = plt.subplots(2)

ax[0].plot(x, funcion_por_trozos(x))
ax[1].plot(x, x%3)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.05955056179775281, 'fraction_numerical': 0.01856889414547605, 'mean_word_length': 4.86576482830385, 'pattern_counts': {'":': 0, '<': 59, '<?xml version=': 0, '>': 58, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '13', 'dir': 'jupyter-structured-clean-dedup', 'id': '442387', 'license': 'MIT', 'n_tokens_mistral': 5654, 'n_tokens_neox': 5421, 'n_words': 2301, 'path': 'semana_9/dia_4/RESU_1-Matplotlib general.ipynb', 'repo_name': 'franciscocanon-thebridge/DS-part-time-sep2020', 'size': '16923'}