`matplotlib.dates`#

Matplotlib fornece recursos sofisticados de plotagem de datas, apoiados em python datetimee no módulo add-on dateutil .

Por padrão, o Matplotlib usa o maquinário de unidades descrito em unitspara converter datetime.datetimee numpy.datetime64 objetos quando plotados em um eixo x ou y. O usuário não precisa fazer nada para que as datas sejam formatadas, mas as datas geralmente têm necessidades de formatação estritas, portanto, este módulo fornece muitos localizadores de eixos e formatadores. Um exemplo básico de uso 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)

Veja também

Formato de data Matplotlib #

Matplotlib representa datas usando números de ponto flutuante especificando o número de dias desde uma época padrão de 01/01/1970 UTC; por exemplo, 1970-01-01, 06:00 é o número de ponto flutuante 0,25. Os formatadores e localizadores requerem o uso de datetime.datetimeobjetos, portanto, somente as datas entre os anos 0001 e 9999 podem ser representadas. A precisão de microssegundos é alcançável por (aproximadamente) 70 anos em cada lado da época e 20 microssegundos para o restante do intervalo permitido de datas (ano 0001 a 9999). A época pode ser alterada no momento da importação via dates.set_epochou rcParams["dates.epoch"]para outras datas se necessário; consulte Precisão de data e épocas para uma discussão.

Observação

Antes do Matplotlib 3.3, a época era 0000-12-31, que perdia a precisão moderna de microssegundos e também tornava o limite de eixo padrão de 0 uma data e hora inválida. Em 3.3, a época foi alterada como acima. Para converter floats ordinais antigos para a nova época, os usuários podem fazer:

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

Há várias funções auxiliares para converter entre datetime objetos e datas do Matplotlib:

`datestr2num`	Converta uma string de data em um datenum usando `dateutil.parser.parse`.
`date2num`	Converta objetos datetime em datas Matplotlib.
`num2date`	Converta datas Matplotlib em `datetime`objetos.
`num2timedelta`	Converta o número de dias em um `timedelta`objeto.
`drange`	Retorna uma sequência de datas Matplotlib igualmente espaçadas.
`set_epoch`	Defina a época (origem das datas) para cálculos de data e hora.
`get_epoch`	Obtenha a época usada por `dates`.

Observação

Como o do Python datetime.datetime, o Matplotlib usa o calendário gregoriano para todas as conversões entre datas e números de ponto flutuante. Essa prática não é universal, e as diferenças de calendário podem causar diferenças confusas entre o que o Python e o Matplotlib fornecem como o número de dias desde 0001-01-01 e o que outros softwares e bancos de dados fornecem. Por exemplo, o Observatório Naval dos EUA usa um calendário que muda de juliano para gregoriano em outubro de 1582. Portanto, usando sua calculadora, o número de dias entre 01-01-0001 e 01-04-2006 é 732403, enquanto que usando o calendário gregoriano calendar através do módulo datetime encontramos:

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

Todos os conversores de data, tickers e formatadores do Matplotlib estão cientes do fuso horário. Se nenhum fuso horário explícito for fornecido, rcParams["timezone"](padrão: 'UTC') será assumido, fornecido como uma string. Se você quiser usar um fuso horário diferente, passe o argumento de palavra-chave tznum2date para qualquer marcador de data ou localizador que você criar. Isso pode ser uma datetime.tzinfoinstância ou uma string com o nome do fuso horário que pode ser analisado por gettz.

Uma ampla variedade de localizadores e formatadores de marcações de data específicos e de uso geral são fornecidos neste módulo. Consulte matplotlib.tickerpara obter informações gerais sobre localizadores de ticks e formatadores. Estes são descritos abaixo.

O módulo dateutil fornece código adicional para lidar com marcações de datas, facilitando a colocação de marcações em qualquer tipo de data. Veja exemplos abaixo.

Marcadores de data #

A maioria dos tickers de data pode localizar valores únicos ou múltiplos. Por exemplo:

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

Além disso, a maioria dos construtores usa um argumento de intervalo:

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

O localizador de regras permite marcações de datas completamente gerais:

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

Os tickers de data disponíveis são:

MicrosecondLocator: Localize microssegundos.
SecondLocator: Localizar segundos.
MinuteLocator: Localizar minutos.
HourLocator: Localizar horas.
DayLocator: Localize os dias especificados do mês.
WeekdayLocator: Localize os dias da semana, por exemplo, MO, TU.
MonthLocator: Localize os meses, por exemplo, 7 para julho.
YearLocator: Localize anos que são múltiplos de base.
RRuleLocator: Localize usando um arquivo rrulewrapper. rrulewrapperé um wrapper simples em torno de dateutil 's dateutil.rrule que permite especificações de marcação de data quase arbitrárias. Veja exemplo de regra .
AutoDateLocator: na autoescala, esta classe escolhe o melhor DateLocator (por exemplo, RRuleLocator) para definir os limites de exibição e os locais de marcação. Se chamado com interval_multiples=Trueele, fará com que os ticks se alinhem com múltiplos sensatos dos intervalos de ticks. Por exemplo, se o intervalo for de 4 horas, ele selecionará as horas 0, 4, 8 etc. como marcações. Esse comportamento não é garantido por padrão.

Formatadores de data #

Os formatadores de data disponíveis são:

AutoDateFormatter: tenta descobrir o melhor formato a ser usado. Isso é mais útil quando usado com o AutoDateLocator.
ConciseDateFormatter: também tenta descobrir o melhor formato a ser usado e torná-lo o mais compacto possível, mantendo as informações de data completas. Isso é mais útil quando usado com o AutoDateLocator.
DateFormatter: use strftimestrings de formato.

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

Bases:Formatter

A Formatterque tenta descobrir o melhor formato para usar. Isso é mais útil quando usado com o AutoDateLocator.

AutoDateFormattertem um .scaledicionário que mapeia escalas de ticks (o intervalo em dias entre um tick principal) para formatar strings; este dicionário tem como padrão

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

O formatador usa a string de formato correspondente à chave mais baixa no dicionário que é maior ou igual à escala atual. As entradas do dicionário podem ser personalizadas:

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

Callables personalizados também podem ser usados em vez de strings de formato. O exemplo a seguir mostra como usar uma função de formato personalizado para retirar os zeros à direita dos segundos decimais e adicionar a data ao primeiro marcador:

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

Formate automaticamente os rótulos de data.

Parâmetros :

localizadorticker.Locator: Localizador que este eixo está usando.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.
defaultfmt str: O formato padrão a ser usado se nenhum dos valores self.scaled for maior que a unidade retornada por locator._get_unit().
usetex bool, padrão: rcParams["text.usetex"](padrão: False): Habilitar/desabilitar o uso do modo matemático do TeX para renderizar os resultados do formatador. Se quaisquer entradas self.scaledforem definidas como funções, caberá à função personalizada habilitar ou desabilitar o próprio modo matemático do TeX.

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

Bases:DateLocator

No dimensionamento automático, essa classe escolhe o melhor DateLocatorpara definir os limites de exibição e os locais de marcação.

Atributos :

ditado intervalado

O mapeamento de frequências de ticks para múltiplos permitiu esse tique-taque. O padrão é

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

onde as chaves são definidas em dateutil.rrule.

O intervalo é usado para especificar múltiplos que são apropriados para a frequência do tique-taque. Por exemplo, a cada 7 dias é sensato para ticks diários, mas para minutos/segundos, 15 ou 30 fazem sentido.

Ao personalizar, você deve modificar apenas os valores das chaves existentes. Você não deve adicionar ou excluir entradas.

Exemplo para forçar ticks a cada 3 horas:

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

Parâmetros :

tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.
minticks int: O número mínimo de ticks desejado; controla se os ticks ocorrem anualmente, mensalmente, etc.
maxticks int: O número máximo de ticks desejado; controla o intervalo entre os tiques (marcando uns aos outros, a cada 3, etc.). Para controle refinado, pode ser um dicionário mapeando constantes de frequência de regra individual (ANUAL, MENSAL, etc.) para seu próprio número máximo de tiques. Isso pode ser usado para manter o número de ticks adequado ao formato escolhido em AutoDateFormatter. Qualquer frequência não especificada neste dicionário recebe um valor padrão.
interval_multiples bool, padrão: True: Se os ticks devem ser escolhidos para serem múltiplos do intervalo, bloqueando-os em locais 'melhores'. Por exemplo, isso forçará os tiques a estarem nas horas 0, 6, 12, 18 quando o tique-taque horário for feito em intervalos de 6 horas.

get_locator ( dmin , dmax ) [fonte] #: Escolha o melhor localizador com base na distância.

não singular ( vmin , vmax ) [fonte] #: Dada a extensão superior e inferior proposta, ajuste o intervalo se estiver muito próximo de ser singular (ou seja, um intervalo de ~0).

tick_values ( vmin , vmax ) [fonte] #

Retorne os valores dos ticks localizados dados vmin e vmax .

Observação

Para obter as localizações dos ticks com os valores vmin e vmax definidos automaticamente para o associado, axisbasta chamar a instância Locator:

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

classe matplotlib.dates. ConciseDateConverter ( formatos = Nenhum , zero_formats = Nenhum , offset_formats = Nenhum , show_offset = Verdadeiro , * , intervalo_multiples = Verdadeiro ) [fonte] #

Bases:DateConverter

axisinfo ( unidade , eixo ) [fonte] #

Retorne AxisInfopara a unidade .

unit é uma instância tzinfo ou None. O argumento do eixo é obrigatório, mas não é usado.

classe matplotlib.dates. ConciseDateFormatter ( localizador , tz = Nenhum , formatos = Nenhum , offset_formats = Nenhum , zero_formats = Nenhum , show_offset = True , * , usetex = Nenhum ) [source] #

Bases:Formatter

Um Formatterque tenta descobrir o melhor formato a ser usado para a data e torná-lo o mais compacto possível, mas ainda assim completo. Isso é mais útil quando usado com AutoDateLocator:

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

Parâmetros :

localizadorticker.Locator

Localizador que este eixo está usando.

tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC')

Fuso horário de ticks, passado para dates.num2date.

lista de formatos de 6 strings, opcional

Strings de formato para 6 níveis de marcação de escala: principalmente anos, meses, dias, horas, minutos e segundos. Strings usam os mesmos códigos de formato que strftime. O padrão é ['%Y', '%b', '%d', '%H:%M', '%H:%M', '%S.%f']

lista zero_formats de 6 strings, opcional

Strings de formato para rótulos de ticks que são "zeros" para um determinado nível de tick. Por exemplo, se a maioria dos ticks forem meses, os ticks em torno de 1º de janeiro de 2005 serão rotulados como "dezembro", "2005", "fevereiro". O padrão é ['', '%Y', '%b', '%b-%d', '%H:%M', '%H:%M']

lista offset_formats de 6 strings, opcional

Strings de formato para os 6 níveis aplicados à string de "deslocamento" encontrada no lado direito de um eixo x ou na parte superior de um eixo y. Combinado com os rótulos de escala, isso deve especificar completamente a data. O padrão é:

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

show_offset bool, padrão: True

Se deve mostrar o deslocamento ou não.

usetex bool, padrão: rcParams["text.usetex"](padrão: False)

Habilitar/desabilitar o uso do modo matemático do TeX para renderizar os resultados do formatador.

Exemplos

Consulte Formatando marcações de data usando ConciseDateFormatter

( Código fonte , png )

Formate automaticamente os rótulos de data. O formato padrão é usado para formar uma string inicial e, em seguida, os elementos redundantes são removidos.

format_data_short ( valor ) [fonte] #

Retorna uma versão de string curta do valor do tick.

O padrão é o valor longo independente da posição.

format_ticks ( valores ) [fonte] #: Retorne os rótulos dos ticks para todos os ticks de uma vez.

get_offset ( ) [fonte] #

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

Bases:ConversionInterface

Conversor para dados datetime.datee datetime.datetimeou para dados de data/hora representados como seriam convertidos por date2num.

A tag 'unit' para tais dados é None ou uma instância tzinfo.

axisinfo ( unidade , eixo ) [fonte] #

Retorne AxisInfopara a unidade .

unit é uma instância tzinfo ou None. O argumento do eixo é obrigatório, mas não é usado.

conversão estática ( valor , unidade , eixo ) [fonte] #

Se o valor ainda não for um número ou uma sequência de números, converta-o com date2num.

Os argumentos de unidade e eixo não são usados.

static default_units ( x , axis ) [source] #: Retorna a instância tzinfo de x ou de seu primeiro elemento, ou None

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

Bases:Formatter

Formate um tick (em dias desde a época) com uma strftimestring de formato.

Parâmetros :

fmt str: strftimestring de formato
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.
usetex bool, padrão: rcParams["text.usetex"](padrão: False): Habilitar/desabilitar o uso do modo matemático do TeX para renderizar os resultados do formatador.

set_tzinfo ( tz ) [fonte] #

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

Bases:Locator

Determina os locais dos ticks ao plotar datas.

Esta classe é uma subclasse de outros localizadores e não deve ser usada sozinha.

Parâmetros :

tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

datalim_to_dt ( ) [fonte] #: Converta o intervalo de dados do eixo em objetos de data e hora.

hms0d = {'byhour': 0, 'byminute': 0, 'bysecond': 0} #

não singular ( vmin , vmax ) [fonte] #: Dada a extensão superior e inferior proposta, ajuste o intervalo se estiver muito próximo de ser singular (ou seja, um intervalo de ~0).

set_tzinfo ( tz ) [fonte] #

Definir informações de fuso horário.

Parâmetros :

tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

viewlim_to_dt ( ) [fonte] #: Converta o intervalo de exibição em objetos de data e hora.

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

Bases:RRuleLocator

Marque as ocorrências de cada dia do mês. Por exemplo, 1, 15, 30.

Parâmetros :

bymonthday int ou lista de int, padrão: todos os dias: Os ticks serão colocados todos os dias em bymonthday . O padrão é , ou seja, todos os dias do mês.bymonthday=range(1, 32)
intervalo int, padrão: 1: O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

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

Bases:RRuleLocator

Marque as ocorrências de cada hora.

Parâmetros :

byhour int ou lista de int, padrão: todas as horas: Os ticks serão colocados a cada hora em byhour . O padrão é byhour=range(24), ou seja, a cada hora.
intervalo int, padrão: 1: O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

classe matplotlib.dates. MicrosecondLocator ( intervalo = 1 , tz = Nenhum ) [fonte] #

Bases:DateLocator

Faça marcações em intervalos regulares de um ou mais microssegundos.

Observação

Por padrão, Matplotlib usa uma representação de ponto flutuante de tempo em dias desde a época, portanto, plotar dados com resolução de tempo de microssegundos não funciona bem para datas distantes (cerca de 70 anos) da época (verifique com get_epoch).

Se você deseja gráficos de tempo com resolução de submicrossegundos, é altamente recomendável usar segundos de ponto flutuante, não representação de tempo semelhante a data e hora.

Se você realmente precisa usar datetime.datetime() ou similar e ainda precisa de precisão de microssegundos, altere a origem do tempo dates.set_epochpara algo mais próximo das datas que estão sendo plotadas. Consulte Precisão de data e épocas .

Parâmetros :

intervalo int, padrão: 1: O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

set_axis ( eixo ) [fonte] #

set_data_interval ( vmin , vmax ) [fonte] #

[ Descontinuado ]

Notas

Obsoleto desde a versão 3.5: Use Axis.set_data_intervalem seu lugar.

set_view_interval ( vmin , vmax ) [fonte] #

[ Descontinuado ]

Notas

Obsoleto desde a versão 3.5: Use Axis.set_view_intervalem seu lugar.

tick_values ( vmin , vmax ) [fonte] #

Retorne os valores dos ticks localizados dados vmin e vmax .

Observação

Para obter as localizações dos ticks com os valores vmin e vmax definidos automaticamente para o associado, axisbasta chamar a instância Locator:

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

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

Bases:RRuleLocator

Marque as ocorrências de cada minuto.

Parâmetros :

byminute int ou lista de int, padrão: todos os minutos: Os ticks serão colocados a cada minuto em byminutes . O padrão é byminute=range(60), ou seja, a cada minuto.
intervalo int, padrão: 1: O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

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

Bases:RRuleLocator

Marque as ocorrências de cada mês, por exemplo, 1, 3, 12.

Parâmetros :

bymonth int ou lista de int, padrão: todos os meses: Os ticks serão colocados todos os meses em bymonth . O padrão é , ou seja, todo mês.range(1, 13)
bymonthday int, padrão: 1: O dia em que colocar os carrapatos.
intervalo int, padrão: 1: O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

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

Bases:DateLocator

Parâmetros :

tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

static get_unit_generic ( freq ) [fonte] #

tick_values ( vmin , vmax ) [fonte] #

Retorne os valores dos ticks localizados dados vmin e vmax .

Observação

Para obter as localizações dos ticks com os valores vmin e vmax definidos automaticamente para o associado, axisbasta chamar a instância Locator:

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

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

Bases:RRuleLocator

Marque as ocorrências de cada segundo.

Parâmetros :

bysecond int ou lista de int, padrão: todos os segundos: Os ticks serão colocados a cada segundo em bysecond . O padrão é , ou seja, a cada segundo.bysecond = range(60)
intervalo int, padrão: 1: O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

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

Bases:RRuleLocator

Marque as ocorrências de cada dia da semana.

Parâmetros :

byweekday int ou lista de int, padrão: todos os dias

Os ticks serão colocados todos os dias da semana em byweekday . O padrão é todos os dias.

Os elementos de byweekday devem ser MO, TU, WE, TH, FR, SA, SU, as constantes de dateutil.rrule, que foram importadas para o matplotlib.datesnamespace.

intervalo int, padrão: 1

O intervalo entre cada iteração. Por exemplo, se interval=2, marque cada segunda ocorrência.

tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC')

Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

classe matplotlib.dates. YearLocator ( base = 1 , mês = 1 , dia = 1 , tz = Nenhum ) [fonte] #

Bases:RRuleLocator

Faça ticks em um determinado dia de cada ano que seja um múltiplo da base.

Exemplos:

# 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, padrão: 1: Mark marca todos os anos base .
mês int, padrão: 1: O mês no qual colocar os ticks, começando em 1. O padrão é janeiro.
day int, padrão: 1: O dia em que colocar os carrapatos.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de tiques. Se for uma string, tz é passado para dateutil.tz.

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

Converta objetos datetime em datas Matplotlib.

Parâmetros :

d datetime.datetimeou numpy.datetime64ou sequências destes

Devoluções :

float ou sequência de floats: Número de dias desde a época. Consulte get_epocha época, que pode ser alterada por rcParams["date.epoch"](padrão: '1970-01-01T00:00:00') ou set_epoch. Se a época for "1970-01-01T00:00:00" (padrão), meio-dia de 1º de janeiro de 1970 ("1970-01-01T12:00:00") retornará 0,5.

Notas

O calendário gregoriano é assumido; esta não é uma prática universal. Para obter detalhes, consulte a documentação do módulo.

matplotlib.dates. datestr2num ( d , padrão = Nenhum ) [fonte] #

Converta uma string de data em um datenum usando dateutil.parser.parse.

Parâmetros :

d str ou sequência de str: As datas a serem convertidas.
data e hora padrão.data e hora, opcional: A data padrão a ser usada quando os campos estão ausentes em d .

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

Retorna uma sequência de datas Matplotlib igualmente espaçadas.

As datas começam em dstart e vão até, mas não incluem dend . Eles são espaçados por delta .

Parâmetros :

dstart, denddatetime: Os limites de data.
deltadatetime.timedelta: Espaçamento das datas.

Devoluções :

numpy.array: Uma lista flutua representando as datas do Matplotlib.

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

[ Obsoleto ] Converte o tempo do UNIX em dias desde a época do Matplotlib.

Parâmetros :

e lista de carros alegóricos: Tempo em segundos desde 1970-01-01.

Devoluções :

numpy.array: Tempo em dias desde a época do Matplotlib (consulte Recursos get_epoch()).

Notas

Obsoleto desde a versão 3.5: use os tipos or numpy.datetime64 em vez disso.[date2num(datetime.utcfromtimestamp(t)) for t in e]

matplotlib.dates. get_epoch ( ) [fonte] #

Obtenha a época usada por dates.

Devoluções :

epoch str: String para a época (analisável por numpy.datetime64).

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

Converta datas Matplotlib em datetimeobjetos.

Parâmetros :

x float ou sequência de floats: Número de dias (a fração representa horas, minutos, segundos) desde a época. Consulte get_epocha época, que pode ser alterada por rcParams["date.epoch"](padrão: '1970-01-01T00:00:00') ou set_epoch.
tz str ou tzinfo, padrão: rcParams["timezone"](padrão: 'UTC'): Fuso horário de x . Se for uma string, tz é passado para dateutil.tz.

Devoluções :

datetimeou sequência dedatetime

As datas são retornadas no fuso horário tz .

Se x for uma sequência, uma sequência de datetimeobjetos será retornada.

Notas

O calendário gregoriano é assumido; esta não é uma prática universal. Para obter detalhes, consulte o módulo docstring.

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

[ Obsoleto ] Converte dias desde a época do Matplotlib para o horário do UNIX.

Parâmetros :

d lista de carros alegóricos: Tempo em dias desde a época do Matplotlib (consulte Recursos get_epoch()).

Devoluções :

numpy.array: Tempo em segundos desde 1970-01-01.

Notas

Obsoleto desde a versão 3.5: Use num2date(e).timestamp()em seu lugar.

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

Converta o número de dias em um timedeltaobjeto.

Se x for uma sequência, uma sequência de timedeltaobjetos será retornada.

Parâmetros :

x float, sequência de floats: Número de dias. A parte fracionária representa horas, minutos, segundos.

Devoluções :

datetime.timedeltaou lista[ datetime.timedelta]

classe matplotlib.dates. parentedelta ( dt1 = Nenhum , dt2 = Nenhum , anos = 0 , meses = 0 , dias = 0 , dias bissextos = 0 , semanas = 0 , horas = 0 , minutos = 0 , segundos = 0 , microssegundos = 0 , ano = Nenhum , mês= Nenhum , dia = Nenhum , dia da semana = Nenhum , dia do ano = Nenhum , nlyearday = Nenhum , hora = Nenhum , minuto = Nenhum , segundo = Nenhum , microssegundo = Nenhum )#

Bases:object

O tipo relateddelta foi projetado para ser aplicado a um datetime existente e pode substituir componentes específicos desse datetime ou representar um intervalo de tempo.

Baseia-se na especificação do excelente trabalho realizado por M.-A. Lemburg em sua extensão mx.DateTime . No entanto, observe que esse tipo NÃO implementa o mesmo algoritmo de seu trabalho. NÃO espere que ele se comporte como a contraparte de mx.DateTime.

Há duas maneiras diferentes de criar uma instância de um relativodelta. A primeira é passar duas classes date/datetime:

relativedelta(datetime1, datetime2)

A segunda é passar qualquer número dos seguintes argumentos de palavra-chave:

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.

Existem formas relativas e absolutas dos argumentos de palavra-chave. O plural é relativo e o singular é absoluto. Para cada argumento na ordem abaixo, a forma absoluta é aplicada primeiro (definindo cada atributo para esse valor) e depois a forma relativa (adicionando o valor ao atributo).

A ordem dos atributos considerados quando este relativodelta é adicionado a um datetime é:

Ano
Mês
Dia
Horas
Minutos
Segundos
Microssegundos

Finalmente, o dia da semana é aplicado, usando a regra descrita acima.

Por exemplo

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

Primeiro, o dia é definido como 1 (o primeiro do mês), depois são adicionadas 25 horas, para chegar ao 2º dia e 14ª hora, finalmente é aplicado o dia da semana, mas como o dia 2 já é segunda-feira, não há efeito .

normalizado ( ) #

Retorne uma versão desse objeto representada inteiramente usando valores inteiros para os atributos relativos.

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

Devoluções :: Retorna um dateutil.relativedelta.relativedeltaobjeto.

semanas de propriedade #

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

Bases:object

Um wrapper simples em torno de uma dateutil.rruleespecificação flexível de data tick.

Parâmetros :

freq {ANUAL, MENSAL, SEMANAL, DIÁRIO, DE HORA, DE MINUTO, SEGUNDO}: Frequência de tiques. Essas constantes são definidas em dateutil.rrule, mas também podem ser acessadas matplotlib.datesem .
tzinfo datetime.tzinfo, opcional: Informação de fuso horário. O padrão é Nenhum.
** kwargs: Argumentos de palavras-chave adicionais são passados para o arquivo dateutil.rrule.

set ( ** kwargs ) [fonte] #: Defina parâmetros para um wrapper existente.

matplotlib.dates. set_epoch ( época ) [fonte] #

Defina a época (origem das datas) para cálculos de data e hora.

A época padrão é rcParams["dates.epoch"](por padrão 1970-01-01T00:00).

Se a precisão de microssegundos for desejada, a data que está sendo plotada precisa estar dentro de aproximadamente 70 anos da época. Matplotlib representa internamente as datas como dias desde a época, portanto, o intervalo dinâmico de ponto flutuante precisa estar dentro de um fator de 2 ^ 52.

set_epochdeve ser chamado antes de quaisquer datas serem convertidas (ou seja, perto da seção de importação) ou um RuntimeError será gerado.

Consulte também Precisão de data e épocas .

Parâmetros :

epoch str: data UTC válida analisável por numpy.datetime64(não inclui fuso horário).

matplotlib.dates#

Formato de data Matplotlib #

Marcadores de data #

Formatadores de data #

`matplotlib.dates`#