R માં ifelse() vs if

Arthur Petit

ગુરુવાર, 28 નવેમ્બર, 2024 એ 07:33:39 PM વાગ્યે

R માં શરતી મૂલ્યાંકન શા માટે અલગ પડે છે?
R માં શરતી કાર્યો સાથે કામ કરવાથી ઘણીવાર સૂક્ષ્મ છતાં ગંભીર તફાવતો પ્રકાશમાં આવે છે. ચર્ચાનો વારંવારનો વિષય એ વર્તન છે ની સરખામણીમાં , ખાસ કરીને જ્યારે જૂથબદ્ધ ડેટા અને ગુમ થયેલ મૂલ્યો સાથે કામ કરતી વખતે. 📊
તાજેતરમાં, વિકાસકર્તાઓએ તે નોંધ્યું છે જ્યારે શરત પોતે પૂરી ન થાય ત્યારે પણ સાચી અને ખોટી બંને સ્થિતિનું મૂલ્યાંકન કરી શકે છે. આનાથી બિનજરૂરી ઓવરહેડ અને પ્રોસેસિંગ વિશે ચિંતા વધે છે, જે અનપેક્ષિત ચેતવણીઓ તરફ દોરી શકે છે. 🛠️
દાખલા તરીકે, ગુમ થયેલ મૂલ્યો સાથે જૂથબદ્ધ ડેટા ફ્રેમ સાથે ચેતવણી જનરેટ કરી શકે છે જે સાથે થતું નથી . જ્યારે આનાથી કોઈ ભૂલ થતી નથી, તે ગૂંચવણમાં મૂકે છે, ખાસ કરીને જ્યારે મોટા ડેટાસેટ્સમાં પ્રદર્શન પ્રાથમિકતા હોય.
આ લેખમાં, અમે અન્વેષણ કરીશું કે આવું શા માટે થાય છે, તેને કેવી રીતે સંબોધિત કરવું અને ક્યારે પસંદ કરવું અથવા . અંત સુધીમાં, તમે આ વિધેયોની ઘોંઘાટ અને તમારા કોડ માટે તેમની અસરોને સમજી શકશો. ચાલો વાસ્તવિક દુનિયાના ઉદાહરણો અને આંતરદૃષ્ટિ સાથે ડાઇવ કરીએ! 🖥️

આદેશ ઉપયોગનું ઉદાહરણ

tibble::tribble() સંક્ષિપ્ત અને વાંચી શકાય તેવી રીતે ડેટા ફ્રેમ બનાવવા માટે વપરાય છે, ખાસ કરીને નાના ડેટાસેટ્સ માટે. દરેક પંક્તિ ઇનલાઇન વ્યાખ્યાયિત કરવામાં આવે છે, જે તેને ઉદાહરણો અથવા પરીક્ષણ દૃશ્યો માટે આદર્શ બનાવે છે.

group_by() શરતી તર્ક અથવા સારાંશ જેવી જૂથબદ્ધ કામગીરીને સક્ષમ કરીને, એક અથવા વધુ કૉલમ્સ દ્વારા ડેટા ફ્રેમ પર જૂથીકરણ લાગુ કરે છે.

mutate() ડેટા ફ્રેમમાં કૉલમ બનાવવા અથવા સુધારવા માટે વપરાય છે. આ કિસ્સામાં, તે દરેક જૂથ માટે શરતોના આધારે નવી કૉલમની ગણતરી કરે છે.

any() જો લોજિકલ વેક્ટરનું ઓછામાં ઓછું એક ઘટક સાચું હોય તો TRUE પરત કરે છે. અહીં, તે તપાસે છે કે શું કોઈ ગુમ થયેલ તારીખો જૂથમાં અસ્તિત્વમાં છે કે નહીં.

is.na() વેક્ટરમાં ગુમ થયેલ મૂલ્યો માટે તપાસે છે. તે પંક્તિઓ ઓળખવા માટે અહીં વપરાય છે જ્યાં તારીખ NA છે.

min() વેક્ટરમાં સૌથી નાનું મૂલ્ય શોધે છે. જ્યારે na.rm = TRUE સાથે જોડવામાં આવે છે, ત્યારે તે NA મૂલ્યોની અવગણના કરે છે, તેને પ્રારંભિક તારીખની ગણતરી માટે ઉપયોગી બનાવે છે.

ifelse() વેક્ટરાઇઝ્ડ કન્ડીશનલ ફંક્શન જે શરતનું મૂલ્યાંકન કરે છે અને સાચા કેસ માટે એક મૂલ્ય અને ખોટા કેસ માટે બીજું આપે છે. તે વધારાના કાસ્ટિંગ (દા.ત. તરીકે. તારીખ()) દ્વારા NA હેન્ડલિંગની મંજૂરી આપે છે.

if_else() dplyr પેકેજમાંથી ifelse() નો સખત વિકલ્પ. તે સાચા અને ખોટા વળતર મૂલ્યો વચ્ચે સુસંગત ડેટા પ્રકારોને લાગુ કરે છે, સંભવિત રનટાઇમ ભૂલોને ઘટાડે છે.

test_that() testthat લાઇબ્રેરીમાંથી, આ આદેશનો ઉપયોગ એકમ પરીક્ષણોને વ્યાખ્યાયિત કરવા માટે થાય છે. તે તપાસે છે કે ફંક્શન અથવા સ્ક્રિપ્ટનું આઉટપુટ અપેક્ષિત પરિણામો સાથે મેળ ખાય છે.

expect_equal() test_that() ની અંદર બે મૂલ્યો સમાન છે તેની ખાતરી કરવા માટે વપરાતું કાર્ય. સોલ્યુશન ઇચ્છિત તરીકે વર્તે છે તે માન્ય કરવા માટે આ મહત્વપૂર્ણ છે.

આદેશ	ઉપયોગનું ઉદાહરણ
tibble::tribble()	સંક્ષિપ્ત અને વાંચી શકાય તેવી રીતે ડેટા ફ્રેમ બનાવવા માટે વપરાય છે, ખાસ કરીને નાના ડેટાસેટ્સ માટે. દરેક પંક્તિ ઇનલાઇન વ્યાખ્યાયિત કરવામાં આવે છે, જે તેને ઉદાહરણો અથવા પરીક્ષણ દૃશ્યો માટે આદર્શ બનાવે છે.
group_by()	શરતી તર્ક અથવા સારાંશ જેવી જૂથબદ્ધ કામગીરીને સક્ષમ કરીને, એક અથવા વધુ કૉલમ્સ દ્વારા ડેટા ફ્રેમ પર જૂથીકરણ લાગુ કરે છે.
mutate()	ડેટા ફ્રેમમાં કૉલમ બનાવવા અથવા સુધારવા માટે વપરાય છે. આ કિસ્સામાં, તે દરેક જૂથ માટે શરતોના આધારે નવી કૉલમની ગણતરી કરે છે.
any()	જો લોજિકલ વેક્ટરનું ઓછામાં ઓછું એક ઘટક સાચું હોય તો TRUE પરત કરે છે. અહીં, તે તપાસે છે કે શું કોઈ ગુમ થયેલ તારીખો જૂથમાં અસ્તિત્વમાં છે કે નહીં.
is.na()	વેક્ટરમાં ગુમ થયેલ મૂલ્યો માટે તપાસે છે. તે પંક્તિઓ ઓળખવા માટે અહીં વપરાય છે જ્યાં તારીખ NA છે.
min()	વેક્ટરમાં સૌથી નાનું મૂલ્ય શોધે છે. જ્યારે na.rm = TRUE સાથે જોડવામાં આવે છે, ત્યારે તે NA મૂલ્યોની અવગણના કરે છે, તેને પ્રારંભિક તારીખની ગણતરી માટે ઉપયોગી બનાવે છે.
ifelse()	વેક્ટરાઇઝ્ડ કન્ડીશનલ ફંક્શન જે શરતનું મૂલ્યાંકન કરે છે અને સાચા કેસ માટે એક મૂલ્ય અને ખોટા કેસ માટે બીજું આપે છે. તે વધારાના કાસ્ટિંગ (દા.ત. તરીકે. તારીખ()) દ્વારા NA હેન્ડલિંગની મંજૂરી આપે છે.
if_else()	dplyr પેકેજમાંથી ifelse() નો સખત વિકલ્પ. તે સાચા અને ખોટા વળતર મૂલ્યો વચ્ચે સુસંગત ડેટા પ્રકારોને લાગુ કરે છે, સંભવિત રનટાઇમ ભૂલોને ઘટાડે છે.
test_that()	testthat લાઇબ્રેરીમાંથી, આ આદેશનો ઉપયોગ એકમ પરીક્ષણોને વ્યાખ્યાયિત કરવા માટે થાય છે. તે તપાસે છે કે ફંક્શન અથવા સ્ક્રિપ્ટનું આઉટપુટ અપેક્ષિત પરિણામો સાથે મેળ ખાય છે.
expect_equal()	test_that() ની અંદર બે મૂલ્યો સમાન છે તેની ખાતરી કરવા માટે વપરાતું કાર્ય. સોલ્યુશન ઇચ્છિત તરીકે વર્તે છે તે માન્ય કરવા માટે આ મહત્વપૂર્ણ છે.

આર માં શરતી મૂલ્યાંકન સમજવું

R માં ડેટા સાથે કામ કરતી વખતે, વચ્ચેનો તફાવત અને મહત્વપૂર્ણ બને છે, ખાસ કરીને જૂથબદ્ધ ડેટા સંદર્ભોમાં. પ્રથમ સ્ક્રિપ્ટનો ઉપયોગ દર્શાવ્યો હતો ifelse() નવી કૉલમની ગણતરી કરવા માટે, જ્યાં શરત તપાસે છે કે શું દરેક જૂથમાં કોઈ ખૂટતી તારીખો અસ્તિત્વમાં નથી. જો શરત સાચી હોય, તો તે સૌથી વહેલી બિન-ગુમ થયેલ તારીખ સોંપે છે; નહિંતર, તે સોંપે છે . આ અભિગમ સીધોસાદો છે અને સારી રીતે કાર્ય કરે છે, જો કે તેને સતત પ્રકારો સુનિશ્ચિત કરવા માટે કાસ્ટિંગ પરિણામોની જરૂર છે, જેમ કે તારીખ() તરીકે. 🎯

બીજી સ્ક્રિપ્ટનો લાભ મળે છે , dplyr પેકેજમાંથી સખત વિકલ્પ. વિપરીત , if_else() સાચા અને ખોટા વળતર મૂલ્યો વચ્ચે કડક પ્રકારની સુસંગતતા લાગુ કરે છે, જે સંભવિત ભૂલોને ઘટાડે છે. જો કે, આ કડકતા ટ્રેડ-ઓફ સાથે આવે છે: if_else() સ્થિતિના પરિણામને ધ્યાનમાં લીધા વિના સાચી અને ખોટી બંને શાખાઓનું મૂલ્યાંકન કરે છે. આના પરિણામે બિનજરૂરી ઓવરહેડ થાય છે, જેમ કે મૂલ્યાંકન કરતી વખતે અમારા ઉદાહરણમાં આપેલી ચેતવણી દ્વારા પુરાવા મળે છે માન્ય તારીખો વિનાના જૂથમાં. 🛠️

આ સમસ્યાઓને હળવી કરવા માટે, ત્રીજી સ્ક્રિપ્ટે કસ્ટમ ફંક્શન રજૂ કર્યું, , જે સૌથી જૂની બિન-ગુમ થયેલ તારીખ શોધવા માટેના તર્કને સમાવે છે. આ કાર્ય વાંચનક્ષમતા અને મોડ્યુલરિટી સુધારે છે, જે તેને સમગ્ર પ્રોજેક્ટમાં ફરીથી વાપરી શકાય તેવું બનાવે છે. તે શરતી તપાસનું સંચાલન કરે છે અને બિનજરૂરી મૂલ્યાંકનને ટાળે છે, સ્વચ્છ અને વધુ કાર્યક્ષમ ઉકેલ પ્રદાન કરે છે. દાખલા તરીકે, નિમણૂકના સમયપત્રકનું સંચાલન કરવા જેવા વાસ્તવિક-વિશ્વના સંજોગોમાં, આ અભિગમ ટાળી શકાય તેવી ચેતવણીઓને ટ્રિગર કર્યા વિના ગુમ થયેલ ડેટાનું સચોટ સંચાલન સુનિશ્ચિત કરે છે.

છેલ્લે, અમે નો ઉપયોગ કરીને તમામ ઉકેલોનું પરીક્ષણ કર્યું ચોકસાઈને માન્ય કરવા માટે પુસ્તકાલય. એકમ પરીક્ષણો, જેમ કે તપાસવું કે ગણતરી કરેલ છે મૂલ્યો અપેક્ષાઓ સાથે મેળ ખાય છે, પુષ્ટિ કરો કે સ્ક્રિપ્ટો હેતુ મુજબ કાર્ય કરે છે. મોટા ડેટાસેટ્સ અથવા ઉત્પાદન વાતાવરણમાં વિશ્વસનીયતા સુનિશ્ચિત કરવા માટે આ પરીક્ષણો આવશ્યક છે. આ તકનીકોને સંયોજિત કરીને, અમે લવચીક, પ્રદર્શન-ઑપ્ટિમાઇઝ સોલ્યુશન્સ પ્રદાન કરીએ છીએ જે R.

R માં શરતી મૂલ્યાંકનનું અન્વેષણ: ifelse() vs if_else()

R પ્રોગ્રામિંગ: જૂથબદ્ધ ડેટા મેનીપ્યુલેશન અને શરતી તર્ક માટે Tidyverse નો ઉપયોગ કરવો

# Load required libraries
library(dplyr)
library(tibble)
library(lubridate)
# Create a sample data frame
df <- tibble::tribble(
  ~record_id, ~date,
  "id_1", as.Date("2025-12-25"),
  "id_1", as.Date("2024-12-25"),
  "id_2", as.Date("2026-12-25"),
  "id_2", NA,
  "id_3", NA
)
# Solution using ifelse()
df_ifelse <- df %>%
  group_by(record_id) %>%
  mutate(non_na = ifelse(any(!is.na(date)),
                        as.Date(min(date, na.rm = TRUE)),
                        as.Date(NA)))
# View the result
print(df_ifelse)

if_else() નો ઉપયોગ કરીને ઑપ્ટિમાઇઝ સોલ્યુશન

R પ્રોગ્રામિંગ: if_else() સાથે કડક પ્રકારના નિયંત્રણ માટે ટાઈડિવર્સનો લાભ લેવો

# Load required libraries
library(dplyr)
library(tibble)
# Solution using if_else()
df_if_else <- df %>%
  group_by(record_id) %>%
  mutate(non_na = if_else(any(!is.na(date)),
                         as.Date(min(date, na.rm = TRUE)),
                         as.Date(NA)))
# View the result
print(df_if_else)

ઉન્નત મોડ્યુલારિટી માટે કસ્ટમ ફંક્શનનો ઉપયોગ કરવો

R પ્રોગ્રામિંગ: ધારના કેસોને સંબોધવા માટે કસ્ટમ ફંક્શનનો અમલ કરવો

# Define a custom function
calculate_non_na <- function(dates) {
  if (any(!is.na(dates))) {
    return(min(dates, na.rm = TRUE))
  } else {
    return(NA)
  }
}
# Apply the custom function
df_custom <- df %>%
  group_by(record_id) %>%
  mutate(non_na = as.Date(calculate_non_na(date)))
# View the result
print(df_custom)

ઉકેલોને માન્ય કરવા માટે એકમ પરીક્ષણ

R પ્રોગ્રામિંગ: ચોકસાઈ અને વિશ્વસનીયતાની ખાતરી કરવા માટે વિવિધ દૃશ્યોનું પરીક્ષણ કરવું

# Load required library for testing
library(testthat)
# Test if ifelse() produces the expected result
test_that("ifelse output is correct", {
  expect_equal(df_ifelse$non_na[1], as.Date("2024-12-25"))
  expect_equal(df_ifelse$non_na[3], as.Date(NA))
})
# Test if if_else() produces the expected result
test_that("if_else output is correct", {
  expect_equal(df_if_else$non_na[1], as.Date("2024-12-25"))
  expect_equal(df_if_else$non_na[3], as.Date(NA))
})
# Test if custom function handles edge cases
test_that("custom function output is correct", {
  expect_equal(df_custom$non_na[1], as.Date("2024-12-25"))
  expect_equal(df_custom$non_na[3], as.Date(NA))
})

R માં શરતી મૂલ્યાંકનની અદ્યતન આંતરદૃષ્ટિ

ઉપયોગ કરવાનું એક નિર્ણાયક પાસું અને R માં તેમની કામગીરીની અસરોમાં રહેલું છે, ખાસ કરીને મોટા ડેટાસેટ્સમાં. દ્વારા બંને શાખાઓનું મૂલ્યાંકન if_else(), જ્યારે સ્થિતિ ખોટી હોય ત્યારે પણ, બિનજરૂરી ગણતરી તરફ દોરી શકે છે. જેવા કાર્યો સાથે કામ કરતી વખતે આ ખાસ કરીને સ્પષ્ટ થાય છે અથવા કામગીરી કે જેમાં ગુમ થયેલ મૂલ્યો શામેલ હોય (NA). આ પ્રકારની વર્તણૂક ઓવરહેડનો પરિચય આપી શકે છે, જે કડક પ્રકારની ચકાસણી અને કોમ્પ્યુટેશનલ કાર્યક્ષમતા વચ્ચેના ટ્રેડ-ઓફનું મૂલ્યાંકન કરવું આવશ્યક બનાવે છે. 🚀

અન્ય પરિપ્રેક્ષ્ય ભૂલ હેન્ડલિંગ અને ડીબગીંગ છે. ની કડક પ્રકૃતિ સુનિશ્ચિત કરે છે કે મેળ ખાતા ડેટા પ્રકારો વહેલા પકડાય છે. આનાથી તેને મજબૂત પ્રકારની સુસંગતતાની જરૂર હોય તેવા પ્રોજેક્ટ્સ માટે એક આદર્શ પસંદગી બનાવે છે. જો કે, એવી પરિસ્થિતિઓમાં જ્યાં પ્રકારનો મેળ ખાતો નથી, વધુ લવચીક વિકલ્પ આપે છે. કમ્પ્યુટેશનલ સ્પીડ વિરુદ્ધ ટાઇપ સેફ્ટીને ક્યારે પ્રાધાન્ય આપવું તે સમજવું એ શરતી તર્ક સાથે કામ કરતા R પ્રોગ્રામરો માટે મુખ્ય નિર્ણય છે. 🔍

છેલ્લે, વૈવિધ્યપૂર્ણ કાર્યોનો ઉપયોગ, જેમ કે અગાઉ અન્વેષણ કરવામાં આવ્યું હતું, જટિલ પરિસ્થિતિઓને નિયંત્રિત કરવામાં મોડ્યુલરિટીનું મહત્વ દર્શાવે છે. શરતી તર્કને ફરીથી વાપરી શકાય તેવા કાર્યોમાં સમાવિષ્ટ કરવાથી માત્ર કોડની સ્પષ્ટતામાં સુધારો થતો નથી પરંતુ અનુરૂપ ઑપ્ટિમાઇઝેશન વ્યૂહરચનાઓ માટે પણ પરવાનગી આપે છે. આ ખાસ કરીને જૂથબદ્ધ કામગીરીને સંડોવતા વર્કફ્લોમાં મૂલ્યવાન છે, જેમ કે સમય-શ્રેણીના ડેટાની પ્રક્રિયા કરવી અથવા ખૂટતા મૂલ્યો સાથે ડેટાસેટ્સ સાફ કરવી. આ વિચારણાઓને કાળજીપૂર્વક સંતુલિત કરીને, વિકાસકર્તાઓ પ્રદર્શન અને વિશ્વસનીયતા જાળવી રાખીને તેમના ચોક્કસ ઉપયોગના કેસ માટે યોગ્ય સાધનો પસંદ કરી શકે છે. 🎯

શા માટે કરે છે બંને શાખાઓનું મૂલ્યાંકન કરો?
ડેટાની સુસંગતતા સુનિશ્ચિત કરવા માટે કડક પ્રકારનું ચેકિંગ લાગુ કરે છે અને બંને શાખાઓનું મૂલ્યાંકન કરે છે, પછી ભલે એક શાખાના પરિણામનો ઉપયોગ ન થાય.
શું ફાયદો છે ?
તે વધુ લવચીક છે, કારણ કે તે માત્ર જરૂરી શાખાનું જ મૂલ્યાંકન કરે છે, જે અમુક પરિસ્થિતિઓમાં તેને ઝડપી બનાવે છે, જોકે પ્રકાર સુસંગતતા વિશે ઓછા કડક છે.
ઉપયોગ કરતી વખતે હું ચેતવણીઓને કેવી રીતે ટાળી શકું ગુમ થયેલ મૂલ્યો સાથે?
શરત અથવા શાખા મૂલ્યો જેવા કાર્યોમાં લપેટી અને ગુમ થયેલ મૂલ્યોને સ્પષ્ટ રીતે હેન્ડલ કરવા માટે.
કરી શકે છે જૂથબદ્ધ કામગીરીને અસરકારક રીતે હેન્ડલ કરો છો?
હા, જ્યારે જેવા કાર્યો સાથે જોડવામાં આવે છે અને , જૂથબદ્ધ ડેટા માટે સારું પ્રદર્શન કરે છે.
શું વર્ણસંકર અભિગમનો ઉપયોગ કરવો શક્ય છે?
હા, સંયોજન વૈવિધ્યપૂર્ણ કાર્યો સાથે શરતી મૂલ્યાંકનમાં વધુ નિયંત્રણ અને ઑપ્ટિમાઇઝેશન માટે પરવાનગી આપે છે.
ઉપયોગ માટેના સામાન્ય કિસ્સાઓ શું છે ?
તે સામાન્ય રીતે ડેટા પ્રીપ્રોસેસિંગમાં ઉપયોગમાં લેવાય છે, જેમ કે ગુમ થયેલ મૂલ્યો પર આરોપ મૂકવો અથવા વ્યુત્પન્ન કૉલમ બનાવવા.
શા માટે પ્રકાર સુસંગતતા મહત્વપૂર્ણ છે ?
તે સુનિશ્ચિત કરે છે કે ડાઉનસ્ટ્રીમ કાર્યોમાં અણધારી પ્રકારની ભૂલો ન આવે, જે ઉત્પાદન કોડમાં નિર્ણાયક બની શકે છે.
કેવી રીતે કરે છે શરતી તર્ક વધારવા?
તે સંદર્ભ-વિશિષ્ટ ગણતરીઓને સક્ષમ કરીને, જૂથ સ્તરે શરતી કામગીરીને લાગુ કરવાની મંજૂરી આપે છે.
કસ્ટમ કાર્યો બદલી શકે છે અથવા ?
હા, વૈવિધ્યપૂર્ણ કાર્યો તર્કને સમાવી શકે છે, એજ કેસોને અસરકારક રીતે હેન્ડલ કરતી વખતે લવચીકતા અને પુનઃઉપયોગીતા પ્રદાન કરે છે.
મુખ્ય પ્રદર્શન વિચારણાઓ શું છે?
જ્યારે આળસુ મૂલ્યાંકનને કારણે ઝડપી છે, પસંદગીને સંદર્ભ-આધારિત બનાવીને સુરક્ષિત પ્રકારનું સંચાલન પૂરું પાડે છે.

ની ઘોંઘાટ સમજવી અને આર.માં કાર્યક્ષમ ડેટા મેનીપ્યુલેશન માટે નિર્ણાયક છે if_else() કડક પ્રકારની ચકાસણી પૂરી પાડે છે, તે વધારાની પ્રક્રિયા તરફ દોરી શકે છે. યોગ્ય કાર્ય પસંદ કરવું તે સંદર્ભ અને ચોક્કસ ડેટાસેટ આવશ્યકતાઓ પર આધારિત છે. 💡

મોડ્યુલર સોલ્યુશન્સ સાથે આ કાર્યોની શક્તિઓને જોડીને, વિકાસકર્તાઓ જૂથબદ્ધ ડેટા અને ગુમ થયેલ મૂલ્યોને અસરકારક રીતે હેન્ડલ કરી શકે છે. એકમ પરીક્ષણો ઉમેરવાથી વધુ વિશ્વસનીયતા સુનિશ્ચિત થાય છે, આ સાધનોને મજબૂત ડેટા વિશ્લેષણ અને સફાઈ વર્કફ્લો માટે અમૂલ્ય બનાવે છે. 📊

R માં શરતી મૂલ્યાંકન અને તેના વર્તન વિશેની વિગતો અને સત્તાવાર આર દસ્તાવેજોમાંથી લેવામાં આવ્યા હતા. પર વધુ અન્વેષણ કરો CRAN R મેન્યુઅલ .
R માં જૂથબદ્ધ ડેટા સાથે કામ કરવા માટેના ઉદાહરણો અને શ્રેષ્ઠ પ્રયાસો Tidyverse પરના સંસાધનોમાંથી સ્વીકારવામાં આવ્યા હતા. પર વધુ જાણો વ્યવસ્થિત dplyr દસ્તાવેજીકરણ .
ગુમ થયેલ ડેટાને હેન્ડલ કરતી વખતે કામગીરીની વિચારણાઓની આંતરદૃષ્ટિ R સમુદાય ફોરમમાં ચર્ચાઓ દ્વારા પ્રેરિત હતી. મુલાકાત આરસ્ટુડિયો સમુદાય ઊંડા જોડાણ માટે.

R માં ifelse() vs if_else() ના વર્તનને સમજવું