`matplotlib.dates`#

Matplotlib fornisce sofisticate funzionalità di tracciamento della data, in piedi sulle spalle di python datetimee del modulo aggiuntivo dateutil .

Per impostazione predefinita, Matplotlib utilizza i macchinari delle unità descritti in unitsper convertire datetime.datetimee numpy.datetime64 gli oggetti quando vengono tracciati su un asse x o y. L'utente non deve fare nulla per la formattazione delle date, ma le date spesso hanno esigenze di formattazione rigorose, quindi questo modulo fornisce molti localizzatori e formattatori di assi. Un esempio di base che utilizza numpy.datetime64è:

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)

Guarda anche

Formato data Matplotlib #

Matplotlib rappresenta le date utilizzando numeri in virgola mobile che specificano il numero di giorni da un'epoca predefinita di 1970-01-01 UTC; ad esempio, 1970-01-01, 06:00 è il numero in virgola mobile 0,25. I formattatori e i localizzatori richiedono l'uso di datetime.datetimeoggetti, quindi possono essere rappresentate solo le date comprese tra l'anno 0001 e 9999. La precisione al microsecondo è ottenibile per (circa) 70 anni su entrambi i lati dell'epoca e 20 microsecondi per il resto dell'intervallo di date consentito (dall'anno 0001 al 9999). L'epoca può essere modificata al momento dell'importazione tramite dates.set_epocho rcParams["dates.epoch"]in altre date se necessario; vedi Date Precision and Epochs per una discussione.

Nota

Prima di Matplotlib 3.3, l'epoca era 0000-12-31 che perdeva la moderna precisione dei microsecondi e rendeva anche il limite dell'asse predefinito di 0 un datetime non valido. In 3.3 l'epoca è stata cambiata come sopra. Per convertire i vecchi float ordinali nella nuova epoca, gli utenti possono fare:

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

Esistono numerose funzioni di supporto da convertire tra datetime oggetti e date Matplotlib:

`datestr2num`	Converti una stringa di data in un datenum usando `dateutil.parser.parse`.
`date2num`	Converti oggetti datetime in date Matplotlib.
`num2date`	Converti le date Matplotlib in `datetime`oggetti.
`num2timedelta`	Converti il numero di giorni in un `timedelta`oggetto.
`drange`	Restituisce una sequenza di date Matplotlib equidistanti.
`set_epoch`	Impostare l'epoca (origine per le date) per i calcoli datetime.
`get_epoch`	Ottieni l'epoca usata da `dates`.

Nota

Come Python datetime.datetime, Matplotlib utilizza il calendario gregoriano per tutte le conversioni tra date e numeri in virgola mobile. Questa pratica non è universale e le differenze di calendario possono causare differenze confuse tra ciò che Python e Matplotlib danno come numero di giorni dal 0001-01-01 e ciò che producono altri software e database. Ad esempio, l'Osservatorio navale degli Stati Uniti utilizza un calendario che passa da giuliano a gregoriano nell'ottobre 1582. Quindi, utilizzando il loro calcolatore, il numero di giorni tra 0001-01-01 e 2006-04-01 è 732403, mentre utilizzando il gregoriano calendar tramite il modulo datetime troviamo:

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

Tutti i convertitori di data, ticker e formattatori di Matplotlib sono a conoscenza del fuso orario. Se non viene fornito alcun fuso orario esplicito, si assume rcParams["timezone"](default: 'UTC'), fornito come stringa. Se desideri utilizzare un fuso orario diverso, passa l' argomento della parola chiave tznum2date a qualsiasi ticker di data o localizzatore che crei. Può essere datetime.tzinfoun'istanza o una stringa con il nome del fuso orario che può essere analizzato da gettz.

In questo modulo viene fornita un'ampia gamma di localizzatori e formattatori di tick di data specifici e generici. Vedere matplotlib.tickerper informazioni generali su tick locator e formattatori. Questi sono descritti di seguito.

Il modulo dateutil fornisce codice aggiuntivo per gestire il ticchettio della data, semplificando l'inserimento di segni di spunta su qualsiasi tipo di data. Vedere gli esempi di seguito.

Ticker data #

La maggior parte dei ticker di data può individuare valori singoli o multipli. Per esempio:

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

Inoltre, la maggior parte dei costruttori accetta un argomento intervallo:

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

Il localizzatore di regole consente il ticking della data completamente generale:

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

I ticker di data disponibili sono:

MicrosecondLocator: Individua i microsecondi.
SecondLocator: Localizza i secondi.
MinuteLocator: individuare i minuti.
HourLocator: individuare gli orari.
DayLocator: Individua i giorni del mese specificati.
WeekdayLocator: Individua i giorni della settimana, ad es. MO, TU.
MonthLocator: Individua i mesi, ad esempio 7 per luglio.
YearLocator: Individua gli anni che sono multipli della base.
RRuleLocator: individuare utilizzando un file rrulewrapper. rrulewrapperè un semplice wrapper attorno a dateutil che dateutil.rrule consente specifiche di tick di data quasi arbitrarie. Vedi l'esempio di regola .
AutoDateLocator: su scalabilità automatica, questa classe sceglie il migliore DateLocator (ad es. RRuleLocator) per impostare i limiti di visualizzazione e le posizioni dei tick. Se chiamato con interval_multiples=Trueesso, i tick si allineeranno con multipli sensibili degli intervalli di tick. Ad esempio, se l'intervallo è di 4 ore, sceglierà le ore 0, 4, 8, ecc. come tick. Questo comportamento non è garantito per impostazione predefinita.

Formattatori di data #

I formati di data disponibili sono:

AutoDateFormatter: tenta di capire il formato migliore da utilizzare. Questo è molto utile se usato con AutoDateLocator.
ConciseDateFormatter: tenta anche di capire il formato migliore da utilizzare e di renderlo il più compatto possibile pur avendo informazioni complete sulla data. Questo è molto utile se usato con AutoDateLocator.
DateFormatter: usa strftimele stringhe di formato.

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

Basi:Formatter

A Formatterche tenta di capire il formato migliore da utilizzare. Questo è molto utile se usato con AutoDateLocator.

AutoDateFormatterha un .scaledizionario che mappa le scale dei tick (l'intervallo in giorni tra un tick principale) per formattare le stringhe; l'impostazione predefinita di questo dizionario è

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'],
}

Il formattatore utilizza la stringa di formato corrispondente alla chiave più bassa nel dizionario che è maggiore o uguale alla scala corrente. Le voci del dizionario possono essere personalizzate:

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

È inoltre possibile utilizzare callable personalizzati al posto delle stringhe di formato. L'esempio seguente mostra come utilizzare una funzione di formato personalizzata per rimuovere gli zeri finali dai secondi decimali e aggiunge la data alla prima etichetta di spunta:

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

Formatta automaticamente le etichette della data.

Parametri :

localizzatoreticker.Locator: Localizzatore utilizzato da questo asse.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.
defaultfmt str: Il formato predefinito da utilizzare se nessuno dei valori in self.scaled è maggiore dell'unità restituita da locator._get_unit().
usetex bool, predefinito: rcParams["text.usetex"](predefinito: False): Per abilitare/disabilitare l'uso della modalità matematica di TeX per il rendering dei risultati del formattatore. Se alcune voci self.scaledsono impostate come funzioni, spetta alla funzione personalizzata abilitare o disabilitare la modalità matematica di TeX stessa.

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

Basi:DateLocator

Nella scalabilità automatica, questa classe sceglie il meglio DateLocatorper impostare i limiti di visualizzazione e le posizioni dei tick.

Attributi :

dict intervallato

Mappatura delle frequenze di tick su multipli consentiti per quel ticking. L'impostazione predefinita è

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],
}

dove le chiavi sono definite in dateutil.rrule.

L'intervallo viene utilizzato per specificare i multipli appropriati per la frequenza del ticchettio. Ad esempio, ogni 7 giorni è ragionevole per i tick giornalieri, ma per minuti/secondi hanno senso 15 o 30.

Durante la personalizzazione, è necessario modificare solo i valori per le chiavi esistenti. Non dovresti aggiungere o eliminare voci.

Esempio per forzare tick ogni 3 ore:

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

Parametri :

tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.
menta int: Il numero minimo di tick desiderati; controlla se i tick si verificano annualmente, mensilmente, ecc.
maxticks int: Il numero massimo di tick desiderati; controlla l'intervallo tra i tick (ticchetti ogni due, ogni 3, ecc.). Per un controllo a grana fine, questo può essere un dizionario che mappa le singole costanti di frequenza delle regole (YEARLY, MONTHLY, ecc.) al proprio numero massimo di tick. Questo può essere utilizzato per mantenere il numero di tick appropriato al formato scelto in AutoDateFormatter. A qualsiasi frequenza non specificata in questo dizionario viene assegnato un valore predefinito.
interval_multiples bool, default: True: Se i tick devono essere scelti per essere multipli dell'intervallo, bloccandoli in posizioni "più belle". Ad esempio, questo forzerà i tick ad essere alle ore 0, 6, 12, 18 quando il tick orario viene eseguito a intervalli di 6 ore.

get_locator ( dmin , dmax ) [fonte] #: Scegli il miglior localizzatore in base alla distanza.

non singolare ( vmin , vmax ) [fonte] #: Data l'estensione superiore e inferiore proposta, regolare l'intervallo se è troppo vicino all'essere singolare (ad es. un intervallo di ~0).

tick_values ( vmin , vmax ) [fonte] #

Restituisce i valori dei tick individuati dati vmin e vmax .

Nota

Per ottenere le posizioni dei tick con i valori vmin e vmax definiti automaticamente per gli associati, axisbasta chiamare l'istanza 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 ) [fonte] #

Basi:DateConverter

axisinfo ( unità , asse ) [fonte] #

Restituisce l' unitàAxisInfo for .

unit è un'istanza tzinfo o None. L' argomento axis è obbligatorio ma non utilizzato.

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

Basi:Formatter

A Formatterche tenta di capire il formato migliore da utilizzare per la data e di renderlo il più compatto possibile, ma comunque completo. Questo è molto utile se usato con AutoDateLocator:

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

Parametri :

localizzatoreticker.Locator

Localizzatore utilizzato da questo asse.

tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC')

Spunta il fuso orario, passato a dates.num2date.

formati elenco di 6 stringhe, facoltativo

Stringhe di formato per 6 livelli di etichettatura tick: principalmente anni, mesi, giorni, ore, minuti e secondi. Le stringhe utilizzano gli stessi codici di formato di strftime. L'impostazione predefinita è ['%Y', '%b', '%d', '%H:%M', '%H:%M', '%S.%f']

zero_formats lista di 6 stringhe, opzionale

Formatta le stringhe per le etichette dei tick che sono "zero" per un determinato livello di tick. Ad esempio, se la maggior parte dei tick sono mesi, i tick intorno al 1 gennaio 2005 saranno etichettati come "Dec", "2005", "Feb". L'impostazione predefinita è ['', '%Y', '%b', '%b-%d', '%H:%M', '%H:%M']

offset_formats elenco di 6 stringhe, facoltativo

Formatta le stringhe per i 6 livelli che vengono applicate alla stringa "offset" che si trova sul lato destro dell'asse x o sopra l'asse y. In combinazione con le etichette dei segni di spunta, questo dovrebbe specificare completamente la data. L'impostazione predefinita è:

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

show_offset bool, predefinito: vero

Se mostrare o meno l'offset.

usetex bool, predefinito: rcParams["text.usetex"](predefinito: False)

Per abilitare/disabilitare l'uso della modalità matematica di TeX per il rendering dei risultati del formattatore.

Esempi

Vedere Formattazione dei segni di spunta della data utilizzando ConciseDateFormatter

( Codice sorgente , png )

Formatta automaticamente le etichette della data. Il formato predefinito viene utilizzato per formare una stringa iniziale, quindi gli elementi ridondanti vengono rimossi.

format_data_short ( valore ) [fonte] #

Restituisce una versione stringa breve del valore tick.

L'impostazione predefinita è il valore long indipendente dalla posizione.

format_ticks ( valori ) [fonte] #: Restituisci le etichette dei tick per tutti i tick contemporaneamente.

get_offset ( ) [fonte] #

classe matplotlib.dates. DateConverter ( * , interval_multiples = True ) [fonte] #

Basi:ConversionInterface

Convertitore per datetime.datee datetime.datetimedati o per dati di data/ora rappresentati come verrebbero convertiti da date2num.

Il tag 'unit' per tali dati è None o un'istanza tzinfo.

axisinfo ( unità , asse ) [fonte] #

Restituisce l' unitàAxisInfo for .

unit è un'istanza tzinfo o None. L' argomento axis è obbligatorio ma non utilizzato.

conversione statica ( valore , unità , asse ) [fonte] #

Se il valore non è già un numero o una sequenza di numeri, convertilo con date2num.

Gli argomenti unità e asse non vengono utilizzati.

static default_units ( x , axis ) [fonte] #: Restituisce l'istanza tzinfo di x o del suo primo elemento, oppure None

classe matplotlib.dates. DateFormatter ( fmt , tz = None , * , usetex = None ) [fonte] #

Basi:Formatter

Formatta un segno di spunta (in giorni dall'epoca) con una strftimestringa di formato.

Parametri :

fm str: strftimestringa di formato
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.
usetex bool, predefinito: rcParams["text.usetex"](predefinito: False): Per abilitare/disabilitare l'uso della modalità matematica di TeX per il rendering dei risultati del formattatore.

set_tzinfo ( tz ) [fonte] #

classe matplotlib.dates. DateLocator ( tz = None ) [fonte] #

Basi:Locator

Determina le posizioni dei tick quando si tracciano le date.

Questa classe è una sottoclasse di altri Locator e non è pensata per essere utilizzata da sola.

Parametri :

tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

datalim_to_dt ( ) [fonte] #: Converti l'intervallo di dati dell'asse in oggetti datetime.

hms0d = {'per ora': 0, 'per minuto': 0, 'per secondo': 0} #

non singolare ( vmin , vmax ) [fonte] #: Data l'estensione superiore e inferiore proposta, regolare l'intervallo se è troppo vicino all'essere singolare (ad es. un intervallo di ~0).

set_tzinfo ( tz ) [fonte] #

Imposta le informazioni sul fuso orario.

Parametri :

tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

viewlim_to_dt ( ) [fonte] #: Converti l'intervallo di visualizzazione in oggetti datetime.

classe matplotlib.dates. DayLocator ( bymonthday = None , interval = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Fai segni di spunta sulle occorrenze di ogni giorno del mese. Ad esempio, 1, 15, 30.

Parametri :

bymonthday int o lista di int, default: tutti i giorni: I tick verranno inseriti ogni giorno in bymonthday . L' impostazione predefinita è , ovvero ogni giorno del mese.bymonthday=range(1, 32)
intervallo int, predefinito: 1: L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

classe matplotlib.dates. HourLocator ( byhour = None , interval = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Fai segni di spunta sulle occorrenze di ogni ora.

Parametri :

byhour int o lista di int, default: tutte le ore: I tick verranno inseriti ogni ora in byhour . L'impostazione predefinita è byhour=range(24), ovvero ogni ora.
intervallo int, predefinito: 1: L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

classe matplotlib.dates. MicrosecondLocator ( intervallo = 1 , tz = None ) [fonte] #

Basi:DateLocator

Effettua tick a intervalli regolari di uno o più microsecondi.

Nota

Per impostazione predefinita, Matplotlib utilizza una rappresentazione in virgola mobile del tempo in giorni dall'epoca, quindi tracciare i dati con una risoluzione temporale in microsecondi non funziona bene per le date che sono lontane (circa 70 anni) dall'epoca (controllare con get_epoch).

Se si desidera tracciare il tempo con una risoluzione inferiore al microsecondo, si consiglia vivamente di utilizzare secondi in virgola mobile, non una rappresentazione del tempo simile a datetime.

Se devi davvero usare datetime.datetime() o simili e hai ancora bisogno di una precisione di microsecondi, cambia l'origine dell'ora tramite dates.set_epochin qualcosa di più vicino alle date che vengono tracciate. Vedi Precisione della data ed epoche .

Parametri :

intervallo int, predefinito: 1: L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

set_axis ( axis ) [fonte] #

set_data_interval ( vmin , vmax ) [fonte] #

[ Deprecato ]

Appunti

Deprecato dalla versione 3.5: utilizzare Axis.set_data_intervalinvece.

set_view_interval ( vmin , vmax ) [fonte] #

[ Deprecato ]

Appunti

Deprecato dalla versione 3.5: utilizzare Axis.set_view_intervalinvece.

tick_values ( vmin , vmax ) [fonte] #

Restituisce i valori dei tick individuati dati vmin e vmax .

Nota

Per ottenere le posizioni dei tick con i valori vmin e vmax definiti automaticamente per gli associati, axisbasta chiamare l'istanza Locator:

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

classe matplotlib.dates. MinuteLocator ( byminute = None , interval = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Fai segni di spunta sulle occorrenze di ogni minuto.

Parametri :

byminute int o lista di int, default: tutti i minuti: I segni di spunta verranno posizionati su ogni minuto in byminutes . L'impostazione predefinita è byminute=range(60), ovvero ogni minuto.
intervallo int, predefinito: 1: L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

classe matplotlib.dates. MonthLocator ( bymonth = None , bymonthday = 1 , interval = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Spunta le occorrenze di ogni mese, ad esempio 1, 3, 12.

Parametri :

bymonth int o lista di int, default: tutti i mesi: I tick verranno inseriti ogni mese in bymonth . L'impostazione predefinita è , ovvero ogni mese.range(1, 13)
permesegiorno int, predefinito: 1: Il giorno in cui posizionare le zecche.
intervallo int, predefinito: 1: L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

classe matplotlib.dates. RRuleLocator ( o , tz = None ) [fonte] #

Basi:DateLocator

Parametri :

tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

static get_unit_generic ( freq ) [fonte] #

tick_values ( vmin , vmax ) [fonte] #

Restituisce i valori dei tick individuati dati vmin e vmax .

Nota

Per ottenere le posizioni dei tick con i valori vmin e vmax definiti automaticamente per gli associati, axisbasta chiamare l'istanza Locator:

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

classe matplotlib.dates. SecondLocator ( bysecond = None , interval = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Fai segni di spunta sulle occorrenze di ogni secondo.

Parametri :

bysecond int o lista di int, default: tutti i secondi: Le zecche verranno posizionate su ogni secondo in bysecond . L'impostazione predefinita è , ovvero ogni secondo.bysecond = range(60)
intervallo int, predefinito: 1: L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

classe matplotlib.dates. WeekdayLocator ( byweekday = 1 , interval = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Fai segni di spunta sulle occorrenze di ogni giorno della settimana.

Parametri :

byweekday int o lista di int, default: tutti i giorni

I tick verranno inseriti ogni giorno della settimana in byweekday . L'impostazione predefinita è tutti i giorni.

Gli elementi di byweekday devono essere uno di MO, TU, WE, TH, FR, SA, SU, le costanti da dateutil.rrule, che sono state importate nello spazio dei matplotlib.datesnomi.

intervallo int, predefinito: 1

L'intervallo tra ogni iterazione. Ad esempio, if interval=2, contrassegna ogni seconda occorrenza.

tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC')

Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

classe matplotlib.dates. YearLocator ( base = 1 , mese = 1 , giorno = 1 , tz = None ) [fonte] #

Basi:RRuleLocator

Effettua tick in un dato giorno di ogni anno che è un multiplo della base.

Esempi:

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

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

Parametri :

base int, predefinito: 1: Mark spunta ogni anno base .
mese int, predefinito: 1: Il mese su cui posizionare i tick, a partire dall'1. Di default è gennaio.
giorno int, predefinito: 1: Il giorno in cui posizionare le zecche.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Zecche fuso orario. Se una stringa, tz viene passato a dateutil.tz.

matplotlib.dates. date2num ( d ) [fonte] #

Converti oggetti datetime in date Matplotlib.

Parametri :

d datetime.datetimeo numpy.datetime64o sequenze di questi

Resi :

float o sequenza di float: Numero di giorni dall'epoca. Vedere get_epochper l'epoca, che può essere modificata da rcParams["date.epoch"](predefinito: '1970-01-01T00:00:00') o set_epoch. Se l'epoca è "1970-01-01T00:00:00" (impostazione predefinita), mezzogiorno 1 gennaio 1970 ("1970-01-01T12:00:00") restituisce 0,5.

Appunti

Si assume il calendario gregoriano; questa non è una pratica universale. Per i dettagli vedere la docstring del modulo.

matplotlib.dates. datestr2num ( d , default = Nessuno ) [fonte] #

Converti una stringa di data in un datenum usando dateutil.parser.parse.

Parametri :

d str o sequenza di str: Le date da convertire.
predefinito datetime.datetime, facoltativo: La data predefinita da utilizzare quando mancano i campi in d .

matplotlib.dates. drange ( dstart , dend , delta ) [fonte] #

Restituisce una sequenza di date Matplotlib equidistanti.

Le date iniziano da dstart e arrivano fino a, ma non includono dend . Sono distanziati da delta .

Parametri :

iniziare, terminaredatetime: I limiti di data.
deltadatetime.timedelta: Spaziatura delle date.

Resi :

numpy.array: Un elenco mobile che rappresenta le date di Matplotlib.

matplotlib.dates. epoca2num ( e ) [fonte] #

[ Deprecato ] Converti il tempo UNIX in giorni dall'epoca di Matplotlib.

Parametri :

e elenco dei galleggianti: Tempo in secondi dal 1970-01-01.

Resi :

numpy.array: Tempo in giorni dall'epoca di Matplotlib (vedi get_epoch()).

Appunti

Deprecato dalla versione 3.5: utilizzare invece i tipi o numpy.datetime64.[date2num(datetime.utcfromtimestamp(t)) for t in e]

matplotlib.dates. get_epoch ( ) [fonte] #

Ottieni l'epoca usata da dates.

Resi :

epoca str: Stringa per l'epoca (analizzabile da numpy.datetime64).

matplotlib.dates. num2date ( x , tz = Nessuno ) [fonte] #

Converti le date Matplotlib in datetimeoggetti.

Parametri :

x float o sequenza di float: Numero di giorni (la parte di frazione rappresenta ore, minuti, secondi) dall'epoca. Vedere get_epochper l'epoca, che può essere modificata da rcParams["date.epoch"](predefinito: '1970-01-01T00:00:00') o set_epoch.
tz str o tzinfo, predefinito: rcParams["timezone"](predefinito: 'UTC'): Fuso orario di x . Se una stringa, tz viene passato a dateutil.tz.

Resi :

datetimeo sequenza didatetime

Le date vengono restituite nel fuso orario tz .

Se x è una sequenza, datetimeverrà restituita una sequenza di oggetti.

Appunti

Si assume il calendario gregoriano; questa non è una pratica universale. Per i dettagli, vedere la docstring del modulo.

matplotlib.dates. num2epoca ( d ) [fonte] #

[ Deprecato ] Converti i giorni dall'epoca Matplotlib all'ora UNIX.

Parametri :

d elenco di float: Tempo in giorni dall'epoca di Matplotlib (vedi get_epoch()).

Resi :

numpy.array: Tempo in secondi dal 1970-01-01.

Appunti

Deprecato dalla versione 3.5: utilizzare num2date(e).timestamp()invece.

matplotlib.dates. num2timedelta ( x ) [fonte] #

Converti il numero di giorni in un timedeltaoggetto.

Se x è una sequenza, timedeltaverrà restituita una sequenza di oggetti.

Parametri :

x float, sequenza di float: Numero di giorni. La parte frazionaria rappresenta ore, minuti, secondi.

Resi :

datetime.timedeltao elenca[ datetime.timedelta]

classe matplotlib.dates. delta relativo ( dt1 = Nessuno , dt2 = Nessuno , anni = 0 , mesi = 0 , giorni = 0 , giorni bisestili = 0 , settimane = 0 , ore = 0 , minuti = 0 , secondi = 0 , microsecondi = 0 , anno = Nessuno , mese= Nessuno , giorno = Nessuno , giorno della settimana = Nessuno , giorno dell'anno = Nessuno , nlyearday = Nessuno , ora = Nessuno , minuto = Nessuno , secondo = Nessuno , microsecondo = Nessuno )#

Basi:object

Il tipo relativedelta è progettato per essere applicato a un datetime esistente e può sostituire componenti specifici di quel datetime o rappresentare un intervallo di tempo.

Si basa sulla specificazione dell'ottimo lavoro svolto da M.-A. Lemburg nella sua estensione mx.DateTime . Tuttavia, si noti che questo tipo NON implementa lo stesso algoritmo del suo lavoro. NON aspettarti che si comporti come la controparte di mx.DateTime .

Esistono due modi diversi per creare un'istanza relativedelta. Il primo lo sta passando due classi di data/data e ora:

relativedelta(datetime1, datetime2)

Il secondo è passargli un numero qualsiasi dei seguenti argomenti di parole chiave:

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.

Esistono forme relative e assolute degli argomenti delle parole chiave. Il plurale è relativo e il singolare è assoluto. Per ogni argomento nell'ordine seguente, viene applicata prima la forma assoluta (impostando ogni attributo a quel valore) e poi la forma relativa (aggiungendo il valore all'attributo).

L'ordine degli attributi considerati quando questo relativedelta viene aggiunto a un datetime è:

Anno
Mese
Giorno
Ore
Minuti
Secondi
Microsecondi

Infine, viene applicato il giorno della settimana, utilizzando la regola sopra descritta.

Per esempio

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

Prima si imposta il giorno a 1 (il primo del mese), poi si aggiungono 25 ore, per arrivare al 2° giorno e alla 14° ora, infine si applica il giorno della settimana, ma poiché il 2° è già un lunedì non si ha alcun effetto .

normalizzato ( ) #

Restituisce una versione di questo oggetto rappresentata interamente utilizzando valori interi per i relativi attributi.

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

Resi :: Restituisce un dateutil.relativedelta.relativedeltaoggetto.

settimane immobiliari #

classe matplotlib.dates. rrulewrapper ( freq , tzinfo = None , ** kwargs ) [fonte] #

Basi:object

Un semplice wrapper attorno a dateutil.rrulespecifiche di spunta di data flessibili che consentono.

Parametri :

freq {ANNUALE, MENSILE, SETTIMANALE, GIORNALIERO, ORARIO, MINUTO, SECONDARIO}: Frequenza del ticchettio. Queste costanti sono definite in dateutil.rrule, ma sono accessibili matplotlib.datesanche da.
tzinfo datetime.tzinfo, facoltativo: Informazioni sul fuso orario. L'impostazione predefinita è Nessuno.
**kwargs: Ulteriori argomenti di parole chiave vengono passati al file dateutil.rrule.

set ( ** kwargs ) [fonte] #: Imposta i parametri per un wrapper esistente.

matplotlib.dates. set_epoca ( epoca ) [fonte] #

Impostare l'epoca (origine per le date) per i calcoli datetime.

L'epoca predefinita è rcParams["dates.epoch"](per impostazione predefinita 1970-01-01T00:00).

Se si desidera una precisione al microsecondo, la data da tracciare deve essere entro circa 70 anni dall'epoca. Matplotlib rappresenta internamente le date come giorni dall'epoca, quindi l'intervallo dinamico in virgola mobile deve essere compreso in un fattore di 2^52.

set_epochdeve essere chiamato prima che qualsiasi data venga convertita (cioè vicino alla sezione di importazione) o verrà sollevato un RuntimeError.

Vedi anche Precisione della data ed Epoche .

Parametri :

epoca str: data UTC valida analizzabile per numpy.datetime64(non includere il fuso orario).

matplotlib.dates#

Formato data Matplotlib #

Ticker data #

Formattatori di data #

`matplotlib.dates`#