Gráficos 3D y subplots con Plotly.

Plotly es una herramienta de gráficos interactivos en Python que ofrece una amplia gama de opciones para visualizar datos en dos y tres dimensiones. Una de sus principales ventajas es la diversidad de tipos de gráficos disponibles, desde gráficos de dispersión hasta gráficos de contorno, lo que permite representar los datos de manera clara y efectiva.

Gráficos en 3D

Plotly permite generar gráficos en tres dimensiones, lo que facilita la visualización de datos complejos en varios ejes. Estos gráficos interactivos se pueden rotar y ajustar en diferentes ángulos, proporcionando una mejor perspectiva de los datos. Son especialmente útiles para la presentación de información tridimensional que necesita ser explorada desde múltiples perspectivas.

Subplots

Además de los gráficos 3D, Plotly también ofrece la funcionalidad de crear subplots. Los subplots permiten mostrar varios gráficos en una sola figura, lo que es excelente para comparar diferentes conjuntos de datos o visualizar la evolución de una variable a lo largo de varios periodos de tiempo. Esto es particularmente útil para la interpretación de datos, ya que permite ver múltiples visualizaciones en un contexto compartido, reduciendo la necesidad de cambiar entre diferentes ventanas o pestañas.

Personalización y Interactividad

Plotly no solo permite la creación de gráficos interactivos, sino que también proporciona herramientas para personalizarlos. Los usuarios pueden ajustar el aspecto visual de los gráficos, como los colores, las etiquetas, los tamaños de los ejes y más. Además, la interactividad de los gráficos permite al usuario explorar los datos mediante zoom, desplazamiento y selección de áreas específicas, lo que facilita una comprensión más profunda de los patrones y relaciones en los datos.

En resumen, Plotly es una herramienta poderosa para la visualización de datos, ofreciendo una amplia gama de opciones para representar información en gráficos 2D y 3D, así como la capacidad de generar subplots para una interpretación de datos más eficiente.

Gráfico 3D de Superficie con Plotly

En Plotly, los gráficos 3D permiten visualizar datos en tres dimensiones, lo que puede ser muy útil para mostrar relaciones entre variables que pueden ser difíciles de ver en gráficos 2D. Para crear un gráfico 3D en Plotly, debes crear una figura 3D, especificar el tipo de trazo (como gráfico de superficie, de línea o de contorno), y definir los datos que se usarán en el trazado. Aquí te muestro un ejemplo básico de cómo crear un gráfico 3D de superficie:

import plotly.graph_objs as go
import numpy as np

# crear datos para el gráfico 3D
x = np.linspace(-np.pi, np.pi, 100)
y = np.linspace(-np.pi, np.pi, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# crear figura 3D y agregar superficie
fig = go.Figure(data=[go.Surface(x=X, y=Y, z=Z)])

# agregar título y etiquetas de eje
fig.update_layout(title='Gráfico 3D de superficie', autosize=False, width=500, height=500,
                  scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'))

# mostrar gráfico
fig.show()

Subplots con Plotly

En cuanto a los subplots, estos permiten representar múltiples gráficos en una misma figura, lo que puede ser útil para comparar distintos conjuntos de datos o visualizar diferentes resultados. Para crear subplots en Plotly, debes crear una figura que contenga varios objetos de trazado, especificar sus disposiciones (por ejemplo, en forma de cuadrícula o una al lado de la otra) y añadir los datos correspondientes. Aquí te dejo un ejemplo básico de cómo crear subplots en Plotly:

import plotly.graph_objs as go
import numpy as np
from plotly.subplots import make_subplots

# crear datos para los gráficos
x = np.linspace(-np.pi, np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# crear figura con dos subplots
fig = make_subplots(rows=1, cols=2)

# agregar gráfico de línea a primer subplot
fig.add_trace(go.Scatter(x=x, y=y1, name='sin(x)'), row=1, col=1)

# agregar gráfico de línea a segundo subplot
fig.add_trace(go.Scatter(x=x, y=y2, name='cos(x)'), row=1, col=2)

# agregar título y etiquetas de eje
fig.update_layout(title='Subplots de sin(x) y cos(x)', autosize=False, width=800, height=400,
                  xaxis=dict(title='x'), yaxis=dict(title='Función'))

# mostrar gráfico
fig.show()

Espero que esto te sea útil en tus proyectos con Plotly ¡Ánimo!

Un ejemplo práctico utilizando Plotly para crear subplots y gráficos 3D

Supongamos que tenemos un conjunto de datos que describe la evolución de la temperatura en tres ciudades diferentes a lo largo del año en formato de tabla. Queremos graficar estos datos en tres subplots, cada uno para una ciudad diferente, y cada subplot con un gráfico 3D que muestre la evolución de la temperatura a lo largo del tiempo y la altura.

Primero, importamos las librerías necesarias:

import plotly.graph_objs as go
from plotly.subplots import make_subplots

Luego, definimos la tabla de datos y las variables necesarias para cada subplot:

# Tabla de datos
data = {
    'ciudad1': {(1, 1): 10, (1, 2): 15, (1, 3): 20, (2, 1): 12, (2, 2): 14, (2, 3): 18, (3, 1): 5, (3, 2): 10, (3, 3): 12},
    'ciudad2': {(1, 1): 14, (1, 2): 18, (1, 3): 22, (2, 1): 10, (2, 2): 12, (2, 3): 16, (3, 1): 2, (3, 2): 8, (3, 3): 10},
    'ciudad3': {(1, 1): 12, (1, 2): 16, (1, 3): 18, (2, 1): 8, (2, 2): 10, (2, 3): 14, (3, 1): 4, (3, 2): 6, (3, 3): 8}
}
# Variables para cada subplot
x_data = [1, 2, 3]
y_data = [1, 2, 3]
z_data = [[data['ciudad1'][(x, y)] for y in y_data] for x in x_data]
z_data_2 = [[data['ciudad2'][(x, y)] for y in y_data] for x in x_data]
z_data_3 = [[data['ciudad3'][(x, y)] for y in y_data] for x in x_data]

A continuación, creamos los subplots y los gráficos 3D correspondientes:

# Crear subplot con tres gráficos 3D
fig = make_subplots(rows=1, cols=3, specs=[[{'type': 'surface'}]*3])
# Agregar los datos y configurar cada subfigura
fig.add_trace(go.Surface(x=x_data, y=y_data, z=z_data, name='Ciudad 1'), row=1, col=1)
fig.add_trace(go.Surface(x=x_data, y=y_data, z=z_data_2, name='Ciudad 2'), row=1, col=2)
fig.add_trace(go.Surface(x=x_data, y=y_data, z=z_data_3, name='Ciudad 3'), row=1, col=3)
# Configurar la figura
fig.update_layout(title='Evolución de la temperatura en diferentes ciudades',
                  scene=dict(xaxis_title='Mes', yaxis_title='Día', zaxis_title='Temperatura'))
# Mostrar la figura
fig.show()

Este código produce un gráfico con tres subplots, uno para cada ciudad, cada uno con un gráfico 3D que muestra la evolución de la temperatura. El usuario puede interactuar con el gráfico girándolo y acercándolo para tener una mejor visualización y comprensión de los datos.

Ejemplo de gráfico 3D interactivo y subtramas con Plotly

A continuación se muestra un ejemplo de cómo hacer un gráfico 3D interactivo y colocarlo en un diseño de subtramas utilizando Plotly:

import plotly.graph_objs as go
from plotly.subplots import make_subplots

# datos para graficar
x = [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]
y = [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
z = [10, 15, 13, 12, 17, 16, 8, 15, 10, 9, 6, 8]

# creando la figura con subplots
fig = make_subplots(rows=1, cols=2, specs=[[{'type': 'scene'}]*2])

# primer subplot (gráfico 3D)
trace1 = go.Scatter3d(
    x=x,
    y=y,
    z=z,
    mode='markers',
    marker=dict(
        color=z,
        size=12,
        colorscale='Viridis',
        opacity=0.8
    )
)
fig.add_trace(trace1, row=1, col=1)

# segundo subplot (gráfico 2D)
trace2 = go.Scatter(
    x=x,
    y=z,
    mode='lines+markers',
    line=dict(
        color='rgb(219, 64, 82)',
        width=3,
    ),
    marker=dict(
        color='white',
        size=7,
        line=dict(
            color='rgb(219, 64, 82)',
            width=1
        )
    )
)
fig.add_trace(trace2, row=1, col=2)

# actualizando la configuración de la figura
fig.update_layout(
    scene=dict(
        xaxis=dict(title='X'),
        yaxis=dict(title='Y'),
        zaxis=dict(title='Z'),
    ),
    title='Gráfico 3D y gráfico 2D',
    height=600,
    width=1000,
    margin=dict(l=10, r=10, t=50, b=10),
    showlegend=False,
)

# mostrando la figura
fig.show()

Este código creará dos gráficos en una figura de subtramas. El primer gráfico es una visualización 3D interactiva de puntos con diferentes alturas y colores, mientras que el segundo gráfico es un gráfico de líneas 2D que muestra la relación entre la altura y la posición en x.

¡Espero que te sea útil!