Utilisation de Plotly pour la visualisation interactive des données de lancer de dés

Dans ce tutoriel, nous apprendrons comment utiliser Plotly pour créer des visualisations interactives. Notre projet se concentre sur l’analyse des résultats du lancer de dés. Lorsque vous lancez un seul dé à six faces, n’importe quel nombre de 1 à 6 a une chance égale d’apparaître. Cependant, lorsque vous lancez plusieurs dés, certains nombres deviennent plus probables que d’autres. Notre objectif est de déterminer ces probabilités en simulant des lancers de dés et en créant un ensemble de données. Après cela, nous représenterons visuellement les résultats de plusieurs lancers pour montrer quels résultats sont statistiquement plus probables.

Qu’est-ce que Plotly ?

Plotly est une bibliothèque graphique open source qui permet aux utilisateurs de créer des visualisations interactives basées sur le Web. Il prend en charge de nombreux types de graphiques, notamment les tracés linéaires, les nuages ​​de points, les graphiques à barres, etc. Plotly est particulièrement utile pour créer des visualisations pouvant être intégrées dans des applications Web, car il offre des fonctionnalités interactives telles que le zoom, le panoramique et les informations de survol.

Installation de Plotly

Nous installerons Plotly en utilisant pip. Nous devons également installer pandas, une bibliothèque pour travailler efficacement avec les données, car Plotly Express en dépend.

$ python -m pip install --user plotly
$ python -m pip install --user pandas

Visitez la galerie de types de graphiques sur le site Web de Plotly pour voir les différentes visualisations que vous pouvez créer avec Plotly.

Création de la classe Die

Tout d'abord, nous allons créer la classe Die suivante pour simuler le lancer d'un dé. Nous nommerons le fichier Die.py.

from random import randint

class Die:
    """A class representing a single die."""

    def __init__(self, num_sides = 6):
        """Assume a six-sided die"""
        self.num_sides = num_sides


    def roll(self):
        """Return a random value between 1 and number of sides."""
        return randint(1, self.num_sides)

La méthode __ init __ prend un argument facultatif. Lorsqu'une instance de Die est créée, le nombre de côtés sera de six si aucun argument n'est fourni. Si un argument est donné, il définira le nombre de faces du dé.

La méthode roll() utilise la fonction randint() pour renvoyer un nombre aléatoire compris entre 1 et le nombre de côtés. Cette fonction peut renvoyer la valeur de départ (1), la valeur de fin (num_sides) ou tout entier intermédiaire. Les dés sont nommés en fonction de leur nombre de faces : un dé à six faces est appelé D6, un dé à dix faces est appelé D10, et ainsi de suite.

Lancer le dé

Nous importons d'abord le module Plotly Express en utilisant l'alias px pour éviter de taper plotly.express à plusieurs reprises. Nous allons créer une instance de dé pour simuler le lancement de deux dés D8. Nous nommons ce fichier dice_visual.py.

import plotly.express as px

from die import Die

# Create two D8.
die_1 = Die(8)
die_2 = Die(8)

# Make some rolls, and store results in a list.
results = []
for roll_num in range(500_000):
    result = die_1.roll() + die_2.roll()
    results.append(result)

Analyser les résultats

Le plus petit résultat possible est la somme du plus petit nombre sur chaque dé (2). Le plus grand résultat possible est la somme du plus grand nombre sur chaque dé (16) attribué à max_results. La variable max_result améliore la lisibilité du code de génération de poss_results. Nous aurions pu écrire range (2,16), mais cela ne fonctionnerait que pour deux dés D8. Lors de la simulation de circonstances réelles, il est préférable de développer un code capable de gérer facilement un large éventail de scénarios.

# Analyze the result.
frequencies = []
max_results = die_1.num_sides + die_2.num_sides
poss_results = range(2, max_results + 1)
for value in poss_results:
    frequency = results.count(value)
    frequencies.append(frequency)

Visualiser les résultats.

Nous avons défini le titre et l'avons attribué à 'titre'. Nous avons créé un dictionnaire pour spécifier les étiquettes des axes. Les clés du dictionnaire représentent les étiquettes que nous souhaitons personnaliser, tandis que les valeurs représentent les étiquettes personnalisées que nous souhaitons utiliser. Nous nommons l'axe des x « Résultat » et l'axe des y, « Fréquence du résultat ». Pour construire un graphique à barres, nous utilisons la fonction px.bar() et transmettons les variables facultatives 'title' et 'labels'.

# Visualize the results.
title = "Results of Rolling Two D8 Dice 500,000 Times"
labels = {'x': 'Result', 'y': 'Frequency of Result'}
fig = px.bar(x = poss_results, y = frequencies, title = title,
 labels = labels)
fig.show()

Le tracé est généré avec un titre et des étiquettes appropriés pour chaque axe, comme le montre l'image ci-dessous.

Autres personnalisations

Il y a un problème que nous devons résoudre avec l'intrigue que nous venons de créer. Comme il y a 11 barres, les paramètres de disposition par défaut de l'axe X laissent certaines barres sans étiquette. Bien que les paramètres par défaut conviennent à la plupart des visualisations, ce graphique apparaîtrait mieux avec toutes les barres étiquetées.

Plotly propose une méthode update_layout() qui vous permet d'apporter diverses modifications à une figure après sa création. Voici comment vous pouvez demander à Plotly de donner à chaque barre sa propre étiquette.

# Further customize chart.
fig.update_layout(xaxis_dtick = 1)
fig.show()
#fig.write_html('dice_visual_d6d10.xhtml')

La méthode update_layout() s'applique à l'objet fig, qui représente l'intégralité du graphique. Nous utilisons l'option xaxis_dtick pour définir la distance entre les graduations sur l'axe des x. Nous définissons l'espacement sur 1 pour que chaque barre soit étiquetée. Lorsque vous exécutez à nouveau dice_visual.py, vous devriez voir des étiquettes sur chaque barre.

Ce code peut être facilement personnalisé pour simuler le lancer de dés de différentes tailles. Pour créer un D6 et un D10, transmettez les arguments 6 et 10 lors de la création des deux instances de die. Modifiez la première boucle avec le nombre de rouleaux souhaité et modifiez le titre du graphique en conséquence.

We can get our program to save the chart as an HTML file automatically by replacing the call to fig.show() with a call to fig.write_html().

The write_html() method requires one argument: the name of the file to write to. If you only provide a filename, the file will be saved in the same directory as the .py file. You can also call write_html() with a Path object to save the output file anywhere on your system.

Here is the complete code:

import plotly.express as px

from die import Die

# Create two D8.
die_1 = Die(8)
die_2 = Die(8)

# Make some rolls, and store results in a list.
results = []
for roll_num in range(500_000):
    result = die_1.roll() + die_2.roll()
    results.append(result)

# Analyze the result.
frequencies = []
max_results = die_1.num_sides + die_2.num_sides
poss_results = range(2, max_results + 1)
for value in poss_results:
    frequency = results.count(value)
    frequencies.append(frequency)

# Visualize the results.
title = "Results of Rolling Two D8 Dice 500,000 Times"
labels = {'x': 'Result', 'y': 'Frequency of Result'}
fig = px.bar(x = poss_results, y = frequencies, title = title, labels = labels)

# Further customize chart.
fig.update_layout(xaxis_dtick = 1)
fig.write_html('dice_visual.xhtml')

Refactoring

For clarity, the listings in this section use the long form of for loops. We can refactor the code by using list comprehensions for one or both of the loops. Here is the code using list comprehension:

import plotly.express as px

from die import Die

# Create two D8.
die_1 = Die(8)
die_2 = Die(8)

# Make some rolls, and store results in a list.
results = [die_1.roll() + die_2.roll() for roll_num in range(500_000) ]

# Analyze the result.
max_results = die_1.num_sides + die_2.num_sides
poss_results = range(2, max_results + 1)
frequencies = [results.count(value) for value in poss_results]

# Visualize the results.
title = "Results of Rolling Two D8 Dice 500,000 Times"
labels = {'x': 'Result', 'y': 'Frequency of Result'}
fig = px.bar(x = poss_results, y = frequencies, title = title, labels = labels)

# Further customize chart.
fig.update_layout(xaxis_dtick = 1)

fig.write_html('dice_visual_list_comprehension.xhtml')

Conclusion

In conclusion, analyzing and presenting statistical data becomes powerful and engaging with Plotly for interactive dice roll data visualization. By simulating dice rolls and visualizing the outcomes, we can better understand the probabilities of different results. Plotly's interactive features, such as hover information, panning, and zooming, enhance the user experience and make data more accessible. Additionally, the ability to customize and save visualizations as HTML files makes it easy to share and integrate them into web applications. This article demonstrates how to use Plotly's features to create informative and attractive charts. Plotly is an excellent tool for data analysis and presentation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!