Dans ce didacticiel, 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 les 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 permettant de 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 lancement 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.

Nous pouvons demander à notre programme d'enregistrer automatiquement le graphique sous forme de fichier HTML en remplaçant l'appel à fig.show() par un appel à fig.write_html().

La méthode write_html() nécessite un argument : le nom du fichier dans lequel écrire. Si vous fournissez uniquement un nom de fichier, le fichier sera enregistré dans le même répertoire que le fichier .py. Vous pouvez également appeler write_html() avec un objet Path pour enregistrer le fichier de sortie n'importe où sur votre système.

Voici le code complet :

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')

Refactorisation

Pour plus de clarté, les listes de cette section utilisent la forme longue des boucles for. Nous pouvons refactoriser le code en utilisant des compréhensions de liste pour l'une ou les deux boucles. Voici le code utilisant la compréhension de liste :

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

En conclusion, l'analyse et la présentation de données statistiques deviennent puissantes et engageantes avec Plotly pour la visualisation interactive des données de lancer de dés. En simulant des lancers de dés et en visualisant les résultats, nous pouvons mieux comprendre les probabilités de différents résultats. Les fonctionnalités interactives de Plotly, telles que les informations de survol, le panoramique et le zoom, améliorent l'expérience utilisateur et rendent les données plus accessibles. De plus, la possibilité de personnaliser et d'enregistrer des visualisations sous forme de fichiers HTML facilite leur partage et leur intégration dans des applications Web. Cet article montre comment utiliser les fonctionnalités de Plotly pour créer des graphiques informatifs et attrayants. Plotly est un excellent outil d'analyse et de présentation de données.