matplotlib.dates

Matplotlib fournit des capacités de traçage de date sophistiquées, reposant sur python datetimeet le module complémentaire dateutil .

Par défaut, Matplotlib utilise les machines d'unités décrites dans unitspour convertir datetime.datetimeet numpy.datetime64 les objets lorsqu'ils sont tracés sur un axe x ou y. L'utilisateur n'a rien à faire pour que les dates soient formatées, mais les dates ont souvent des besoins de formatage stricts, ce module fournit donc de nombreux localisateurs et formateurs d'axes. Un exemple de base utilisant numpy.datetime64est:

import numpy as np

times = np.arange(np.datetime64('2001-01-02'),
                  np.datetime64('2002-02-03'), np.timedelta64(75, 'm'))
y = np.random.randn(len(times))

fig, ax = plt.subplots()
ax.plot(times, y)

Voir également

• Étiquettes de coche de date

• Formatage des graduations de date à l'aide de ConciseDateFormatter

• Convertir la démo de date

Format de date Matplotlib

Matplotlib représente les dates à l'aide de nombres à virgule flottante spécifiant le nombre de jours depuis une époque par défaut de 1970-01-01 UTC ; par exemple, 1970-01-01, 06:00 est le nombre à virgule flottante 0,25. Les formateurs et les localisateurs nécessitent l'utilisation d' datetime.datetimeobjets, de sorte que seules les dates comprises entre 0001 et 9999 peuvent être représentées. Une précision à la microseconde est réalisable pendant (environ) 70 ans de part et d'autre de l'époque et 20 microsecondes pour le reste de la plage de dates autorisée (année 0001 à 9999). L'époque peut être modifiée au moment de l'importation via dates.set_epochou rcParams["dates.epoch"]à d'autres dates si nécessaire ; voir Précision de la date et époques pour une discussion.

Noter

Avant Matplotlib 3.3, l'époque était 0000-12-31, ce qui perdait la précision de la microseconde moderne et faisait également de la limite d'axe par défaut de 0 une date/heure invalide. Dans 3.3, l'époque a été modifiée comme ci-dessus. Pour convertir les anciens flottants ordinaux vers la nouvelle époque, les utilisateurs peuvent faire :

new_ordinal = old_ordinal + mdates.date2num(np.datetime64('0000-12-31'))

Il existe un certain nombre de fonctions d'assistance pour convertir entre datetime les objets et les dates Matplotlib :

datestr2num	Convertissez une chaîne de date en datenum en utilisant dateutil.parser.parse.
date2num	Convertissez les objets datetime en dates Matplotlib.
num2date	Convertissez les dates Matplotlib en datetimeobjets.
num2timedelta	Convertir le nombre de jours en timedeltaobjet.
drange	Renvoie une séquence de dates Matplotlib également espacées.
set_epoch	Définissez l'époque (origine des dates) pour les calculs datetime.
get_epoch	Obtenez l'époque utilisée par dates.

Noter

Comme Python datetime.datetime, Matplotlib utilise le calendrier grégorien pour toutes les conversions entre les dates et les nombres à virgule flottante. Cette pratique n'est pas universelle et les différences de calendrier peuvent entraîner des différences déroutantes entre ce que Python et Matplotlib donnent comme nombre de jours depuis le 01-01-0001 et ce que produisent les autres logiciels et bases de données. Par exemple, l'US Naval Observatory utilise un calendrier qui passe du julien au grégorien en octobre 1582. Ainsi, en utilisant leur calculatrice, le nombre de jours entre 0001-01-01 et 2006-04-01 est 732403, alors qu'en utilisant le grégorien calendrier via le module datetime on trouve :

In [1]: date(2006, 4, 1).toordinal() - date(1, 1, 1).toordinal()
Out[1]: 732401

Tous les convertisseurs de date Matplotlib, tickers et formateurs sont conscients du fuseau horaire. Si aucun fuseau horaire explicite n'est fourni, rcParams["timezone"](par défaut : 'UTC') est supposé, fourni sous forme de chaîne. Si vous souhaitez utiliser un fuseau horaire différent, transmettez l' argument du mot-clé tznum2date à tous les tickers ou localisateurs de date que vous créez. Il peut s'agir d'une datetime.tzinfoinstance ou d'une chaîne avec le nom du fuseau horaire qui peut être analysé par gettz.

Une large gamme de localisateurs et de formateurs de dates spécifiques et à usage général sont fournis dans ce module. Voir matplotlib.tickerpour des informations générales sur les localisateurs de ticks et les formateurs. Ceux-ci sont décrits ci-dessous.

Le module dateutil fournit un code supplémentaire pour gérer le tic-tac de date, ce qui facilite le placement de tiques sur n'importe quel type de date. Voir les exemples ci-dessous.

Symboles de date

La plupart des tickers de date peuvent localiser des valeurs uniques ou multiples. Par exemple:

# import constants for the days of the week
from matplotlib.dates import MO, TU, WE, TH, FR, SA, SU

# tick on mondays every week
loc = WeekdayLocator(byweekday=MO, tz=tz)

# tick on mondays and saturdays
loc = WeekdayLocator(byweekday=(MO, SA))

De plus, la plupart des constructeurs prennent un argument d'intervalle :

# tick on mondays every second week
loc = WeekdayLocator(byweekday=MO, interval=2)

Le localisateur de règles permet un tic-tac complètement général :

# tick every 5th easter
rule = rrulewrapper(YEARLY, byeaster=1, interval=5)
loc = RRuleLocator(rule)

Les tickers de date disponibles sont :

• MicrosecondLocator: Localisez les microsecondes.

• SecondLocator: Localisez les secondes.

• MinuteLocator: localiser les minutes.

• HourLocator: Localiser les heures.

• DayLocator: Localiser les jours spécifiés du mois.

• WeekdayLocator: Localisez les jours de la semaine, par exemple, MO, TU.

• MonthLocator: Localisez les mois, par exemple, 7 pour juillet.

• YearLocator: Repérez les années qui sont des multiples de la base.

• RRuleLocator: Localiser à l'aide d'un rrulewrapper. rrulewrapperest un simple wrapper autour de dateutildateutil.rrule qui permet des spécifications de tick de date presque arbitraires. Voir exemple de règle .

• AutoDateLocator: Sur l'échelle automatique, cette classe sélectionne le meilleur DateLocator (par exemple, RRuleLocator) pour définir les limites de vue et les emplacements des ticks. S'il est appelé avec interval_multiples=True, les ticks s'aligneront avec des multiples sensibles des intervalles de ticks. Par exemple, si l'intervalle est de 4 heures, il choisira les heures 0, 4, 8, etc. comme tiques. Ce comportement n'est pas garanti par défaut.

Formateurs de date

Les formateurs de date disponibles sont :

• AutoDateFormatter: tente de trouver le meilleur format à utiliser. Ceci est particulièrement utile lorsqu'il est utilisé avec le AutoDateLocator.

• ConciseDateFormatter: tente également de déterminer le meilleur format à utiliser et de rendre le format aussi compact que possible tout en conservant des informations de date complètes. Ceci est particulièrement utile lorsqu'il est utilisé avec le AutoDateLocator.

• DateFormatter: utilise strftimedes chaînes de format.

classe matplotlib.dates. AutoDateFormatter ( locator , tz = None , defaultfmt = '%Y-%m-%d' , * , usetex = None )

Socles :Formatter

A Formatterqui tente de trouver le meilleur format à utiliser. Ceci est particulièrement utile lorsqu'il est utilisé avec le AutoDateLocator.

AutoDateFormattera un .scaledictionnaire qui mappe les échelles de graduation (l'intervalle en jours entre une graduation majeure) pour formater les chaînes ; ce dictionnaire est par défaut

self.scaled = {
    DAYS_PER_YEAR: rcParams['date.autoformatter.year'],
    DAYS_PER_MONTH: rcParams['date.autoformatter.month'],
    1: rcParams['date.autoformatter.day'],
    1 / HOURS_PER_DAY: rcParams['date.autoformatter.hour'],
    1 / MINUTES_PER_DAY: rcParams['date.autoformatter.minute'],
    1 / SEC_PER_DAY: rcParams['date.autoformatter.second'],
    1 / MUSECONDS_PER_DAY: rcParams['date.autoformatter.microsecond'],
}

Le formateur utilise la chaîne de format correspondant à la clé la plus basse du dictionnaire qui est supérieure ou égale à l'échelle actuelle. Les entrées du dictionnaire peuvent être personnalisées :

locator = AutoDateLocator()
formatter = AutoDateFormatter(locator)
formatter.scaled[1/(24*60)] = '%M:%S' # only show min and sec

Les callables personnalisés peuvent également être utilisés à la place des chaînes de format. L'exemple suivant montre comment utiliser une fonction de format personnalisée pour supprimer les zéros de fin des secondes décimales et ajouter la date au premier ticklabel :

def my_format_function(x, pos=None):
    x = matplotlib.dates.num2date(x)
    if pos == 0:
        fmt = '%D %H:%M:%S.%f'
    else:
        fmt = '%H:%M:%S.%f'
    label = x.strftime(fmt)
    label = label.rstrip("0")
    label = label.rstrip(".")
    return label

formatter.scaled[1/(24*60)] = my_format_function

Formater automatiquement les étiquettes de date.

Paramètres :

localisateurticker.Locator

Localisateur utilisé par cet axe.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

chaîne fmt par défaut

Format par défaut à utiliser si aucune des valeurs de self.scaled n'est supérieure à l'unité renvoyée par locator._get_unit().

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 le rendu des résultats du formateur. Si des entrées self.scaledsont définies en tant que fonctions, il appartient à la fonction personnalisée d'activer ou de désactiver le mode mathématique de TeX lui-même.

classe matplotlib.dates. AutoDateLocator ( tz = None , minticks = 5 , maxticks = None , interval_multiples = True )

Socles :DateLocator

Sur la mise à l'échelle automatique, cette classe sélectionne le meilleur DateLocatorpour définir les limites de vue et les emplacements des ticks.

Attributs :

dict intervalle

Mappage des fréquences de tic aux multiples autorisés pour ce tic-tac. La valeur par défaut est

self.intervald = {
    YEARLY  : [1, 2, 4, 5, 10, 20, 40, 50, 100, 200, 400, 500,
               1000, 2000, 4000, 5000, 10000],
    MONTHLY : [1, 2, 3, 4, 6],
    DAILY   : [1, 2, 3, 7, 14, 21],
    HOURLY  : [1, 2, 3, 4, 6, 12],
    MINUTELY: [1, 5, 10, 15, 30],
    SECONDLY: [1, 5, 10, 15, 30],
    MICROSECONDLY: [1, 2, 5, 10, 20, 50, 100, 200, 500,
                    1000, 2000, 5000, 10000, 20000, 50000,
                    100000, 200000, 500000, 1000000],
}

où les clés sont définies dans dateutil.rrule.

L'intervalle est utilisé pour spécifier les multiples qui conviennent à la fréquence du ticking. Par exemple, tous les 7 jours est raisonnable pour les ticks quotidiens, mais pour les minutes/secondes, 15 ou 30 ont du sens.

Lors de la personnalisation, vous ne devez modifier que les valeurs des clés existantes. Vous ne devez pas ajouter ou supprimer des entrées.

Exemple pour forcer les ticks toutes les 3 heures :

locator = AutoDateLocator()
locator.intervald[HOURLY] = [3]  # only show every 3 hours

Paramètres :

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

minticks int

Le nombre minimum de ticks souhaités ; contrôle si les tiques se produisent annuellement, mensuellement, etc.

maxticks int

Le nombre maximum de ticks souhaités ; contrôle l'intervalle entre les ticks (tic-tac tous les deux, tous les 3, etc.). Pour un contrôle plus précis, il peut s'agir d'un dictionnaire mappant les constantes de fréquence des règles individuelles (ANNUEL, MENSUEL, etc.) à leur propre nombre maximum de ticks. Cela peut être utilisé pour conserver le nombre de graduations approprié au format choisi dans AutoDateFormatter. Toute fréquence non spécifiée dans ce dictionnaire reçoit une valeur par défaut.

interval_multiples bool, par défaut : True

Si les ticks doivent être choisis pour être multiples de l'intervalle, en les verrouillant à des emplacements "plus agréables". Par exemple, cela forcera les ticks à être aux heures 0, 6, 12, 18 lorsque le tick horaire est effectué à des intervalles de 6 heures.

get_locator ( dmin , dmax )

Choisissez le meilleur localisateur en fonction d'une distance.

non singulier ( vmin , vmax )

Compte tenu de l'étendue supérieure et inférieure proposée, ajustez la plage si elle est trop proche d'être singulière (c'est-à-dire une plage de ~0).

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.dates. ConciseDateConverter ( formats = None , zero_formats = None , offset_formats = None , show_offset = True , * , interval_multiples = True )

Socles :DateConverter

axisinfo ( unité , axe )

Renvoie l' unitéAxisInfo pour .

unit est une instance tzinfo ou None. L' argument d' axe est obligatoire mais non utilisé.

classe matplotlib.dates. ConciseDateFormatter ( locator , tz = None , formats = None , offset_formats = None , zero_formats = None , show_offset = True , * , usetex = None )

Socles :Formatter

A Formatterqui tente de déterminer le meilleur format à utiliser pour la date et de le rendre aussi compact que possible, mais toujours complet. Ceci est particulièrement utile lorsqu'il est utilisé avec AutoDateLocator:

>>> locator = AutoDateLocator()
>>> formatter = ConciseDateFormatter(locator)

Paramètres :

localisateurticker.Locator

Localisateur utilisé par cet axe.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire, passé à dates.num2date.

formats liste de 6 chaînes, facultatif

Formatez les chaînes pour 6 niveaux d'étiquetage des ticks : principalement des années, des mois, des jours, des heures, des minutes et des secondes. Les chaînes utilisent les mêmes codes de format que strftime. La valeur par défaut est ['%Y', '%b', '%d', '%H:%M', '%H:%M', '%S.%f']

zero_formats liste de 6 chaînes, facultative

Formater les chaînes pour les étiquettes de tick qui sont "zéros" pour un niveau de tick donné. Par exemple, si la plupart des ticks sont des mois, les ticks autour du 1er janvier 2005 seront étiquetés "Dec", "2005", "Feb". La valeur par défaut est ['', '%Y', '%b', '%b-%d', '%H:%M', '%H:%M']

offset_formats liste de 6 chaînes, facultative

Chaînes de format pour les 6 niveaux qui sont appliquées à la chaîne "offset" trouvée sur le côté droit d'un axe des x ou en haut d'un axe des y. Combiné avec les étiquettes de coche, cela devrait spécifier complètement la date. La valeur par défaut est :

['', '%Y', '%Y-%b', '%Y-%b-%d', '%Y-%b-%d', '%Y-%b-%d %H:%M']

show_offset booléen , par défaut : Vrai

Afficher ou non le décalage.

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 le rendu des résultats du formateur.

Exemples

Voir Mise en forme des graduations de date à l'aide de ConciseDateFormatter

( Code source , png )

Formater automatiquement les étiquettes de date. Le format par défaut est utilisé pour former une chaîne initiale, puis les éléments redondants sont supprimés.

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

classe matplotlib.dates. DateConverter ( * , interval_multiples = True )

Socles :ConversionInterface

Convertisseur pour les données datetime.dateet datetime.datetime, ou pour les données de date/heure représentées telles qu'elles seraient converties par date2num.

La balise 'unit' pour ces données est None ou une instance tzinfo.

axisinfo ( unité , axe )

Renvoie l' unitéAxisInfo pour .

unit est une instance tzinfo ou None. L' argument d' axe est obligatoire mais non utilisé.

conversion statique ( valeur , unité , axe )

Si la valeur n'est pas déjà un nombre ou une séquence de nombres, convertissez-la avec date2num.

Les arguments d'unité et d' axe ne sont pas utilisés.

static default_units ( x , axe )

Renvoie l'instance tzinfo de x ou de son premier élément, ou None

classe matplotlib.dates. DateFormatter ( fmt , tz = Aucun , * , usetex = Aucun )

Socles :Formatter

Formatez une coche (en jours depuis l'époque) avec une strftimechaîne de format.

Paramètres :

chaîne fmt

strftimeformater la chaîne

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

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 le rendu des résultats du formateur.

set_tzinfo ( tz )

classe matplotlib.dates. DateLocator ( tz = Aucun )

Socles :Locator

Détermine les emplacements des graduations lors du traçage des dates.

Cette classe est sous-classée par d'autres localisateurs et n'est pas destinée à être utilisée seule.

Paramètres :

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

datalim_to_dt ( )

Convertir l'intervalle de données d'axe en objets datetime.

hms0d = {'par heure' : 0, 'par minute' : 0, 'par seconde' : 0}

non singulier ( vmin , vmax )

Compte tenu de l'étendue supérieure et inférieure proposée, ajustez la plage si elle est trop proche d'être singulière (c'est-à-dire une plage de ~0).

set_tzinfo ( tz )

Définir les informations de fuseau horaire.

Paramètres :

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

viewlim_to_dt ( )

Convertissez l'intervalle de vue en objets datetime.

classe matplotlib.dates. DayLocator ( bymonthday = None , interval = 1 , tz = None )

Socles :RRuleLocator

Cochez les occurrences de chaque jour du mois. Par exemple, 1, 15, 30.

Paramètres :

bymonthday entier ou liste d'entiers, par défaut : tous les jours

Les tiques seront placées tous les jours de bymonthday . La valeur par défaut est , c'est-à-dire tous les jours du mois.bymonthday=range(1, 32)

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

classe matplotlib.dates. HourLocator ( byhour = None , interval = 1 , tz = None )

Socles :RRuleLocator

Cochez les occurrences de chaque heure.

Paramètres :

byhour entier ou liste d'entiers, par défaut : toutes les heures

Les tiques seront placées sur chaque heure de byhour . La valeur par défaut est byhour=range(24), c'est-à-dire toutes les heures.

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

classe matplotlib.dates. MicrosecondLocator ( intervalle = 1 , tz = Aucun )

Socles :DateLocator

Faire des ticks à intervalles réguliers d'une ou plusieurs microseconde(s).

Noter

Par défaut, Matplotlib utilise une représentation en virgule flottante du temps en jours depuis l'époque, donc le traçage des données avec une résolution temporelle en microsecondes ne fonctionne pas bien pour les dates éloignées (environ 70 ans) de l'époque (vérifier avec get_epoch).

Si vous souhaitez des tracés temporels de résolution inférieure à la microseconde, il est fortement recommandé d'utiliser des secondes à virgule flottante, et non une représentation temporelle de type datetime.

Si vous devez vraiment utiliser datetime.datetime() ou similaire et que vous avez toujours besoin d'une précision à la microseconde, modifiez l'origine de l'heure via dates.set_epochquelque chose de plus proche des dates tracées. Voir Précision de la date et Époques .

Paramètres :

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

set_axis ( axe )

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.

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.dates. MinuteLocator ( byminute = None , interval = 1 , tz = None )

Socles :RRuleLocator

Cochez les occurrences de chaque minute.

Paramètres :

byminute entier ou liste d'entiers, par défaut : toutes les minutes

Les ticks seront placés toutes les minutes en byminutes . La valeur par défaut est byminute=range(60), c'est-à-dire toutes les minutes.

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

classe matplotlib.dates. MonthLocator ( bymonth = None , bymonthday = 1 , interval = 1 , tz = None )

Socles :RRuleLocator

Cochez les occurrences de chaque mois, par exemple, 1, 3, 12.

Paramètres :

bymonth int ou liste d'entiers, par défaut : tous les mois

Les tiques seront placées chaque mois par mois . La valeur par défaut est , c'est-à-dire tous les mois.range(1, 13)

parmoisjour entier , par défaut : 1

Le jour où placer les tiques.

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

classe matplotlib.dates. RRuleLocator ( o , tz = Aucun )

Socles :DateLocator

Paramètres :

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

static get_unit_generic ( freq )

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.dates. SecondLocator ( bysecond = None , interval = 1 , tz = None )

Socles :RRuleLocator

Cochez les occurrences de chaque seconde.

Paramètres :

bysecond int ou liste d'entiers, par défaut : toutes les secondes

Les ticks seront placés sur chaque seconde en bysecond . La valeur par défaut est , c'est-à-dire toutes les secondes.bysecond = range(60)

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

classe matplotlib.dates. WeekdayLocator ( byweekday = 1 , interval = 1 , tz = None )

Socles :RRuleLocator

Cochez les occurrences de chaque jour de la semaine.

Paramètres :

byweekday entier ou liste d'entiers, par défaut : tous les jours

Les tiques seront placées chaque jour de la semaine dans byweekday . La valeur par défaut est tous les jours.

Les éléments de byweekday doivent être l'un des MO, TU, WE, TH, FR, SA, SU, les constantes de dateutil.rrule, qui ont été importées dans l' espace de matplotlib.datesnoms.

intervalle entier, par défaut : 1

L'intervalle entre chaque itération. Par exemple, si interval=2, marquez une occurrence sur deux.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

classe matplotlib.dates. YearLocator ( base = 1 , month = 1 , day = 1 , tz = None )

Socles :RRuleLocator

Faire des tiques un jour donné de chaque année qui est un multiple de la base.

Exemples:

# Tick every year on Jan 1st
locator = YearLocator()

# Tick every 5 years on July 4th
locator = YearLocator(5, month=7, day=4)

Paramètres :

entier de base , par défaut : 1

Mark coche toutes les années de base .

mois entier, par défaut : 1

Le mois sur lequel placer les ticks, à partir du 1. La valeur par défaut est janvier.

jour entier, par défaut : 1

Le jour où placer les tiques.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Cochez le fuseau horaire. S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

matplotlib.dates. date2num ( j )

Convertissez les objets datetime en dates Matplotlib.

Paramètres :

d datetime.datetimeou numpy.datetime64ou séquences de ces

Retours :

flotteur ou séquence de flotteurs

Nombre de jours depuis l'époque. Voir get_epochpour l'époque, qui peut être modifiée par rcParams["date.epoch"](par défaut : '1970-01-01T00:00:00') ou set_epoch. Si l'époque est "1970-01-01T00:00:00" (par défaut), alors midi 1er janvier 1970 ("1970-01-01T12:00:00") renvoie 0,5.

Remarques

Le calendrier grégorien est supposé ; ce n'est pas une pratique universelle. Pour plus de détails, consultez la docstring du module.

matplotlib.dates. datestr2num ( d , par défaut = Aucun )

Convertissez une chaîne de date en datenum en utilisant dateutil.parser.parse.

Paramètres :

d str ou séquence de str

Les dates à convertir.

datetime.datetime par défaut , facultatif

La date par défaut à utiliser lorsque des champs sont manquants dans d .

matplotlib.dates. drange ( dstart , dend , delta )

Renvoie une séquence de dates Matplotlib également espacées.

Les dates commencent à dstart et vont jusqu'à, mais sans inclure dend . Ils sont espacés par delta .

Paramètres :

commencer, finirdatetime

Les dates limites.

deltadatetime.timedelta

Espacement des dates.

Retours :

numpy.array

Une liste flotte représentant les dates Matplotlib.

matplotlib.dates. epoch2num ( e )

[ Obsolète ] Convertir l'heure UNIX en jours depuis l'époque Matplotlib.

Paramètres :

e liste des flotteurs

Temps en secondes depuis le 1970-01-01.

Retours :

numpy.array

Temps en jours depuis l'époque Matplotlib (voir get_epoch()).

Remarques

Obsolète depuis la version 3.5 : utilisez les types or numpy.datetime64 à la place.[date2num(datetime.utcfromtimestamp(t)) for t in e]

matplotlib.dates. get_epoch ( )

Obtenez l'époque utilisée par dates.

Retours :

époque str

Chaîne pour l'époque (analysable par numpy.datetime64).

matplotlib.dates. num2date ( x , tz = Aucun )

Convertissez les dates Matplotlib en datetimeobjets.

Paramètres :

x flottant ou séquence de flottants

Nombre de jours (la partie fractionnaire représente les heures, les minutes, les secondes) depuis l'époque. Voir get_epochpour l'époque, qui peut être modifiée par rcParams["date.epoch"](par défaut : '1970-01-01T00:00:00') ou set_epoch.

tz str ou tzinfo, par défaut : rcParams["timezone"](par défaut : 'UTC')

Fuseau horaire de x . S'il s'agit d'une chaîne, tz est passé à dateutil.tz.

Retours :

datetimeou suite dedatetime

Les dates sont renvoyées dans le fuseau horaire tz .

Si x est une séquence, une séquence d' datetimeobjets sera renvoyée.

Remarques

Le calendrier grégorien est supposé ; ce n'est pas une pratique universelle. Pour plus de détails, consultez la docstring du module.

matplotlib.dates. num2epoch ( d )

[ Obsolète ] Convertir les jours depuis l'époque Matplotlib en heure UNIX.

Paramètres :

d liste des flotteurs

Temps en jours depuis l'époque Matplotlib (voir get_epoch()).

Retours :

numpy.array

Temps en secondes depuis le 1970-01-01.

Remarques

Obsolète depuis la version 3.5 : utilisez à la num2date(e).timestamp()place.

matplotlib.dates. num2timedelta ( x )

Convertir le nombre de jours en timedeltaobjet.

Si x est une séquence, une séquence d' timedeltaobjets sera renvoyée.

Paramètres :

x float, suite de floats

Nombre de jours. La partie fractionnaire représente les heures, les minutes, les secondes.

Retours :

datetime.timedeltaou liste[ datetime.timedelta]

classe matplotlib.dates. relatifdelta ( dt1 = Aucun , dt2 = Aucun , années = 0 , mois = 0 , jours = 0 , jours bissextiles = 0 , semaines = 0 , heures = 0 , minutes = 0 , secondes = 0 , microsecondes = 0 , année = Aucun , mois= Aucun , jour = Aucun , jour de la semaine = Aucun , jour de l'année = Aucun , jour de l'année = Aucun , heure = Aucun , minute = Aucun , seconde = Aucun , microseconde = Aucun )

Socles :object

Le type relativedelta est conçu pour être appliqué à une date/heure existante et peut remplacer des composants spécifiques de cette date/heure ou représenter un intervalle de temps.

Il s'appuie sur le cahier des charges de l'excellent travail réalisé par M.-A. Lemburg dans son extension mx.DateTime . Cependant, notez que ce type n'implémente PAS le même algorithme que son travail. Ne vous attendez PAS à ce qu'il se comporte comme l'homologue de mx.DateTime.

Il existe deux manières différentes de créer une instance relativedelta. Le premier lui passe deux classes date/datetime :

relativedelta(datetime1, datetime2)

Le second lui passe n'importe quel nombre d'arguments de mots-clés suivants :

relativedelta(arg1=x,arg2=y,arg3=z...)

year, month, day, hour, minute, second, microsecond:
    Absolute information (argument is singular); adding or subtracting a
    relativedelta with absolute information does not perform an arithmetic
    operation, but rather REPLACES the corresponding value in the
    original datetime with the value(s) in relativedelta.

years, months, weeks, days, hours, minutes, seconds, microseconds:
    Relative information, may be negative (argument is plural); adding
    or subtracting a relativedelta with relative information performs
    the corresponding arithmetic operation on the original datetime value
    with the information in the relativedelta.

weekday: 
    One of the weekday instances (MO, TU, etc) available in the
    relativedelta module. These instances may receive a parameter N,
    specifying the Nth weekday, which could be positive or negative
    (like MO(+1) or MO(-2)). Not specifying it is the same as specifying
    +1. You can also use an integer, where 0=MO. This argument is always
    relative e.g. if the calculated date is already Monday, using MO(1)
    or MO(-1) won't change the day. To effectively make it absolute, use
    it in combination with the day argument (e.g. day=1, MO(1) for first
    Monday of the month).

leapdays:
    Will add given days to the date found, if year is a leap
    year, and the date found is post 28 of february.

yearday, nlyearday:
    Set the yearday or the non-leap year day (jump leap days).
    These are converted to day/month/leapdays information.

Il existe des formes relatives et absolues des arguments de mots-clés. Le pluriel est relatif et le singulier est absolu. Pour chaque argument dans l'ordre ci-dessous, la forme absolue est appliquée en premier (en définissant chaque attribut sur cette valeur) puis la forme relative (en ajoutant la valeur à l'attribut).

L'ordre des attributs pris en compte lorsque ce delta relatif est ajouté à une date/heure est :

1. An

2. Mois

3. Jour

4. Heures

5. Minutes

6. Secondes

7. Microsecondes

Enfin, le jour de la semaine est appliqué, en utilisant la règle décrite ci-dessus.

Par exemple

>>> from datetime import datetime
>>> from dateutil.relativedelta import relativedelta, MO
>>> dt = datetime(2018, 4, 9, 13, 37, 0)
>>> delta = relativedelta(hours=25, day=1, weekday=MO(1))
>>> dt + delta
datetime.datetime(2018, 4, 2, 14, 37)

Tout d'abord, le jour est mis à 1 (le premier du mois), puis 25 heures sont ajoutées, pour arriver au 2ème jour et 14ème heure, enfin le jour de la semaine est appliqué, mais comme le 2ème est déjà un lundi il n'y a aucun effet .

normalisé ( )

Renvoie une version de cet objet entièrement représentée à l'aide de valeurs entières pour les attributs relatifs.

>>> relativedelta(days=1.5, hours=2).normalized()
relativedelta(days=+1, hours=+14)

Retours :

Renvoie un dateutil.relativedelta.relativedeltaobjet.

semaines de propriété

classe matplotlib.dates. rrulewrapper ( freq , tzinfo = None , ** kwargs )

Socles :object

Un wrapper simple autour d'un dateutil.rrulecahier des charges de dates flexibles.

Paramètres :

freq {ANNUELLE, MENSUELLE, HEBDOMADAIRE, QUOTIDIENNE, HORAIRE, MINUTELLE, SECONDE}

Fréquence des tiques. Ces constantes sont définies dans dateutil.rrule, mais elles sont également accessibles depuis matplotlib.dates.

tzinfo datetime.tzinfo, facultatif

Informations sur le fuseau horaire. La valeur par défaut est Aucun.

**kwargs

Des arguments de mots clés supplémentaires sont passés au dateutil.rrule.

ensemble ( ** kwargs )

Définissez les paramètres d'un wrapper existant.

matplotlib.dates. set_epoch ( époque )

Définissez l'époque (origine des dates) pour les calculs datetime.

L'époque par défaut est rcParams["dates.epoch"](par défaut 1970-01-01T00:00).

Si une précision à la microseconde est souhaitée, la date tracée doit se situer à environ 70 ans de l'époque. Matplotlib représente en interne les dates en jours depuis l'époque, de sorte que la plage dynamique en virgule flottante doit être comprise dans un facteur de 2 ^ 52.

set_epochdoit être appelée avant que les dates ne soient converties (c'est-à-dire près de la section d'importation) ou une RuntimeError sera déclenchée.

Voir aussi Précision de la date et Époques .

Paramètres :

époque str

date UTC valide analysable par numpy.datetime64(ne pas inclure le fuseau horaire).