`matplotlib.dates`#

Matplotlib proporciona capacidades sofisticadas de trazado de fechas, apoyadas en python datetimey el módulo adicional dateutil .

De forma predeterminada, Matplotlib utiliza la maquinaria de unidades descrita en unitspara convertir datetime.datetimey numpy.datetime64 objetos cuando se trazan en un eje x o y. El usuario no necesita hacer nada para formatear las fechas, pero las fechas a menudo tienen necesidades estrictas de formato, por lo que este módulo proporciona muchos formateadores y localizadores de ejes. Un ejemplo básico usando numpy.datetime64es:

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)

Ver también

Formato de fecha Matplotlib #

Matplotlib representa fechas utilizando números de coma flotante que especifican la cantidad de días desde una época predeterminada de 1970-01-01 UTC; por ejemplo, 1970-01-01, 06:00 es el número de punto flotante 0,25. Los formateadores y localizadores requieren el uso de datetime.datetimeobjetos, por lo que solo se pueden representar fechas entre el año 0001 y 9999. La precisión de microsegundos se puede lograr durante (aproximadamente) 70 años en cualquier lado de la época, y 20 microsegundos para el resto del rango de fechas permitido (año 0001 a 9999). La época se puede cambiar en el momento de la importación a través de dates.set_epochoa rcParams["dates.epoch"]otras fechas si es necesario; ver Precisión de fecha y épocas para una discusión.

Nota

Antes de Matplotlib 3.3, la época era 0000-12-31, que perdía la precisión moderna de microsegundos y también convertía el límite de eje predeterminado de 0 en una fecha y hora no válida. En 3.3, la época se cambió como se indica arriba. Para convertir viejos flotadores ordinales a la nueva época, los usuarios pueden hacer lo siguiente:

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

Hay una serie de funciones auxiliares para convertir entre datetime objetos y fechas de Matplotlib:

`datestr2num`	Convierta una cadena de fecha en un número de fecha usando `dateutil.parser.parse`.
`date2num`	Convierta objetos de fecha y hora en fechas de Matplotlib.
`num2date`	Convierta las fechas de Matplotlib en `datetime`objetos.
`num2timedelta`	Convierta el número de días en un `timedelta`objeto.
`drange`	Devuelve una secuencia de fechas de Matplotlib igualmente espaciadas.
`set_epoch`	Establezca la época (origen de las fechas) para los cálculos de fecha y hora.
`get_epoch`	Obtener la época utilizada por `dates`.

Nota

Al igual que Python datetime.datetime, Matplotlib usa el calendario gregoriano para todas las conversiones entre fechas y números de coma flotante. Esta práctica no es universal, y las diferencias de calendario pueden causar diferencias confusas entre lo que dan Python y Matplotlib como el número de días desde el 01-01-0001 y lo que dan otros programas y bases de datos. Por ejemplo, el Observatorio Naval de EE. UU. usa un calendario que cambia de juliano a gregoriano en octubre de 1582. Por lo tanto, usando su calculadora, el número de días entre 0001-01-01 y 2006-04-01 es 732403, mientras que usando el gregoriano calendario a través del módulo de fecha y hora encontramos:

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

Todos los convertidores de fechas, tickers y formateadores de Matplotlib son conscientes de la zona horaria. Si no se proporciona una zona horaria explícita, se asume rcParams["timezone"](predeterminado: ), proporcionada como una cadena. 'UTC'Si desea utilizar una zona horaria diferente, pase el argumento de la palabra clave tznum2date a cualquier indicador de fecha o localizador que cree. Puede ser una datetime.tzinfoinstancia o una cadena con el nombre de la zona horaria que puede analizar gettz.

En este módulo se proporciona una amplia gama de formateadores y localizadores de marca de fecha de uso específico y general. Consulte matplotlib.tickerpara obtener información general sobre localizadores de ticks y formateadores. Estos se describen a continuación.

El módulo dateutil proporciona código adicional para manejar el tictac de la fecha, lo que facilita la colocación de tictac en cualquier tipo de fecha. Vea los ejemplos a continuación.

Marcadores de fecha #

La mayoría de los teletipos de fecha pueden ubicar valores únicos o múltiples. Por ejemplo:

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

Además, la mayoría de los constructores toman un argumento de intervalo:

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

El localizador de reglas permite un marcado de fechas completamente general:

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

Los tickers de fecha disponibles son:

MicrosecondLocator: Localiza microsegundos.
SecondLocator: Localiza los segundos.
MinuteLocator: Localizar minutos.
HourLocator: Localizar horas.
DayLocator: Localice los días especificados del mes.
WeekdayLocator: Localice los días de la semana, por ejemplo, MO, TU.
MonthLocator: Localice los meses, por ejemplo, 7 para julio.
YearLocator: Ubica años que sean múltiplos de la base.
RRuleLocator: Ubique usando un rrulewrapper. rrulewrapperes un contenedor simple alrededor de dateutil dateutil.rrule que permite especificaciones de marca de fecha casi arbitrarias. Ver ejemplo de regla .
AutoDateLocator: en la escala automática, esta clase elige lo mejor DateLocator (p. ej., RRuleLocator) para establecer los límites de vista y las ubicaciones de marca. Si se llama con interval_multiples=Trueél, hará que los ticks se alineen con múltiplos sensibles de los intervalos de ticks. Por ejemplo, si el intervalo es de 4 horas, seleccionará las horas 0, 4, 8, etc. como ticks. Este comportamiento no está garantizado de forma predeterminada.

Formateadores de fecha #

Los formateadores de fecha disponibles son:

AutoDateFormatter: intenta descubrir el mejor formato a utilizar. Esto es más útil cuando se usa con AutoDateLocator.
ConciseDateFormatter: también intenta descubrir el mejor formato para usar y hacer que el formato sea lo más compacto posible sin dejar de tener información de fecha completa. Esto es más útil cuando se usa con AutoDateLocator.
DateFormatter: usa strftimecadenas de formato.

clase matplotlib.fechas. AutoDateFormatter ( locator , tz = Ninguno , defaultfmt = '%Y-%m-%d' , * , usetex = Ninguno ) [fuente] #

Bases:Formatter

A Formatterque intenta averiguar el mejor formato a utilizar. Esto es más útil cuando se usa con AutoDateLocator.

AutoDateFormattertiene un .scalediccionario que asigna escalas de ticks (el intervalo en días entre un tick principal) para formatear cadenas; este diccionario por defecto es

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

El formateador utiliza la cadena de formato correspondiente a la clave más baja del diccionario que es mayor o igual a la escala actual. Las entradas del diccionario se pueden personalizar:

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

También se pueden usar llamadas personalizadas en lugar de cadenas de formato. El siguiente ejemplo muestra cómo usar una función de formato personalizado para eliminar los ceros finales de los segundos decimales y agrega la fecha a la primera etiqueta de verificación:

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

Autoformatear las etiquetas de fecha.

Parámetros :

locadorticker.Locator: Localizador que este eje está utilizando.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.
cadena fmt por defecto: El formato predeterminado que se usará si ninguno de los valores self.scaled es mayor que la unidad devuelta por locator._get_unit().
usetex bool, predeterminado: rcParams["text.usetex"](predeterminado: False): Para habilitar/deshabilitar el uso del modo matemático de TeX para representar los resultados del formateador. Si alguna de las entradas self.scaledse establece como funciones, depende de la función personalizada habilitar o deshabilitar el modo matemático de TeX.

clase matplotlib.fechas. AutoDateLocator ( tz = Ninguno , minticks = 5 , maxticks = Ninguno , interval_multiples = True ) [fuente] #

Bases:DateLocator

En la escala automática, esta clase elige lo mejor DateLocatorpara establecer los límites de vista y las ubicaciones de marca.

Atributos :

dictado a intervalos

Mapeo de frecuencias de ticks a múltiplos permitidos para ese ticking. El valor predeterminado es

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

donde las claves se definen en dateutil.rrule.

El intervalo se usa para especificar los múltiplos que son apropiados para la frecuencia del tictac. Por ejemplo, cada 7 días es sensato para los ticks diarios, pero para minutos/segundos, 15 o 30 tienen sentido.

Al personalizar, solo debe modificar los valores de las claves existentes. No debe agregar o eliminar entradas.

Ejemplo para forzar ticks cada 3 horas:

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

Parámetros :

tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.
minticks int: El número mínimo de ticks deseado; controla si los ticks ocurren anualmente, mensualmente, etc.
maxticks int: El número máximo de ticks deseado; controla el intervalo entre ticks (marcando cada dos, cada 3, etc.). Para un control detallado, esto puede ser un diccionario que asigna constantes de frecuencia de reglas individuales (ANUAL, MENSUAL, etc.) a su propio número máximo de marcas. Esto se puede usar para mantener el número de marcas apropiado para el formato elegido en AutoDateFormatter. Cualquier frecuencia no especificada en este diccionario recibe un valor predeterminado.
interval_multiples bool, predeterminado: Verdadero: Si los ticks deben elegirse para que sean múltiplos del intervalo, bloqueándolos en ubicaciones "más agradables". Por ejemplo, esto forzará que los ticks estén en las horas 0, 6, 12, 18 cuando el ticking por hora se realiza en intervalos de 6 horas.

get_locator ( dmin , dmax ) [fuente] #: Elija el mejor localizador en función de la distancia.

no singular ( vmin , vmax ) [fuente] #: Dada la extensión superior e inferior propuesta, ajuste el rango si está demasiado cerca de ser singular (es decir, un rango de ~0).

tick_values ( vmin , vmax ) [fuente] #

Devuelve los valores de los ticks ubicados dados vmin y vmax .

Nota

Para obtener ubicaciones de ticks con los valores vmin y vmax definidos automáticamente para el asociado, axissimplemente llame a la instancia de Locator:

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

clase matplotlib.fechas. ConciseDateConverter ( formatos = Ninguno , zero_formats = Ninguno , offset_formats = Ninguno , show_offset = True , * , interval_multiples = True ) [fuente] #

Bases:DateConverter

axisinfo ( unidad , eje ) [fuente] #

Devuelve la unidadAxisInfo for .

unit es una instancia de tzinfo o None. El argumento del eje es obligatorio pero no se utiliza.

clase matplotlib.fechas. ConciseDateFormatter ( locator , tz = Ninguno , formatos = Ninguno , offset_formats = Ninguno , zero_formats = Ninguno , show_offset = True , * , usetex = Ninguno ) [fuente] #

Bases:Formatter

A Formatterque intenta descubrir el mejor formato para usar para la fecha y hacerlo lo más compacto posible, pero aún así completo. Esto es más útil cuando se usa con AutoDateLocator:

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

Parámetros :

locadorticker.Locator

Localizador que este eje está utilizando.

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

Marca la zona horaria, pasada a dates.num2date.

lista de formatos de 6 cadenas, opcional

Cadenas de formato para 6 niveles de etiquetado de ticks: principalmente años, meses, días, horas, minutos y segundos. Las cadenas usan los mismos códigos de formato que strftime. El valor predeterminado es ['%Y', '%b', '%d', '%H:%M', '%H:%M', '%S.%f']

lista zero_formats de 6 cadenas, opcional

Cadenas de formato para etiquetas de marca que son "ceros" para un nivel de marca dado. Por ejemplo, si la mayoría de los ticks son meses, los ticks alrededor del 1 de enero de 2005 se etiquetarán como "diciembre", "2005", "febrero". El valor predeterminado es ['', '%Y', '%b', '%b-%d', '%H:%M', '%H:%M']

lista de offset_formats de 6 cadenas, opcional

Cadenas de formato para los 6 niveles que se aplican a la cadena de "desplazamiento" que se encuentra en el lado derecho de un eje x o en la parte superior de un eje y. Combinado con las etiquetas de marca, esto debería especificar completamente la fecha. El valor predeterminado es:

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

show_offset booleano , predeterminado: Verdadero

Ya sea para mostrar el desplazamiento o no.

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

Para habilitar/deshabilitar el uso del modo matemático de TeX para representar los resultados del formateador.

Ejemplos

Ver Formateo de marcas de fecha usando ConciseDateFormatter

( Código fuente , png )

Autoformatear las etiquetas de fecha. El formato predeterminado se usa para formar una cadena inicial y luego se eliminan los elementos redundantes.

format_data_short ( valor ) [fuente] #

Devuelve una versión de cadena corta del valor de marca.

El valor predeterminado es el valor largo independiente de la posición.

format_ticks ( valores ) [fuente] #: Devuelve las etiquetas de ticks para todos los ticks a la vez.

get_offset ( ) [fuente] #

clase matplotlib.fechas. DateConverter ( * , interval_multiples = True ) [fuente] #

Bases:ConversionInterface

Convertidor para datos datetime.datey datetime.datetime, o para datos de fecha/hora representados como serían convertidos por date2num.

La etiqueta de 'unidad' para dichos datos es Ninguno o una instancia de tzinfo.

axisinfo ( unidad , eje ) [fuente] #

Devuelve la unidadAxisInfo for .

unit es una instancia de tzinfo o None. El argumento del eje es obligatorio pero no se utiliza.

conversión estática ( valor , unidad , eje ) [fuente] #

Si el valor aún no es un número o una secuencia de números, conviértalo con date2num.

Los argumentos de unidad y eje no se utilizan.

unidades predeterminadas estáticas ( x , eje ) [fuente] #: Devuelve la instancia tzinfo de x o de su primer elemento, o Ninguno

clase matplotlib.fechas. DateFormatter ( fmt , tz = Ninguno , * , usetex = Ninguno ) [fuente] #

Bases:Formatter

Formatee un tick (en días desde la época) con una strftimecadena de formato.

Parámetros :

calle fmt: strftimecadena de formato
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.
usetex bool, predeterminado: rcParams["text.usetex"](predeterminado: False): Para habilitar/deshabilitar el uso del modo matemático de TeX para representar los resultados del formateador.

set_tzinfo ( tz ) [fuente] #

clase matplotlib.fechas. DateLocator ( tz = Ninguno ) [fuente] #

Bases:Locator

Determina las ubicaciones de las marcas al trazar fechas.

Esta clase es una subclase de otros localizadores y no está pensada para usarse sola.

Parámetros :

tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

datalim_to_dt ( ) [fuente] #: Convierta el intervalo de datos del eje en objetos de fecha y hora.

hms0d = {'porhora': 0, 'por minuto': 0, 'por segundo': 0} #

no singular ( vmin , vmax ) [fuente] #: Dada la extensión superior e inferior propuesta, ajuste el rango si está demasiado cerca de ser singular (es decir, un rango de ~0).

set_tzinfo ( tz ) [fuente] #

Establecer información de zona horaria.

Parámetros :

tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

viewlim_to_dt ( ) [fuente] #: Convierta el intervalo de visualización en objetos de fecha y hora.

clase matplotlib.fechas. DayLocator ( bymonthday = Ninguno , intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Marque las apariciones de cada día del mes. Por ejemplo, 1, 15, 30.

Parámetros :

bymonthday int o lista de int, predeterminado: todos los días: Se marcarán todos los días de bymonthday . El valor predeterminado es , es decir, todos los días del mes.bymonthday=range(1, 32)
intervalo int, predeterminado: 1: El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

clase matplotlib.fechas. HourLocator ( porhora = Ninguno , intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Marca las ocurrencias de cada hora.

Parámetros :

byhour int o lista de int, por defecto: todas las horas: Las marcas se colocarán cada hora por hora . El valor predeterminado es byhour=range(24), es decir, cada hora.
intervalo int, predeterminado: 1: El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

clase matplotlib.fechas. Localizador de microsegundos ( intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:DateLocator

Haga ticks en intervalos regulares de uno o más microsegundos.

Nota

De forma predeterminada, Matplotlib utiliza una representación de punto flotante del tiempo en días desde la época, por lo que trazar datos con una resolución de tiempo de microsegundos no funciona bien para fechas que están lejos (alrededor de 70 años) de la época (compruébelo con get_epoch).

Si desea gráficos de tiempo de resolución de submicrosegundos, se recomienda encarecidamente utilizar segundos de punto flotante, no una representación de tiempo similar a la fecha y hora.

Si realmente debe usar datetime.datetime() o similar y aún necesita una precisión de microsegundos, cambie el origen del tiempo dates.set_epocha algo más cercano a las fechas que se están trazando. Consulte Precisión de fechas y épocas .

Parámetros :

intervalo int, predeterminado: 1: El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

set_axis ( eje ) [fuente] #

set_data_interval ( vmin , vmax ) [fuente] #

[ Obsoleto ]

notas

En desuso desde la versión 3.5: Usar Axis.set_data_intervalen su lugar.

set_view_interval ( vmin , vmax ) [fuente] #

[ Obsoleto ]

notas

En desuso desde la versión 3.5: Usar Axis.set_view_intervalen su lugar.

tick_values ( vmin , vmax ) [fuente] #

Devuelve los valores de los ticks ubicados dados vmin y vmax .

Nota

Para obtener ubicaciones de ticks con los valores vmin y vmax definidos automáticamente para el asociado, axissimplemente llame a la instancia de Locator:

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

clase matplotlib.fechas. MinuteLocator ( byminute = Ninguno , intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Marca las ocurrencias de cada minuto.

Parámetros :

byminute int o lista de int, por defecto: todos los minutos: Las marcas se colocarán en cada minuto en byminutes . El valor predeterminado es byminute=range(60), es decir, cada minuto.
intervalo int, predeterminado: 1: El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

clase matplotlib.fechas. LocalizadorMes ( bymonth = Ninguno , bymonthday = 1 , intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Marque las ocurrencias de cada mes, por ejemplo, 1, 3, 12.

Parámetros :

bymonth int o lista de int, por defecto: todos los meses: Las marcas se colocarán en cada mes en bymonth . El valor predeterminado es , es decir, todos los meses.range(1, 13)
bymonthday int, predeterminado: 1: El día en el que colocar las garrapatas.
intervalo int, predeterminado: 1: El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

clase matplotlib.fechas. RRuleLocator ( o , tz = Ninguno ) [fuente] #

Bases:DateLocator

Parámetros :

tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

static get_unit_generic ( frecuencia ) [fuente] #

tick_values ( vmin , vmax ) [fuente] #

Devuelve los valores de los ticks ubicados dados vmin y vmax .

Nota

Para obtener ubicaciones de ticks con los valores vmin y vmax definidos automáticamente para el asociado, axissimplemente llame a la instancia de Locator:

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

clase matplotlib.fechas. SecondLocator ( por segundo = Ninguno , intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Marca las ocurrencias de cada segundo.

Parámetros :

por segundo int o lista de int, por defecto: todos los segundos: Las marcas se colocarán en cada segundo por segundo . El valor predeterminado es , es decir, cada segundo.bysecond = range(60)
intervalo int, predeterminado: 1: El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

clase matplotlib.fechas. WeekdayLocator ( byweekday = 1 , intervalo = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Marque las apariciones de cada día de la semana.

Parámetros :

byweekday int o lista de int, predeterminado: todos los días

Las marcas se colocarán todos los días de la semana en byweekday . El valor predeterminado es todos los días.

Los elementos de byweekday deben ser uno de MO, TU, WE, TH, FR, SA, SU, las constantes de dateutil.rrule, que se han importado al espacio de matplotlib.datesnombres.

intervalo int, predeterminado: 1

El intervalo entre cada iteración. Por ejemplo, si interval=2, marque cada segunda ocurrencia.

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

Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

clase matplotlib.fechas. YearLocator ( base = 1 , mes = 1 , día = 1 , tz = Ninguno ) [fuente] #

Bases:RRuleLocator

Haga ticks en un día determinado de cada año que sea un múltiplo de la base.

Ejemplos:

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

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

Parámetros :

base int, por defecto: 1: Marque las garrapatas cada año base .
mes entero, por defecto: 1: El mes en el que colocar las marcas, a partir del 1. El valor predeterminado es enero.
día entero, predeterminado: 1: El día en el que colocar las garrapatas.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Marca la zona horaria. Si es una cadena, tz se pasa a dateutil.tz.

matplotlib.fechas. date2num ( d ) [fuente] #

Convierta objetos de fecha y hora en fechas de Matplotlib.

Parámetros :

d datetime.datetimeo numpy.datetime64o secuencias de estos

Devoluciones :

flotador o secuencia de flotadores: Número de días desde la época. Consulte get_epochla época, que se puede cambiar mediante rcParams["date.epoch"](predeterminado: '1970-01-01T00:00:00') o set_epoch. Si la época es "1970-01-01T00:00:00" (predeterminado), entonces el mediodía del 1 de enero de 1970 ("1970-01-01T12:00:00") devuelve 0,5.

notas

Se asume el calendario gregoriano; esta no es una práctica universal. Para obtener más información, consulte la cadena de documentación del módulo.

matplotlib.fechas. datestr2num ( d , predeterminado = Ninguno ) [fuente] #

Convierta una cadena de fecha en un número de fecha usando dateutil.parser.parse.

Parámetros :

d str o secuencia de str: Las fechas para convertir.
fecha y hora por defecto . fecha y hora, opcional: La fecha predeterminada para usar cuando faltan campos en d .

matplotlib.fechas. drange ( dstart , dend , delta ) [fuente] #

Devuelve una secuencia de fechas de Matplotlib igualmente espaciadas.

Las fechas comienzan en dstart y llegan hasta, pero sin incluir dend . Están espaciados por delta .

Parámetros :

empezar, terminardatetime: Los límites de fecha.
deltadatetime.timedelta: Espaciamiento de las fechas.

Devoluciones :

numpy.array: Una lista flotante representa las fechas de Matplotlib.

matplotlib.fechas. epoch2num ( e ) [fuente] #

[ Obsoleto ] Convierta el tiempo de UNIX en días desde la época de Matplotlib.

Parámetros :

e lista de carrozas: Tiempo en segundos desde 1970-01-01.

Devoluciones :

numpy.array: Tiempo en días desde la época de Matplotlib (ver get_epoch()).

notas

En desuso desde la versión 3.5: utilice los tipos o numpy.datetime64 en su lugar.[date2num(datetime.utcfromtimestamp(t)) for t in e]

matplotlib.fechas. get_epoch ( ) [fuente] #

Obtener la época utilizada por dates.

Devoluciones :

calle de época: Cadena para la época (parsable por numpy.datetime64).

matplotlib.fechas. num2date ( x , tz = Ninguno ) [fuente] #

Convierta las fechas de Matplotlib en datetimeobjetos.

Parámetros :

x float o secuencia de floats: Número de días (la parte fraccionaria representa horas, minutos, segundos) desde la época. Consulte get_epochla época, que se puede cambiar mediante rcParams["date.epoch"](predeterminado: '1970-01-01T00:00:00') o set_epoch.
tz str o tzinfo, predeterminado: rcParams["timezone"](predeterminado: 'UTC'): Zona horaria de x . Si es una cadena, tz se pasa a dateutil.tz.

Devoluciones :

datetimeo secuencia dedatetime

Las fechas se devuelven en la zona horaria tz .

Si x es una secuencia, datetimese devolverá una secuencia de objetos.

notas

Se asume el calendario gregoriano; esta no es una práctica universal. Para obtener más información, consulte la cadena de documentación del módulo.

matplotlib.fechas. num2epoch ( d ) [fuente] #

[ Obsoleto ] Convierta los días desde la época de Matplotlib a la hora de UNIX.

Parámetros :

d lista de flotadores: Tiempo en días desde la época de Matplotlib (ver get_epoch()).

Devoluciones :

numpy.array: Tiempo en segundos desde 1970-01-01.

notas

En desuso desde la versión 3.5: Usar num2date(e).timestamp()en su lugar.

matplotlib.fechas. num2timedelta ( x ) [fuente] #

Convierta el número de días en un timedeltaobjeto.

Si x es una secuencia, timedeltase devolverá una secuencia de objetos.

Parámetros :

x flotador, secuencia de flotadores: Número de días. La parte fraccionaria representa horas, minutos, segundos.

Devoluciones :

datetime.timedeltao lista[ datetime.timedelta]

clase matplotlib.fechas. relativdelta ( dt1 = Ninguno , dt2 = Ninguno , años = 0 , meses = 0 , días = 0 , días bisiestos = 0 , semanas = 0 , horas = 0 , minutos = 0 , segundos = 0 , microsegundos = 0 , año = Ninguno , mes= Ninguno , día = Ninguno , día de la semana = Ninguno , día del año = Ninguno , ndía del año = Ninguno , hora = Ninguno , minuto = Ninguno , segundo = Ninguno , microsegundo = Ninguno )#

Bases:object

El tipo relativedelta está diseñado para aplicarse a una fecha y hora existente y puede reemplazar componentes específicos de esa fecha y hora, o representar un intervalo de tiempo.

Se basa en la especificación del excelente trabajo realizado por M.-A. Lemburg en su extensión mx.DateTime . Sin embargo, tenga en cuenta que este tipo NO implementa el mismo algoritmo que su trabajo. NO espere que se comporte como la contraparte de mx.DateTime .

Hay dos formas diferentes de construir una instancia derelativadelta. El primero es pasarle dos clases de fecha/fechahora:

relativedelta(datetime1, datetime2)

El segundo es pasarle cualquier número de los siguientes argumentos de palabras clave:

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.

Hay formas relativas y absolutas de los argumentos de palabras clave. El plural es relativo y el singular es absoluto. Para cada argumento en el orden siguiente, primero se aplica la forma absoluta (al establecer cada atributo en ese valor) y luego la forma relativa (al agregar el valor al atributo).

El orden de los atributos que se consideran cuando se agrega este delta relativo a una fecha y hora es:

Año
Mes
Día
Horas
Minutos
Segundos
Microsegundos

Finalmente, se aplica el día de la semana, utilizando la regla descrita anteriormente.

Por ejemplo

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

Primero se pone el día 1 (el primero del mes), luego se le suman 25 horas, para llegar al 2° día y 14° hora, finalmente se aplica el día de la semana, pero como el 2 ya es lunes no hay efecto .

normalizado ( ) #

Devuelve una versión de este objeto representada completamente usando valores enteros para los atributos relativos.

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

Devoluciones :: Devuelve un dateutil.relativedelta.relativedeltaobjeto.

propiedad semanas #

clase matplotlib.fechas. rrulewrapper ( frecuencia , tzinfo = Ninguno , ** kwargs ) [fuente] #

Bases:object

Un envoltorio simple que dateutil.rrulepermite especificaciones de marca de fecha flexibles.

Parámetros :

frecuencia {ANUAL, MENSUAL, SEMANAL, DIARIA, HORA, MINUTAMENTE, SEGUNDAMENTE}: Frecuencia de marca. Estas constantes se definen en dateutil.rrule, pero también son accesibles desde matplotlib.dates.
tzinfo datetime.tzinfo, opcional: Información de la zona horaria. El valor predeterminado es Ninguno.
**kwargs: Los argumentos de palabra clave adicionales se pasan al dateutil.rrule.

conjunto ( ** kwargs ) [fuente] #: Establecer parámetros para un contenedor existente.

matplotlib.fechas. set_epoch ( época ) [fuente] #

Establezca la época (origen de las fechas) para los cálculos de fecha y hora.

La época predeterminada es rcParams["dates.epoch"](por defecto 1970-01-01T00:00).

Si se desea una precisión de microsegundos, la fecha que se grafica debe estar dentro de aproximadamente 70 años de la época. Matplotlib representa internamente las fechas como días desde la época, por lo que el rango dinámico de punto flotante debe estar dentro de un factor de 2^52.

set_epochdebe llamarse antes de que se conviertan las fechas (es decir, cerca de la sección de importación) o se generará un RuntimeError.

Consulte también Precisión de fechas y épocas .

Parámetros :

calle de época: fecha UTC válida analizable por numpy.datetime64(no incluir zona horaria).

matplotlib.dates#

Formato de fecha Matplotlib #

Marcadores de fecha #

Formateadores de fecha #

`matplotlib.dates`#