Comment dessiner des graphiques 3D en utilisant Python et Plotly

L'équipe de la communauté open source chinoise a réalisé sa première diffusion en direct, racontant l'histoire de la communauté open source chinoise au nom du partage.

Cet article est partagé par la communauté Huawei Cloud « Plotly Drawing 3D Graphics » par Lemony Hug.

Dans le domaine de la visualisation de données, les graphiques 3D constituent un outil puissant pour montrer les relations et structures complexes entre les données. Le langage Python dispose d'une riche bibliothèque de visualisation de données, parmi laquelle Plotly est un outil populaire qui permet de dessiner des graphiques tridimensionnels de haute qualité. Cet article explique comment utiliser Python et Plotly pour dessiner différents types de graphiques 3D et donne des exemples de code.

Préparation

Tout d’abord, assurez-vous que la bibliothèque Plotly est installée. Vous pouvez utiliser la commande pip pour installer :

pip installer plotly

Ensuite, nous utiliserons plotly.graph_objectsles modules de Plotly pour créer des graphiques 3D. Nous utiliserons également numpyla bibliothèque pour générer des exemples de données.

importer plotly.graph_objects au fur et à mesure
importer numpy en tant que np

Dessinez un nuage de points

Tout d’abord, nous allons dessiner un nuage de points simple. Supposons que nous ayons des données tridimensionnelles stockées dans x_data, y_dataet z_data.

# Générer des exemples de données
np.random.seed(42)
n_points = 100
x_data = np.random.rand(n_points)
y_data = np.random.rand(n_points)
z_data = np.random.rand(n_points)

#Créer un nuage de points
fig = go.Figure(data=[go.Scatter3d(x=x_data, y=y_data, z=z_data, mode='markers')])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='Diagramme de points 3D')
fig.show()

Le code ci-dessus générera un simple nuage de points tridimensionnel montrant la distribution de points de données générés aléatoirement dans un espace tridimensionnel.

Dessiner un tracé de surface

Ensuite, nous allons dessiner un tracé de surface. Supposons que nous ayons une fonction f(x, y)et que nous voulions visualiser sa surface en trois dimensions.

# définir la fonction
déf f(x,y):
    retourner np.sin(x) * np.cos(y)

# Générer des données de grille
x_grid = np.linspace(0, 2*np.pi, 50)
y_grid = np.linspace(0, 2*np.pi, 50)
x_grid, y_grid = np.meshgrid(x_grid, y_grid)
z_grid = f(x_grid, y_grid)

#Créer un tracé de surface
fig = go.Figure(data=[go.Surface(z=z_grid, x=x_grid, y=y_grid)])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='Tracé de surface 3D')
fig.show()

Le code ci-dessus générera un tracé de surface 3D montrant la surface de la fonction.

Dessiner des wireframes

Enfin, nous dessinerons un wireframe montrant la continuité des données.

# Générer des données filaires
thêta = np.linspace(-4*np.pi, 4*np.pi, 100)
z_line = np.linspace(-2, 2, 100)
x_line = z_line * np.sin(thêta)
y_line = z_line * np.cos(thêta)

#Créer un filaire
fig = go.Figure(data=[go.Scatter3d(x=x_line, y=y_line, z=z_line, mode='lines')])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='Tracé filaire 3D')
fig.show()

Le code ci-dessus générera un graphique 3D montrant le filaire.

À travers les exemples ci-dessus, nous avons montré comment utiliser Python et Plotly pour dessiner différents types de graphiques tridimensionnels. Vous pouvez personnaliser davantage ces graphiques en fonction de vos besoins et explorer les fonctionnalités plus riches de la bibliothèque Plotly. Bon complot !

Dessiner un graphique à barres 3D

En plus des nuages de points, des tracés de surface et des tracés filaires, nous pouvons également dessiner des graphiques à barres 3D pour montrer les différences et les relations entre les données.

# Générer des exemples de données
catégories = ['A', 'B', 'C', 'D']
valeurs = np.random.randint(1, 10, size=(len(catégories), len(catégories)))
x_bar, y_bar = np.meshgrid(np.arange(len(catégories)), np.arange(len(catégories)))
x_bar = x_bar.flatten()
y_bar = y_bar.flatten()
z_bar = np.zeros_like(x_bar)

#Définissez la hauteur du graphique à barres
bar_heights = valeurs.flatten()

#Créer un graphique à barres 3D
fig = go.Figure(data=[go.Bar3d(x=x_bar, y=y_bar, z=z_bar, dx=1, dy=1, dz=bar_heights)])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='Graphique à barres 3D')
fig.show()

Le code ci-dessus générera un graphique à barres tridimensionnel montrant la relation entre les différentes catégories et valeurs.

Style graphique personnalisé

Plotly offre une multitude d'options de personnalisation pour ajuster le style, la mise en page et l'apparence des graphiques. Vous pouvez modifier la couleur, le type de ligne, l'étiquette et d'autres propriétés des graphiques selon vos besoins pour répondre à des besoins de visualisation spécifiques.

# Style graphique personnalisé
fig.update_traces(marker=dict(color='rgb(255, 127, 14)', taille=10),
                  selector=dict(mode='markers'))
fig.update_layout(scene=dict(xaxis=dict(backgroundcolor="rgb(200, 200, 230)",
                                       couleur de la grille = "blanc",
                                       showbackground=Vrai,
                                       zerolinecolor="blanc"),
                             yaxis=dict(backgroundcolor="rgb(230, 200,230)",
                                       couleur de la grille = "blanc",
                                       showbackground=Vrai,
                                       zerolinecolor="blanc"),
                             zaxis=dict(backgroundcolor="rgb(230, 230,200)",
                                       couleur de la grille = "blanc",
                                       showbackground=Vrai,
                                       zerolinecolor="blanc")),
                  title='Diagramme de points 3D personnalisé')
fig.show()

Graphiques 3D interactifs

Plotly prend également en charge la création de graphiques interactifs en trois dimensions, permettant aux utilisateurs d'explorer les données via l'interaction de la souris. Voici un exemple de nuage de points interactif :

# Créer un nuage de points interactif
fig = go.Figure(data=[go.Scatter3d(x=x_data, y=y_data, z=z_data, mode='markers')])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='Diagramme de points 3D interactif')
fig.show()

En passant la souris sur les points de données, les utilisateurs peuvent afficher la valeur numérique spécifique de chaque point de données pour mieux comprendre les données.

Exporter des graphiques

Une fois que vous avez créé un graphique 3D qui vous convient, vous pouvez l'exporter sous forme d'image statique ou de fichier HTML interactif pour un partage et une présentation faciles. Plotly fournit une fonction d'exportation pratique, vous permettant d'enregistrer facilement des graphiques dans des fichiers locaux.

#Exporter des graphiques sous forme d'images statiques
fig.write_image("3d_plot.png")

# Exporter des graphiques sous forme de fichiers HTML interactifs
fig.write_html("3d_plot.html")

Explorez plus de fonctionnalités

En plus des fonctionnalités présentées dans cet article, Plotly fournit également de nombreuses autres fonctionnalités puissantes, telles que l'animation, les sprites, le contrôle de la caméra, etc., pour améliorer et personnaliser davantage vos graphiques tridimensionnels. Vous pouvez en apprendre davantage sur ces fonctionnalités et les appliquer à vos projets en consultant la documentation officielle ou en vous référant à des tutoriels en ligne.

Résumer

Grâce à cet article, nous avons appris à utiliser Python et la bibliothèque Plotly pour dessiner différents types de graphiques tridimensionnels, notamment des nuages de points, des tracés de surface, des tracés filaires et des graphiques à barres. Nous avons appris les étapes de base et les exemples de code requis pour dessiner chaque type de graphique, et avons exploré comment personnaliser les styles de graphiques, créer des graphiques interactifs et exporter des graphiques sous forme d'images statiques ou de fichiers HTML interactifs. Avec ces techniques et fonctionnalités, nous pouvons facilement créer des graphiques 3D attrayants et utiles dans le domaine de la visualisation des données pour mieux comprendre et analyser les données. Que ce soit dans la recherche scientifique, les applications d'ingénierie ou l'analyse de données, les graphiques 3D sont des outils puissants qui nous aident à découvrir des modèles et des relations entre les données, et à présenter les résultats et les informations de la recherche. En explorant et en appliquant continuellement les fonctions des bibliothèques Python et Plotly, nous pouvons améliorer encore l'efficacité et l'efficience de la visualisation des données, apportant ainsi plus de valeur et de réalisations à notre travail et à nos projets.

Cliquez pour suivre et découvrir les nouvelles technologies de Huawei Cloud dès que possible~