matplotlib.ticker

Cochez la localisation et le formatage

Ce module contient des classes pour configurer la localisation et le formatage des ticks. Des localisateurs et formateurs de ticks génériques sont fournis, ainsi que des outils personnalisés spécifiques à un domaine.

Bien que les localisateurs ne sachent rien des graduations majeures ou mineures, ils sont utilisés par la classe Axis pour prendre en charge la localisation et la mise en forme des graduations majeures et mineures.

Cochez la localisation

La classe Locator est la classe de base pour tous les localisateurs de ticks. Les localisateurs gèrent la mise à l'échelle automatique des limites de vue en fonction des limites de données et le choix des emplacements de ticks. Un localisateur de tiques semi-automatique utile est MultipleLocator. Il est initialisé avec une base, par exemple 10, et il choisit des limites d'axe et des graduations qui sont des multiples de cette base.

Les sous-classes Locator définies ici sont :

AutoLocator	MaxNLocatoravec des valeurs par défaut simples. Il s'agit du localisateur de ticks par défaut pour la plupart des tracés.
MaxNLocator	Trouve jusqu'à un nombre maximum d'intervalles avec des ticks à des endroits agréables.
LinearLocator	Espacez les ticks uniformément du min au max.
LogLocator	Espacez les ticks de manière logarithmique du min au max.
MultipleLocator	Les graduations et la gamme sont un multiple de la base ; entier ou flottant.
FixedLocator	Les emplacements des ticks sont fixes.
IndexLocator	Localisateur pour les tracés d'index (par exemple, où ).x = range(len(y))
NullLocator	Pas de tiques.
SymmetricalLogLocator	Localisateur à utiliser avec la norme symlog ; fonctionne comme LogLocatorpour la partie en dehors du seuil et ajoute 0 si à l'intérieur des limites.
AsinhLocator	Localisateur à utiliser avec la norme asinh, essayant d'espacer les tiques de manière approximativement uniforme.
LogitLocator	Localisateur pour la mise à l'échelle logit.
AutoMinorLocator	Localisateur de graduations mineures lorsque l'axe est linéaire et que les graduations principales sont uniformément espacées. Subdivise l'intervalle de graduation majeur en un nombre spécifié d'intervalles mineurs, par défaut à 4 ou 5 selon l'intervalle majeur.

Il existe un certain nombre de localisateurs spécialisés pour les emplacements de date - voir le datesmodule.

Vous pouvez définir votre propre localisateur en dérivant de Locator. Vous devez remplacer la __call__méthode, qui renvoie une séquence d'emplacements, et vous souhaiterez probablement remplacer la méthode de mise à l'échelle automatique pour définir les limites de vue à partir des limites de données.

Si vous souhaitez remplacer le localisateur par défaut, utilisez l'un des éléments ci-dessus ou un localisateur personnalisé et transmettez-le à l'instance d'axe x ou y. Les méthodes concernées sont :

ax.xaxis.set_major_locator(xmajor_locator)
ax.xaxis.set_minor_locator(xminor_locator)
ax.yaxis.set_major_locator(ymajor_locator)
ax.yaxis.set_minor_locator(yminor_locator)

Le localisateur mineur par défaut est NullLocator, c'est-à-dire qu'aucun tick mineur n'est activé par défaut.

Noter

LocatorLes instances ne doivent pas être utilisées avec plus d'un Axisou Axes. Donc au lieu de :

locator = MultipleLocator(5)
ax.xaxis.set_major_locator(locator)
ax2.xaxis.set_major_locator(locator)

faites plutôt ceci :

ax.xaxis.set_major_locator(MultipleLocator(5))
ax2.xaxis.set_major_locator(MultipleLocator(5))

Cochez la mise en forme

Le formatage des ticks est contrôlé par des classes dérivées de Formatter. Le formateur fonctionne sur une seule valeur de graduation et renvoie une chaîne à l'axe.

NullFormatter	Pas d'étiquettes sur les tiques.
FixedFormatter	Définissez les chaînes manuellement pour les étiquettes.
FuncFormatter	La fonction définie par l'utilisateur définit les étiquettes.
StrMethodFormatter	Utilisez la méthode de la chaîne format.
FormatStrFormatter	Utilisez une chaîne de format sprintf à l'ancienne.
ScalarFormatter	Formateur par défaut pour les scalaires : sélectionnez automatiquement la chaîne de format.
LogFormatter	Formateur pour les axes de journal.
LogFormatterExponent	Formatez les valeurs pour l'axe du journal à l'aide de .exponent = log_base(value)
LogFormatterMathtext	Mettez en forme les valeurs de l'axe du journal à l' aide du texte Math.exponent = log_base(value)
LogFormatterSciNotation	Mettre en forme les valeurs de l'axe logarithmique à l'aide de la notation scientifique.
LogitFormatter	Formateur de probabilité.
EngFormatter	Formater les étiquettes en notation technique.
PercentFormatter	Formater les étiquettes en pourcentage.

Vous pouvez dériver votre propre formateur de la classe de base Formatter en remplaçant simplement la __call__méthode. La classe de formateur a accès à la vue d'axe et aux limites de données.

Pour contrôler les formats d'étiquette de graduation majeure et mineure, utilisez l'une des méthodes suivantes :

ax.xaxis.set_major_formatter(xmajor_formatter)
ax.xaxis.set_minor_formatter(xminor_formatter)
ax.yaxis.set_major_formatter(ymajor_formatter)
ax.yaxis.set_minor_formatter(yminor_formatter)

En plus d'une Formatterinstance, set_major_formatteret set_minor_formatteracceptez également une strfonction ou . strl'entrée sera remplacée en interne par un autogénéré StrMethodFormatteravec l'entrée str. Pour l'entrée de fonction, un FuncFormatteravec la fonction d'entrée sera généré et utilisé.

Voir Coches majeures et mineures pour un exemple de définition de coches majeurs et mineurs. Voir le matplotlib.datesmodule pour plus d'informations et des exemples d'utilisation des localisateurs de date et des formateurs.

classe matplotlib.ticker. AsinhLocator ( linear_width , numticks = 11 , symthresh = 0.2 , base = 10 , subs = None )

Socles :Locator

Un localisateur de ticks d'axe spécialisé pour l'échelle inverse-sinh

Il est très peu probable que cela ait une quelconque utilité au-delà de la AsinhScaleclasse.

Noter

Cette API est provisoire et peut être révisée à l'avenir en fonction des premiers commentaires des utilisateurs.

Paramètres :

flottant linear_width

Paramètre d'échelle définissant l'étendue de la région quasi-linéaire.

numticks int, par défaut : 11

Le nombre approximatif de graduations principales qui s'adapteront le long de l'axe entier

flottant symthresh , par défaut : 0,2

Le seuil fractionnaire en dessous duquel les données qui couvrent une plage approximativement symétrique par rapport à zéro auront des graduations qui sont exactement symétriques.

entier de base , par défaut : 10

La base numérique utilisée pour arrondir les emplacements des graduations sur une échelle logarithmique. S'il est inférieur à un, l'arrondi se fait au multiple entier le plus proche des puissances de dix.

sous- tuple, par défaut : aucun

Multiples de la base numérique, généralement utilisés pour les graduations mineures, par exemple (2, 5) lorsque base=10.

set_params ( numticks = None , symthresh = None , base = None , subs = None )

Définissez les paramètres dans ce localisateur.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

classe matplotlib.ticker. Localisateur automatique

Socles :MaxNLocator

Trouvez dynamiquement les principales positions des ticks. Il s'agit en fait d'une sous-classe de MaxNLocator, avec les paramètres nbins = 'auto' et steps = [1, 2, 2.5, 5, 10] .

Pour connaître les valeurs des paramètres non publics, veuillez consulter les valeurs par défaut de MaxNLocator.

classe matplotlib.ticker. AutoMinorLocator ( n = Aucun )

Socles :Locator

Trouvez dynamiquement les positions des ticks mineurs en fonction des positions des ticks majeurs. L'échelle doit être linéaire avec des graduations principales régulièrement espacées.

n est le nombre de subdivisions de l'intervalle entre les graduations principales ; par exemple, n=2 placera un seul tick mineur à mi-chemin entre les ticks majeurs.

Si n est omis ou Aucun, il sera défini sur 5 ou 4.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

classe matplotlib.ticker. EngFormatter ( unit = '' , places = None , sep = ' ' , * , usetex = None , useMathText = None )

Socles :Formatter

Formatez les valeurs d'axe en utilisant des préfixes d'ingénierie pour représenter des puissances de 1000, plus une unité spécifiée, par exemple, 10 MHz au lieu de 1e7.

Paramètres :

chaîne d'unité , par défaut : ""

Symbole d'unité à utiliser, adapté aux représentations à une seule lettre des puissances de 1 000. Par exemple, « Hz » ou « m ».

places int, par défaut : Aucun

Précision avec laquelle afficher le nombre, spécifié en chiffres après la virgule (il y aura entre un et trois chiffres avant la virgule). S'il vaut Aucun, le formatage revient au format virgule flottante '%g', qui affiche jusqu'à 6 chiffres significatifs , c'est-à-dire que la valeur équivalente pour les places varie entre 0 et 5 (inclus).

chaîne sep , par défaut : " "

Séparateur utilisé entre la valeur et le préfixe/unité. Par exemple, on obtient '3.14 mV' si sepest " " (par défaut) et '3.14mV' si sepest "". Outre le comportement par défaut, d'autres options utiles peuvent être :

• sep=""ajouter directement le préfixe/unité à la valeur ;

• sep="\N{THIN SPACE}"( U+2009);

• sep="\N{NARROW NO-BREAK SPACE}"( U+202F);

• sep="\N{NO-BREAK SPACE}"( U+00A0).

usetex booléen , par défaut : rcParams["text.usetex"](par défaut : False)

Pour activer/désactiver l'utilisation du mode mathématique de TeX pour rendre les nombres dans le formateur.

useMathText booléen , par défaut : rcParams["axes.formatter.use_mathtext"](par défaut : False)

Pour activer/désactiver l'utilisation de mathtext pour le rendu des nombres dans le formateur.

FRA_PREFIXES = {-24 : 'y', -21 : 'z', -18 : 'a', -15 : 'f', -12 : 'p', -9 : 'n', -6 : 'µ ', -3 : 'm', 0 : '', 3 : 'k', 6 : 'M', 9 : 'G', 12 : 'T', 15 : 'P', 18 : 'E', 21 : 'Z', 24 : 'O'}

format_eng ( num )

Formater un nombre en notation technique, en ajoutant une lettre représentant la puissance de 1000 du nombre d'origine. Quelques exemples:

>>> format_eng(0)        # for self.places = 0
'0'

>>> format_eng(1000000)  # for self.places = 1
'1.0 M'

>>> format_eng("-1e-6")  # for self.places = 2
'-1.00 µ'

get_useMathText ( )

get_usetex ( )

set_useMathText ( val )

set_usetex ( val )

propriété useMathText

propriété usetex

classe matplotlib.ticker. FixedFormatter ( seq )

Socles :Formatter

Renvoie des chaînes fixes pour les étiquettes de graduation basées uniquement sur la position, pas sur la valeur.

Noter

FixedFormatterne doit être utilisé qu'avec FixedLocator. Sinon, les étiquettes peuvent se retrouver dans des positions inattendues.

Définissez la séquence seq des chaînes qui seront utilisées pour les étiquettes.

get_offset ( )

set_offset_string ( ofs )

classe matplotlib.ticker. FixedLocator ( locs , nbins = None )

Socles :Locator

Les emplacements des ticks sont fixes. Si nbins n'est pas None, le tableau des positions possibles sera sous-échantillonné pour garder le nombre de ticks <= nbins +1. Le sous-échantillonnage sera effectué de manière à inclure la plus petite valeur absolue ; par exemple, si zéro est inclus dans le tableau des possibilités, il est garanti qu'il s'agit de l'un des ticks choisis.

set_params ( nbins = Aucun )

Définissez les paramètres dans ce localisateur.

tick_values ​​( vmin , vmax )

Renvoyez les emplacements des tiques.

Noter

Étant donné que les valeurs sont fixes, vmin et vmax ne sont pas utilisés dans cette méthode.

classe matplotlib.ticker. FormatStrFormatter ( fmt )

Socles :Formatter

Utilisez une chaîne de format à l'ancienne (opérateur '%') pour formater la coche.

La chaîne de format doit contenir un seul format de variable (%). Il sera appliqué à la valeur (et non à la position) du tick.

Les valeurs numériques négatives utiliseront un tiret, pas un moins Unicode ; utilisez mathtext pour obtenir un moins Unicode en enveloppant le spécificateur de format avec $ (par exemple "$%g$").

classe matplotlib.ticker. Formateur

Socles :TickHelper

Créez une chaîne basée sur une valeur de graduation et un emplacement.

fix_minus statique ( s )

Certaines classes peuvent vouloir remplacer un trait d'union pour moins par le symbole Unicode approprié (U+2212) pour l'exactitude typographique. Il s'agit d'une méthode d'assistance pour effectuer un tel remplacement lorsqu'elle est activée via rcParams["axes.unicode_minus"](par défaut : True).

format_data ( valeur )

Renvoie la représentation sous forme de chaîne complète de la valeur avec la position non spécifiée.

format_data_short ( valeur )

Renvoie une version courte de la chaîne de caractères de la valeur du tick.

Par défaut, la valeur longue indépendante de la position.

format_ticks ( valeurs )

Renvoyez les étiquettes de ticks pour tous les ticks à la fois.

get_offset ( )

locs = []

set_locs ( locs )

Définissez les emplacements des tiques.

Cette méthode est appelée avant de calculer les étiquettes de ticks car certains formateurs ont besoin de connaître tous les emplacements de ticks pour le faire.

classe matplotlib.ticker. FuncFormatter ( func )

Socles :Formatter

Utilisez une fonction définie par l'utilisateur pour le formatage.

La fonction doit accepter deux entrées (une valeur de graduation xet une position pos) et renvoyer une chaîne contenant l'étiquette de graduation correspondante.

get_offset ( )

set_offset_string ( ofs )

classe matplotlib.ticker. IndexLocator ( base , décalage )

Socles :Locator

Cochez chaque multiple d'un certain nombre de points de base tracés, par exemple, tous les 5 points. Il est supposé que vous effectuez un tracé d'index ; c'est-à-dire que l'axe est 0, len(data). Ceci est principalement utile pour x ticks.

Place marque chaque point de données de base , en commençant à offset .

set_params ( base = Aucun , décalage = Aucun )

Définir les paramètres dans ce localisateur

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

classe matplotlib.ticker. LinearLocator ( numticks = None , presets = None )

Socles :Locator

Déterminer les emplacements des tiques

La première fois que cette fonction est appelée, elle essaiera de définir le nombre de ticks pour créer un joli partitionnement des ticks. Par la suite le nombre de ticks sera fixé pour que la navigation interactive soit agréable

Utilisez des préréglages pour définir des localisations basées sur lom. Un dict mappant vmin, vmax->locs

chiffres de propriété

set_params ( numticks = None , presets = None )

Définissez les paramètres dans ce localisateur.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

view_limits ( vmin , vmax )

Essayez de choisir intelligemment les limites de la vue.

classe matplotlib.ticker. Localisateur

Socles :TickHelper

Déterminez les emplacements des tiques;

Notez que le même localisateur ne doit pas être utilisé sur plusieurs Axis, car le localisateur stocke les références aux données Axis et aux limites de vue.

MAXTICKS = 1000

non singulier ( v0 , v1 )

Ajustez une plage si nécessaire pour éviter les singularités.

Cette méthode est appelée lors de la mise à l'échelle automatique, avec la définition des limites de données sur les axes si les axes contiennent des données, ou sinon.(v0, v1)(-inf, +inf)

• Si (éventuellement jusqu'à une pente en virgule flottante), cette méthode renvoie un intervalle étendu autour de cette valeur.v0 == v1

• Si , cette méthode renvoie les limites d'affichage par défaut appropriées.(v0, v1) == (-inf, +inf)

• Sinon, est retourné sans modification.(v0, v1)

raise_if_exceeds ( locs )

Connectez-vous au niveau AVERTISSEMENT si locs est plus long que Locator.MAXTICKS.

Ceci est destiné à être appelé immédiatement avant de renvoyer les locs__call__ pour informer les utilisateurs au cas où leur localisateur renvoie un grand nombre de ticks, provoquant un manque de mémoire de Matplotlib.

Le nom "étrange" de cette méthode remonte à l'époque où elle levait une exception au lieu d'émettre un journal.

set_params ( ** kwargs )

Ne rien faire et donner un avertissement. Toute classe de localisateur ne prenant pas en charge la fonction set_params() l'appellera.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

view_limits ( vmin , vmax )

Sélectionnez une échelle pour la plage de vmin à vmax.

Les sous-classes doivent remplacer cette méthode pour modifier le comportement du localisateur.

classe matplotlib.ticker. LogFormatter ( base = 10.0 , labelOnlyBase = False , minor_thresholds = None , linthresh = None )

Socles :Formatter

Classe de base pour le formatage des graduations sur une échelle logarithmique ou symlog.

Il peut être instancié directement ou sous-classé.

Paramètres :

flotteur de base , par défaut : 10.

Base du logarithme utilisé dans tous les calculs.

labelOnlyBase bool, par défaut : False

Si True, label ne coche qu'aux puissances entières de base. Ceci est normalement Vrai pour les ticks majeurs et Faux pour les ticks mineurs.

minor_thresholds (sous-ensemble, tous), par défaut : (1, 0,4)

Si labelOnlyBase vaut False, ces deux nombres contrôlent l'étiquetage des ticks qui ne sont pas à des puissances entières de base ; normalement ce sont les tiques mineures. Le paramètre de contrôle est le journal de la plage de données de l'axe. Dans le cas typique où la base est 10, il s'agit du nombre de décennies couvertes par l'axe, nous pouvons donc l'appeler "numdec". Si , toutes les graduations mineures seront étiquetées. Si , alors seul un sous-ensemble de graduations mineures sera étiqueté, afin d'éviter l'encombrement. Si c'est le cas , aucune coche mineure ne sera étiquetée.numdec <= allall < numdec <= subsetnumdec > subset

linthresh Aucun ou flottant, par défaut : Aucun

Si une échelle logarithmique symétrique est utilisée, son linthresh paramètre doit être fourni ici.

Remarques

La set_locsméthode doit être appelée pour activer la logique de sous-ensemble contrôlée par le minor_thresholdsparamètre.

Dans certains cas, comme la barre de couleurs, il n'y a pas de distinction entre les graduations majeures et mineures ; les emplacements des ticks peuvent être définis manuellement ou par un localisateur qui place les ticks à des puissances entières de base et à des emplacements intermédiaires. Dans cette situation, désactivez la logique minor_thresholds en utilisant , afin que tous les ticks soient étiquetés.minor_thresholds=(np.inf, np.inf)

Pour désactiver l'étiquetage des graduations mineures lorsque 'labelOnlyBase' est False, utilisez . C'est la valeur par défaut pour le style "classique".minor_thresholds=(0, 0)

Exemples

Pour étiqueter un sous-ensemble de ticks mineurs lorsque les limites de la vue s'étendent jusqu'à 2 décades, et tous les ticks lorsqu'ils sont agrandis à 0,5 décades ou moins, utilisez .minor_thresholds=(2, 0.5)

Pour étiqueter toutes les graduations mineures lorsque les limites de la vue s'étendent jusqu'à 1,5 décades, utilisez .minor_thresholds=(1.5, 1.5)

base ( base )

[ Obsolète ] Modifiez la base de l'étiquetage.

Avertissement

Doit toujours correspondre à la base utilisée pourLogLocator

Remarques

Obsolète depuis la version 3.6 : utilisez plutôt set_base().

format_data ( valeur )

Renvoie la représentation sous forme de chaîne complète de la valeur avec la position non spécifiée.

format_data_short ( valeur )

Renvoie une version courte de la chaîne de caractères de la valeur du tick.

Par défaut, la valeur longue indépendante de la position.

label_minor ( labelOnlyBase )

[ Obsolète ] Activez ou désactivez l'étiquetage des ticks mineurs.

Paramètres :

labelOnlyBase booléen

Si True, label ne coche qu'aux puissances entières de base.

Remarques

Obsolète depuis la version 3.6 : utilisez plutôt set_label_minor().

set_base ( base )

Changer la base pour l'étiquetage.

Avertissement

Doit toujours correspondre à la base utilisée pourLogLocator

set_label_minor ( labelOnlyBase )

Activez ou désactivez l'étiquetage des ticks mineurs.

Paramètres :

labelOnlyBase booléen

Si True, label ne coche qu'aux puissances entières de base.

set_locs ( locs = Aucun )

Utilisez les limites de la vue d'axe pour contrôler les graduations étiquetées.

Le paramètre locs est ignoré dans le présent algorithme.

classe matplotlib.ticker. LogFormatterExponent ( base = 10.0 , labelOnlyBase = False , minor_thresholds = None , linthresh = None )

Socles :LogFormatter

Formatez les valeurs pour l'axe du journal à l'aide de .exponent = log_base(value)

classe matplotlib.ticker. LogFormatterMathtext ( base = 10.0 , labelOnlyBase = False , minor_thresholds = None , linthresh = None )

Socles :LogFormatter

Formatez les valeurs pour l'axe du journal à l'aide de .exponent = log_base(value)

classe matplotlib.ticker. LogFormatterSciNotation ( base = 10.0 , labelOnlyBase = False , minor_thresholds = None , linthresh = None )

Socles :LogFormatterMathtext

Formatez les valeurs en suivant la notation scientifique dans un axe logarithmique.

classe matplotlib.ticker. LogLocator ( base = 10.0 , subs = (1.0,) , numdecs = 4 , numticks = None )

Socles :Locator

Déterminer les emplacements des graduations pour les axes de journal

Cochez les emplacements : subs[j] * base**i

Paramètres :

flottant de base , par défaut : 10,0

La base du log utilisé, donc les graduations majeures sont placées à base**n, n entier.

subs None ou str ou séquence de float, par défaut : (1.0,)

Donne les multiples des puissances entières de la base à laquelle placer les graduations. La valeur par défaut place les graduations uniquement aux puissances entières de la base. Les valeurs de chaîne autorisées sont 'auto'et 'all', qui utilisent toutes deux un algorithme basé sur les limites de la vue de l'axe pour déterminer si et comment mettre des graduations entre les puissances entières de la base. Avec 'auto', les graduations ne sont placées qu'entre les puissances entières ; avec 'all', les puissances entières sont incluses. La valeur Aucun équivaut à 'auto'.

numticks None ou int, par défaut : None

Le nombre maximum de graduations à autoriser sur un axe donné. La valeur par défaut de Nonetentera de choisir intelligemment tant que ce localisateur a déjà été affecté à un axe à l'aide de get_tick_space, mais retombe sinon à 9.

base ( base )

[ Obsolète ] Définissez la base du journal (tic majeur tous les base**i, i entier).

Remarques

Obsolète depuis la version 3.6 : utilisez plutôt set_params(base=...).

non singulier ( vmin , vmax )

Ajustez une plage si nécessaire pour éviter les singularités.

Cette méthode est appelée lors de la mise à l'échelle automatique, avec la définition des limites de données sur les axes si les axes contiennent des données, ou sinon.(v0, v1)(-inf, +inf)

• Si (éventuellement jusqu'à une pente en virgule flottante), cette méthode renvoie un intervalle étendu autour de cette valeur.v0 == v1

• Si , cette méthode renvoie les limites d'affichage par défaut appropriées.(v0, v1) == (-inf, +inf)

• Sinon, est retourné sans modification.(v0, v1)

set_params ( base = None , subs = None , numdecs = None , numticks = None )

Définissez les paramètres dans ce localisateur.

sous- marins ( sous- marins )

[ Obsolète ] Définissez les ticks mineurs pour la mise à l'échelle du journal tous les base**i*subs[j].

Remarques

Obsolète depuis la version 3.6 : utilisez set_params(subs=...) à la place.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

view_limits ( vmin , vmax )

Essayez de choisir intelligemment les limites de la vue.

classe matplotlib.ticker. LogitFormatter ( * , use_overline = False , one_half = '\\frac{1}{2}' , minor = False , minor_threshold = 25 , minor_number = 6 )

Socles :Formatter

Formateur de probabilité (utilisant du texte mathématique).

Paramètres :

use_overline bool, par défaut : False

Si x > 1/2, avec x = 1-v, indiquez si x doit être affiché sous la forme $overline{v}$. La valeur par défaut est d'afficher $1-v$.

one_half str, par défaut : r"frac{1}{2}"

La chaîne utilisée pour représenter 1/2.

booléen mineur , par défaut : False

Indiquez si le formateur formate les graduations mineures ou non. Fondamentalement, les ticks mineurs ne sont pas étiquetés, sauf lorsque seuls quelques ticks sont fournis, les ticks avec le plus d'espace avec les ticks voisins sont étiquetés. Consultez les autres paramètres pour modifier le comportement par défaut.

minor_threshold int, par défaut : 25

Nombre maximum de locs pour étiqueter certaines ticks mineurs. Ce paramètre n'a aucun effet si minor vaut False.

nombre_mineur entier , par défaut : 6

Nombre de ticks étiquetés lorsque le nombre de ticks est inférieur au seuil.

format_data_short ( valeur )

Renvoie une version courte de la chaîne de caractères de la valeur du tick.

Par défaut, la valeur longue indépendante de la position.

set_locs ( locs )

Définissez les emplacements des tiques.

Cette méthode est appelée avant de calculer les étiquettes de ticks car certains formateurs ont besoin de connaître tous les emplacements de ticks pour le faire.

set_minor_number ( minor_number )

Définissez le nombre de graduations mineures à étiqueter lorsque certaines graduations mineures sont étiquetées.

Paramètres :

minor_number int

Nombre de ticks étiquetés lorsque le nombre de ticks est inférieur au seuil.

set_minor_threshold ( minor_threshold )

Définissez le seuil d'étiquetage des tiques mineures.

Paramètres :

minor_threshold int

Nombre maximum d'emplacements pour l'étiquetage de certaines tiques mineures. Ce paramètre n'a aucun effet si minor vaut False.

set_one_half ( one_half )

Définissez la façon dont une moitié est affichée.

one_half str, par défaut : r"frac{1}{2}"

La chaîne utilisée pour représenter 1/2.

use_overline ( use_overline )

Changer de mode d'affichage avec surlignage pour l'étiquetage p>1/2.

Paramètres :

use_overline bool, par défaut : False

Si x > 1/2, avec x = 1-v, indiquez si x doit être affiché sous la forme $overline{v}$. La valeur par défaut est d'afficher $1-v$.

classe matplotlib.ticker. LogitLocator ( minor = False , * , nbins = 'auto' )

Socles :MaxNLocator

Déterminer les emplacements des graduations pour les axes logit

Placer des coches sur les emplacements logit

Paramètres :

nbins int ou 'auto', facultatif

Nombre de ticks. Utilisé uniquement si minor vaut False.

booléen mineur , par défaut : False

Indiquez si ce localisateur est pour les ticks mineurs ou non.

bien mineur

non singulier ( vmin , vmax )

Ajustez une plage si nécessaire pour éviter les singularités.

Cette méthode est appelée lors de la mise à l'échelle automatique, avec la définition des limites de données sur les axes si les axes contiennent des données, ou sinon.(v0, v1)(-inf, +inf)

• Si (éventuellement jusqu'à une pente en virgule flottante), cette méthode renvoie un intervalle étendu autour de cette valeur.v0 == v1

• Si , cette méthode renvoie les limites d'affichage par défaut appropriées.(v0, v1) == (-inf, +inf)

• Sinon, est retourné sans modification.(v0, v1)

set_params ( mineur = Aucun , ** kwargs )

Définissez les paramètres dans ce localisateur.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

classe matplotlib.ticker. MaxNLocator ( nbins = None , ** kwargs )

Socles :Locator

Trouvez de bons emplacements de ticks avec pas plus de N dans les limites de la vue. Les emplacements au-delà des limites sont ajoutés pour prendre en charge la mise à l'échelle automatique.

Paramètres :

nbins int ou 'auto', par défaut : 10

Nombre maximal d'intervalles ; un de moins que le nombre maximum de ticks. Si la chaîne est 'auto', le nombre de bacs sera automatiquement déterminé en fonction de la longueur de l'axe.

étapes de type tableau, facultatif

Séquence de jolis nombres commençant par 1 et se terminant par 10 ; par exemple, [1, 2, 4, 5, 10], où les valeurs sont des multiples de graduation acceptables. c'est-à-dire que pour l'exemple, 20, 40, 60 seraient un ensemble acceptable de graduations, tout comme 0,4, 0,6, 0,8, car ce sont des multiples de 2. Cependant, 30, 60, 90 ne seraient pas autorisés car 3 n'apparaît pas dans la liste des étapes.

entier booléen, par défaut : False

Si True, les ticks ne prendront que des valeurs entières, à condition qu'au moins min_n_ticks entiers soient trouvés dans les limites de la vue.

booléen symétrique , par défaut : False

Si True, la mise à l'échelle automatique se traduira par une plage symétrique autour de zéro.

prune {'inférieur', 'supérieur', 'les deux', Aucun}, par défaut : Aucun

Supprimer les graduations de bord - utile pour les tracés empilés ou groupés où la graduation supérieure d'un axe chevauche la graduation inférieure des axes au-dessus, principalement lorsque rcParams["axes.autolimit_mode"](par défaut : 'data') est 'round_numbers'. Si prune=='lower', la plus petite coche sera supprimée. Si , la coche la plus grande sera supprimée. Si , les graduations les plus grandes et les plus petites seront supprimées. Si prune est None , aucune coche ne sera supprimée.prune == 'upper'prune == 'both'

min_n_ticks entier , par défaut : 2

Relâchez les nbins et les contraintes entières si nécessaire pour obtenir ce nombre minimum de ticks.

default_params = {'integer' : Faux, 'min_n_ticks' : 2, 'nbins' : 10, 'prune' : Aucun, 'steps' : Aucun, 'symmetric' : Faux}

set_params ( ** kwargs )

Définissez les paramètres de ce localisateur.

Paramètres :

nbins int ou 'auto', facultatif

voirMaxNLocator

étapes de type tableau, facultatif

voirMaxNLocator

entier booléen, facultatif

voirMaxNLocator

booléen symétrique , facultatif

voirMaxNLocator

prune {'inférieur', 'supérieur', 'les deux', Aucun}, facultatif

voirMaxNLocator

min_n_ticks entier , facultatif

voirMaxNLocator

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

view_limits ( dmin , dmax )

Sélectionnez une échelle pour la plage de vmin à vmax.

Les sous-classes doivent remplacer cette méthode pour modifier le comportement du localisateur.

classe matplotlib.ticker. MultipleLocator ( base = 1.0 )

Socles :Locator

Définissez une coche sur chaque multiple entier d'une base dans l'intervalle de vue.

set_params ( base )

Définissez les paramètres dans ce localisateur.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

view_limits ( dmin , dmax )

Définissez les limites de la vue sur les multiples de base les plus proches contenant les données.

classe matplotlib.ticker. NullFormatter

Socles :Formatter

Renvoie toujours la chaîne vide.

classe matplotlib.ticker. NullLocalator

Socles :Locator

Pas de tiques

tick_values ​​( vmin , vmax )

Renvoyez les emplacements des tiques.

Noter

Étant donné que les valeurs sont Null, vmin et vmax ne sont pas utilisés dans cette méthode.

classe matplotlib.ticker. PercentFormatter ( xmax = 100 , decimals = None , symbol = '%' , is_latex = False )

Socles :Formatter

Formater les nombres en pourcentage.

Paramètres :

flotteur xmax

Détermine comment le nombre est converti en pourcentage. xmax est la valeur de données qui correspond à 100 %. Les pourcentages sont calculés comme . Ainsi, si les données sont déjà mises à l'échelle en pourcentages, xmax sera de 100. Une autre situation courante est celle où xmax est de 1,0.x / xmax * 100

décimales Aucune ou int

Le nombre de décimales à placer après le point. Si Aucun (valeur par défaut), le nombre sera calculé automatiquement.

symbole str ou Aucun

Une chaîne qui sera ajoutée à l'étiquette. Il peut être Aucun ou vide pour indiquer qu'aucun symbole ne doit être utilisé. Les caractères spéciaux LaTeX sont échappés dans le symbole chaque fois que le mode latex est activé, sauf si is_latex vaut True .

is_latex booléen

Si False , les caractères LaTeX réservés dans le symbole seront échappés.

convert_to_pct ( x )

format_pct ( x , display_range )

Formatez le nombre sous forme de pourcentage avec le nombre correct de décimales et ajoutez le symbole de pourcentage, le cas échéant.

Si self.decimalsest None, le nombre de chiffres après la virgule décimale est défini en fonction de la plage_affichage de l'axe comme suit :

display_range	décimales	goûter
>50	0	x = 34.5=> 35%
>5	1	x = 34.5=> 34,5%
>0,5	2	x = 34.5=> 34,50%
...	...	...

Cette méthode ne sera pas très bonne pour les plages d'axes minuscules ou extrêmement grandes. Il suppose que les valeurs du graphique sont des pourcentages affichés sur une échelle raisonnable.

symbole de propriété

Le symbole de pourcentage configuré sous forme de chaîne.

Si LaTeX est activé via rcParams["text.usetex"](par défaut : False), les caractères spéciaux sont automatiquement échappés dans la chaîne.{'#', '$', '%', '&', '~', '_', '^', '\', '{', '}'}

classe matplotlib.ticker. ScalarFormatter ( useOffset = None , useMathText = None , useLocale = None )

Socles :Formatter

Formater les valeurs de graduation sous forme de nombre.

Paramètres :

useOffset booléen ou flottant, par défaut : rcParams["axes.formatter.useoffset"](par défaut : True)

S'il faut utiliser la notation de décalage. Voir set_useOffset.

useMathText booléen , par défaut : rcParams["axes.formatter.use_mathtext"](par défaut : False)

S'il faut utiliser un formatage mathématique sophistiqué. Voir set_useMathText.

useLocale booléen , par défaut : rcParams["axes.formatter.use_locale"](par défaut : False).

Indique s'il faut utiliser les paramètres régionaux pour le signe décimal et le signe positif. Voir set_useLocale.

Remarques

En plus des paramètres ci-dessus, le formatage de la représentation scientifique par rapport à la représentation en virgule flottante peut être configuré via set_scientific et set_powerlimits).

Notation décalée et notation scientifique

La notation décalée et la notation scientifique se ressemblent à première vue. Les deux séparent certaines informations des valeurs de graduation formatées et les affichent à la fin de l'axe.

• La notation scientifique divise l'ordre de grandeur, c'est-à-dire un facteur d'échelle multiplicatif, par exemple 1e6.

• La notation offset sépare une constante additive, par exemple +1e6. L'étiquette de notation de décalage est toujours précédée d'un signe +ou -et se distingue ainsi de l'étiquette d'ordre de grandeur.

Le graphique suivant avec des limites x 1_000_000pour 1_000_010illustrer les différentes mises en forme. Notez les étiquettes sur le bord droit de l'axe x.

( Code source , png )

format_data ( valeur )

Renvoie la représentation sous forme de chaîne complète de la valeur avec la position non spécifiée.

format_data_short ( valeur )

Renvoie une version courte de la chaîne de caractères de la valeur du tick.

Par défaut, la valeur longue indépendante de la position.

get_offset ( )

Renvoie la notation scientifique, plus le décalage.

get_useLocale ( )

Indique si les paramètres régionaux sont utilisés pour le formatage.

Voir également

ScalarFormatter.set_useLocale

get_useMathText ( )

Retourne s'il faut utiliser un formatage mathématique sophistiqué.

Voir également

ScalarFormatter.set_useMathText

get_useOffset ( )

Renvoie si le mode automatique pour la notation de décalage est actif.

Cela renvoie True si set_useOffset(True); il renvoie False si un décalage explicite a été défini, par exemple set_useOffset(1000).

Voir également

ScalarFormatter.set_useOffset

set_locs ( locs )

Définissez les emplacements des tiques.

Cette méthode est appelée avant de calculer les étiquettes de ticks car certains formateurs ont besoin de connaître tous les emplacements de ticks pour le faire.

set_powerlimits ( lims )

Définissez des seuils de taille pour la notation scientifique.

Paramètres :

lims (entier, entier)

Un tuple (min_exp, max_exp) contenant les puissances de 10 qui déterminent le seuil de basculement. Pour un nombre représentable par \(a \times 10^\mathrm{exp}\)avec\(1 <= |a| < 10\), la notation scientifique sera utilisée si ou .exp <= min_expexp >= max_exp

Les limites par défaut sont contrôlées par rcParams["axes.formatter.limits"](par défaut : ).[-5, 6]

En particulier les nombres avec exp égal aux seuils sont écrits en notation scientifique.

Typiquement, min_exp sera négatif et max_exp sera positif.

Par exemple, fournira la mise en forme suivante : formatter.set_powerlimits((-3, 4))\(1 \times 10^{-3}, 9.9 \times 10^{-3}, 0.01,\) \(9999, 1 \times 10^4\).

Voir également

ScalarFormatter.set_scientific

set_scientific ( b )

Activez ou désactivez la notation scientifique.

Voir également

ScalarFormatter.set_powerlimits

set_useLocale ( val )

Définissez s'il faut utiliser les paramètres régionaux pour le signe décimal et le signe positif.

Paramètres :

val booléen ou Aucun

Aucun réinitialise à rcParams["axes.formatter.use_locale"](par défaut : False).

set_useMathText ( val )

Indiquez si vous souhaitez utiliser un formatage mathématique sophistiqué.

Si elle est active, la notation scientifique est formatée comme\(1.2 \times 10^3\).

Paramètres :

val booléen ou Aucun

Aucun réinitialise à rcParams["axes.formatter.use_mathtext"](par défaut : False).

set_useOffset ( val )

Définissez s'il faut utiliser la notation de décalage.

Lors du formatage d'un ensemble de nombres dont la valeur est grande par rapport à leur plage, le formateur peut séparer une constante additive. Cela peut raccourcir les nombres formatés afin qu'ils soient moins susceptibles de se chevaucher lorsqu'ils sont dessinés sur un axe.

Paramètres :

val booléen ou flottant

• Si False, n'utilisez pas la notation de décalage.

• Si True (= mode automatique), utilisez la notation offset si elle peut raccourcir considérablement les nombres résiduels. Le comportement exact est contrôlé par rcParams["axes.formatter.offset_threshold"](par défaut : 4).

• S'il s'agit d'un nombre, force un décalage de la valeur donnée.

Exemples

Avec la notation offset active, les valeurs

100_000, 100_002, 100_004, 100_006, 100_008

sera formaté comme plus un offset , qui est écrit sur le bord de l'axe.0, 2, 4, 6, 8+1e5

propriété useLocale

Indique si les paramètres régionaux sont utilisés pour le formatage.

Voir également

ScalarFormatter.set_useLocale

propriété useMathText

Retourne s'il faut utiliser un formatage mathématique sophistiqué.

Voir également

ScalarFormatter.set_useMathText

propriété useOffset

Renvoie si le mode automatique pour la notation de décalage est actif.

Cela renvoie True si set_useOffset(True); il renvoie False si un décalage explicite a été défini, par exemple set_useOffset(1000).

Voir également

ScalarFormatter.set_useOffset

classe matplotlib.ticker. StrMethodFormatter ( fmt )

Socles :Formatter

Utilisez une chaîne de format de style nouveau (telle qu'utilisée par str.format) pour formater la coche.

Le champ utilisé pour la valeur du tick doit être étiqueté x et le champ utilisé pour la position du tick doit être étiqueté pos .

classe matplotlib.ticker. SymmetricalLogLocator ( transform = None , subs = None , linthresh = None , base = None )

Socles :Locator

Déterminez les emplacements des graduations pour les axes de journal symétriques.

Paramètres :

transformer SymmetricalLogTransform, facultatif

S'il est défini, définit la base et le linthresh de la transformation symlog.

base, flotteur de lin, en option

La base et le linthresh de la transformation symlog, comme documenté pour SymmetricalLogScale. Ces paramètres ne sont utilisés que si transform n'est pas défini.

sous- séquence de float, par défaut : [1]

Les multiples de puissances entières de la base où les graduations sont placées, c'est-à-dire, les graduations sont placées à .[sub * base**i for i in ... for sub in subs]

Remarques

Soit transform , soit base et linthresh , doivent être donnés.

set_params ( subs = None , numticks = None )

Définissez les paramètres dans ce localisateur.

tick_values ​​( vmin , vmax )

Renvoie les valeurs des ticks localisés donnés vmin et vmax .

Noter

Pour obtenir les emplacements des ticks avec les valeurs vmin et vmax définies automatiquement pour l'associé, axisappelez simplement l'instance Locator :

>>> print(type(loc))
<type 'Locator'>
>>> print(loc())
[1, 2, 3, 4]

view_limits ( vmin , vmax )

Essayez de choisir intelligemment les limites de la vue.

classe matplotlib.ticker. TickHelper

Socles :object

axe = Aucun

create_dummy_axis ( ** kwargs )

set_axis ( axe )

set_bounds ( vmin , vmax )

[ Obsolète ]

Remarques

Obsolète depuis la version 3.5 : utilisez Axis.set_view_intervalet Axis.set_data_intervalà la place.

set_data_interval ( vmin , vmax )

[ Obsolète ]

Remarques

Obsolète depuis la version 3.5 : utilisez à la Axis.set_data_intervalplace.

set_view_interval ( vmin , vmax )

[ Obsolète ]

Remarques

Obsolète depuis la version 3.5 : utilisez à la Axis.set_view_intervalplace.