Méthodes pour définir la valeur alpha d'une couleur

MatplotlibMatplotlibBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Ce laboratoire explore comment définir la transparence des couleurs (valeurs alpha) à l'aide de la bibliothèque Python Matplotlib. En visualisation de données, la transparence est un outil puissant qui peut révéler des motifs dans les éléments qui se chevauchent ou mettre en évidence certains points de données.

Les valeurs alpha dans Matplotlib vont de 0 à 1 :

  • 0 signifie complètement transparent (invisible)
  • 1 signifie complètement opaque (solide)
  • Les valeurs entre 0 et 1 créent différents niveaux de transparence

Nous allons explorer deux approches principales pour définir les valeurs alpha dans Matplotlib :

  1. En utilisant l'argument mot-clé alpha
  2. En utilisant le format de couleur (matplotlib_color, alpha)

À la fin de ce laboratoire, vous serez en mesure de créer des visualisations avec des paramètres de transparence personnalisés qui améliorent la présentation de vos données.

Conseils pour la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook et pratiquer.

click-notebook

Vous devrez peut-être attendre quelques secondes que Jupyter Notebook ait fini de charger. En raison des limitations de Jupyter Notebook, la validation des opérations ne peut pas être automatisée.

Si vous rencontrez des problèmes pendant le laboratoire, n'hésitez pas à demander de l'aide à Labby. Nous apprécions vos commentaires après la session pour nous aider à améliorer l'expérience du laboratoire.

Comprendre les valeurs alpha dans Matplotlib

Dans cette première étape, nous allons créer un notebook Jupyter et apprendre à configurer une visualisation de base avec des valeurs alpha.

Création de votre première cellule de notebook Jupyter

Dans cette cellule, nous allons importer les bibliothèques nécessaires et créer deux cercles qui se chevauchent avec différentes valeurs alpha pour démontrer la transparence.

import matplotlib.pyplot as plt
import numpy as np

## Create a figure and an axes
fig, ax = plt.subplots(figsize=(6, 4))

## Create a circle with alpha=1.0 (completely opaque)
circle1 = plt.Circle((0.5, 0.5), 0.3, color='blue', alpha=1.0, label='Opaque (alpha=1.0)')

## Create a circle with alpha=0.5 (semi-transparent)
circle2 = plt.Circle((0.7, 0.5), 0.3, color='red', alpha=0.5, label='Semi-transparent (alpha=0.5)')

## Add circles to the axes
ax.add_patch(circle1)
ax.add_patch(circle2)

## Set axis limits
ax.set_xlim(0, 1.2)
ax.set_ylim(0, 1)

## Add a title and legend
ax.set_title('Demonstrating Alpha Values in Matplotlib')
ax.legend(loc='upper right')

## Show the plot
plt.show()

Une fois que vous avez entré ce code dans la cellule, exécutez-le en appuyant sur Shift+Enter ou en cliquant sur le bouton "Run" dans la barre d'outils.

Comprendre la sortie

Vous devriez voir deux cercles qui se chevauchent :

  • Le cercle bleu à gauche est complètement opaque (alpha = 1,0)
  • Le cercle rouge à droite est semi-transparent (alpha = 0,5)

Remarquez comment vous pouvez voir le cercle bleu à travers le cercle rouge là où ils se chevauchent. C'est l'effet de la définition de la valeur alpha à 0,5 pour le cercle rouge.

Les valeurs alpha contrôlent la transparence dans les visualisations et peuvent être utiles lorsque :

  • Vous affichez des points de données qui se chevauchent
  • Vous mettez en évidence certains éléments
  • Vous réduisez le bruit visuel dans les graphiques denses
  • Vous créez des visualisations en couches

Passons à l'étape suivante pour explorer davantage les applications des valeurs alpha.

Création d'un diagramme à barres avec une valeur alpha uniforme

Dans cette étape, nous allons créer un diagramme à barres où toutes les barres ont le même niveau de transparence en utilisant l'argument mot-clé alpha.

Ajout d'une nouvelle cellule

Ajoutez une nouvelle cellule à votre notebook Jupyter en cliquant sur le bouton "+" dans la barre d'outils ou en appuyant sur "Esc" puis sur "b" en mode commande.

Création du diagramme à barres avec une valeur alpha uniforme

Entrez et exécutez le code suivant dans la nouvelle cellule :

import matplotlib.pyplot as plt
import numpy as np

## Set a random seed for reproducibility
np.random.seed(19680801)

## Create a figure and an axes
fig, ax = plt.subplots(figsize=(10, 6))

## Generate data
x_values = list(range(20))  ## 0 to 19
y_values = np.random.randn(20)  ## 20 random values from standard normal distribution

## Determine bar colors based on y-values (green for positive, red for negative)
facecolors = ['green' if y > 0 else 'red' for y in y_values]
edgecolors = facecolors  ## Same color for edges

## Create the bar chart with alpha=0.5 for all bars
ax.bar(x_values, y_values, color=facecolors, edgecolor=edgecolors, alpha=0.5)

## Add a title and labels
ax.set_title("Bar Chart with Uniform Alpha Value (alpha=0.5)")
ax.set_xlabel("X Values")
ax.set_ylabel("Y Values")

## Add a grid for better readability
ax.grid(True, linestyle='--', alpha=0.7)

## Show the plot
plt.show()

Comprendre le code et la sortie

Après avoir exécuté le code, vous devriez voir un diagramme à barres avec 20 barres. Chaque barre est soit verte (valeur positive de y) soit rouge (valeur négative de y) avec le même niveau de transparence (alpha = 0,5).

Décortiquons les parties clés :

  1. np.random.seed(19680801) - Cela garantit que les nombres aléatoires générés sont les mêmes chaque fois que vous exécutez le code.

  2. x_values = list(range(20)) - Crée une liste d'entiers de 0 à 19 pour l'axe des x.

  3. y_values = np.random.randn(20) - Génère 20 valeurs aléatoires à partir d'une distribution normale standard pour l'axe des y.

  4. facecolors = ['green' if y > 0 else 'red' for y in y_values] - Cette compréhension de liste attribue la couleur verte aux valeurs positives et la couleur rouge aux valeurs négatives.

  5. ax.bar(..., alpha=0.5) - La partie clé qui définit une valeur alpha uniforme de 0,5 pour toutes les barres.

La valeur alpha uniforme rend toutes les barres également transparentes, ce qui peut être utile lorsque vous souhaitez :

  • Afficher les lignes de grille de fond à travers les barres
  • Créer une visualisation plus subtile
  • Réduire l'importance visuelle de tous les éléments de manière égale

Dans l'étape suivante, nous allons explorer comment définir des valeurs alpha différentes pour différentes barres.

Création d'un diagramme à barres avec des valeurs alpha variables

Dans cette étape, nous allons utiliser le format de tuple (matplotlib_color, alpha) pour attribuer différents niveaux de transparence à chaque barre en fonction de sa valeur de données.

Ajout d'une nouvelle cellule

Ajoutez une nouvelle cellule à votre notebook Jupyter en cliquant sur le bouton "+" dans la barre d'outils ou en appuyant sur "Esc" puis sur "b" en mode commande.

Création du diagramme à barres avec des valeurs alpha variables

Entrez et exécutez le code suivant dans la nouvelle cellule :

import matplotlib.pyplot as plt
import numpy as np

## Set a random seed for reproducibility
np.random.seed(19680801)

## Create a figure and an axes
fig, ax = plt.subplots(figsize=(10, 6))

## Generate data (using the same data as in Step 2 for comparison)
x_values = list(range(20))  ## 0 to 19
y_values = np.random.randn(20)  ## 20 random values from standard normal distribution

## Determine bar colors based on y-values (green for positive, red for negative)
facecolors = ['green' if y > 0 else 'red' for y in y_values]
edgecolors = facecolors  ## Same color for edges

## Calculate alpha values based on the absolute y-values
## Normalize y values to get alpha values between 0.2 and 1.0
abs_y = [abs(y) for y in y_values]
max_abs_y = max(abs_y)
face_alphas = [0.2 + 0.8 * (val / max_abs_y) for val in abs_y]

## Create color-alpha tuples for each bar
colors_with_alphas = list(zip(facecolors, face_alphas))

## Create the bar chart with varying alpha values
ax.bar(x_values, y_values, color=colors_with_alphas, edgecolor=edgecolors)

## Add a title and labels
ax.set_title("Bar Chart with Varying Alpha Values Based on Bar Height")
ax.set_xlabel("X Values")
ax.set_ylabel("Y Values")

## Add a grid for better readability
ax.grid(True, linestyle='--', alpha=0.7)

## Show the plot
plt.show()

Comprendre le code et la sortie

Après avoir exécuté le code, vous devriez voir un diagramme à barres avec 20 barres. Chaque barre a un niveau de transparence proportionnel à la valeur absolue de son axe y - les barres plus hautes sont plus opaques, les barres plus courtes sont plus transparentes.

Décortiquons les parties clés du code :

  1. abs_y = [abs(y) for y in y_values] - Cela crée une liste des valeurs absolues de toutes les valeurs de y.

  2. max_abs_y = max(abs_y) - Trouve la valeur absolue maximale pour normaliser les données.

  3. face_alphas = [0.2 + 0.8 * (val / max_abs_y) for val in abs_y] - Calcule les valeurs alpha entre 0,2 et 1,0 en fonction des valeurs absolues normalisées de y.

  4. colors_with_alphas = list(zip(facecolors, face_alphas)) - Crée une liste de tuples (couleur, alpha) en associant chaque couleur à sa valeur alpha correspondante.

  5. ax.bar(..., color=colors_with_alphas, ...) - Utilise les tuples (couleur, alpha) pour définir des valeurs alpha différentes pour chaque barre.

Cette approche d'utilisation de niveaux de transparence variables est efficace pour :

  • Mettre en évidence les points de données les plus significatifs
  • Mettre moins en évidence les points de données moins significatifs
  • Créer une hiérarchie visuelle basée sur les valeurs de données
  • Ajouter une dimension supplémentaire d'information à votre visualisation

Vous pouvez clairement voir comment les valeurs alpha variables créent un effet visuel où l'amplitude d'un point de données est mise en évidence à la fois par la hauteur de la barre et son opacité.

Création d'un nuage de points avec des valeurs alpha

Dans cette étape, nous allons appliquer nos connaissances sur les valeurs alpha pour créer un nuage de points. Cela démontrera comment la transparence peut aider à visualiser la densité des données dans les nuages de points avec des points qui se chevauchent.

Ajout d'une nouvelle cellule

Ajoutez une nouvelle cellule à votre notebook Jupyter en cliquant sur le bouton "+" dans la barre d'outils ou en appuyant sur "Esc" puis sur "b" en mode commande.

Création d'un nuage de points avec transparence

Entrez et exécutez le code suivant dans la nouvelle cellule :

import matplotlib.pyplot as plt
import numpy as np

## Set a random seed for reproducibility
np.random.seed(19680801)

## Create a figure and an axes
fig, ax = plt.subplots(figsize=(10, 6))

## Create two clusters of points
cluster1_x = np.random.normal(0.3, 0.15, 500)
cluster1_y = np.random.normal(0.3, 0.15, 500)

cluster2_x = np.random.normal(0.7, 0.15, 500)
cluster2_y = np.random.normal(0.7, 0.15, 500)

## Combine the clusters
x = np.concatenate([cluster1_x, cluster2_x])
y = np.concatenate([cluster1_y, cluster2_y])

## Create a scatter plot with alpha=0.5
scatter = ax.scatter(x, y, s=30, c='blue', alpha=0.5)

## Add a title and labels
ax.set_title("Scatter Plot with Alpha=0.5 Showing Data Density")
ax.set_xlabel("X")
ax.set_ylabel("Y")

## Set axis limits
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)

## Add a grid
ax.grid(True, linestyle='--', alpha=0.7)

## Show the plot
plt.show()

Comprendre le code et la sortie

Après avoir exécuté le code, vous devriez voir un nuage de points avec deux groupes de points. Chaque point a un niveau de transparence de 0,5, ce qui vous permet de voir où les points se chevauchent.

Décortiquons les parties clés du code :

  1. cluster1_x = np.random.normal(0.3, 0.15, 500) - Génère 500 coordonnées x aléatoires suivant une distribution normale de moyenne 0,3 et d'écart - type 0,15.

  2. cluster1_y = np.random.normal(0.3, 0.15, 500) - Génère 500 coordonnées y aléatoires pour le premier groupe.

  3. cluster2_x et cluster2_y - Génèrent de manière similaire les coordonnées pour le deuxième groupe centré en (0,7 ; 0,7).

  4. ax.scatter(..., alpha=0.5) - Crée un nuage de points avec des points à 50 % d'opacité.

Les avantages de l'utilisation de l'alpha dans les nuages de points incluent :

  1. Visualisation de la densité : Les zones où de nombreux points se chevauchent apparaissent plus sombres, révélant la densité des données.

  2. Réduction du chevauchement des points : Sans transparence, les points qui se chevauchent cacheraient complètement les uns les autres.

  3. Reconnaissance de motifs : La transparence aide à identifier les groupes et les motifs dans les données.

Remarquez comment les zones avec plus de points qui se chevauchent apparaissent plus sombres dans la visualisation. C'est un moyen puissant de visualiser la densité des données sans avoir besoin de techniques supplémentaires comme l'estimation de densité.

Création d'une visualisation combinée avec différentes techniques d'alpha

Dans cette étape finale, nous allons combiner plusieurs techniques pour créer une visualisation plus complexe qui démontre à la fois des valeurs alpha uniformes et variables dans un seul graphique.

Ajout d'une nouvelle cellule

Ajoutez une nouvelle cellule à votre notebook Jupyter en cliquant sur le bouton "+" dans la barre d'outils ou en appuyant sur "Esc" puis sur "b" en mode commande.

Création d'une visualisation combinée

Entrez et exécutez le code suivant dans la nouvelle cellule :

import matplotlib.pyplot as plt
import numpy as np

## Set a random seed for reproducibility
np.random.seed(19680801)

## Create a figure with two subplots side by side
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))

## Generate some common data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.cos(x)

## First subplot: Fixed alpha for all lines
ax1.plot(x, y1, color='red', linewidth=2, label='sin(x)', alpha=0.7)
ax1.plot(x, y2, color='blue', linewidth=2, label='cos(x)', alpha=0.7)
ax1.plot(x, y3, color='green', linewidth=2, label='sin(x)cos(x)', alpha=0.7)

## Add title and legend to first subplot
ax1.set_title("Multiple Lines with Uniform Alpha")
ax1.set_xlabel("x")
ax1.set_ylabel("y")
ax1.legend()
ax1.grid(True, linestyle='--', alpha=0.5)

## Second subplot: Scatter plot with varying alpha based on y-value
sizes = np.abs(y3 * 100) + 10  ## Vary point sizes based on y3
colors = y3  ## Use y3 values for coloring

## Calculate varying alpha values between 0.3 and 1.0 based on absolute y3 values
alphas = 0.3 + 0.7 * (np.abs(y3) / max(np.abs(y3)))

## Create a scatter plot with varying sizes, colors, and alphas
scatter = ax2.scatter(x, y3, s=sizes, c=colors, cmap='viridis',
                     alpha=alphas)

## Add title and labels to second subplot
ax2.set_title("Scatter Plot with Varying Alpha Based on Y-Value")
ax2.set_xlabel("x")
ax2.set_ylabel("sin(x)cos(x)")
ax2.grid(True, linestyle='--', alpha=0.5)

## Add a colorbar to the second subplot
cbar = plt.colorbar(scatter, ax=ax2)
cbar.set_label('Value of sin(x)cos(x)')

## Adjust layout and show the plot
plt.tight_layout()
plt.show()

Comprendre le code et la sortie

Après avoir exécuté le code, vous devriez voir une figure avec deux sous - graphiques côte à côte :

  1. Sous - graphique de gauche (Alpha uniforme) : Affiche trois fonctions trigonométriques tracées avec la même valeur alpha (0,7).

  2. Sous - graphique de droite (Alpha variable) : Affiche un nuage de points où :

    • L'abscisse est la valeur d'entrée.
    • L'ordonnée est sin(x)cos(x).
    • La taille de chaque point varie en fonction de la valeur absolue de l'ordonnée.
    • La couleur de chaque point varie en fonction de la valeur de l'ordonnée.
    • L'alpha (transparence) de chaque point varie en fonction de la valeur absolue de l'ordonnée.

Analysons les parties clés du code :

  1. fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) - Crée une figure avec deux sous - graphiques côte à côte.

  2. Pour le premier sous - graphique :

    • ax1.plot(..., alpha=0.7) - Utilise une valeur alpha uniforme pour les trois lignes.
  3. Pour le deuxième sous - graphique :

    • alphas = 0.3 + 0.7 * (np.abs(y3) / max(np.abs(y3))) - Calcule des valeurs alpha variables entre 0,3 et 1,0.
    • ax2.scatter(..., alpha=alphas) - Utilise des valeurs alpha variables pour les points du nuage de points.

Cette combinaison de techniques démontre comment les valeurs alpha peuvent être utilisées de diverses manières pour améliorer les visualisations :

  • Alpha uniforme est utile lorsque vous devez afficher plusieurs éléments qui se chevauchent avec une importance égale.

  • Alpha variable est utile lorsque vous voulez mettre en évidence certains points de données en fonction de leurs valeurs.

En maîtrisant ces techniques, vous pouvez créer des visualisations de données plus efficaces et esthétiquement agréables.

Résumé

Dans ce laboratoire (lab), vous avez appris à utiliser les valeurs alpha (transparence) dans Matplotlib pour améliorer vos visualisations de données. Récapitulons ce que nous avons couvert :

Concepts clés

  1. Valeurs alpha : Les valeurs alpha vont de 0 (complètement transparent) à 1 (complètement opaque) et déterminent la transparence des éléments visuels.

  2. Définition d'un alpha uniforme : Vous pouvez utiliser l'argument mot - clé alpha pour définir le même niveau de transparence pour tous les éléments d'un graphique.

    plt.plot(x, y, alpha=0.5)
  3. Définition d'un alpha variable : Vous pouvez utiliser le format de tuple (color, alpha) pour définir différents niveaux de transparence pour différents éléments.

    colors_with_alphas = list(zip(colors, alpha_values))
    plt.bar(x, y, color=colors_with_alphas)

Applications pratiques

  • Éléments qui se chevauchent : Les valeurs alpha aident à visualiser les éléments qui se chevauchent en les rendant transparents.
  • Densité des données : Dans les nuages de points, les valeurs alpha révèlent les zones de forte densité de données.
  • Mise en évidence des données : Des valeurs alpha variables peuvent mettre en évidence les points de données importants tout en diminuant l'importance des points moins importants.
  • Hiérarchie visuelle : Différents niveaux de transparence créent une hiérarchie visuelle dans votre graphique.

Ce que vous avez créé

  1. Une simple démonstration des valeurs alpha avec des cercles qui se chevauchent
  2. Un diagramme à barres avec une transparence uniforme
  3. Un diagramme à barres avec une transparence variable en fonction de la hauteur des barres
  4. Un nuage de points utilisant l'alpha pour révéler la densité des données
  5. Une visualisation combinée démontrant à la fois des techniques d'alpha uniforme et variable

Ces techniques vous permettront de créer des visualisations de données plus efficaces et esthétiquement agréables qui communiquent mieux l'histoire de vos données.