ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയിലും നിലവിലെ തീയതി നേടുക, "ഹലോ വേൾഡ്!" എന്നതിന് തുല്യമായ പ്രവർത്തനമാണ്. ആർ ഭാഷയും ഒരു അപവാദമല്ല.

ഈ ലേഖനത്തിൽ, R ഭാഷയുടെ അടിസ്ഥാന വാക്യഘടനയിൽ തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നത് എങ്ങനെയെന്ന് നോക്കാം, കൂടാതെ തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ അതിന്റെ കഴിവുകൾ വികസിപ്പിക്കുന്ന നിരവധി ഉപയോഗപ്രദമായ പാക്കേജുകളും നോക്കാം:

• lubridate - തീയതികൾക്കിടയിൽ ഗണിത കണക്കുകൂട്ടലുകൾ നടത്താൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പാക്കേജ്;
• timeperiodsR - സമയ ഇടവേളകളും അവയുടെ ഘടകങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു പാക്കേജ്.

ഉള്ളടക്കം

നിങ്ങൾക്ക് ഡാറ്റ വിശകലനത്തിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, പ്രത്യേകിച്ച് R ഭാഷയിൽ, നിങ്ങൾക്ക് എന്റെ താൽപ്പര്യമുണ്ടാകാം ടെലഗ്രാം и YouTube ചാനലുകൾ. ഉള്ളടക്കത്തിന്റെ ഭൂരിഭാഗവും R ഭാഷയ്‌ക്കായി സമർപ്പിച്ചിരിക്കുന്നു.

1. അടിസ്ഥാന R വാക്യഘടനയിൽ തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു
   1.1. വാചകം തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുക
   1.2. അടിസ്ഥാന R-ൽ തീയതി ഘടകങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു
2. ലൂബ്രിഡേറ്റ് പാക്കേജ് ഉപയോഗിച്ച് തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു
   2.1. ലൂബ്രിഡേറ്റ് ഉപയോഗിച്ച് വാചകം തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുക
   2.2. ലൂബ്രിഡേറ്റ് പാക്കേജ് ഉപയോഗിച്ച് തീയതി ഘടകങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു
   2.3. തീയതികളുള്ള ഗണിത പ്രവർത്തനങ്ങൾ
3. കാലയളവുകൾ, സമയപരിധികൾ ആർ പാക്കേജ് എന്നിവയ്‌ക്കൊപ്പം ലളിതമാക്കിയ ജോലി
   3.1. സമയപരിധികളിൽ സമയ ഇടവേളകൾR
   3.2. timeperiodsR ഉപയോഗിച്ച് തീയതികളുടെ വെക്റ്റർ ഫിൽട്ടർ ചെയ്യുന്നു
4. തീരുമാനം

അടിസ്ഥാന R വാക്യഘടനയിൽ തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

വാചകം തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുക

അടിസ്ഥാന R തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു കൂട്ടം ഫംഗ്ഷനുകൾ ഉണ്ട്. ഫംഗ്‌ഷൻ നാമങ്ങളുടെയും ആർഗ്യുമെന്റുകളുടെയും കേസ് വളരെ ചിതറിക്കിടക്കുന്നതും പ്രായോഗികമായി ലോജിക്കൽ കണക്ഷനില്ലാത്തതുമാണ് അടിസ്ഥാന വാക്യഘടനയുടെ പോരായ്മ. എന്നിരുന്നാലും, ഭാഷയുടെ അടിസ്ഥാന പ്രവർത്തനങ്ങൾ നിങ്ങൾ അറിയേണ്ടതുണ്ട്, അതിനാൽ ഞങ്ങൾ അവരുമായി ആരംഭിക്കും.

മിക്കപ്പോഴും, csv ഫയലുകളിൽ നിന്നോ മറ്റ് ഉറവിടങ്ങളിൽ നിന്നോ R-ലേക്ക് ഡാറ്റ ലോഡുചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് ഒരു തീയതി ടെക്‌സ്‌റ്റായി ലഭിക്കും. ഈ വാചകം ശരിയായ ഡാറ്റ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ, ഫംഗ്ഷൻ ഉപയോഗിക്കുക 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"

സ്ഥിരമായി as.Date() രണ്ട് ഫോർമാറ്റുകളിൽ തീയതി സ്വീകരിക്കുന്നു: YYYY-MM-DD അഥവാ YYYY/MM/DD.
നിങ്ങളുടെ ഡാറ്റാ സെറ്റിൽ മറ്റേതെങ്കിലും ഫോർമാറ്റിലുള്ള തീയതികൾ ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ആർഗ്യുമെന്റ് ഉപയോഗിക്കാം format.

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

ഫോർമാറ്റ് ഏത് സമയ ഇടവേളയും അതിന്റെ ഫോർമാറ്റും സൂചിപ്പിക്കുന്ന സ്ട്രിംഗ് രൂപത്തിൽ ഓപ്പറേറ്റർമാരെ സ്വീകരിക്കുന്നു; ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന മൂല്യങ്ങൾ ചുവടെയുള്ള പട്ടികയിൽ കാണിച്ചിരിക്കുന്നു:

ഫോർമാറ്റ് ചെയ്യുക
വിവരണം

%d
മാസത്തിലെ ദിവസ നമ്പർ

%a
ആഴ്ചയിലെ ദിവസത്തിന്റെ പേരിന്റെ ചുരുക്കെഴുത്ത്

%A
ആഴ്ചയിലെ ദിവസത്തിന്റെ മുഴുവൻ പേര്

%w
ആഴ്ചയിലെ ദിവസത്തിന്റെ എണ്ണം (0-6, ഇവിടെ 0 ഞായറാഴ്ചയാണ്)

%m
രണ്ടക്ക മാസ പദവി (01-12)

%b
മാസത്തിന്റെ പേരിന്റെ ചുരുക്കെഴുത്ത് (ഏപ്രിൽ, മാർ, ...)

%B
മുഴുവൻ മാസവും പേര്

%y
രണ്ട് അക്ക വർഷ പദവി

%Y
നാലക്ക വർഷ പദവി

%j
വർഷത്തിലെ ദിവസ സംഖ്യ (001 - 366)

%U
വർഷത്തിലെ ആഴ്ചയുടെ എണ്ണം (00 - 53), ആഴ്ചയുടെ ആരംഭം ഞായറാഴ്ച

%W
വർഷത്തിലെ ആഴ്ച സംഖ്യ (00 - 53), ആഴ്ചയുടെ ആരംഭം തിങ്കളാഴ്ച

അതനുസരിച്ച്, “സെപ്റ്റംബർ 26, 2019” എന്നത് മാസത്തിന്റെയും തീയതിയുടെയും വർഷത്തിന്റെയും മുഴുവൻ പേരാണ്. ഓപ്പറേറ്റർമാർ ഉപയോഗിച്ച് ഈ തീയതി ഫോർമാറ്റ് ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിക്കാം:"%B %d, %Y".

എവിടെയാണ്:

• %B - മാസത്തിന്റെ മുഴുവൻ പേര്
• %d - മാസത്തിലെ ദിവസത്തിന്റെ എണ്ണം
• %Y - നാലക്ക വർഷ പദവി

തീയതി ഫോർമാറ്റ് വിവരിക്കുമ്പോൾ, നിങ്ങളുടെ സ്‌ട്രിംഗിൽ നിന്ന് ഡാഷുകൾ, കോമകൾ, പിരീഡുകൾ, സ്‌പെയ്‌സുകൾ മുതലായവ പോലുള്ള എല്ലാ അധിക പ്രതീകങ്ങളും ഉൾപ്പെടുത്തേണ്ടത് പ്രധാനമാണ്. എന്റെ ഉദാഹരണത്തിൽ, “സെപ്റ്റംബർ 26, 2019”, തീയതിക്ക് ശേഷം ഒരു കോമയുണ്ട്, കൂടാതെ ഫോർമാറ്റ് വിവരണത്തിൽ നിങ്ങൾ ഒരു കോമ ഇടുകയും വേണം:"%B %d, %Y".

സ്റ്റാൻഡേർഡ് ഫോർമാറ്റുകളുമായി പൊരുത്തപ്പെടാത്ത ഒരു തീയതി നിങ്ങൾക്ക് ലഭിക്കുമ്പോൾ സാഹചര്യങ്ങളുണ്ട് (YYYY-MM-DD അല്ലെങ്കിൽ YYYY/MM/DD), മാത്രമല്ല നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഡിഫോൾട്ടിൽ നിന്നും വ്യത്യസ്തമായ ഭാഷയിലും. ഉദാഹരണത്തിന്, തീയതി ഇതുപോലെ സൂചിപ്പിച്ചിരിക്കുന്ന ഡാറ്റ നിങ്ങൾ ഡൗൺലോഡ് ചെയ്തു: "ഡിസംബർ 15, 2019." ഈ സ്‌ട്രിംഗ് ഒരു തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിന് മുമ്പ്, നിങ്ങൾ ലൊക്കേൽ മാറ്റേണ്ടതുണ്ട്.

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

അടിസ്ഥാന R-ൽ തീയതി ഘടകങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു

ഒരു ക്ലാസ് ഒബ്‌ജക്‌റ്റിൽ നിന്ന് ഒരു തീയതിയുടെ ഏതെങ്കിലും ഭാഗം എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന അടിസ്ഥാന R-ൽ ധാരാളം ഫംഗ്‌ഷനുകൾ ഇല്ല തീയതി.

current_date <- Sys.Date() # текущая дата
weekdays(current_date)     # получить номер дня недели
months(current_date)       # получить номер месяца в году
quarters(current_date)     # получить номер квартала в году

പ്രധാന ഒബ്ജക്റ്റ് ക്ലാസിന് പുറമേ തീയതി അടിസ്ഥാന R-ൽ ഒരു ടൈംസ്റ്റാമ്പ് സംഭരിക്കുന്ന 2 ഡാറ്റ തരങ്ങൾ കൂടി ഉണ്ട്: POSIXlt, POSIXct. ഈ ക്ലാസുകൾ തമ്മിലുള്ള പ്രധാന വ്യത്യാസവും തീയതി അത് അവർ സമയം സംഭരിക്കുന്ന തീയതിക്ക് പുറമേയാണ്.

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

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

# "POSIXct" "POSIXt"

ഫംഗ്ഷൻ Sys.time() ഫോർമാറ്റിൽ നിലവിലെ തീയതിയും സമയവും നൽകുന്നു POSIXct. ഈ ഫോർമാറ്റ് അർത്ഥത്തിൽ സമാനമാണ് UNIXTIME, കൂടാതെ UNIX യുഗത്തിന്റെ തുടക്കം മുതലുള്ള സെക്കൻഡുകളുടെ എണ്ണം സംഭരിക്കുന്നു (അർദ്ധരാത്രി (UTC) ഡിസംബർ 31, 1969 മുതൽ ജനുവരി 1, 1970 വരെ).

ക്ലാസ് POSIXlt ഇത് സമയവും തീയതിയും അവയുടെ എല്ലാ ഘടകങ്ങളും സംഭരിക്കുന്നു. അതിനാൽ, ഇത് കൂടുതൽ സങ്കീർണ്ണമായ ഘടനയുള്ള ഒരു വസ്തുവാണ്, എന്നാൽ അതിൽ നിന്ന് ഏത് തീയതിയും സമയവും ഘടകഭാഗം ലഭിക്കാൻ എളുപ്പമാണ് സത്യത്തിൽ POSIXlt അത് പട്ടിക.

# Получаем текущую дату и время
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  # часовой пояс

സംഖ്യാ, ടെക്സ്റ്റ് ഡാറ്റ ഫോർമാറ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു പോസിക്സ്* പ്രവർത്തനങ്ങൾ നടത്തി as.POSIXct() и as.POSIXlt(). ഈ ഫംഗ്‌ഷനുകൾക്ക് ഒരു ചെറിയ കൂട്ടം ആർഗ്യുമെന്റുകളുണ്ട്.

• x - നമ്പർ, സ്ട്രിംഗ് അല്ലെങ്കിൽ ക്ലാസ് ഒബ്ജക്റ്റ് തീയതി, പരിവർത്തനം ചെയ്യേണ്ടത്;
• tz - സമയ മേഖല, സ്ഥിരസ്ഥിതി "GMT";
• ഫോർമാറ്റ് - x ആർഗ്യുമെന്റിലേക്ക് കൈമാറിയ ഡാറ്റ പ്രതിനിധീകരിക്കുന്ന തീയതി ഫോർമാറ്റിന്റെ വിവരണം;
• ഉത്ഭവം - ഒരു സംഖ്യയെ POSIX-ലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ മാത്രം ഉപയോഗിക്കുന്നു; ഈ ആർഗ്യുമെന്റിലേക്ക് സെക്കൻഡുകൾ കണക്കാക്കുന്ന തീയതി ഒബ്ജക്റ്റും സമയവും നിങ്ങൾ നൽകണം. UNIXTIME മുതൽ വിവർത്തനം ചെയ്യാൻ സാധാരണയായി ഉപയോഗിക്കുന്നു.

നിങ്ങളുടെ തീയതിയും സമയവും സംബന്ധിച്ച വിവരങ്ങൾ ഉണ്ടെങ്കിൽ UNIXTIME, തുടർന്ന് അവയെ വ്യക്തവും വായിക്കാവുന്നതുമായ തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിന്, ഇനിപ്പറയുന്ന ഉദാഹരണം ഉപയോഗിക്കുക:

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

ഉത്ഭവത്തിൽ നിങ്ങൾക്ക് ഏത് സമയ സ്റ്റാമ്പും വ്യക്തമാക്കാം. ഉദാഹരണത്തിന്, നിങ്ങളുടെ ഡാറ്റയിൽ 15 സെപ്റ്റംബർ 2019, 12:15 pm മുതലുള്ള സെക്കൻഡുകളുടെ എണ്ണമായി തീയതിയും സമയവും അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അത് ഒരു തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ഉപയോഗിക്കുക:

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

ലൂബ്രിഡേറ്റ് പാക്കേജ് ഉപയോഗിച്ച് തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

lubridate R ഭാഷയിൽ തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഏറ്റവും ജനപ്രിയമായ പാക്കേജ്. ഇത് നിങ്ങൾക്ക് മൂന്ന് അധിക ക്ലാസുകൾ നൽകുന്നു.

• ദൈർഘ്യം - ദൈർഘ്യം, അതായത്. രണ്ട് ടൈംസ്റ്റാമ്പുകൾക്കിടയിലുള്ള സെക്കൻഡുകളുടെ എണ്ണം;
• കാലയളവുകൾ - മനുഷ്യർക്ക് വായിക്കാവുന്ന ഇടവേളകളിൽ തീയതികൾക്കിടയിൽ കണക്കുകൂട്ടലുകൾ നടത്താൻ കാലയളവുകൾ നിങ്ങളെ അനുവദിക്കുന്നു: ദിവസങ്ങൾ, മാസങ്ങൾ, ആഴ്ചകൾ മുതലായവ;
• ഇടവേളകൾ - സമയത്തിന്റെ ആരംഭവും അവസാനവും നൽകുന്ന വസ്തുക്കൾ.

സ്റ്റാൻഡേർഡ് ഫംഗ്ഷൻ ഉപയോഗിച്ചാണ് R ഭാഷയിൽ അധിക പാക്കേജുകളുടെ ഇൻസ്റ്റാളേഷൻ നടത്തുന്നത് install.packages().

പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു lubridate:

install.packages("lubridate")

ലൂബ്രിഡേറ്റ് ഉപയോഗിച്ച് വാചകം തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുക

പാക്കേജ് സവിശേഷതകൾ lubridate വാചകം ഒരു തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുന്ന പ്രക്രിയയെ ഗണ്യമായി ലഘൂകരിക്കുന്നു, കൂടാതെ തീയതികളും സമയവും ഉപയോഗിച്ച് ഏതെങ്കിലും ഗണിത പ്രവർത്തനങ്ങൾ നടത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു.

നിലവിലെ തീയതി അല്ലെങ്കിൽ തീയതിയും സമയവും ലഭിക്കാൻ ഫംഗ്ഷനുകൾ നിങ്ങളെ സഹായിക്കും today() и now().

today() # текущая дата
now()   # текущая дата и время

ഒരു സ്ട്രിംഗിനെ ഒരു തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ lubridate ഫംഗ്‌ഷനുകളുടെ ഒരു കുടുംബം മുഴുവനും ഉണ്ട്, അവയുടെ പേരുകൾ എല്ലായ്പ്പോഴും മൂന്ന് അക്ഷരങ്ങൾ ഉൾക്കൊള്ളുന്നു, കൂടാതെ തീയതി ഘടകങ്ങളുടെ ക്രമം സൂചിപ്പിക്കുന്നു:

• y - വർഷം
• m - മാസം
• d - ദിവസം

ലൂബ്രിഡേറ്റ് വഴി വാചകം തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള പ്രവർത്തനങ്ങളുടെ ലിസ്റ്റ്

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

സ്ട്രിംഗുകൾ തീയതികളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ചില ഉദാഹരണങ്ങൾ:

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

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ lubridate തീയതി വിവരണങ്ങൾ ടെക്‌സ്‌റ്റായി തിരിച്ചറിയുന്നതിൽ ഇത് കൂടുതൽ കാര്യക്ഷമമാണ്, കൂടാതെ ഫോർമാറ്റ് വിവരിക്കുന്നതിന് അധിക ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കാതെ തന്നെ വാചകം തീയതിയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ലൂബ്രിഡേറ്റ് പാക്കേജ് ഉപയോഗിച്ച് തീയതി ഘടകങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു

കൂടാതെ ഉപയോഗിക്കുന്നു lubridate ഒരു തീയതി മുതൽ നിങ്ങൾക്ക് ഏത് ഘടകവും ലഭിക്കും:

dt <- ymd("2017 jan 21")

year(dt)  # год
month(dt) # месяц
mday(dt)  # день в месяце
yday(dt)  # день в году
wday(dt)  # день недели

തീയതികളുള്ള ഗണിത പ്രവർത്തനങ്ങൾ

എന്നാൽ ഏറ്റവും പ്രധാനപ്പെട്ടതും അടിസ്ഥാനപരവുമായ പ്രവർത്തനം lubridate തീയതികൾ ഉപയോഗിച്ച് വിവിധ ഗണിത പ്രവർത്തനങ്ങൾ നടത്താനുള്ള കഴിവാണ്.

തീയതി റൗണ്ടിംഗ് മൂന്ന് ഫംഗ്ഷനുകളാൽ നിർവ്വഹിക്കുന്നു:

• floor_date - ഏറ്റവും അടുത്തുള്ള ഭൂതകാലത്തിലേക്ക് റൗണ്ടിംഗ്
• ceiling_date - സമീപഭാവി കാലഘട്ടത്തിലേക്ക് റൗണ്ടിംഗ്
• round_date - അടുത്തുള്ള സമയത്തേക്ക് റൗണ്ടിംഗ്

ഈ പ്രവർത്തനങ്ങളിൽ ഓരോന്നിനും ഒരു വാദം ഉണ്ട് യൂണിറ്റ്റൗണ്ടിംഗ് യൂണിറ്റ് വ്യക്തമാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു: സെക്കൻഡ്, മിനിറ്റ്, മണിക്കൂർ, ദിവസം, ആഴ്ച, മാസം, ദ്വിമാസം, പാദം, സീസൺ, അർദ്ധവർഷം, വർഷം

dt <- ymd("2017 jan 21")

round_date(dt, unit = "month")    # округлить до месяца
round_date(dt, unit = "3 month")  # округлить до 3 месяцев
round_date(dt, unit = "quarter")  # округлить до квартала
round_date(dt, unit = "season")   # округлить до сезона
round_date(dt, unit = "halfyear") # округлить до полугодия

അതിനാൽ, നിലവിലെ തീയതിയിൽ നിന്ന് 8 ദിവസത്തിന് ശേഷമുള്ള ഒരു തീയതി എങ്ങനെ നേടാമെന്നും രണ്ട് തീയതികൾക്കിടയിൽ മറ്റ് വിവിധ ഗണിത കണക്കുകൂട്ടലുകൾ നടത്താമെന്നും നമുക്ക് നോക്കാം.

today() + days(8)   # какая дата будет через 8 дней
today() - months(2) # какая дата была 2 месяца назад
today() + weeks(12) # какая дата будет через 12 недель
today() - years(2)  # какая дата была 2 года назад

കാലയളവുകൾ, സമയപരിധികൾ ആർ പാക്കേജ് എന്നിവയ്‌ക്കൊപ്പം ലളിതമാക്കിയ ജോലി.

timeperiodsR - 2019 സെപ്റ്റംബറിൽ CRAN-ൽ പ്രസിദ്ധീകരിച്ച തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു പുതിയ പാക്കേജ്.

പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു timeperiodsR:

install.packages("timeperiodsR")

ഒരു നിശ്ചിത തീയതിയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഒരു നിശ്ചിത സമയ ഇടവേള വേഗത്തിൽ നിർണ്ണയിക്കുക എന്നതാണ് പ്രധാന ലക്ഷ്യം. ഉദാഹരണത്തിന്, അതിന്റെ പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് എളുപ്പത്തിൽ ചെയ്യാം:

• R-ൽ കഴിഞ്ഞ ആഴ്‌ചയോ മാസമോ പാദമോ വർഷമോ നേടുക.
• ഒരു തീയതിയുമായി ബന്ധപ്പെട്ട ഒരു നിശ്ചിത സമയ ഇടവേളകൾ നേടുക, ഉദാഹരണത്തിന് കഴിഞ്ഞ 4 ആഴ്ചകൾ.
• തത്ഫലമായുണ്ടാകുന്ന സമയ ഇടവേളയിൽ നിന്ന് അതിന്റെ ഘടകങ്ങൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നത് എളുപ്പമാണ്: ആരംഭ, അവസാന തീയതി, ഇടവേളയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ദിവസങ്ങളുടെ എണ്ണം, അതിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന തീയതികളുടെ മുഴുവൻ ക്രമവും.

എല്ലാ പാക്കേജ് ഫംഗ്‌ഷനുകളുടെയും പേര് timeperiodsR അവബോധജന്യവും രണ്ട് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു: ദിശ_ഇടവേള, എവിടെയാണ്:

• ദിശ അതിൽ നിങ്ങൾ നൽകിയിരിക്കുന്ന തീയതിയുമായി താരതമ്യപ്പെടുത്തേണ്ടതുണ്ട്: last_n, മുമ്പത്തെ, ഇത്, അടുത്തത്, next_n.
• താൽക്കാലികം ഇടവേള കാലയളവ് കണക്കാക്കാൻ: ദിവസം, ആഴ്ച, മാസം, പാദം, വർഷം.

പ്രവർത്തനങ്ങളുടെ പൂർണ്ണ സെറ്റ്:

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

സമയപരിധികളിൽ സമയ ഇടവേളകൾR

കഴിഞ്ഞ ആഴ്‌ചയിലോ മാസത്തിലോ ഉള്ള ഡാറ്റയെ അടിസ്ഥാനമാക്കി നിങ്ങൾ റിപ്പോർട്ടുകൾ നിർമ്മിക്കേണ്ട സന്ദർഭങ്ങളിൽ ഈ ഫംഗ്‌ഷനുകൾ ഉപയോഗപ്രദമാണ്. കഴിഞ്ഞ മാസം ലഭിക്കാൻ, അതേ പേരിന്റെ പ്രവർത്തനം ഉപയോഗിക്കുക previous_month():

prmonth <- previous_month()

അതിനുശേഷം നിങ്ങൾക്ക് ഒരു വസ്തു ഉണ്ടാകും മാസം ക്ലാസ് ടിപിആർ, അതിൽ നിന്ന് ഇനിപ്പറയുന്ന ഘടകങ്ങൾ എളുപ്പത്തിൽ ലഭിക്കും:

• കാലയളവിന്റെ ആരംഭ തീയതി, ഞങ്ങളുടെ ഉദാഹരണത്തിൽ ഇത് അവസാന മാസമാണ്
• കാലയളവ് അവസാനിക്കുന്ന തീയതി
• കാലയളവിൽ ഉൾപ്പെടുത്തിയ ദിവസങ്ങളുടെ എണ്ണം
• കാലയളവിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന തീയതികളുടെ ക്രമം

കൂടാതെ, നിങ്ങൾക്ക് ഓരോ ഘടകങ്ങളും വ്യത്യസ്ത രീതികളിൽ ലഭിക്കും:

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

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

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

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

ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഏതെങ്കിലും ഘടകങ്ങൾ നേടാനും കഴിയും ഭാഗം, ഇത് ഓരോ പാക്കേജ് ഫംഗ്ഷനുകളിലും ഉണ്ട്. സാധ്യമായ മൂല്യങ്ങൾ: ആരംഭം, അവസാനം, ക്രമം, ദൈർഘ്യം.

previous_month(part = "start")    # начало периода
previous_month(part = "end")      # конец периода
previous_month(part = "sequence") # последовательность дат
previous_month(part = "length")   # количество дней в периоде

അതിനാൽ പാക്കേജ് ഫംഗ്ഷനുകളിൽ ലഭ്യമായ എല്ലാ ആർഗ്യുമെന്റുകളും നോക്കാം timeperiodsR:

• x - കാലയളവ് കണക്കാക്കുന്ന റഫറൻസ് തീയതി, സ്ഥിരസ്ഥിതിയായി നിലവിലെ തീയതി;
• n - കാലയളവിൽ ഉൾപ്പെടുത്തേണ്ട ഇടവേളകളുടെ എണ്ണം, ഉദാഹരണത്തിന് മുമ്പത്തെ 3 ആഴ്ചകൾ;
• part - വസ്തുവിന്റെ ഏത് ഘടകം tpr നിങ്ങൾക്ക് സ്ഥിരസ്ഥിതിയായി ലഭിക്കേണ്ടതുണ്ട് all;
• week_start — ആഴ്‌ചകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഫംഗ്‌ഷനുകളിൽ മാത്രമേ വാദം നിലവിലുള്ളൂ, കൂടാതെ ആഴ്‌ചയിലെ ദിവസത്തിന്റെ എണ്ണം അതിന്റെ ആരംഭമായി കണക്കാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ആഴ്‌ചയുടെ ആരംഭം തിങ്കളാഴ്ചയാണ്, എന്നാൽ നിങ്ങൾക്ക് ഇതിൽ നിന്ന് ഏത് വേണമെങ്കിലും സജ്ജീകരിക്കാനാകും. 1 - തിങ്കൾ മുതൽ 7 വരെ - ഞായർ.

അതിനാൽ, നിലവിലുള്ള അല്ലെങ്കിൽ മറ്റേതെങ്കിലും തീയതിയുമായി ബന്ധപ്പെട്ട ഏത് സമയ കാലയളവും നിങ്ങൾക്ക് കണക്കാക്കാം; കുറച്ച് ഉദാഹരണങ്ങൾ കൂടി ഇതാ:

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

 Time period: from  9 September of 2019, Monday to 29 September of 2019, Sunday

ഒക്ടോബർ 6 ഞായറാഴ്ചയാണ്:

ഒക്ടോബർ 6 ന് ആപേക്ഷികമായി, മുമ്പത്തെ 3 ആഴ്‌ചകൾ എടുക്കുന്ന ഒരു കാലയളവ് ഞങ്ങൾക്ക് ആവശ്യമാണ്. ഒക്ടോബർ 6 ഉൾപ്പെടുന്ന ആഴ്‌ച ഉൾപ്പെടുത്തിയിട്ടില്ല. ഇതനുസരിച്ച് സെപ്റ്റംബർ 9 മുതൽ 29 വരെയുള്ള കാലയളവാണിത്.

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

 Time period: from  1 May of 2019, Wednesday to 31 May of 2019, Friday

ഈ ഉദാഹരണത്തിൽ, 4 മാസം മുമ്പുള്ള മാസത്തിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്, ഞങ്ങൾ 16 സെപ്റ്റംബർ 2019 മുതൽ ആരംഭിക്കുകയാണെങ്കിൽ, അത് മെയ് 2019 ആയിരുന്നു.

timeperiodsR ഉപയോഗിച്ച് തീയതികളുടെ വെക്റ്റർ ഫിൽട്ടർ ചെയ്യുന്നു

തീയതികൾ ഫിൽട്ടർ ചെയ്യാൻ timeperiodsR നിരവധി ഓപ്പറേറ്റർമാർ ഉണ്ട്:

• %left_out% - രണ്ട് tpr ക്ലാസ് ഒബ്‌ജക്‌റ്റുകൾ താരതമ്യം ചെയ്യുന്നു, കൂടാതെ വലത്തേതിൽ വിട്ടുപോയ ഇടതുവശത്ത് നിന്ന് മൂല്യം നൽകുന്നു.
• %left_in% - tpr ക്ലാസിലെ രണ്ട് ഒബ്‌ജക്‌റ്റുകൾ താരതമ്യം ചെയ്യുന്നു, കൂടാതെ വലത് ഭാഗത്ത് ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഇടത് ഒബ്‌ജക്‌റ്റിൽ നിന്നുള്ള തീയതികൾ നൽകുന്നു.
• %right_out% - രണ്ട് tpr ക്ലാസ് ഒബ്‌ജക്‌റ്റുകൾ താരതമ്യം ചെയ്യുന്നു, കൂടാതെ ഇടതുവശത്ത് നിന്ന് നഷ്‌ടമായ വലത്തേതിൽ നിന്നുള്ള മൂല്യം നൽകുന്നു.
• %right_in% - tpr ക്ലാസിലെ രണ്ട് ഒബ്‌ജക്റ്റുകളെ താരതമ്യം ചെയ്യുന്നു, കൂടാതെ ഇടതുവശത്തുള്ള വലത് ഒബ്‌ജക്റ്റിൽ നിന്നുള്ള തീയതികൾ നൽകുന്നു.

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

period1 %left_in% period2   # получить даты из period1 которые входят в period2
period1 %left_out% period2  # получить даты из period1 которые не входят в period2
period1 %right_in% period2  # получить даты из period2 которые входят в period1
period1 %right_out% period2 # получить даты из period2 которые не входят в period1

പാക്കേജിൽ timeperiodsR ഒരു ഔദ്യോഗിക റഷ്യൻ ഭാഷയുണ്ട് YouTube പ്ലേലിസ്റ്റ്.

തീരുമാനം

തീയതികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനായി R ഭാഷയിൽ രൂപകൽപ്പന ചെയ്തിട്ടുള്ള വസ്തുക്കളുടെ ക്ലാസുകൾ ഞങ്ങൾ വിശദമായി പരിശോധിച്ചു. കൂടാതെ ഇപ്പോൾ നിങ്ങൾക്ക് തീയതികളിൽ ഗണിത പ്രവർത്തനങ്ങൾ നടത്താനും പാക്കേജ് ഉപയോഗിച്ച് ഏത് സമയ കാലയളവുകളും വേഗത്തിൽ നേടാനും കഴിയും timeperiodsR.

നിങ്ങൾക്ക് R ഭാഷയിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, എന്റെ ടെലിഗ്രാം ചാനൽ സബ്‌സ്‌ക്രൈബുചെയ്യാൻ ഞാൻ നിങ്ങളെ ക്ഷണിക്കുന്നു R4 മാർക്കറ്റിംഗ്, നിങ്ങളുടെ ദൈനംദിന പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് R ഭാഷ ഉപയോഗിക്കുന്നതിനെ കുറിച്ച് ഞാൻ ദിവസേന ഉപയോഗപ്രദമായ മെറ്റീരിയലുകൾ പങ്കിടുന്നു.

അവലംബം: www.habr.com