Este artículo es compartido por la comunidad de nube de Huawei " De los datos a la implementación usando Plotly y Dash para realizar la visualización de datos y la implementación del entorno de producción " por Lemony Hug.
La visualización de datos es una parte vital del análisis de datos, que puede ayudarnos a comprender los datos de manera más intuitiva y descubrir patrones y tendencias ocultos. Hay muchas herramientas poderosas para la visualización de datos en Python, siendo Plotly y Dash dos opciones populares. Plotly proporciona una variedad de funciones de dibujo interactivo, mientras que Dash es un marco de Python para crear aplicaciones web interactivas. Este artículo presentará cómo utilizar Plotly y Dash para la visualización de datos y demostrará su aplicación a través del código del caso.
Instalar Plotly y Dash
Primero, necesitamos instalar las bibliotecas Plotly y Dash. Puedes instalarlos usando pip con el siguiente comando:
pip instalar plotly guión
Una vez completada la instalación, podemos comenzar a utilizar estas dos bibliotecas.
Código de caso: aplicación de visualización de datos simple
Comencemos con un ejemplo simple, digamos que tenemos algunos archivos CSV de datos de ventas y queremos crear un gráfico interactivo para visualizar estos datos e implementarlos como una aplicación web. Primero, necesitamos importar las bibliotecas necesarias:
importar guión
desde guión importar dcc, html
importar plotly.express como px
importar pandas como pd
#Leer datos
df = pd.read_csv('ventas_data.csv')
#Crear aplicación Dash
aplicación = guión.Dash(__nombre__)
# disposición
aplicación.diseño = html.Div([
html.H1("Visualización de datos de ventas"),
dcc.Graph(
id='gráfico-de-ventas'
)
])
# Llamar de vuelta
@aplicación.devolución de llamada(
dash.dependencies.Output('gráfico-de-ventas', 'figura'),
[dash.dependencies.Input('gráfico-de-ventas', 'valor')]
)
def update_graph(año_seleccionado):
filtrado_df = df[df['Año'] == año_seleccionado]
fig = px.bar(filtered_df, x='Mes', y='Ventas', title=f'Datos de ventas-{año_seleccionado}')
volver higo
# Iniciar aplicación
si __nombre__ == '__principal__':
app.run_server(depuración=Verdadero)
En este ejemplo, primero leemos un archivo CSV llamado sales_data.csv y luego creamos una aplicación Dash. En el diseño de la aplicación, definimos un título y un área de gráfico vacía. Luego configuramos una función de devolución de llamada para que cuando el usuario seleccione un año diferente, el gráfico se actualice para mostrar los datos de ventas de ese año. Finalmente, iniciamos la aplicación llamando al método run_server.
Asegúrese de que su archivo sales_data.csv contenga los campos de datos necesarios (como Año, Mes y Ventas) para que el código se pueda ejecutar correctamente.
Código de caso: visualización e interacción de datos avanzada
En el caso anterior, mostramos cómo crear una aplicación de visualización de datos simple usando Dash y Plotly. Ahora, exploremos más a fondo algunas funciones avanzadas, como agregar más interactividad y personalización.
Digamos que queremos mostrar tendencias en los datos de ventas y permitir que los usuarios vean diferentes tendencias seleccionando diferentes categorías de productos. Podemos lograr esta función a través del siguiente código:
importar guión
desde guión importar dcc, html
importar plotly.express como px
importar pandas como pd
#Leer datos
df = pd.read_csv('ventas_data.csv')
#Crear aplicación Dash
aplicación = guión.Dash(__nombre__)
# disposición
aplicación.diseño = html.Div([
html.H1("Tendencia de datos de ventas"),
dcc.Desplegable(
id='producto-desplegable',
opciones=[
{'etiqueta': 'Producto A', 'valor': 'Producto A'},
{'etiqueta': 'Producto B', 'valor': 'Producto B'},
{'etiqueta': 'Producto C', 'valor': 'Producto C'}
],
valor = 'Producto A'
),
dcc.Graph(
id='tendencia-de-ventas'
)
])
# Llamar de vuelta
@aplicación.devolución de llamada(
dash.dependencies.Output('tendencia-de-ventas', 'figura'),
[dash.dependencies.Input('producto-desplegable', 'valor')]
)
def update_trend(producto_seleccionado):
filtrado_df = df[df['Producto'] == producto_seleccionado]
fig = px.line(filtered_df, x='Mes', y='Ventas', title=f'{selected_product}Tendencia de ventas')
volver higo
# Iniciar aplicación
si __nombre__ == '__principal__':
app.run_server(depuración=Verdadero)
En este ejemplo, agregamos un menú desplegable que permite al usuario seleccionar diferentes categorías de productos. A medida que el usuario selecciona un producto diferente, el gráfico se actualizará para mostrar las tendencias de ventas del producto seleccionado. Esto brinda a los usuarios más flexibilidad para explorar las ventas de diferentes productos.
Además de gráficos de líneas simples, Plotly también proporciona una gran cantidad de tipos de gráficos y opciones de personalización para satisfacer necesidades de visualización más complejas. Dash nos permite crear aplicaciones web interactivas y actualizar gráficos dinámicamente a través de funciones de devolución de llamada para brindar a los usuarios una mejor experiencia.
Agregue interactividad y estilo
En el caso anterior, mostramos cómo usar Dash y Plotly para crear una aplicación de visualización de datos y proporcionar funciones interactivas básicas. Ahora, agreguemos más interactividad y estilo para hacer nuestra aplicación más atractiva y fácil de usar.
importar guión
desde guión importar dcc, html, callback_context
importar plotly.express como px
importar pandas como pd
#Leer datos
df = pd.read_csv('ventas_data.csv')
# Obtener una lista de productos única
productos_disponibles = df['Producto'].unique()
#Crear aplicación Dash
aplicación = guión.Dash(__nombre__)
#Aplicar estilo
aplicación.diseño = html.Div([
html.H1("Tendencia de datos de ventas", estilo={'textAlign': 'center'}),
html.Div([
html.Label("Seleccione producto:"),
dcc.Desplegable(
id='producto-desplegable',
opciones=[{'etiqueta': producto, 'valor': producto} para producto en productos_disponibles],
valor=productos_disponibles[0]
)
], estilo={'ancho': '50%', 'margen': 'automático', 'textAlign': 'centro'}),
dcc.Graph(
id='tendencia-de-ventas',
config={'displayModeBar': False} # Deshabilita la barra de modo del gráfico
)
], estilo={'padding': '20px'})
# Llamar de vuelta
@aplicación.devolución de llamada(
dash.dependencies.Output('tendencia-de-ventas', 'figura'),
[dash.dependencies.Input('producto-desplegable', 'valor')]
)
def update_trend(producto_seleccionado):
filtrado_df = df[df['Producto'] == producto_seleccionado]
fig = px.line(filtered_df, x='Mes', y='Ventas', title=f'{selected_product}Tendencia de ventas')
volver higo
# Iniciar aplicación
si __nombre__ == '__principal__':
app.run_server(depuración=Verdadero)
En este ejemplo, agregamos algunos estilos para que la aplicación parezca más atractiva. Centramos el título y agregamos un espacio en blanco alrededor del menú desplegable del producto para aumentar la estética del diseño. Además, desactivamos la barra de modo del gráfico para simplificar la interfaz de usuario.
Con estas mejoras, nuestra aplicación ahora no solo proporciona potentes capacidades interactivas de visualización de datos, sino que también tiene una mejor apariencia y experiencia de usuario. Esto hará que los usuarios estén más dispuestos a utilizar nuestras aplicaciones para explorar datos y obtener información valiosa a partir de ellos.
Implementar en el entorno de producción
Después de completar el desarrollo de una aplicación de visualización de datos, normalmente queremos implementar la aplicación en un entorno de producción para que otros usuarios puedan acceder a ella y utilizarla. En esta sección, discutiremos cómo implementar nuestra aplicación Dash en un servidor de producción.
Usando Gunicorn y Nginx
Gunicorn es un servidor HTTP Python WSGI (servidor HTTP) que puede manejar solicitudes HTTP de aplicaciones web. Nginx es un servidor proxy inverso y HTTP de alto rendimiento, generalmente utilizado para procesar archivos estáticos y equilibrar la carga.
Primero, necesitamos instalar Gunicorn y Nginx:
pip instalar gunicorn sudo apt-get instalar nginx
A continuación, usamos Gunicorn para ejecutar nuestra aplicación Dash:
gunicornio -w 4 -b 0.0.0.0:8050 your_app:app
Esto iniciará el servidor Gunicorn localmente y ejecutará la aplicación Dash en el puerto 8050. A continuación, necesitamos configurar Nginx como un proxy inverso para reenviar solicitudes HTTP al servidor Gunicorn.
Configurar Nginx
Agregue el siguiente contenido al archivo de configuración de Nginx:
servidor {
escuchar 80;
nombre_servidor su_dominio.com;
ubicación / {
proxy_pass http://127.0.0.1:8050;
proxy_redirect desactivado;
proxy_set_header Anfitrión $anfitrión;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Reenviado-Para $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $esquema;
}
}
Reemplace your_domain.com con su nombre de dominio. Luego recarga la configuración de Nginx:
sudo systemctl recarga nginx
Ahora, su aplicación Dash se ha implementado con éxito en el entorno de producción y se puede acceder a ella a través de su nombre de dominio.
Usar HTTPS
Para mejorar la seguridad, también podemos configurar Nginx para que utilice el protocolo HTTPS. Debe obtener un certificado SSL y configurarlo en Nginx. Una forma sencilla es utilizar Let's Encrypt para obtener un certificado SSL gratuito. Aquí hay un ejemplo de configuración simple:
servidor {
escuchar 80;
nombre_servidor su_dominio.com;
ubicación / {
devolver 301 https://$host$request_uri;
}
}
servidor {
escuchar 443 ssl;
nombre_servidor su_dominio.com;
ssl_certificate /etc/letsencrypt/live/your_domain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/your_domain.com/privkey.pem;
ubicación / {
proxy_pass http://127.0.0.1:8050;
proxy_redirect desactivado;
proxy_set_header Anfitrión $anfitrión;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Reenviado-Para $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $esquema;
}
}
Una vez configurada de esta manera, su aplicación Dash se entregará a través del protocolo HTTPS y todas las solicitudes HTTP se redirigirán a HTTPS.
Autenticación de usuarios y gestión de derechos integrada
En algunos casos, es posible que desee restringir el acceso a una aplicación de visualización de datos solo a usuarios o grupos de usuarios específicos. Para lograrlo, podemos integrar sistemas de autenticación de usuarios y gestión de derechos.
Usar autenticación básica
Un método sencillo es utilizar la autenticación básica. Puede configurar la autenticación básica en Nginx para requerir que los usuarios proporcionen un nombre de usuario y contraseña antes de acceder a la aplicación. La siguiente es una configuración de Nginx de muestra:
servidor {
escuchar 443 ssl;
nombre_servidor su_dominio.com;
ssl_certificate /etc/letsencrypt/live/your_domain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/your_domain.com/privkey.pem;
ubicación / {
auth_basic "Acceso restringido";
auth_basic_user_file /etc/nginx/.htpasswd;
proxy_pass http://127.0.0.1:8050;
proxy_redirect desactivado;
proxy_set_header Anfitrión $anfitrión;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Reenviado-Para $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $esquema;
}
}
En esta configuración, habilitamos la autenticación básica usando la directiva auth_basic y especificamos un archivo de contraseña /etc/nginx/.htpasswd. Debe utilizar la herramienta htpasswd para crear este archivo de contraseña y agregarle el nombre de usuario y la contraseña.
Utilice la autenticación OAuth
Otro método común es utilizar la autenticación OAuth. A través de OAuth se puede delegar el proceso de autenticación del usuario a proveedores de identidad de terceros, como Google, GitHub, etc. Una vez que un usuario se ha autenticado exitosamente con un proveedor de identidad externo, puede acceder a su aplicación.
Puede utilizar la biblioteca dash-auth de Dash para implementar la autenticación OAuth. Esta biblioteca proporciona una manera sencilla de integrar múltiples proveedores de OAuth y restringir el acceso a las aplicaciones Dash.
Agregar gestión de permisos
Además de la autenticación, es posible que también desee autorizar a los usuarios a determinar si tienen acceso a datos o funciones específicas. Un enfoque común es implementar un sistema de control de acceso basado en roles (RBAC) en la aplicación. Con RBAC, puede asignar usuarios a diferentes roles y restringir el acceso a diferentes roles en su aplicación.
Puede implementar un sistema RBAC en su aplicación Dash para determinar si un usuario tiene permiso para realizar ciertas acciones según su función. Esto podría implicar verificar la función de un usuario cuando inicia sesión y ajustar dinámicamente la funcionalidad y el acceso a los datos en la aplicación según la función.
Registro y manejo de errores
El registro y el manejo de errores son muy importantes al implementar aplicaciones en entornos de producción. Un buen registro puede ayudarle a realizar un seguimiento del funcionamiento de su aplicación y detectar y resolver problemas de manera oportuna. El manejo de errores puede mejorar la estabilidad de la aplicación y reducir las interrupciones del servicio causadas por errores.
Configurar el registro
Primero, configuremos el registro para nuestra aplicación. Las aplicaciones Dash generalmente envían registros a stdout o stderr. Podemos registrar estos registros redirigiéndolos a un archivo. También podemos usar el módulo de registro de Python para implementar un registro más avanzado.
importar registro logging.basicConfig(nombre de archivo='app.log', nivel=logging.INFO)
Agregar el código anterior a la aplicación Dash registrará el registro en un archivo llamado app.log y establecerá el nivel de registro en INFO. Puede ajustar el nivel de registro según sea necesario para registrar diferentes niveles de información.
Manejo de errores
Otro aspecto importante es el manejo de errores. Cuando se producen errores en la aplicación, queremos poder capturar y registrar estos errores mientras proporcionamos mensajes de error fáciles de usar.
En una aplicación Dash, puede usar bloques try-except para detectar excepciones y devolver una página de error o mostrar un mensaje de error amigable cuando ocurre una excepción.
@app.server.errorhandler(Excepción)
def handle_error(e):
logging.error(f'Se produjo un error: {str(e)}')
return html.H1("¡Ups! Algo salió mal."), 500
En el código anterior, definimos una función de manejo de errores handle_error, que detecta todas las excepciones. Cuando ocurre una excepción, registrará el mensaje de error y devolverá una página que contiene el mensaje de error al usuario.
Mediante un buen registro y manejo de errores, podemos comprender mejor el funcionamiento de la aplicación y tomar las medidas adecuadas cuando ocurren errores para garantizar la estabilidad y confiabilidad de la aplicación.
Monitoreo y optimización del rendimiento.
Finalmente, una vez que la aplicación se implementa en un entorno de producción, también debemos monitorear periódicamente el rendimiento de la aplicación y tomar medidas para optimizar el rendimiento. Esto incluye monitorear el tiempo de respuesta de la aplicación, el uso de memoria, la carga de la CPU y otros indicadores, y optimizar en función de los resultados del monitoreo.
Puede utilizar herramientas de monitoreo como Prometheus, Grafana, etc. para monitorear los indicadores de rendimiento de la aplicación y realizar ajustes y optimizaciones en función de los resultados del monitoreo.
Resumir
Este artículo detalla los pasos clave y las medidas necesarias para implementar aplicaciones Dash en un entorno de producción. Primero, discutimos cómo implementar aplicaciones Dash usando Gunicorn y Nginx, y mostramos cómo mejorar la seguridad de las aplicaciones a través del protocolo HTTPS. A continuación, exploramos cómo integrar los sistemas de administración de derechos y autenticación de usuarios, y cómo configurar el registro y el manejo de errores para mejorar la estabilidad y confiabilidad de las aplicaciones. Finalmente, enfatizamos la importancia del monitoreo y la optimización del rendimiento y proponemos algunas herramientas de monitoreo y métodos de optimización. A través de estas medidas, podemos implementar la aplicación Dash en el entorno de producción, hacerla más robusta y confiable en el entorno de producción y brindar a los usuarios servicios y experiencia de alta calidad.
Haga clic para seguir y conocer las nuevas tecnologías de Huawei Cloud lo antes posible ~
¡Compañero pollo deepin-IDE de "código abierto" y finalmente logró el arranque! Buen chico, Tencent realmente ha convertido Switch en una "máquina de aprendizaje pensante" Revisión de fallas de Tencent Cloud del 8 de abril y explicación de la situación Reconstrucción de inicio de escritorio remoto de RustDesk Cliente web Base de datos de terminal de código abierto WeChat basada en SQLite WCDB marcó el comienzo de una actualización importante Lista de abril de TIOBE: PHP cayó a un mínimo histórico, Fabrice Bellard, el padre de FFmpeg, lanzó la herramienta de compresión de audio TSAC , Google lanzó un modelo de código grande, CodeGemma , ¿te va a matar? Es tan bueno que es de código abierto: herramienta de edición de carteles e imágenes de código abierto