<jupyter_start><jupyter_text>Gráficos de Dispersión simples Otro tipo de diagrama de uso común es el diagrama de dispersión simple, un primo cercano del grafico de líneas. A diferencia de este, en lugar de que los puntos estén unidos por segmentos de línea, aquí los puntos se representan individualmente con un marcador como un punto, círculo u otra forma.Comenzaremos configurando el notebook para graficar e importar las funciones que usaremos:<jupyter_code>%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import numpy as np<jupyter_output><empty_output><jupyter_text>Gráficos de dispersión con ``plt.plot``En el notebook pasado, hemos visto la dualidad de interfaz que presenta Matplotlib para representar gráficos: ``plt.plot``/``ax.plot``.Pues así como antes la hemos empleado para representar gráficas de línea, también la podremos usar ahora para representar gráficos de dispersión, lo único que deberemos hacer es establecer un marcador:<jupyter_code>help(plt.plot)
x = np.linspace(0, 10, 30)
y = np.sin(x)

plt.plot(x, y, ':.k');<jupyter_output><empty_output><jupyter_text>El tercer argumento en la llamada a la función es un carácter que representa el tipo de símbolo utilizado para el trazado. Así como antes específicabamos opciones como ``-`` o  ``-`` para controlar el estilo de línea, el estilo de marcador tiene su propio conjunto de códigos cortos. La lista completa de símbolos disponibles se puede ver en la documentación de `` plt.plot ``, o en la documentación en línea de Matplotlib.La mayoría de las posibilidades son bastante intuitivas y mostraremos algunas de las más comunes aquí:<jupyter_code>var1 = 20
"asda {}".format(var1)
np.random.seed(0)

for marker in ['o', '.', ',', 'x', '+', 'v', '^', '<', '>', 's', 'd']:
    plt.plot(np.random.rand(5), np.random.rand(5), marker,
             label="marker='{}'".format(marker))
    
plt.legend(numpoints=1)
plt.xlim(0, 1.8);<jupyter_output><empty_output><jupyter_text>Para obtener aún más posibilidades, estos códigos de caracteres pueden combinarse con códigos de línea y color para trazar puntos junto con una línea que los conecte:<jupyter_code>plt.plot(x, y, '-ok')<jupyter_output><empty_output><jupyter_text>Los parámetros de `` plt.plot `` se pueden utilizar para especificar una amplia gama de propiedades de las líneas y marcadores:<jupyter_code>plt.plot(x, y, '-p',
        color='gray',
        linewidth=4,
        markerfacecolor='yellow',
        markersize=15,
        markeredgecolor='blue',
        markeredgewidth=2);<jupyter_output><empty_output><jupyter_text>Esta flexibilidad de la función `` plt.plot `` permite una amplia variedad de posibles opciones de visualización.Para obtener una descripción más completa, te recomendaría que consultases la documentación de `` plt.plot ``.  Gráficos de dispersión con ``plt.scatter``Otra de las herramientas más potentes para crear diagramas de dispersión es la función `` plt.scatter ``, que se puede usar de manera muy similar a la función `` plt.plot ``:<jupyter_code>plt.scatter(x, y, marker='o');<jupyter_output><empty_output><jupyter_text>**La principal diferencia entre `` plt.scatter `` y `` plt.plot `` es que el primero se puede usar para crear diagramas de dispersión donde las propiedades de cada punto individual (tamaño, color marcador, color de borde, etc.) se puede controlar individualmente o asignar a los datos. **Demostremos esto creando un diagrama de dispersión aleatorio con puntos de muchos colores y tamaños.Para ver mejor los resultados superpuestos, también usaremos la palabra clave ``alfa`` para ajustar el nivel de transparencia:<jupyter_code>x
rng = np.random.RandomState(10)
x = rng.randn(100)
y = rng.randn(100)
colors = rng.rand(100)
sizes = 1000 * rng.rand(100)

plt.scatter(x, y, c=colors, s=sizes, alpha=0.3,
            cmap='viridis')
plt.colorbar();  # show color scale<jupyter_output><empty_output><jupyter_text>Fíjate que el argumento de color se asigna automáticamente a una escala de colores (mediante el comando `` colorbar () ``), y que el argumento de tamaño se especifica en píxeles.De esta forma, el color y tamaño de los puntos se pueden utilizar para transmitir información en la visualización, con el fin de mostrar datos multidimensionales.Por ejemplo, podríamos usar los datos de Iris de Scikit-Learn, donde cada muestra es uno de los tres tipos de flores a las que se les ha medido cuidadosamente el tamaño de sus pétalos y sépalos:<jupyter_code>from sklearn.datasets import load_iris
iris = load_iris()
features = iris.data.T

plt.scatter(features[0], features[1], alpha=0.5,
            s=100*features[3], c=iris.target, cmap='viridis')
plt.xlabel(iris.feature_names[0])
plt.ylabel(iris.feature_names[1]);<jupyter_output><empty_output><jupyter_text>Podemos ver que este diagrama de dispersión nos da la capacidad de explorar simultáneamente cuatro dimensiones diferentes de los datos: la ubicación (x, y) de cada punto corresponde al largo y ancho del sépalo, el tamaño del punto está relacionado con el ancho del pétalo, y el color está relacionado con la especie particular de flor.Los diagramas de dispersión multicolores y de múltiples características como este pueden ser útiles tanto para la exploración como para la presentación de datos.  ``plot`` vs. ``scatter``: Una nota sobre eficiencia:Bien, ya hemos definido las principales funciones disponibles en Matplotlib para la representación de gráficos de línea y dispersos: `` plt.plot `` y `` plt.scatter ``, pero... ¿por qué debería usar una sobre la otra?Si bien es cierto que no importa tanto para pequeñas cantidades de datos, según los datasets comienzan a crecer en tamaño hasta llegar a miles y miles de puntos, `` plt.plot `` puede ser notablemente más eficiente que `` plt.scatter ``. La razón es que `` plt.scatter `` tiene la capacidad de representar un tamaño y / o color diferente para cada punto, por lo que el renderizador debe hacer el trabajo adicional de construir cada punto individualmente.Por otro lado, en `` plt.plot `` los puntos son siempre esencialmente clones entre sí, por lo que el trabajo de determinar la apariencia de los puntos se realiza solo una vez para todo el conjunto de datos.Para conjuntos de datos grandes, la diferencia entre estos dos puede llevar a un rendimiento muy diferente y, por esta razón, se debe preferir `` plt.plot `` sobre `` plt.scatter `` para conjuntos de datos grandes.  Ejercicio 11. Créate un vector ``x`` de 40 puntos definido en [-5, 5]2. Representa la función $y = 10^{sin(x+pi/2)} $ con una línea3. Sobre la misma Figura, representa la misma función ahora con marcadores con la forma * y de color verde4. Créate otra figura donde dibujes una línea con sus marcadores, pero en una sola representación, no hagas 2 como antes. Deberás usar un marcador 'o' y un color rojo  Ejercicio 2Hasta ahora hemos estado generando puntos de un vector y representando una función. Sin embargo, como hemos hecho en este notebook, también podemos representar puntos que no tienen por qué obedecer a un vector equiespaciado y su función, sino que pueden ser conjuntos de puntos independientes, como pueden ser 2 columnas d eun DataFrame.En este caso, vamos a cargar los datos del fichero csv "data_to_plot.csv", donde tienes una columna ``x`` y otra ``y``, que deberás pasarle al plot. Representa estos puntos en un gráfico con un marcador ``.`` de color negro. Añádele todos los extras que quieras: leyenda, nombre de la gráfica...<jupyter_code>import pandas as pd
df = pd.read_csv("data_to_plot.csv")

plt.plot(df['x'].values, df['y'].values, 'o')<jupyter_output><empty_output><jupyter_text>Ejercicio 3Para realizar representaciones en este notebook, hemos utilizado un dataset de prueba de sklearn, el cual tenía diferentes medidas de flores. A continuación, utilizaremos uno de los dataset que ya hemos visto para analizarlo gráficamente:1. Lee el fichero de coches ('coches.csv') que tienes en esta carpeta2. Representa, en la misma figura, los caballos de potencia ("hp") frente a el tiempo que tarda en hacer 1/4 de milla ("qsec") y frente a las millas por galón ("mpg").  1. La variable "qsec" deberá ser representada con marcadores 'o' y una línea dashed de color rojo (marcador y linea)  2. La variable "mpg" deberá ser representada con marcadores '^' verdes de tamaño 8 y una línea azul sólida3. Representa con el método ``scatter`` la variable 'hp' frente a 'qsec' pero con el color en función de 'mpg', el tamaño en función de 'gear' (con un factor que puedes decidir tú para que se vean más grandes) y un mapeo de color 'viridis'. Muestra la barra de color a la derecha del gráfico, como hemos hecho antes. Añade los complementos visuales que quieras.<jupyter_code># 1. 
import numpy as np
import pandas as pd

df = pd.read_csv("coches.csv")
df
# 2. 
df = df.sort_values(by='hp')
plt.plot(df['hp'], df['qsec'], '--or', label='qsec')
plt.plot(df['hp'], df['mpg'], color = 'b', marker='^', markeredgecolor='g', markersize=8, markerfacecolor='g', linestyle='solid', label='mpg')
plt.xlabel('Cv')
plt.ylabel('Unds')
plt.legend();
# 3. 
plt.scatter(df['qsec'], df['hp'], s= df.gear*100, c= df.mpg, alpha= 0.3, cmap= 'viridis')
plt.xlabel('Quarter Mile per Sec')
plt.ylabel('Horse Power')
plt.title('Car Efficiency')
plt.colorbar();<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08926844988720593, 'fraction_numerical': 0.008916102696315393, 'mean_word_length': 5.077023498694517, 'pattern_counts': {'":': 0, '<': 42, '<?xml version=': 0, '>': 42, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '145969', 'license': 'MIT', 'n_tokens_mistral': 3167, 'n_tokens_neox': 3097, 'n_words': 1207, 'path': 'Bloque 2 - Data_Analyst/04_Visualización/01_Matplotlib/05_Gráficos de dispersión.ipynb', 'repo_name': 'franciscocanon-thebridge/bootcamp_thebridge_PTSep20', 'size': '9309'}