At få den aktuelle dato i ethvert programmeringssprog er en operation, der svarer til "Hello world!". R-sproget er ingen undtagelse.

I denne artikel vil vi se på, hvordan arbejdet med datoer er struktureret i R-sprogets grundlæggende syntaks, samt vi vil gennemgå nogle nyttige pakker, der udvider mulighederne for at arbejde med datoer:

lubridate — en pakke, der muliggør aritmetiske beregninger mellem datoer;
timeperiodsR — en pakke til at arbejde med tidsintervaller og deres komponenter.

Indhold

Hvis du er interesseret i dataanalyse, og specifikt R-sproget, kan mine telegram og youtube kanaler være interessante for dig. Størstedelen af indholdet er dedikeret til R-sproget.

Arbejdet med datoer i R's grundlæggende syntaks
1.1. Konvertering af tekst til en dato
1.2. Udtakning af datoens komponenter i grundlæggende R
Arbejdet med datoer ved hjælp af pakken lubridate
2.1. Konvertering af tekst til en dato med lubridate
2.2. Udtakning af datokomponenter ved hjælp af pakken lubridate
2.3. Aritmetiske operationer med datoer
Forenklet arbejde med perioder, pakken timeperiodsR
3.1. Tidsintervaller i timeperiodsR
3.2. Filtrering af datovektorer ved hjælp af timeperiodsR
Konklusion

Arbejdet med datoer i R's grundlæggende syntaks

Konvertering af tekst til en dato

I grundlæggende R findes der et sæt funktioner til at arbejde med datoer. Ulempen ved den grundlæggende syntaks er, at registrene af navne og arguments for funktioner er meget fragmenteret og næsten ikke har en logisk forbindelse. Alligevel skal man kende de grundlæggende funktioner i sproget, så vi starter med dem.

Når du oftest indlæser data i R fra csv-filer eller andre kilder, får du datoen som tekst. For at konvertere denne tekst til den korrekte datatype bruger du funktionen as.Date().

# создаём текстовый вектор с датами
my_dates <- c("2019-09-01", "2019-09-10", "2019-09-23")

# проверяем тип данных
class(my_dates)

#> [1] "character"

# преобразуем текст в дату
my_dates <- as.Date(my_dates)

# проверяем тип данных
class(my_dates)

#> [1] "Date"

By default as.Date() der tager datoen i to formater: ÅÅÅÅ-MM-DD eller ÅÅÅÅ/MM/DD.
Hvis dine data indeholder datoer i et andet format, kan argumentet format.

as.Date("September 26, 2019", format = "%B %d, %Y")

format accept i en streng formatoperatører, der angiver en eller anden tidsinterval og dets format, de mest anvendte værdier er angivet i tabellen nedenfor:

Format
Description

%d
Dagens nummer i måneden

%a
Forkortelsen for ugedagens navn

%A
Det fulde navn på ugedagen

%w
Ugedagens nummer (0-6, hvor 0 er søndag)

%m
To-cifret måned (01-12)

%b
Forkortelsen for månedsnavnet (apr, mar, …)

%B
Det fulde navn på måneden

%y
To-cifret år

%Y
Fire-cifret år

%j
Dagenummer i året (001 — 366)

%U
Ugenummer i året (00 — 53), ugen starter søndag

%W
Ugenummer i året (00 — 53), ugen starter mandag

Derfor, "26. september 2019" er - det fulde månedsnavn, dato og år. Dette date format kan beskrives med operatorer som:"%B %d, %Y".

Hvor:

%B — Det fulde månedsnavn
%d — Dagenummer i måneden
%Y — Fire-cifret år

Når du beskriver formatet af en dato, er det vigtigt at inkludere alle ekstra tegn fra din streng, som bindestreger, kommaer, punkter, mellemrum osv. I mit eksempel, "26. september 2019", står der et komma efter datoen, og i beskrivelsen af formatet skal der også være et komma:"%B %d, %Y".

Der kan være situationer, hvor du får en dato, der ikke blot ikke svarer til de standardformater (ÅÅÅÅ-MM-DD eller ÅÅÅÅ/MM/DD), men også på et sprog, der adskiller sig fra det, der er indstillet som standard i dit operativsystem. For eksempel, hvis du indlæser data, hvor datoen er angivet som: "15. december 2019". Før du konverterer denne streng til en dato, skal du ændre lokaliteten.

# Меняем локаль
Sys.setlocale("LC_TIME", "Russian")
# Конвертируем строку в дату
as.Date("Декабрь 15, 2019 г.", format = "%B %d, %Y")

Udtakning af datoens komponenter i grundlæggende R

I basis R er der ikke så mange funktioner, der tillader dig at udtrække nogen del af datoen fra et objekt af klassen Dato.

current_date <- Sys.Date() # Aktuel dato
weekdays(current_date)     # få ugedagen
months(current_date)       # få måneden i året
quarters(current_date)     # få kvartalet i året

Udover hovedklassen af objekter Dato er der i basis R også 2 typer data, der gemmer tidsstempler: POSIXlt, POSIXct. Den primære forskel mellem disse klasser og Dato er, at de gemmer tid ud over datoen.

# получить текущую дату и время
current_time <- Sys.time()

# узнать класс объекта current_time 
class(current_time)

# "POSIXct" "POSIXt"

Funktion Sys.time() returnerer den aktuelle dato og tid i formatet POSIXct. Dette format er betydningsmæssigt lig med UNIXTIME, og gemmer antallet af sekunder siden begyndelsen af UNIX-ævind (midnat (UTC) fra 31. december 1969 til 1. januar 1970).

Klasse POSIXlt gemmer også tid og dato samt alle deres komponenter. Derfor er det et objekt med en mere kompleks struktur, men fra hvilket det er nemt at få enhver komponent af dato og tid, da det i bund og grund POSIXlt dette list.

# Получаем текущую дату и время
current_time_ct <- Sys.time()

# Преобразуем в формат POSIXlt
current_time_lt <- as.POSIXlt(current_time_ct)

# извлекаем компоненты даты и времени
current_time_lt$sec   # секунды
current_time_lt$min   # минуты
current_time_lt$hour  # часы
current_time_lt$mday  # день месяца
current_time_lt$mon   # месяц
current_time_lt$year  # год
current_time_lt$wday  # день недели
current_time_lt$yday  # день года
current_time_lt$zone  # часовой пояс

Konvertering af numeriske og tekstlige data til POSIX* foregår med funktioner as.POSIXct() og as.POSIXlt(). Disse funktioner har et lille sæt argumenter.

x — Tal, streng eller objekt af klassen Dato, som skal konverteres;
tz — Tidszone, standard er "GMT";
format — Beskrivelsen af datoformatet, hvori de data, der sendes til argument x, er angivet;
origin — Bruges kun ved konvertering af et tal til POSIX, i dette argument skal du angive et dato- og tidsobjekt, som sekunderne tælles fra. Det bruges typisk til at omregne fra UNIXTIME.

Hvis dine dato- og tidsoplysninger præsenteres i UNIXTIME, så kan du bruge følgende eksempel til at konvertere dem til en forståelig, læsbar dato:

# Конвертируем UNIXTIME в читаемую дату 
as.POSIXlt(1570084639,  origin = "1970-01-01")

I origin kan du angive enhver tidsstempel. For eksempel, hvis dine data viser dato og tid som antal sekunder siden 15. september 2019 kl. 12:15, kan du bruge følgende til at omdanne dem til en dato:

# Конвертируем UNIXTIME в дату учитывая что начало отсчёта 15 сентября 2019 12:15
as.POSIXlt(1546123,  origin = "2019-09-15 12:15:00")

Arbejdet med datoer ved hjælp af pakken lubridate

lubridate måske den mest populære pakke til håndtering af datoer i R-sproget. Den giver dig desuden tre yderligere klasser.

durations — varigheden, dvs. antallet af sekunder mellem to tidsstempler;
periods — perioder tillader beregninger mellem datoer i menneskeligt forståelige intervaller: dage, måneder, uger osv;
intervals — objekter, der giver det start og slut tidspunkt.

Installation af yderligere pakker i R-sproget udføres med den standardfunktion install.packages().

Installation af pakken lubridate:

install.packages("lubridate")

Konvertering af tekst til en dato med lubridate

Funktionerne i pakken lubridate letterligt forenkler processen med at konvertere tekst til dato, og gør det også muligt at udføre enhver aritmetisk operation med datoer og tid.

Funktionerne today() og now().

today() # dagens dato
now()   # dagens dato og tid

For at konvertere en streng til en dato i lubridate er der en hel familie af funktioner, hvis navne altid består af tre bogstaver og angiver rækkefølgen af datokomponenter:

y — år
m — måned
d — dag

Liste over funktioner til at konvertere tekst til dato via lubridate

ymd()
ydm()
mdy()
myd()
dmy()
dym()
yq()

Flere eksempler på konvertering af strenge til datoer:

ymd("2017 jan 21")
mdy("March 20th, 2019")
dmy("1st april of 2018")

Som du kan se, lubridate er betydeligt mere effektiv til at genkende tekstbeskrivelser af datoer og muliggør at konvertere tekst til dato uden at bruge yderligere operatorer til at beskrive formatet.

Udtakning af datokomponenter ved hjælp af pakken lubridate

Desuden kan du med lubridate få enhver komponent fra en dato:

dt <- ymd("2017 jan 21")

year(dt)  # år
month(dt) # måned
mday(dt)  # dag i måneden
yday(dt)  # dag på året
wday(dt)  # ugedag

Aritmetiske operationer med datoer

Men den mest vigtige og grundlæggende funktionalitet lubridate er muligheden for at udføre forskellige aritmetiske operationer med datoer.

Datoen rundes af ved hjælp af tre funktioner:

floor_date — runding til det nærmeste forgangne tidspunkt
ceiling_date — runding til det nærmeste kommende tidspunkt
round_date — runding til det nærmeste tidspunkt

Hver af disse funktioner har et argument unit, som gør det muligt for dig at angive rundingsenheden: second, minute, hour, day, week, month, bimonth, quarter, season, halfyear, year

dt <- ymd("2017 jan 21")

round_date(dt, unit = "month")    # rund til måned
round_date(dt, unit = "3 month")  # rund til 3 måneder
round_date(dt, unit = "quarter")  # rund til kvartal
round_date(dt, unit = "season")   # rund til sæson
round_date(dt, unit = "halfyear") # rund til halvår

Lad os så se på, hvordan man kan få en dato, der er 8 dage efter den aktuelle dato, og udføre forskellige andre aritmetiske beregninger mellem to datoer.

today() + days(8)   # hvilken dato vil der være om 8 dage
today() - months(2) # hvilken dato var for 2 måneder siden
today() + weeks(12) # hvilken dato vil der være om 12 uger
today() - years(2)  # hvilken dato var for 2 år siden

Forenklet arbejde med perioder, pakken timeperiodsR.

timeperiodsR — en ny pakke til arbejde med datoer, der blev offentliggjort på CRAN i september 2019.

Installation af pakken timeperiodsR:

install.packages("timeperiodsR")

Hovedformålet er hurtig bestemmelse af et tidsinterval i forhold til en given dato. For eksempel kan du nemt:

Finde den forgangne uge, måned, kvartal eller år i R.
Finde et angivet antal tidsintervaller i forhold til en dato, såsom de forgangne 4 uger.
Nem ekstraktion af komponenterne i det opnåede tidsinterval: start- og slutdato, antal dage der falder inden for intervallet, hele rækken af datoer, der indgår i det.

Navnene på alle funktioner i pakken timeperiodsR er intuitive og består af to dele: retning_interval, hvor:

retning den retning, der skal bevæges i forhold til den givne dato: last_n, previous, this, next, next_n.
tidsmæssig interval til beregning af perioden: day, week, month, quarter, year.

Det fulde sæt funktioner:

last_n_days()
last_n_weeks()
last_n_months()
last_n_quarters()
last_n_years()
previous_week()
previous_month()
previous_quarter()
previous_year()
this_week()
this_month()
this_quarter()
this_year()
next_week()
next_month()
next_quarter()
next_year()
next_n_days()
next_n_weeks()
next_n_months()
next_n_quarters()
next_n_years()
custom_period()

Tidsintervaller i timeperiodsR

Disse funktioner er nyttige i tilfælde, hvor du har brug for at udarbejde rapporter baseret på data fra den forgangne uge eller måned. For at få den forgangne måned, brug den tilsvarende funktion previous_month():

prmonth <- previous_month()

Efterfølgende vil du have et objekt prmåned klassen tpr, hvorfra du nemt kan få følgende komponenter:

startdatoen for perioden, i vores eksempel den forrige måned
slutdatoen for perioden
antallet af dage, der er inkluderet i perioden
sekvensen af datoer, der er inkluderet i perioden

Og du kan få hver af komponenterne på forskellige måder:

# первый день периода
prmonth$start
start(prmonth)

# последний день периода
prmonth$end
end(prmonth)

# последовательность дат
prmonth$sequence
seq(prmonth)

# количество дней входящих в период
prmonth$length
length(prmonth)

Du kan også få en hvilken som helst af komponenterne ved at bruge argumentet part, som er til stede i hver af funktionerne i pakken. Mulige værdier: start, end, sequence, length.

previous_month(part = "start")    # starten af perioden
previous_month(part = "end")      # slutningen af perioden
previous_month(part = "sequence") # sekvens af datoer
previous_month(part = "length")   # antal dage i perioden

Lad os se på alle argumenterne tilgængelige i funktionerne i pakken timeperiodsR:

x — Referencedatoen, som tidsperioden vil blive beregnet fra, som standard den nuværende dato;
n — Antallet af intervaller, der vil være inkluderet i perioden, for eksempel 3 foregående uger;
part — Hvilken komponent af objektet tpr du skal have, som standard alle;
uge_start — Argumentet er kun til stede i funktioner til arbejde med uger og tillader at angive, hvilken ugedag der skal betragtes som starten; som standard er starten af ugen mandag, men du kan angive en hvilken som helst fra 1 — mandag til 7 — søndag.

Dermed kan du beregne enhver tidsperiode i forhold til den nuværende eller enhver anden given dato, lad mig give flere eksempler:

# получить 3 прошлые недели
# от 6 октября 2019 года
# начало недели - понедельник
last_n_weeks(x = "2019-10-06", 
             n = 3, 
             week_start = 1)

 Tidsperiode: fra 9. september 2019, mandag til 29. september 2019, søndag

6. oktober er en søndag:

Vi har brug for en periode, der i forhold til 6. oktober tager 3 foregående uger. Uden at inkludere den uge, hvor 6. oktober falder. Derfor er det perioden fra 9. til 29. september.

# получить месяц отстающий на 4 месяца
# от 16 сентября 2019 года
previous_month(x = "2019-09-16", n = 4)

 Tidsperiode: fra 1. maj 2019, onsdag til 31. maj 2019, fredag

I dette eksempel er vi interesseret i den måned, der var for 4 måneder siden, hvis vi tager udgangspunkt i 16. september 2019, så var det maj 2019.

Filtrering af datovektorer ved hjælp af timeperiodsR

Til filtrering af datoer i timeperiodsR er der flere operatorer:

%left_out% — sammenligner to objekter af klassen tpr og returnerer værdien fra venstre, som ikke findes i højre.
%left_in% — sammenligner to objekter af klassen tpr og returnerer datoer fra det venstre objekt, der er inkluderet i det højre.
%right_out% — sammenligner to objekter af klassen tpr og returnerer værdien fra højre, som ikke findes i venstre.
%right_in% — sammenligner to objekter af klassen tpr og returnerer datoerne fra det højre objekt, som findes i det venstre.

period1 <- this_month("2019-11-07")
period2 <- previous_week("2019-11-07")

period1 %left_in% period2   # få datoer fra period1, der er i period2
period1 %left_out% period2  # få datoer fra period1, der ikke er i period2
period1 %right_in% period2  # få datoer fra period2, der er i period1
period1 %right_out% period2 # få datoer fra period2, der ikke er i period1

Pakken timeperiodsR har en officiel, dansksproget YouTube-playliste.

Konklusion

Vi har grundigt gennemgået de objektklasser, der er designet i R-sproget til at arbejde med datoer. Du har også lært at udføre aritmetiske operationer med datoer og hurtigt få adgang til ethvert tidsrum ved hjælp af pakken timeperiodsR.

Hvis du er interesseret i R-sproget, inviterer jeg dig til at tilmelde dig min Telegram-kanal R4marketing, hvor jeg dagligt deler nyttige materialer om anvendelsen af R-sproget til løsning af mine daglige opgaver.

Kilde: habr.com