9 Trabalhando com datas
Trabalhar com datas no R requer mais atenção do que trabalhar com outras classes de objetos. Abaixo, estão apresentadas algumas ferramentas e exemplos para tornar esse processo menos doloroso. Felizmente, as datas podem ser alteradas facilmente com a prática e com um conjunto de pacotes úteis, como lubridate.
Na importação de dados brutos, o R frequentemente interpreta as datas como objetos de caracteres - isso significa que elas não podem ser usados para operações gerais de data, como criar séries temporais e calcular intervalos de tempo. Para tornar as coisas mais difíceis, existem muitas maneiras de formatar uma data e é preciso ajudar o R a saber qual parte da data representa o quê (mês, dia, hora, etc.).
As datas no R possuem sua própria classe de objeto - a classe Date. Deve-se destacar que também existe uma classe que armazena objetos com data e hora. Objetos de data e hora são formalmente chamados de classes POSIXt, POSIXct, e/ou POSIXlt (a diferença não é importante). Esses objetos são informalmente chamados de classes de data-e-hora (datetime).
É importante fazer com que o R reconheça quando uma coluna contém datas.
As datas são uma classe de objeto própria e podem ser complicado de trabalhar com elas.
Aqui, são apresentadas várias maneiras de converter colunas com datas em classe de objeto Date.
9.1 Preparação
Carregar os pacotes
Esse trecho de código mostra o carregamento dos pacotes necessários para esta página. Neste manual enfatizamos a função p_load() do pacman, que instala o pacote se necessário e o carrega para utilização. Tamém é possível carregar os pacotes instalados com library() a partir do R base. Para mais informações, veja a página em Introdução ao R sobre pacotes no R.
# Confere se o pacote está instalado, instala o pacote se necessário, e carrega-o para a sessão atual
pacman::p_load(
lubridate, # pacote geral para manipulação e conversão de datas
parsedate, # possui a função de "adivinhar" datas desorganizadas
aweek, # outra opção para conversão de datas em semanas, e de semanas em datas
zoo, # funções adicionais de data/hora
tidyverse, # gerenciamento e visualização dos dados
rio) # importação/exportação dos dadosImportação dos dados
Importamos o conjunto de dados de casos de uma simulação de epidemia de Ebola. Se você deseja baixar os dados para acompanhar passo a passo, consulte as instruções na página Baixar manual e dados. Presumimos que o arquivo está no diretório de trabalho, portanto, nenhuma subpasta é especificada neste caminho de arquivo.
linelist <- import("linelist_cleaned.xlsx")9.2 Data atual
Você pode obter a data atual do “sistema” ou a data e hora do sistema do seu computador por meio da seguintes funções presentes no R base.
# obter a data do sistema - esta é uma classe DATE
Sys.Date()## [1] "2023-10-24"
# obter a hora do sistema - esta é uma classe DATETIME
Sys.time()## [1] "2023-10-24 07:56:43 CEST"Com o pacote lubridate, essas informações também pode ser retornadas com today() e now(), respectivamente. date() retorna a data e hora atual com os nomes dos dias da semana e dos meses.
9.3 Converter para Data
Depois de importar um conjunto de dados para o R, os valores da coluna com datas podem ser semelhantes a “1989/12/30”, “05/06/2014”, ou “13 Janeiro 2020”. Nesses casos, é provável que o R ainda esteja lendo esses valores como caracteres. O R deve ser informado que esses valores são datas… e o que esse fomato de data representa (qual parte é referente ao dia, mês, ano, etc).
Uma vez informado, o R converte esses valores para a classe Date. Em segundo plano, o R armazenará as datas como números (o número de dias a partir de sua data de “origem” 1 de janeiro de 1970). Você não fará interface com o número da data com frequência, mas isso permite que R trate as datas como variáveis contínuas e permita operações especiais, como calcular a distância entre as datas.
Por padrão, os valores da classe Date em R são exibidos como AAAA-MM-DD. Posteriormente nesta seção, discutiremos como alterar a exibição dos valores de data.
A seguir, apresentamos duas abordagens para converter uma coluna de valores de caracteres para a classe Date.
DICA: Você pode checar a classe atual de uma coluna utilizando a função class()presente na base do R , como por exemplo class(linelist$date_onset).
R base
as.Date() é a função presente no R base para conversão um objeto ou coluna para a classe Data (observe a capitalização de “D”).
Para o uso da função as.Date() é preciso que:
- Você especifique o formato existente da data como um caractere bruto ou então que especifique a data de origem, caso forneça datas como números (consulte a seção sobre datas do Excel);
- Se foi usado em uma coluna de caracteres, todos os valores de data devem ter o mesmo formato exato (se este não for o caso, tente
parse_date()do pacote parsedate).
Primeiro, verifique a classe de sua coluna com class() do R base. Se você não tem certeza ou está confuso sobre a classe de seus dados (por exemplo, você vê “POSIXct”, etc.) pode ser mais fácil primeiro converter a coluna para a classe Character com a função as.character(), e depois converter para a classe Date.
Segundo, dentro da função as.Date(), use o argumento format = para informar ao R o formato atual dos componentes da data como caractere - quais caracteres se referem ao mês, dia e ano, e como eles são separados. Se seus valores já estiverem em um dos formatos de data padrão do R (“AAAA-MM-DD” ou “AAAA/MM/DD”), o argumento format = não é necessário.
Para format =, forneça uma sequência de caracteres (entre aspas) que representa o formato de data atual usando as abreviações especiais “strptime” abaixo. Por exemplo, se as datas dos caracteres estão atualmente no formato “DD/MM/AAAA”, como “24/04/1968”, você usaria format = "%d/%m/%Y" para converter os valores em datas. É necessário colocar o formato entre aspas. E não se esqueça de quaisquer barras ou travessões!
# Converter para classe data
linelist <- linelist %>%
mutate(date_onset = as.Date(date_of_onset, format = "%d/%m/%Y"))A maioria das abreviações de strptime estão listadas abaixo. Você pode ver a lista completa executando ?strptime.
%d = Número do dia do mês (5, 17, 28, etc.)
%j = Número do dia do ano (dia Juliano 001-366)
%a = Dia da semana abreviado (Seg, Ter, Quarta,etc. ou Mon, Tue, Wed, etc.)
%A = Dia da semana completo (segunda, terça, etc.)
%w = Número do dia da semana (0-6, sendo que domingo é 0)
%u = Número do dia da semana (1-7, sendo que segunda é 1)
%W = Número da semana (00-53, segunda é início da semana)
%U = Número da semana (01-53, domingo é o início da semana)
%m = Número do mês (por exemplo, 01, 02, 03, 04)
%b = Mês abreviado (Jan, Fev, etc.)
%B = Mês completo (Janeiro, Fevereiro, etc.) %y = Ano em 2 dígitos (por exemplo, 89)
%Y = Ano em 4 dígitos (por exemplo, 1989)
%h = horas (relógio de 24 horas)
%M = minutos
%s = segundos
%z = deslocamento do GMT
%Z = fuso horário (caractere)
DICA: TO argumento format = da função as.Date() não está informando ao R o formato que deseja que as datas tenham, mas sim como identificar as partes da data da forma como elas estão, antes de rodar o comando.
DICA: Certifique-se de que no argumento format = você usa o separador de data (por exemplo, /, -, ou espaço) que está presente em suas datas.
Uma vez que os valores estão na classe Date, o R os exibirá no formato padrão, que é AAAA-MM-DD.
lubridate
A conversão de objetos de caracteres em datas pode ser facilitada com o uso do pacote lubridate. Este é um pacote tidyverse projetado para tornar o trabalho com datas e horários mais simples e consistente do que nO R base. Por essas razões, lubridate é frequentemente considerado o pacote padrão ouro para datas e horários, e é recomendado sempre que trabalhar com eles.
O pacote lubridate fornece diferentes funções auxiliares projetadas para converter objetos de caracteres em datas de uma forma intuitiva e mais branda do que especificar o formato em as.Date(). Essas funções são específicas para o formato de data aproximada, mas permitem uma variedade de separadores e sinônimos para datas (como, 01 vs Jan vs Janeiro) - eles são nomeados após abreviações de formatos de data.
# instale/carregue lubridate
pacman::p_load(lubridate)A função ymd() converte de forma flexível os valores de data fornecidos como ano, seguido de mês, e depois dia.
# Leia a data no formato ano-mês-dia
ymd("2020-10-11")## [1] "2020-10-11"
ymd("20201011")## [1] "2020-10-11"A função mdy() converte de forma flexível os valores de data fornecidos como mês, seguido de dia, e ano.
# Leia a data no formato mês-dia-ano
mdy("10/11/2020")## [1] "2020-10-11"
mdy("Oct 11 20")## [1] "2020-10-11"A função dmy() converte de forma flexível os valores de data fornecidos como dia, seguida de mês, e ano.
# Leia a data no formato dia-mês-ano
dmy("11 10 2020")## [1] "2020-10-11"
dmy("11 October 2020")## [1] "2020-10-11"Se estiver usando o pipe %>%, a conversão de uma coluna de caracteres para datas com lubridate pode ser feita assim:
Depois de concluído, você pode executar class() para verificar a classe da coluna
# Confira a classe da coluna
class(linelist$date_onset) Uma vez que os valores estão na classe Date, o R os exibirá por padrão no formato AAAA-MM-DD.
Observe que as funções acima funcionam melhor com anos de 4 dígitos. Anos de 2 dígitos podem produzir resultados inesperados, à medida que lubridate tenta adivinhar o século.
Para converter um ano de 2 dígitos em um ano de 4 dígitos (todos no mesmo século) você pode converter as datas para caractere e então combinar os dígitos existentes com uma pré-correção usando str_glue() do pacote stringr (veja Caracteres e strings). Em seguida, converta para data.
## 2015
## 2015
## 2016
## 2017Combine colunas
Você pode usar as funções do lubridate make_date() e make_datetime() para combinar múltiplas colunas numéricas em uma coluna de data. Por exemplo, se você tiver colunas numéricas onset_day, onset_month, e onset_year na tabela de dados linelist:
9.4 Datas do Excel
Em segundo plano, a maioria dos softwares armazena datas como números. O R armazena datas de uma origem de 1º Janeiro, 1970. Portanto, se você executar as.numeric(as.Date("1970-01-01)) você obterá 0.
O Microsoft Excel armazena datas com um origem em 30 de dezembro de 1899 (Windows) ou 1 de janeiro de 1904 (Mac), dependendo do seu sistema operacional. Consulte em Microsoft guidance para obter mais informações.
As datas do Excel geralmente são importadas para o R como esses valores numéricos, em vez de caracteres. Se o conjunto de dados que você importou do Excel mostra datas como números ou caracteres como “41369” … use as.Date() (ou a função do lubridate as_date()) para converter, mas no lugar de fornecer um “formato” como acima, forneça a data de origem do Excel no argumento origin =.
Isso não irá funcionar se as datas do Excel contidas no R estiverem como caracteres, assim, confirme se os números estão classificados como Numérico!
NOTA: Você deve fornecer a data de origem no formato de data padrão do R (“AAAA-MM-DD”).
# Um exemplo de fornecimento da 'data de origem' do Excel ao converter datas numéricas do Excel
data_cleaned <- data %>%
mutate(date_onset = as.numeric(date_onset)) %>% # garantir que a classe seja numérica
mutate(date_onset = as.Date(date_onset, origin = "1899-12-30")) # converter para data usando a origem do Excel9.5 Datas bagunçadas
A função parse_date() do pacote parsedate tenta ler uma coluna de data “bagunçada” contendo datas em muitos formatos diferentes e converte as datas para um formato padrão. Você pode ler mais online sobre parse_date().
Por exemplo, o parse_date() vê um vetor dos seguintes caracteres de datas “03 Jan 2018”, “07/03/1982”, e “08/20/85” e os converteria para a classe Date como: 2018-01-03, 1982-03-07, e 1985-08-20.
parsedate::parse_date(c("03 Jan 2018",
"07/03/1982",
"08/20/85"))## [1] "2018-01-03 UTC" "1982-07-03 UTC" "1985-08-20 UTC"
# Um exemplo usando parse_date() na coluna `date_onset` (data de início de sintomas)
linelist <- linelist %>%
mutate(date_onset = parse_date(date_onset))9.6 Trabalhando com classe de data-hora
Conforme mencionado anteriormente, o R também oferece suporte para dados de classe datetime - uma coluna que contém informações de data e hora. Assim como a classe Date, eles geralmente precisam ser convertidos de objetos de character para objetos datetime.
Converter datas com horas
Um objeto datetime padrão é formatado com a data primeiro, que é seguida por um componente de hora - por exemplo, 01 de janeiro de 2020, 16:30. Assim como acontece com as datas, isso pode ser formatado de muitas maneiras e vários níveis de precisão (horas, minutos, segundos) que podem ser fornecidos.
Felizmente, as funções auxiliares do lubridate também existem para ajudar a converter essas junções para objetos datetime. Essas funções são extensões das funções auxiliares de data, com _h (apenas horas fornecidas), _hm (horas e minutos fornecidos), ou _hms (horas, minutos e segundos fornecidos) anexado ao final (por exemplo, dmy_hms()). Eles podem ser usados conforme mostrado abaixo:
Converte “data e hora” contendo apenas horas para o objeto do tipo datetime
ymd_h("2020-01-01 16hrs")## [1] "2020-01-01 16:00:00 UTC"Converte “data e hora” com horas e minutos para o objeto do tipo datetime
dmy_hm("01 January 2020 16:20")## [1] "2020-01-01 16:20:00 UTC"Converte “data e hora” com horas, minutos e segundos para o objeto do tipo datetime
mdy_hms("01 January 2020, 16:20:40")## [1] "2020-01-20 16:20:40 UTC"Você pode fornecer o fuso horário, mas ele será ignorado. Consulte a seção mais adiante nesta página sobre fusos horários.
mdy_hms("01 January 2020, 16:20:40 PST")## [1] "2020-01-20 16:20:40 UTC"Ao trabalhar com uma tabela de dados, as colunas de hora e data podem ser combinadas para criar uma coluna data-e-hora (datetime) usando str_glue() do pacote stringr e uma função apropriada do lubridate. Consulte a página em Caracteres e strings para obter detalhes sobre o stringr.
Neste exemplo, a tabela de dados do linelist possui uma coluna no formato “horas:minutos”. Para converter isso para data-e-hora, seguem-se algumas etapas:
- Crie uma coluna de tempo de admissão “limpa” na qual os valores ausentes são preenchidos pela mediana da coluna. Isso é realizado, pois lubridate não funciona com valores ausentes. Combine-o com a coluna
date_hospitalisation, e então use a funçãoymd_hm()para converter.
# pacotes
pacman::p_load(tidyverse, lubridate, stringr)
# time_admission é a coluna em horas:minutos
linelist <- linelist %>%
# quando o horário de admissão não é fornecido, atribua o horário médio de admissão
mutate(
time_admission_clean = ifelse(
is.na(time_admission), # se horário estiver faltando
median(time_admission), # atribua a mediana
time_admission # se não estiver faltando, mantenha como está
)) %>%
# use str_glue() para combinar as colunas de data-e-horas em uma coluna de caracteres
# em seguida, use ymd_hm() para converter em formato datetime
mutate(
date_time_of_admission = str_glue("{date_hospitalisation}{time_admission_clean}") %>%
ymd_hm()
)Converta horários isolados
Se seus dados contém apenas caracteres referente a um horário (horas e minutos), você pode convertê-los e manipulá-los como tempos usando strptime() a partir do R base. Por exemplo, para obter a diferença entre dois desses tempos:
# horário como caracteres brutos
time1 <- "13:45"
time2 <- "15:20"
# horário convertidos para classe datetime
time1_clean <- strptime(time1, format = "%H:%M")
time2_clean <- strptime(time2, format = "%H:%M")
# Por padrão, a diferença é da classe "difftime", aqui convertida em horas numéricas
as.numeric(time2_clean - time1_clean) # diferença em horas## [1] 1.583333Observe, entretanto, que sem um valor de data fornecido, ele assume que a data é hoje. , Veja como usar stringr na seção acima para combinar uma data string e um tempo string. Leia mais sobre strptime() aqui.
Para converter números de um dígito em dois dígitos (por exemplo, para “preencher” horas ou minutos com zeros à esquerda para atingir 2 dígitos), consulte a seção “Pad length” da página Caracteres e junções.
Extrair o tempo
Você pode extrair elementos de um tempo com hour(), minute(), ou second() do lubridate.
Aqui está um exemplo de extração da hora e em seguida, sua classificação por período do dia. Começamos com a coluna time_admission, a qual está na classe Caractere no formato “HH:MM”. Primeiro, a strptime() é usado conforme descrito acima para converter os caracteres para a classe datetime. Em seguida, a hora é extraída com with hour(), retornando um número de 0-24. Finalmente, uma coluna time_period usando a lógica com a função case_when() para classificar as linhas em Manhã / Tarde / Início da noite / Noite com base na hora de admissão.
linelist <- linelist %>%
mutate(hour_admit = hour(strptime(time_admission, format = "%H:%M"))) %>%
mutate(time_period = case_when(
hour_admit > 06 & hour_admit < 12 ~ "Manhã",
hour_admit >= 12 & hour_admit < 17 ~ "Tarde",
hour_admit >= 17 & hour_admit < 21 ~ "Início da noite",
hour_admit >=21 | hour_admit <= 6 ~ "Noite"))Para saber mais sobre case_when() , consulte a página Limpeza dos daos e principais funções.
9.7 Trabalhando com datas
lubridate também pode ser usado para uma variedade de outras funções, como extrair aspectos de uma data / data e hora, realizar cálculos aritiméticos de data ou calcular intervalos de data.
Aqui, definimos uma data que será usada para os exemplos:
# criar um objeto de classe Date
example_date <- ymd("2020-03-01")Extrair os componentes de datas
Você pode extrair aspectos comuns, como mês, dia, dia da semana:
month(example_date) # número do mês## [1] 3
day(example_date) # dia do mês (número)## [1] 1
wday(example_date) # número do dia da semana (1-7)## [1] 1Você também pode extrair componentes de tempo de um objeto ou coluna datetime. Isso pode ser útil se você quiser ver a distribuição dos horários de admissão.
example_datetime <- ymd_hm("2020-03-01 14:45")
hour(example_datetime) # extrair hora
minute(example_datetime) # extrair minuto
second(example_datetime) # extrair segundoExistem várias opções para recuperar semanas. Veja a seção sobre semanas epidemiológicas abaixo.
Observe que se você deseja exibir uma data de uma determinada maneira (por exemplo, “janeiro de 2020” ou “Quinta-feira, 20 de março” ou “Semana 20 de 1977”), pode fazer isso de forma mais flexível, conforme descrito na seção Exibição de data.
Cálculos com datas
Você pode adicionar determinados números de dias ou semanas usando suas respectivas funções do lubridate.
# adicione 3 dias à essa data
example_date + days(3)## [1] "2020-03-04"## [1] "2020-04-17"Intervalos entre datas
A diferença entre as datas pode ser calculada por:
- Certifique-se de que ambas as datas estejam como classe data
- Use a subtração para retornar a diferença “difftime” entre as duas datas
- Se necessário, converta o resultado em classe numérica para realizar cálculos matemáticos subsequentes
Abaixo, o intervalo entre duas datas é calculado e exibido. Você pode encontrar intervalos usando o símbolo de subtração “menos” em valores que estão como classe Data. Contudo, observe que a classe do valor retornado é “difftime” conforme exibido abaixo e deve ser convertida para numérico.
# encontre o intervalo entre essa data e 20 de fevereiro de 2020
output <- example_date - ymd("2020-02-20")
output # print## Time difference of 10 days
class(output)## [1] "difftime"Para fazer as operações subsequentes em um “difftime”, converta-o para numérico com as.numeric().
Tudo isso pode ser reunido para trabalhar com dados - por exemplo:
pacman::p_load(lubridate, tidyverse) # carregue os pacotes
linelist <- linelist %>%
# converter a data de início (date_onset) de caracteres em objetos de data, especificando o formato dmy
mutate(date_onset = dmy(date_onset),
date_hospitalisation = dmy(date_hospitalisation)) %>%
# filtrar todos os casos sem início em março
filter(month(date_onset) == 3) %>%
# encontrar a diferença, em dias, entre a data de ínicio e o início da hospitalização
mutate(days_onset_to_hosp = date_hospitalisation - date_of_onset)No contexto de uma tabela de dados (data frame), se uma das datas acima estiver faltando, a operação falhará para essa linha. Isso resultará em um NA em vez de um valor numérico. Ao usar esta coluna para cálculos, certifique-se de definir o argumento na.rm = como TRUE. Por exemplo:
# calcule o número médio de dias até a hospitalização para todos os casos em que os dados estão disponíveis
median(linelist_delay$days_onset_to_hosp, na.rm = T)9.8 Exibição das datas
Uma vez que as datas essão na classe correta, você geralmente deseja que elas sejam exibidas de forma diferente, por exemplo, como “Segunda-feira, 5 de janeiro” em vez de “05/01/2018”. Você também pode ajustar a exibição para agrupar as linhas pelos elementos de data exibidos - por exemplo, agrupar por mês-ano.
format()
Ajuste a exibição de data com a função format()do R base. Esta função aceita uma cadeia de caracteres entre aspas (string) especificando o formato de saída desejado nas abreviações de strptime “%” (a mesma sintaxe usada em as.Date()). Abaixo estão relacionadas a maioria das abreviações comuns.
Observação: o uso de format() converterá os valores para a classe Caractere, então geralmente é usado no final de uma análise ou apenas para fins de exibição! Você pode ver a lista completa executando ?strptime.
%d = Número do dia do mês (5, 17, 28, etc.)
%j = Número do dia do ano (Julho dia 001-366)
%a = Dia da semana abreviado (Mon, Tue, Wed, etc.)
%A = Dia da semana completo (Monday, Tuesday, etc.)
%w = Número do dia da semana (0-6, Domingo é 0)
%u = Número do dia da semana (1-7, Segunda-feira é 1)
%W = Número da semana (00-53, Segunda-feira é o início da semana)
%U = Número da semana (01-53, Domingo é o início da semana)
%m = Número do mês (exemplo, 01, 02, 03, 04)
%b = Mês abreviado (Jan, Fev, etc.)
%B = Mês completo (Janeiro, Fevereiro, etc.)
%y = Ano em 2 dígitos (por exemplo, 89)
%Y = Ano em 7 dígitos (por exemplo, 1989)
%h = horas (relógio de 24 horas)
%M = minutos
%s = segundos
%z = deslocamento do GMT
%Z = Fuso horário (caractere)
Um exemplo de formatação da data de hoje:
## [1] "24 October 2023"
# maneira fácil de obter data e hora completas (formatação padrão)
date()## [1] "Tue Oct 24 07:56:44 2023"
# data, hora e fuso horário combinados e formatados usando a função str_glue()
str_glue("{format(Sys.Date(), format = '%A, %B %d %Y, %z %Z, ')}{format(Sys.time(), format = '%H:%M:%S')}")## Tuesday, October 24 2023, +0000 UTC, 07:56:44## [1] "2023 Week 43"Observe que se estiver usando str_glue(), esteja ciente de que dentro das aspas duplas esperadas “, você deve usar apenas aspas simples (como acima).
Mês-ano
Para converter uma coluna de Data para o formato mês-ano, sugerimos que você use a função as.yearmon() do pacote zoo. Isso converte a data para a classe “yearmon” e mantém a ordem adequada. Em contraste, o uso de format(column, "%Y %B") irá converter para a classe Caractere e irá ordenar os valores alfabeticamente (incorretamente).
Abaixo, uma nova coluna yearmonth é criada a partir da coluna date_onset, usando a função as.yearmon(). A ordem padrão (correta) dos valores resultantes é mostrada na tabela.
# criando uma nova tabela
test_zoo <- linelist %>%
mutate(yearmonth = zoo::as.yearmon(date_onset))
# mostrar tabela
table(test_zoo$yearmon)##
## Apr 2014 May 2014 Jun 2014 Jul 2014 Aug 2014 Sep 2014 Oct 2014 Nov 2014 Dec 2014
## 7 64 100 226 528 1070 1112 763 562
## Jan 2015 Feb 2015 Mar 2015 Apr 2015
## 431 306 277 186Em contraste, você pode ver como usando apenas format() é possível atingir ao formato de exibição desejado, mas não na ordem correta.
# criar uma nova coluna
test_format <- linelist %>%
mutate(yearmonth = format(date_onset, "%b %Y"))
# mostrar tabela
table(test_format$yearmon)##
## Apr 2014 Apr 2015 Aug 2014 Dec 2014 Feb 2015 Jan 2015 Jul 2014 Jun 2014 Mar 2015
## 7 186 528 562 306 431 226 100 277
## May 2014 Nov 2014 Oct 2014 Sep 2014
## 64 763 1112 1070Observação: se você estiver trabalhando em um ggplot() e quiser ajustar apenas a forma como as datas são exibidas, pode ser suficiente fornecer um formato strptime para o argumento date_labels = na função scale_x_date() - você pode usar "%b %Y" ou "%Y %b". Veja a página Dicas para ggplot.
zoo também oferece a função as.yearqtr(), e você pode usar scale_x_yearmon() ao usar ggplot().
9.9 Semanas epidemiológicas
lubridate
Consulte a página em Agrupando dados para exemplos mais abrangentes de dados de agrupamento por data. Abaixo, descrevemos resumidamente os dados de agrupamento por semanas.
Geralmente recomendamos usar a função floor_date() do lubridate, com o argumento unit = "week". Isso arredonda a data para o “início” da semana, conforme definido pelo argumento week_start =. O início da semana padrão é 1 (para segundas-feiras), mas você pode especificar qualquer dia da semana como o início (por exemplo, 7 para domingos). floor_date() é versátil e pode ser usado para arredondar outras unidades de tempo definindo unit = para “segundo”, “minuto”, “hora”, “dia”, “mês” ou “ano”.
O valor retornado é a data de início da semana, na classe Date. A classe de data é útil ao plotar os dados, pois serão facilmente reconhecidos e ordenados corretamente por ggplot().
Se você estiver interessado apenas em ajustar as datas para exibição por semana em um gráfico, consulte a seção nesta página sobre Exibição de data. Por exemplo, ao plotar uma curva epidemiológica, você pode formatar a exibição da data fornecendo a nomenclatura “%” do strptime desejada. Por exemplo, use “%Y-%W” ou “%Y-%U” para retornar o ano e o número da semana (dado o início da semana na segunda-feira ou no domingo, respectivamente).
Contagens semanais
Veja a página em Agrupando dados para uma explicação completa de dados de agrupamento com count(), group_by(), e summarise(). Um breve exemplo está mostrado abaixo.
- Crie uma nova coluna ‘semana’ com
mutate(), usandofloor_date()comunit = "week"; - Obtenha contagens de linhas (casos) por semana com
count(); remova quaisquer casos com data ausente; - Conclua com
complete()do tidyr para garantir que todas as semanas apareçam nos dados - mesmo aquelas sem linhas/casos. Por padrão, os valores de contagem para quaisquer “novas” linhas são NA, mas você pode torná-los 0 com o argumentofill =, que espera uma lista nomeada (abaixo,né o nome da coluna de contagens).
# Faça um conjunto de dados agregado de contagens de casos semanais
weekly_counts <- linelist %>%
drop_na(date_onset) %>% # remover casos sem data de início onset date
mutate(weekly_cases = floor_date( # fazer nova coluna, semana de início
date_onset,
unit = "week")) %>%
count(weekly_cases) %>% # agrupar dados por semana e contar linhas por grupo (cria a coluna 'n')
tidyr::complete( # garantir que todas as semanas estejam presentes, mesmo aquelas sem casos relatados
weekly_cases = seq.Date( # redefina a coluna "weekly_cases" como uma sequência completa,
from = min(weekly_cases), # a partir da data mínima
to = max(weekly_cases), # para a data máxima
by = "week"), # por semanas
fill = list(n = 0)) # preencha NAs na coluna de n contagens com 0Aqui estão as primeiras linhas da tabela de dados resultante:
Alternativas do Epiweek
Note que lubridate também tem as funções week(), epiweek(), e isoweek(), cada uma com datas de início ligeiramente diferentes e outras nuances. De modo geral, porém, floor_date() deve ser tudo o que você precisa. Leia os detalhes dessas funções inserindo ?week no console ou lendo a documentação aqui.
Você pode considerar usar o pacote aweek para definir semanas epidemiológicas. Você pode ler mais sobre isso no site do RECON. Possui as funções date2week()e week2date() nas quais você pode definir o dia de início da semana com week_start = "Monday". Este pacote é mais fácil se você quiser saídas no estilo “semana” (por exemplo, “2020-W12”, sendo W = semana). Outra vantagem de aweek é que quando date2week() é aplicado a uma coluna de data, a coluna retornada (formato de semana) é automaticamente da classe Fator e e inclui níveis para todas as semanas no intervalo de tempo (isso evita a etapa extra de complete() descrito acima). Porém, aweek não tem a funcionalidade de arredondar datas para outras unidades de tempo, como meses, anos, etc..
Outra alternativa para séries temporais que também funciona bem para mostrar um formato de “semana” (“2020 W12”) é yearweek() do pacote tsibble, como demonstrado na página Séries temporais e detecção de surto.
9.10 Conversão de datas / fusos horários
Quando os dados estão presentes em fusos horários diferentes, muitas vezes pode ser importante padronizar esses dados em um fuso horário unificado. Isso pode representar um desafio adicional, pois o componente de fuso horário dos dados deve ser codificado manualmente na maioria dos casos.
No R, cada objeto datetime possui um componente de fuso horário. Por padrão, todos os objetos datetime levarão o fuso horário local do computador que está sendo usado - isso geralmente é específico para um local em vez de um nome do fuso horário, pois os fusos horários geralmente mudam nos locais devido ao horário de verão. Não é possível compensar com precisão os fusos horários sem um componente de tempo de uma data, pois o evento que uma coluna de data representa não pode ser atribuído a um tempo específico e, portanto, as mudanças de tempo medidas em horas não podem ser razoavelmente contabilizadas.
Para lidar com fusos horários, há várias funções auxiliares no lubridate que podem ser usadas para alterar o fuso horário de um objeto datetime do seu fuso horário local para um fuso horário diferente. Os fusos horários são definidos atribuindo um fuso horário do banco de dados tz válido ao objeto datetime. Uma lista deles pode ser encontrada aqui - se o local do qual você está usando os dados não estiver nessa lista, grandes cidades próximas no fuso horário estão disponíveis e têm a mesma finalidade.
https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
# atribuir a hora atual a uma coluna
time_now <- Sys.time()
time_now## [1] "2023-10-24 07:56:45 CEST"
# use with_tz() para atribuir um novo fuso horário à coluna, enquanto ALTERA a hora do relógio
time_london_real <- with_tz(time_now, "Europe/London")
# use force_tz() para atribuir um novo fuso horário para a coluna, enquanto MANTÉM a hora do relógio
time_london_local <- force_tz(time_now, "Europe/London")
# observe que, desde que o computador usado para executar este código NÃO esteja definido para o horário de Londres,
# haverá uma diferença nos horários
# (o número de horas de diferença do fuso horário do computador para Londres)
time_london_real - time_london_local## Time difference of -1 hoursIsso pode parecer muito abstrato e geralmente não é necessário se o usuário não estiver trabalhando em outros fusos horários.
9.11 Cálculos com valores anteriores ou posteriores
lead() and lag() são funções do pacote dplyr que ajudam a encontrar valores anteriores (lag) ou subsequentes (lead) em um vetor - normalmente um vetor numérico ou de data. Isso é útil ao fazer cálculos de mudança / diferença entre unidades de tempo.
Digamos que você queira calcular a diferença de casos entre uma semana atual e a anterior. Os dados são fornecidos inicialmente em contagens semanais, conforme mostrado abaixo.
Ao usar lag() ou lead(), a ordem das linhas no seus dados é muito importante! - preste atenção se suas datas / números estão de forma crescentes ou decrescentes
Primeiro, crie uma nova coluna contendo o valor da semana anterior (defasada).
- Controle o número de unidades para trás / para frente com
n =(deve ser um número inteiro não negativo)
- Use
default =para definir o valor colocado em linhas não existentes (por exemplo, a primeira linha para a qual não há valor defasado). Por padrão, isso éNA.
- Use
order_by = TRUEse suas linhas não estiverem ordenadas por sua coluna de referência
A seguir, crie uma nova coluna que é a diferença entre as duas colunas de casos:
counts <- counts %>%
mutate(cases_prev_wk = lag(cases_wk, n = 1),
case_diff = cases_wk - cases_prev_wk)Você pode ler mais sobre lead() e lag() no documento aqui ou inserindo ?lag no seu console.
9.12 Recursos
lubridate página tidyverse
lubridate RStudio cheatsheet
R para Ciência dos Dados na página datas e horas
Tutorial Online de Formatos de datas