Python pas cher
- Nouvelles fonctionnalités PHP 7 pour les développeurs WordPress • WPShout
- Comment créer et s'engager dans un calendrier de blogs cohérent
- Episode # 264 10 conseils que tout développeur de Flask devrait connaître
- Deux webinaires ouverts gratuits et plus • WPShout
- Test Python efficace avec Pytest – Real Python
Une partie importante du travail avec les données est de pouvoir visualiser il. Python dispose de plusieurs modules tiers que vous pouvez utiliser pour la visualisation des données. L'un des modules les plus populaires est Matplotlib et son sous-module pyplot, souvent appelé à utiliser l'alias plt
. Matplotlib fournit un outil très polyvalent appelé plt.scatter ()
qui vous permet de créer des nuages de points basiques et plus complexes.
Ci-dessous, vous découvrirez plusieurs exemples qui vous montreront comment utiliser efficacement la fonction.
Dans ce didacticiel, vous apprendrez à:
- Créer un nuage de points utilisant
plt.scatter ()
- Utilisez le requis et facultatif Paramètres d'entrée
- Personnaliser les nuages de points pour tracés de base et plus avancés
- Représenter plus de deux dimensions sur un nuage de points
Pour tirer le meilleur parti de ce didacticiel, vous devez vous familiariser avec les principes de base de la programmation Python et les bases de NumPy et de ses ndarray
objet. Vous n’avez pas besoin de vous familiariser avec Matplotlib pour suivre ce didacticiel, mais si vous souhaitez en savoir plus sur le module, consultez Python Plotting With Matplotlib (Guide).
Création de nuages de points
Un nuage de points est une représentation visuelle de la relation entre deux variables. Vous pouvez utiliser des nuages de points pour explorer la relation entre deux variables, par exemple en recherchant une corrélation entre elles.
Dans cette section du didacticiel, vous vous familiariserez avec la création de nuages de points de base à l’aide de Matplotlib. Dans les sections suivantes, vous apprendrez à personnaliser davantage vos tracés pour représenter des données plus complexes en utilisant plus de deux dimensions.
Débuter avec plt.scatter ()
Avant de pouvoir commencer à travailler avec plt.scatter ()
, vous devrez installer Matplotlib. Vous pouvez le faire en utilisant le gestionnaire de packages standard de Python, pépin
, en exécutant la commande suivante dans la console:
$ python -m pip installer matplotlib
Maintenant que Matplotlib est installé, considérez le cas d'utilisation suivant. Un café vend six types différents de boissons à l'orange en bouteille. Le propriétaire veut comprendre la relation entre le prix des boissons et combien de chacune il vend, il garde donc une trace de la quantité de chaque boisson qu'il vend chaque jour. Vous pouvez visualiser cette relation comme suit:
importer matplotlib.pyplot comme plt
le prix = [[[[2,50, 1,23, 4,02, 3,25, 5,00, 4.40]
sales_per_day = [[[[34, 62, 49, 22, 13, 19]
plt.dispersion(le prix, sales_per_day)
plt.spectacle()
Dans ce script Python, vous importez le pyplot
sous-module de Matplotlib utilisant l'alias plt
. Cet alias est généralement utilisé par convention pour raccourcir les noms de module et de sous-module. Vous créez ensuite des listes avec le prix et les ventes moyennes par jour pour chacune des six boissons à l'orange vendues.
Enfin, vous créez le nuage de points en utilisant plt.scatter ()
avec les deux variables que vous souhaitez comparer comme arguments d'entrée. Comme vous utilisez un script Python, vous devez également afficher explicitement la figure en utilisant plt.show ()
.
Lorsque vous utilisez un environnement interactif, tel qu'une console ou un bloc-notes Jupyter, vous n'avez pas besoin d'appeler plt.show ()
. Dans ce tutoriel, tous les exemples seront sous forme de scripts et incluront l'appel à plt.show ()
.
Voici le résultat de ce code:
Ce graphique montre qu'en général, plus une boisson est chère, moins il y a d'articles vendus. Cependant, la boisson qui coûte 4,02 $ est une valeur aberrante, ce qui peut montrer qu'il s'agit d'un produit particulièrement populaire. Lorsque vous utilisez des nuages de points de cette manière, une inspection minutieuse peut vous aider à explorer la relation entre les variables. Vous pouvez ensuite effectuer une analyse plus approfondie, que ce soit à l’aide de la régression linéaire ou d’autres techniques.
Comparant plt.scatter ()
et plt.plot ()
Vous pouvez également produire le nuage de points illustré ci-dessus en utilisant une autre fonction dans matplotlib.pyplot
. Matplotlib plt.plot ()
est une fonction de traçage à usage général qui vous permettra de créer différents tracés linéaires ou marqueurs.
Vous pouvez obtenir le même nuage de points que celui que vous avez obtenu dans la section ci-dessus avec l'appel suivant à plt.plot ()
, en utilisant les mêmes données:
plt.parcelle(le prix, sales_per_day, "o")
plt.spectacle()
Dans ce cas, vous deviez inclure le marqueur "o"
comme troisième argument, autrement plt.plot ()
tracerait un graphique linéaire. Le tracé que vous avez créé avec ce code est identique au tracé que vous avez créé précédemment avec plt.scatter ()
.
Dans certains cas, pour le nuage de points de base que vous tracez dans cet exemple, utilisez plt.plot ()
peut être préférable. Vous pouvez comparer l'efficacité des deux fonctions à l'aide du timeit
module:
importer timeit
importer matplotlib.pyplot comme plt
le prix = [[[[2,50, 1,23, 4,02, 3,25, 5,00, 4.40]
sales_per_day = [[[[34, 62, 49, 22, 13, 19]
imprimer(
"plt.scatter ()",
timeit.timeit(
"plt.scatter (prix, ventes_par_jour)",
numéro=1000,
globaux=globaux(),
),
)
imprimer(
"plt.plot ()",
timeit.timeit(
"plt.plot (prix, ventes_par_jour, 'o')",
numéro=1000,
globaux=globaux(),
),
)
Les performances varient selon les ordinateurs, mais lorsque vous exécutez ce code, vous constaterez que plt.plot ()
est nettement plus efficace que plt.scatter ()
. Lors de l'exécution de l'exemple ci-dessus sur mon système, plt.plot ()
était plus de sept fois plus rapide.
Si vous pouvez créer des nuages de points en utilisant plt.plot ()
, et c'est aussi beaucoup plus rapide, pourquoi devriez-vous utiliser plt.scatter ()
? Vous trouverez la réponse dans la suite de ce didacticiel. La plupart des personnalisations et des utilisations avancées que vous découvrirez dans ce didacticiel ne sont possibles que lorsque vous utilisez plt.scatter ()
. Voici une règle de base que vous pouvez utiliser:
- Si vous avez besoin d'un nuage de points de base, utilisez
plt.plot ()
, surtout si vous souhaitez donner la priorité aux performances. - Si vous souhaitez personnaliser votre nuage de points en utilisant des fonctionnalités de traçage plus avancées, utilisez
plt.scatter ()
.
Dans la section suivante, vous allez commencer à explorer des utilisations plus avancées de plt.scatter ()
.
Personnalisation des marqueurs dans les nuages de points
Vous pouvez visualiser plus de deux variables sur un nuage de points bidimensionnel en personnalisant les marqueurs. Il existe quatre caractéristiques principales des marqueurs utilisés dans un nuage de points que vous pouvez personnaliser avec plt.scatter ()
:
- Taille
- Couleur
- Façonner
- Transparence
Dans cette section du didacticiel, vous apprendrez à modifier toutes ces propriétés.
Changer la taille
Revenons au propriétaire du café que vous avez rencontré plus tôt dans ce didacticiel. Les différentes boissons à l'orange qu'il vend proviennent de différents fournisseurs et ont des marges bénéficiaires différentes. Vous pouvez afficher ces informations supplémentaires dans le nuage de points en ajustant la taille du marqueur. La marge bénéficiaire est donnée en pourcentage dans cet exemple:
importer matplotlib.pyplot comme plt
importer engourdi comme np
le prix = np.asarray([[[[2,50, 1,23, 4,02, 3,25, 5,00, 4.40])
sales_per_day = np.asarray([[[[34, 62, 49, 22, 13, 19])
profit_margin = np.asarray([[[[20, 35, 40, 20, 27,5, 15])
plt.dispersion(X=le prix, y=sales_per_day, s=profit_margin * dix)
plt.spectacle()
Vous pouvez remarquer quelques changements par rapport au premier exemple. Au lieu de listes, vous utilisez désormais des tableaux NumPy. Vous pouvez utiliser n'importe quelle structure de données de type tableau pour les données, et les tableaux NumPy sont couramment utilisés dans ces types d'applications car ils permettent opérations élémentaires qui sont exécutés efficacement. Le module NumPy est une dépendance de Matplotlib, c'est pourquoi vous n'avez pas besoin de l'installer manuellement.
Vous avez également utilisé paramètres nommés comme arguments d'entrée dans l'appel de fonction. Les paramètres X
et y
sont obligatoires, mais tous les autres paramètres sont facultatifs.
Le paramètre s
indique la taille du marqueur. Dans cet exemple, vous utilisez la marge bénéficiaire comme variable pour déterminer la taille du marqueur et la multipliez par dix
pour afficher plus clairement la différence de taille.
Vous pouvez voir le nuage de points créé par ce code ci-dessous:
La taille du marqueur indique la marge bénéficiaire de chaque produit. Les deux boissons à l'orange qui se vendent le plus sont également celles qui ont la marge bénéficiaire la plus élevée. C'est une bonne nouvelle pour le propriétaire du café!
Changer la couleur
De nombreux clients du café aiment lire attentivement les étiquettes, notamment pour connaître la teneur en sucre des boissons qu’ils achètent. Le propriétaire du café souhaite mettre l'accent sur sa sélection d'aliments sains lors de sa prochaine campagne de marketing.Il catégorise donc les boissons en fonction de leur teneur en sucre et utilise un système de feux de signalisation pour indiquer une teneur en sucre faible, moyenne ou élevée des boissons.
Vous pouvez ajouter de la couleur aux marqueurs dans le nuage de points pour afficher la teneur en sucre de chaque boisson:
# ...
faible = (0, 1, 0)
moyen = (1, 1, 0)
haute = (1, 0, 0)
sucre_contenu = [[[[faible, haute, moyen, moyen, haute, faible]
plt.dispersion(
X=le prix,
y=sales_per_day,
s=profit_margin * dix,
c=sucre_contenu,
)
plt.spectacle()
Vous définissez les variables faible
, moyen
, et haute
pour être des tuples, chacun contenant trois valeurs qui représentent les composants de couleur rouge, vert et bleu, dans cet ordre. Ce sont des valeurs de couleur RVB. Les tuples pour faible
, moyen
, et haute
représentent respectivement le vert, le jaune et le rouge.
Vous avez ensuite défini la variable sucre_contenu
pour classer chaque boisson. Vous utilisez le paramètre facultatif c
dans l'appel de fonction pour définir la couleur de chaque marqueur. Voici le nuage de points produit par ce code:
Le propriétaire du café a déjà décidé de supprimer la boisson la plus chère du menu car elle ne se vend pas bien et a une teneur élevée en sucre. Devrait-il également arrêter de stocker les boissons les moins chères pour renforcer les références en matière de santé de l'entreprise, même si elle se vend bien et dispose d'une bonne marge bénéficiaire?
Changer la forme
Le propriétaire du café a trouvé cet exercice très utile et il souhaite étudier un autre produit. En plus des boissons à l'orange, vous allez maintenant tracer des données similaires pour la gamme de barres de céréales disponibles dans le café:
importer matplotlib.pyplot comme plt
importer engourdi comme np
faible = (0, 1, 0)
moyen = (1, 1, 0)
haute = (1, 0, 0)
price_orange = np.asarray([[[[2,50, 1,23, 4,02, 3,25, 5,00, 4.40])
sales_per_day_orange = np.asarray([[[[34, 62, 49, 22, 13, 19])
profit_margin_orange = np.asarray([[[[20, 35, 40, 20, 27,5, 15])
sucre_contenu_orange = [[[[faible, haute, moyen, moyen, haute, faible]
price_cereal = np.asarray([[[[1,50, 2,50, 1,15, 1,95])
sales_per_day_cereal = np.asarray([[[[67, 34, 36, 12])
profit_margin_cereal = np.asarray([[[[20, 42,5, 33,3, 18])
sucre_contenu_céréal = [[[[faible, haute, moyen, faible]
plt.dispersion(
X=price_orange,
y=sales_per_day_orange,
s=profit_margin_orange * dix,
c=sucre_contenu_orange,
)
plt.dispersion(
X=price_cereal,
y=sales_per_day_cereal,
s=profit_margin_cereal * dix,
c=sucre_contenu_céréal,
)
plt.spectacle()
Dans ce code, vous refactorisez les noms de variables pour prendre en compte le fait que vous disposez désormais de données pour deux produits différents. Vous tracez ensuite les deux nuages de points sur une seule figure. Cela donne la sortie suivante:
Malheureusement, vous ne pouvez plus déterminer quels points de données appartiennent aux boissons à l'orange et lesquels aux barres de céréales. Vous pouvez modifier la forme du marqueur pour l'un des nuages de points:
importer matplotlib.pyplot comme plt
importer engourdi comme np
faible = (0, 1, 0)
moyen = (1, 1, 0)
haute = (1, 0, 0)
price_orange = np.asarray([[[[2,50, 1,23, 4,02, 3,25, 5,00, 4.40])
sales_per_day_orange = np.asarray([[[[34, 62, 49, 22, 13, 19])
profit_margin_orange = np.asarray([[[[20, 35, 40, 20, 27,5, 15])
sucre_contenu_orange = [[[[faible, haute, moyen, moyen, haute, faible]
price_cereal = np.asarray([[[[1,50, 2,50, 1,15, 1,95])
sales_per_day_cereal = np.asarray([[[[67, 34, 36, 12])
profit_margin_cereal = np.asarray([[[[20, 42,5, 33,3, 18])
sucre_contenu_céréal = [[[[faible, haute, moyen, faible]
plt.dispersion(
X=price_orange,
y=sales_per_day_orange,
s=profit_margin_orange * dix,
c=sucre_contenu_orange,
)
plt.dispersion(
X=price_cereal,
y=sales_per_day_cereal,
s=profit_margin_cereal * dix,
c=sucre_contenu_céréal,
marqueur="ré",
)
plt.spectacle()
Vous conservez la forme de marqueur par défaut pour les données de boisson orange. Le marqueur par défaut est "o"
, qui représente un point. Pour les données de la barre de céréales, vous définissez la forme du marqueur sur "ré"
, qui représente un marqueur de diamant. Vous pouvez trouver la liste de tous les marqueurs que vous pouvez utiliser dans la page de documentation sur les marqueurs. Voici les deux nuages de points superposés sur la même figure:
Vous pouvez maintenant distinguer les points de données des boissons à l'orange de ceux des barres de céréales. Mais il y a un problème avec le dernier tracé que vous avez créé que vous explorerez dans la section suivante.
Changer la transparence
L'un des points de données pour les boissons à l'orange a disparu. Il devrait y avoir six boissons orange, mais seuls cinq marqueurs ronds peuvent être vus sur la figure. L'un des points de données de la barre de céréales cache un point de données de boisson à l'orange.
Vous pouvez résoudre ce problème de visualisation en rendant les points de données partiellement transparents à l'aide de la valeur alpha:
# ...
plt.dispersion(
X=price_orange,
y=sales_per_day_orange,
s=profit_margin_orange * dix,
c=sucre_contenu_orange,
alpha=0,5,
)
plt.dispersion(
X=price_cereal,
y=sales_per_day_cereal,
s=profit_margin_cereal * dix,
c=sucre_contenu_céréal,
marqueur="ré",
alpha=0,5,
)
plt.Titre("Ventes vs prix des boissons à l'orange et des barres de céréales")
plt.Légende([[[["Boissons à l'orange", "Barres de céréales"])
plt.xlabel("Prix (unité monétaire)")
plt.ylabel("Ventes hebdomadaires moyennes")
plt.texte(
3.2,
55,
"Taille du marqueur = marge bénéficiaire n" "Couleur du marqueur = teneur en sucre",
)
plt.spectacle()
Vous avez défini le alpha
valeur des deux ensembles de marqueurs à 0,5
, ce qui signifie qu’ils sont semi-transparents. Vous pouvez maintenant voir tous les points de données dans ce graphique, y compris ceux qui coïncident:
Vous avez également ajouté un titre et d'autres étiquettes au tracé pour compléter la figure avec plus d'informations sur ce qui est affiché.
Personnalisation de la palette de couleurs et du style
Dans les nuages de points que vous avez créés jusqu'à présent, vous avez utilisé trois couleurs pour représenter une teneur en sucre faible, moyenne ou élevée pour les boissons et les barres de céréales. Vous allez maintenant changer cela pour que la couleur représente directement la teneur réelle en sucre des articles.
Vous devez d'abord refactoriser les variables sucre_contenu_orange
et sucre_contenu_céréal
afin qu'ils représentent la valeur de la teneur en sucre plutôt que simplement les valeurs de couleur RVB:
sucre_contenu_orange = [[[[15, 35, 22, 27, 38, 14]
sucre_contenu_céréal = [[[[21, 49, 29, 24]
Ce sont maintenant des listes contenant le pourcentage de la quantité quotidienne recommandée de sucre dans chaque article. Le reste du code reste le même, mais vous pouvez maintenant choisir la palette de couleurs à utiliser. Cela mappe les valeurs aux couleurs:
# ...
plt.dispersion(
X=price_orange,
y=sales_per_day_orange,
s=profit_margin_orange * dix,
c=sucre_contenu_orange,
cmap="jet",
alpha=0,5,
)
plt.dispersion(
X=price_cereal,
y=sales_per_day_cereal,
s=profit_margin_cereal * dix,
c=sucre_contenu_céréal,
cmap="jet",
marqueur="ré",
alpha=0,5,
)
plt.Titre("Ventes vs prix des boissons à l'orange et des barres de céréales")
plt.Légende([[[["Boissons à l'orange", "Barres de céréales"])
plt.xlabel("Prix (unité monétaire)")
plt.ylabel("Ventes hebdomadaires moyennes")
plt.texte(
2,7,
55,
"Taille du marqueur = marge bénéficiaire n" "Couleur du marqueur = teneur en sucre",
)
plt.barre de couleur()
plt.spectacle()
La couleur des marqueurs est désormais basée sur une échelle continue, et vous avez également affiché le barre de couleur qui agit comme une légende pour la couleur des marqueurs. Voici le nuage de points résultant:
Tous les tracés que vous avez tracés jusqu'à présent ont été affichés dans le style natif de Matplotlib. Vous pouvez modifier ce style en utilisant l'une des nombreuses options. Vous pouvez afficher les styles disponibles à l'aide de la commande suivante:
>>> plt.style.disponible
[[[[
"Solarize_Light2",
"_classic_test_patch",
"bmh",
"classique",
"dark_background",
"vite",
"cinq trente-huit",
"ggplot",
"niveaux de gris",
"seaborn",
"seaborn-bright",
"daltonien marin",
"seaborn-dark",
"seaborn-dark-palette",
"seaborn-darkgrid",
"Seaborn-deep",
"seaborn-muted",
"carnet marin",
"papier marin",
"seaborn-pastel",
"seaborn-poster",
"seaborn-talk",
"seaborn-ticks",
"seaborn-white",
"seaborn-whitegrid",
"tableau-colorblind10",
]
Vous pouvez maintenant changer le style de tracé lors de l'utilisation de Matplotlib en utilisant l'appel de fonction suivant avant d'appeler plt.scatter ()
:
importer matplotlib.pyplot comme plt
importer engourdi comme np
plt.style.utiliser("seaborn")
# ...
Cela change le style de celui de Seaborn, un autre package de visualisation tiers. Vous pouvez voir les différents styles en traçant le nuage de points final que vous avez affiché ci-dessus à l'aide du style Seaborn:
Vous pouvez en savoir plus sur la personnalisation des tracés dans Matplotlib, et il existe également d'autres didacticiels sur les pages de documentation de Matplotlib.
Utilisant plt.scatter ()
pour créer des nuages de points vous permet d'afficher plus de deux variables. Voici les variables représentées dans cet exemple:
Variable | Représenté par |
---|---|
Prix | Axe X |
Nombre moyen vendu | Axe Y |
Marge bénéficiaire | Taille du marqueur |
Type de produit | Forme du marqueur |
Teneur en sucre | Couleur du marqueur |
La capacité de représenter plus de deux variables rend plt.scatter ()
un outil très puissant et polyvalent.
Explorant plt.scatter
() Plus loin
plt.scatter ()
offre encore plus de flexibilité dans la personnalisation des nuages de points. Dans cette section, vous découvrirez comment masquer des données à l'aide de tableaux NumPy et de nuages de points à travers un exemple. Dans cet exemple, vous allez générer des points de données aléatoires, puis les séparer en deux régions distinctes au sein du même nuage de points.
Une navetteuse désireuse de collecter des données a rassemblé les heures d'arrivée des bus à son arrêt de bus local sur une période de six mois. Les heures d'arrivée prévues sont à 15 minutes et 45 minutes après l'heure, mais elle a remarqué que les heures d'arrivée réelles suivent une distribution normale autour de ces heures:
Ce graphique montre la probabilité relative qu'un bus arrive à chaque minute en moins d'une heure. Cette distribution de probabilité peut être représentée à l'aide de NumPy et np.linspace ()
:
importer matplotlib.pyplot comme plt
importer engourdi comme np
moyenne = 15, 45
Dakota du Sud = 5, 7
X = np.linspace(0, 59, 60) # Représente chaque minute dans l'heure
first_distribution = np.exp(-0,5 * ((X - moyenne[[[[0]) / Dakota du Sud[[[[0]) ** 2)
second_distribution = 0,9 * np.exp(-0,5 * ((X - moyenne[[[[1]) / Dakota du Sud[[[[1]) ** 2)
y = first_distribution + second_distribution
y = y / max(y)
plt.parcelle(X, y)
plt.ylabel("Probabilité relative des arrivées de bus")
plt.xlabel("Quelques minutes après l'heure")
plt.spectacle()
Vous avez créé deux distributions normales centrées sur 15
et 45
minutes après l'heure et les a additionnés. Vous définissez l'heure d'arrivée la plus probable sur une valeur de 1
en divisant par la valeur maximale.
Vous pouvez maintenant simuler les heures d'arrivée des bus à l'aide de cette distribution. Pour ce faire, vous pouvez créer des temps aléatoires et des probabilités relatives aléatoires à l'aide de la fonction intégrée Aléatoire
module. Dans le code ci-dessous, vous utiliserez également des compréhensions de liste:
importer Aléatoire
importer matplotlib.pyplot comme plt
importer engourdi comme np
n_bus = 40
bus_times = np.asarray([[[[Aléatoire.Randint(0, 59) pour _ dans intervalle(n_bus)])
bus_likelihood = np.asarray([[[[Aléatoire.Aléatoire() pour _ dans intervalle(n_bus)])
plt.dispersion(X=bus_times, y=bus_likelihood)
plt.Titre("Heures d'arrivée des bus choisies au hasard et probabilités relatives")
plt.ylabel("Probabilité relative des arrivées de bus")
plt.xlabel("Quelques minutes après l'heure")
plt.spectacle()
Vous avez simulé 40
arrivées de bus, que vous pouvez visualiser avec le nuage de points suivant:
Votre tracé sera différent car les données que vous générez sont aléatoires. Cependant, tous ces points ne sont probablement pas proches de la réalité que le navetteur a observée à partir des données qu'elle a rassemblées et analysées. Vous pouvez tracer la distribution qu'elle a obtenue à partir des données avec les arrivées de bus simulées:
importer Aléatoire
importer matplotlib.pyplot comme plt
importer engourdi comme np
moyenne = 15, 45
Dakota du Sud = 5, 7
X = np.linspace(0, 59, 60)
first_distribution = np.exp(-0,5 * ((X - moyenne[[[[0]) / Dakota du Sud[[[[0]) ** 2)
second_distribution = 0,9 * np.exp(-0,5 * ((X - moyenne[[[[1]) / Dakota du Sud[[[[1]) ** 2)
y = first_distribution + second_distribution
y = y / max(y)
n_bus = 40
bus_times = np.asarray([[[[Aléatoire.Randint(0, 59) pour _ dans intervalle(n_bus)])
bus_likelihood = np.asarray([[[[Aléatoire.Aléatoire() pour _ dans intervalle(n_bus)])
plt.dispersion(X=bus_times, y=bus_likelihood)
plt.parcelle(X, y)
plt.Titre("Heures d'arrivée des bus choisies au hasard et probabilités relatives")
plt.ylabel("Probabilité relative des arrivées de bus")
plt.xlabel("Quelques minutes après l'heure")
plt.spectacle()
Cela donne la sortie suivante:
Pour que la simulation reste réaliste, vous devez vous assurer que les arrivées de bus aléatoires correspondent aux données et à la distribution obtenues à partir de ces données. Vous pouvez filtrer les points générés aléatoirement en ne conservant que ceux qui appartiennent à la distribution de probabilité. Vous pouvez y parvenir en créant un masquer pour le nuage de points:
# ...
in_region = bus_likelihood < y[[[[bus_times]
out_region = bus_likelihood > = y[[[[bus_times]
plt.dispersion(
X=bus_times[[[[in_region],
y=bus_likelihood[[[[in_region],
Couleur="vert",
)
plt.dispersion(
X=bus_times[[[[out_region],
y=bus_likelihood[[[[out_region],
Couleur="rouge",
marqueur="X",
)
plt.parcelle(X, y)
plt.Titre("Heures d'arrivée des bus choisies au hasard et probabilités relatives")
plt.ylabel("Probabilité relative des arrivées de bus")
plt.xlabel("Quelques minutes après l'heure")
plt.spectacle()
Les variables in_region
et out_region
are NumPy arrays containing Boolean values based on whether the randomly generated likelihoods fall above or below the distribution y
. You then plot two separate scatter plots, one with the points that fall within the distribution and another for the points that fall outside the distribution. The data points that fall above the distribution are not representative of the real data:
You’ve segmented the data points from the original scatter plot based on whether they fall within the distribution and used a different color and marker to identify the two sets of data.
Reviewing the Key Input Parameters
You’ve learned about the main input parameters to create scatter plots in the sections above. Here’s a brief summary of key points to remember about the main input parameters:
Parameter | La description |
---|---|
x et y |
These parameters represent the two main variables and can be any array-like data types, such as lists or NumPy arrays. These are required parameters. |
s |
This parameter defines the size of the marker. It can be a float if all the markers have the same size or an array-like data structure if the markers have different sizes. |
c |
This parameter represents the color of the markers. It will typically be either an array of colors, such as RGB values, or a sequence of values that will be mapped onto a colormap using the parameter cmap . |
marker |
This parameter is used to customize the shape of the marker. |
cmap |
If a sequence of values is used for the parameter c , then this parameter can be used to select the mapping between values and colors, typically by using one of the standard colormaps or a custom colormap. |
alpha |
This parameter is a float that can take any value between 0 et 1 and represents the transparency of the markers, where 1 represents an opaque marker. |
These are not the only input parameters available with plt.scatter()
. You can access the full list of input parameters from the documentation.
Conclusion
Now that you know how to create and customize scatter plots using plt.scatter()
, you’re ready to start practicing with your own datasets and examples. This versatile function gives you the ability to explore your data and present your findings in a clear way.
In this tutorial you’ve learned how to:
- Create a scatter plot using
plt.scatter
() - Use the required and optional input parameters
- Customize scatter plots for basic and more advanced plots
- Represent more than two dimensions with
plt.scatter()
You can get the most out of visualization using plt.scatter()
by learning more about all the features in Matplotlib and dealing with data using NumPy.
[ad_2]