একই সাথে এক তালিকায় একাধিক ডেটা.ফ্রেমগুলি মার্জ করুন


258

আমার কাছে অনেকগুলি ডেটা ফ্রেমগুলির একটি তালিকা রয়েছে যা আমি মার্জ করতে চাই want এখানে সমস্যাটি হ'ল প্রতিটি ডাটা.ফ্রেম সারি এবং কলামগুলির সংখ্যার ক্ষেত্রে পৃথক হয় তবে তারা সমস্ত কী ভেরিয়েবলগুলি ভাগ করে দেয় (যা আমি কল করেছি "var1"এবং "var2"নীচের কোডটিতে)। যদি rbindডেটা.ফ্রেমগুলি কলামগুলির ক্ষেত্রে একরকম হত তবে আমি কেবল এটিই করতে পারতাম , যার জন্য প্লেয়ারের rbind.fill কাজটি করবে তবে এই ডেটাগুলির ক্ষেত্রে এটি ঘটেনি

কারণ mergeকমান্ড শুধুমাত্র 2 data.frames কাজ করে, আমি ধারনা ইন্টারনেটের সাথে পরিণত। আমি এটিকে এখান থেকে পেয়েছি , যা পুরোপুরি 2.7.2 আর তে কাজ করেছিল, যা আমার সময়ে ছিল:

merge.rec <- function(.list, ...){
    if(length(.list)==1) return(.list[[1]])
    Recall(c(list(merge(.list[[1]], .list[[2]], ...)), .list[-(1:2)]), ...)
}

এবং আমি এইভাবে ফাংশন কল করব:

df <- merge.rec(my.list, by.x = c("var1", "var2"), 
                by.y = c("var1", "var2"), all = T, suffixes=c("", ""))

তবে 2.11 এবং 2.12 সহ 2.7.2 এর পরে যে কোনও আর সংস্করণে, এই কোডটি নিম্নলিখিত ত্রুটির সাথে ব্যর্থ হয়েছে:

Error in match.names(clabs, names(xi)) : 
  names do not match previous names

(ঘটনাক্রমে, আমি এই ত্রুটির অন্যান্য উল্লেখগুলি সমাধান ছাড়াই অন্য কোথাও দেখতে পাচ্ছি )।

এটি সমাধান করার কোনও উপায় আছে?

উত্তর:


182

আর একটি প্রশ্নে স্পষ্টভাবে জিজ্ঞাসা করা হয়েছিল যে কীভাবে একাধিক বামে আরপিতে dplyr ব্যবহার করে যোগদান করতে হয় । প্রশ্নটি এর একটি সদৃশ হিসাবে চিহ্নিত হয়েছে তাই আমি নীচে 3 নমুনা ডেটা ফ্রেম ব্যবহার করে এখানে উত্তর দিচ্ছি:

x <- data.frame(i = c("a","b","c"), j = 1:3, stringsAsFactors=FALSE)
y <- data.frame(i = c("b","c","d"), k = 4:6, stringsAsFactors=FALSE)
z <- data.frame(i = c("c","d","a"), l = 7:9, stringsAsFactors=FALSE)

জুন 2018 আপডেট করুন : আমি মার্জটি সম্পাদন করার জন্য তিনটি পৃথক উপায়ে প্রতিনিধিত্ব করে তিনটি বিভাগে উত্তর ভাগ করেছি। আপনি purrrযদি ইতিমধ্যে পরিপাটি প্যাকেজ ব্যবহার করেন তবে আপনি সম্ভবত উপায়টি ব্যবহার করতে চান । নীচের তুলনা উদ্দেশ্যে, আপনি একই নমুনা ডেটাसेट ব্যবহার করে একটি বেস আর সংস্করণ পাবেন।


1) প্যাকেজ reduceথেকে তাদের সাথে যোগ দিন purrr:

purrrপ্যাকেজের মাধ্যমে একটি উপলব্ধ reduceফাংশন যা সংক্ষিপ্ত বাক্য গঠন আছে:

library(tidyverse)
list(x, y, z) %>% reduce(left_join, by = "i")
#  A tibble: 3 x 4
#  i       j     k     l
#  <chr> <int> <int> <int>
# 1 a      1    NA     9
# 2 b      2     4    NA
# 3 c      3     5     7

এছাড়াও আপনি এই ধরনের একটি হিসেবে সম্পাদন করতে পারবেন অন্যান্য যোগদান করে full_joinবা inner_join:

list(x, y, z) %>% reduce(full_join, by = "i")
# A tibble: 4 x 4
# i       j     k     l
# <chr> <int> <int> <int>
# 1 a     1     NA     9
# 2 b     2     4      NA
# 3 c     3     5      7
# 4 d     NA    6      8

list(x, y, z) %>% reduce(inner_join, by = "i")
# A tibble: 1 x 4
# i       j     k     l
# <chr> <int> <int> <int>
# 1 c     3     5     7

2) dplyr::left_join()বেস আর সহ Reduce():

list(x,y,z) %>%
    Reduce(function(dtf1,dtf2) left_join(dtf1,dtf2,by="i"), .)

#   i j  k  l
# 1 a 1 NA  9
# 2 b 2  4 NA
# 3 c 3  5  7

3) বেস আর merge()সঙ্গে বেস আর Reduce():

এবং তুলনা উদ্দেশ্যে, এখানে বাম জোড় একটি বেস আর সংস্করণ

 Reduce(function(dtf1, dtf2) merge(dtf1, dtf2, by = "i", all.x = TRUE),
        list(x,y,z))
#   i j  k  l
# 1 a 1 NA  9
# 2 b 2  4 NA
# 3 c 3  5  7

1
সম্পূর্ণ_জয়িন রূপটি নিখুঁতভাবে কাজ করে এবং স্বীকৃত উত্তরের চেয়ে অনেক কম ভীতিজনক দেখাচ্ছে। যদিও গতির পার্থক্য খুব বেশি নয়।
bshor

1
@ অ্যাক্সমান ঠিক বলেছেন তবে আপনি সম্ভবত ডেটা ফ্রেমের একটি তালিকা ফিরিয়ে এড়াতে পারবেন (দৃশ্যমান) map_dfr()অথবাmap_dfc()
ডেভরজিপি

আমি যদিও ´ls (প্যাটার্ন = "ডিএফ_ নাম_কন্টেনস_এই") ব্যবহার করে একটি প্যাটার্নের ভিত্তিতে অনেকগুলি ডিএফ-তে যোগদান করতে পারি, তবে না no অ্যানোকোট (পেস্ট (()) Used ব্যবহার করা হয়েছে, তবে আমি এখনও ডিএফের তালিকার পরিবর্তে একটি চরিত্রের ভেক্টর তৈরি করছি the নামগুলি টাইপ করে শেষ করেছি যা খারাপ নয়
জর্জ উইলিয়াম রাসেলের পেন

আরেকটি প্রশ্ন একটি অজগর বাস্তবায়ন সরবরাহ করে : dfs = [df1, df2, df3]তখন পান্ডাস ডেটা ফ্রেমের তালিকা reduce(pandas.merge, dfs)
পল রাউজিউক্স

222

হ্রাস এটিকে মোটামুটি সহজ করে তোলে:

merged.data.frame = Reduce(function(...) merge(..., all=T), list.of.data.frames)

কিছু মক ডেটা ব্যবহার করে এখানে সম্পূর্ণ উদাহরণ:

set.seed(1)
list.of.data.frames = list(data.frame(x=1:10, a=1:10), data.frame(x=5:14, b=11:20), data.frame(x=sample(20, 10), y=runif(10)))
merged.data.frame = Reduce(function(...) merge(..., all=T), list.of.data.frames)
tail(merged.data.frame)
#    x  a  b         y
#12 12 NA 18        NA
#13 13 NA 19        NA
#14 14 NA 20 0.4976992
#15 15 NA NA 0.7176185
#16 16 NA NA 0.3841037
#17 19 NA NA 0.3800352

এবং অনুলিপি করতে এখানে এই ডেটা ব্যবহার করে একটি উদাহরণ দেওয়া হয়েছে my.list:

merged.data.frame = Reduce(function(...) merge(..., by=match.by, all=T), my.list)
merged.data.frame[, 1:12]

#  matchname party st district chamber senate1993 name.x v2.x v3.x v4.x senate1994 name.y
#1   ALGIERE   200 RI      026       S         NA   <NA>   NA   NA   NA         NA   <NA>
#2     ALVES   100 RI      019       S         NA   <NA>   NA   NA   NA         NA   <NA>
#3    BADEAU   100 RI      032       S         NA   <NA>   NA   NA   NA         NA   <NA>

দ্রষ্টব্য: দেখে মনে হচ্ছে এটি ত্রুটিযুক্তভাবে একটি বাগ ইন merge। সমস্যাটি নেই যে প্রত্যয় যুক্ত করা (ওভারল্যাপিং নয় এমন নামগুলি হ্যান্ডেল করতে) আসলে এগুলি অনন্য করে তোলে। একটি নির্দিষ্ট সময়ে এটি ব্যবহার করে [.data.frameযা আছে make.unique যার ফলে নাম, rbindব্যর্থ।

# first merge will end up with 'name.x' & 'name.y'
merge(my.list[[1]], my.list[[2]], by=match.by, all=T)
# [1] matchname    party        st           district     chamber      senate1993   name.x      
# [8] votes.year.x senate1994   name.y       votes.year.y
#<0 rows> (or 0-length row.names)
# as there is no clash, we retain 'name.x' & 'name.y' and get 'name' again
merge(merge(my.list[[1]], my.list[[2]], by=match.by, all=T), my.list[[3]], by=match.by, all=T)
# [1] matchname    party        st           district     chamber      senate1993   name.x      
# [8] votes.year.x senate1994   name.y       votes.year.y senate1995   name         votes.year  
#<0 rows> (or 0-length row.names)
# the next merge will fail as 'name' will get renamed to a pre-existing field.

সমাধানের সহজতম উপায় হ'ল ক্ষেত্রটির সদৃশ ক্ষেত্রগুলির নাম পরিবর্তন করা (যার মধ্যে এখানে অনেকগুলি রয়েছে) merge। উদাহরণ:

my.list2 = Map(function(x, i) setNames(x, ifelse(names(x) %in% match.by,
      names(x), sprintf('%s.%d', names(x), i))), my.list, seq_along(my.list))

merge/ Reduceতারপর কাজ জরিমানা হবে।


ধন্যবাদ! আমি এই সমাধানটি রামনাথের লিঙ্কটিতেও দেখেছি। যথেষ্ট সহজ দেখাচ্ছে। তবে আমি নিম্নলিখিত ত্রুটিটি পেয়েছি: "ম্যাচ.নেমগুলিতে ত্রুটি (তালি, নাম (xi)): নামগুলি পূর্বের নামের সাথে মেলে না"। আমি যে ভেরিয়েবলগুলির সাথে মিলে যাচ্ছি সেগুলি তালিকার সমস্ত ডেটাফ্রেমে উপস্থিত রয়েছে, সুতরাং এই ত্রুটিটি আমাকে কী বলছে তা আমি ধরছি না।
bshor

1
আমি এই সমাধানটি আর -২.২.২ এ পরীক্ষা করেছি এবং আমি একই মিল পেয়েছি name নামগুলির ত্রুটি। সুতরাং এই সমাধান এবং আমার ডেটা নিয়ে আরও কিছু মৌলিক সমস্যা আছে। আমি কোডটি ব্যবহার করেছি: হ্রাস করুন (ফাংশন (x, y) মার্জ (x, y, all = T, by.x = match.by, by.y = ম্যাচ.বি)), আমার.লিস্ট, জমা = এফ)
bshor

1
আশ্চর্যের বিষয়, আমি কোডটি যুক্ত করেছিলাম যা এটি পরীক্ষা করেছিলাম যা দিয়ে ভাল চলে। আমি অনুমান করি যে আপনি যে মার্জড আরগগুলি ব্যবহার করছেন তার উপর ভিত্তি করে কিছু ফিল্ড-নামকরণ হচ্ছে? সংযুক্ত ফলাফলের পরবর্তী ডেটা ফ্রেমের সাথে একত্রীকরণের জন্য এখনও প্রাসঙ্গিক কী থাকতে হবে।
চার্লস

আমি খালি ডেটা ফ্রেমের সাথে কিছু ঘটছে বলে সন্দেহ করি। আমি এর মতো কয়েকটি উদাহরণ ব্যবহার করে দেখেছি: empty <- data.frame(x=numeric(0),a=numeric(0); L3 <- c(empty,empty,list.of.data.frames,empty,empty,empty)এবং এমন কিছু অদ্ভুত জিনিস পেয়েছি যা আমি এখনও খুঁজে পাইনি।
বেন বলকার

@ চার্লস আপনি কোনও কিছুর উপরে রয়েছেন। আপনার কোডটি আমার পক্ষে উপরে চলেছে। এবং যখন আমি এটি আমার সাথে খাপ খাই, এটি খুব সূক্ষ্মভাবে চালিত হয় - এটি বাদে এটি আমি চাইলে মূল ভেরিয়েবলগুলি উপেক্ষা করে একীভূত হয়। আমি যখন কী ভেরিয়েবলগুলি বাদ দেওয়ার পরিবর্তে যুক্ত করার চেষ্টা করব তখন আমি একটি নতুন ত্রুটি পেয়েছি "is.null (x): 'x' অনুপস্থিত" Error কোড লাইনটি হ'ল "টেস্ট.রেডস <- হ্রাস করুন (ফাংশন (...) মার্জ করুন (দ্বারা = ম্যাচ.বি, সমস্ত = টি), মাই.লিস্ট)" যেখানে ম্যাচ.বি আমি যে ভেরিয়েবলের নামগুলি মার্জ করতে চাই তার ভেক্টর where দ্বারা.
bshor

52

ব্যবহার করে আপনি এটা করতে পারেন merge_allমধ্যে reshapeপ্যাকেজ। আপনি যুক্তিটি mergeব্যবহার করে প্যারামিটারগুলি পাস করতে পারেন...

reshape::merge_all(list_of_dataframes, ...)

ডেটা ফ্রেমগুলিকে একীভূত করতে বিভিন্ন পদ্ধতিতে এখানে একটি দুর্দান্ত উত্স


দেখে মনে হচ্ছে যে এই ফাংশনটি ইতিমধ্যে বিদ্যমান বলে আমি স্রেফ একীভূত_আরচনা =) অনুলিপি করেছি।
এসফুন 28

16
হ্যাঁ. যখনই আমার কোনও ধারণা আছে, আমি সর্বদা এটি পরীক্ষা করে দেখি যে @ হ্যাডলি ইতিমধ্যে এটি সম্পন্ন করেছে কিনা, এবং বেশিরভাগ সময় তাঁর :-)
রামনাথ

1
আমি একটু বিভ্রান্ত; আমি কি একীভূত_সামগ্রী করা বা মেশানো_আরচিপন করব? যাই হোক না কেন, আমি যখন আমার অতিরিক্ত যুক্তিগুলিতে উভয়কে যুক্ত করার চেষ্টা করি তখন আমি ত্রুটিটি "আনুষ্ঠানিক যুক্তি" সমস্ত "একাধিক আসল যুক্তির সাথে মিলে যায়" get
bshor

2
আমি মনে করি এটি পুনরায় আকার 2 থেকে বাদ দিয়েছি। হ্রাস + একত্রিত করা ঠিক তত সহজ।
হ্যাডলি

2
@ রমনাথ, লিঙ্কটি মারা গেছে, আয়না আছে কি?
এডুয়ার্ডো

4

এটি করতে আপনি পুনরাবৃত্তি ব্যবহার করতে পারেন। আমি নিম্নলিখিতগুলি যাচাই করি নি তবে এটি আপনাকে সঠিক ধারণা দেবে:

MergeListOfDf = function( data , ... )
{
    if ( length( data ) == 2 ) 
    {
        return( merge( data[[ 1 ]] , data[[ 2 ]] , ... ) )
    }    
    return( merge( MergeListOfDf( data[ -1 ] , ... ) , data[[ 1 ]] , ... ) )
}

2

@PaulRougieux থেকে ডেটা উদাহরণ পুনরায় ব্যবহার করব

x <- data_frame(i = c("a","b","c"), j = 1:3)
y <- data_frame(i = c("b","c","d"), k = 4:6)
z <- data_frame(i = c("c","d","a"), l = 7:9)

এখানে একটি ছোট এবং মিষ্টি সলিউশন ব্যবহার এর purrrএবংtidyr

library(tidyverse)

 list(x, y, z) %>% 
  map_df(gather, key=key, value=value, -i) %>% 
  spread(key, value)

1

ফাংশন eatআমার প্যাকেজের safejoin যদি আপনি এটি data.frames একটি দ্বিতীয় ইনপুট হিসাবে এটা তাদের প্রথম ইনপুট যাও recursively যোগ দেবেন একটি তালিকা দিতে, এই ধরনের বৈশিষ্ট্য রয়েছে।

গৃহীত এবং গৃহীত উত্তরের ডেটা প্রসারিত:

x <- data_frame(i = c("a","b","c"), j = 1:3)
y <- data_frame(i = c("b","c","d"), k = 4:6)
z <- data_frame(i = c("c","d","a"), l = 7:9)
z2 <- data_frame(i = c("a","b","c"), l = rep(100L,3),l2 = rep(100L,3)) # for later

# devtools::install_github("moodymudskipper/safejoin")
library(safejoin)
eat(x, list(y,z), .by = "i")
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <int>
# 1 a         1    NA     9
# 2 b         2     4    NA
# 3 c         3     5     7

আমাদের সমস্ত কলাম নিতে হবে না, আমরা tidyselect থেকে নির্বাচিত সাহায্যকারীদের ব্যবহার করতে পারি এবং বেছে নিতে পারি (যেমনটি আমরা .xসমস্ত .xকলাম থেকে শুরু করি তেমন রাখা হয়):

eat(x, list(y,z), starts_with("l") ,.by = "i")
# # A tibble: 3 x 3
#   i         j     l
#   <chr> <int> <int>
# 1 a         1     9
# 2 b         2    NA
# 3 c         3     7

বা নির্দিষ্টগুলি অপসারণ:

eat(x, list(y,z), -starts_with("l") ,.by = "i")
# # A tibble: 3 x 3
#   i         j     k
#   <chr> <int> <int>
# 1 a         1    NA
# 2 b         2     4
# 3 c         3     5

তালিকার নাম দেওয়া থাকলে নামগুলি উপসর্গ হিসাবে ব্যবহৃত হবে:

eat(x, dplyr::lst(y,z), .by = "i")
# # A tibble: 3 x 4
#   i         j   y_k   z_l
#   <chr> <int> <int> <int>
# 1 a         1    NA     9
# 2 b         2     4    NA
# 3 c         3     5     7

যদি কলামের বিরোধ রয়েছে তবে .conflictআর্গুমেন্ট আপনাকে এটিকে সমাধান করার অনুমতি দেয়, উদাহরণস্বরূপ প্রথম / দ্বিতীয়টি গ্রহণ করে, সেগুলি যুক্ত করে, কোয়েলেস করে বা বাসা বাঁধে।

প্রথমে রাখুন:

eat(x, list(y, z, z2), .by = "i", .conflict = ~.x)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <int>
# 1 a         1    NA     9
# 2 b         2     4    NA
# 3 c         3     5     7

শেষ রাখুন:

eat(x, list(y, z, z2), .by = "i", .conflict = ~.y)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <dbl>
# 1 a         1    NA   100
# 2 b         2     4   100
# 3 c         3     5   100

যোগ করুন:

eat(x, list(y, z, z2), .by = "i", .conflict = `+`)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <dbl>
# 1 a         1    NA   109
# 2 b         2     4    NA
# 3 c         3     5   107

সমবেত হত্তয়া:

eat(x, list(y, z, z2), .by = "i", .conflict = dplyr::coalesce)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <dbl>
# 1 a         1    NA     9
# 2 b         2     4   100
# 3 c         3     5     7

নীড়:

eat(x, list(y, z, z2), .by = "i", .conflict = ~tibble(first=.x, second=.y))
# # A tibble: 3 x 4
#   i         j     k l$first $second
#   <chr> <int> <int>   <int>   <int>
# 1 a         1    NA       9     100
# 2 b         2     4      NA     100
# 3 c         3     5       7     100

NA.fillযুক্তি ব্যবহার করে মানগুলি প্রতিস্থাপন করা যেতে পারে ।

eat(x, list(y, z), .by = "i", .fill = 0)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <dbl> <dbl>
# 1 a         1     0     9
# 2 b         2     4     0
# 3 c         3     5     7

ডিফল্টরূপে এটি একটি বর্ধিত হচ্ছে left_joinকিন্তু সব dplyr মাধ্যমে সমর্থিত অগ্রহায়ণ .modeযুক্তি, ঝাপসা এছাড়াও সমর্থিত অগ্রহায়ণ match_fun যুক্তি (এটা প্যাকেজ প্রায় আবৃত এর fuzzyjoin) অথবা যেমন একটি সূত্র দান ~ X("var1") > Y("var2") & X("var3") < Y("var4")করার byযুক্তি।


0

আমার কাছে সাধারণ আইডি কলামের সাথে ডেটাফ্রেমের একটি তালিকা ছিল।
আমার অনেক ডিএফএসে ডেটা ছিল না। নাল মান ছিল। টেবিল ফাংশন ব্যবহার করে ডেটাফ্রেমগুলি তৈরি করা হয়েছিল। হ্রাস, মার্জিং, rbind, rbind.fill এবং তাদের পছন্দগুলি আমার লক্ষ্যে সহায়তা করতে পারে না। আমার লক্ষ্যটি ছিল একটি অনুধাবনযোগ্য মার্জড ডেটাফ্রেম তৈরি করা, অনুপস্থিত ডেটা এবং সাধারণ আইডি কলাম সম্পর্কিত অপ্রাসঙ্গিক।

অতএব, আমি নিম্নলিখিত ফাংশন করেছি। হতে পারে এই ফাংশনটি কাউকে সহায়তা করতে পারে।

##########################################################
####             Dependencies                        #####
##########################################################

# Depends on Base R only

##########################################################
####             Example DF                          #####
##########################################################

# Example df
ex_df           <- cbind(c( seq(1, 10, 1), rep("NA", 0), seq(1,10, 1) ), 
                         c( seq(1, 7, 1),  rep("NA", 3), seq(1, 12, 1) ), 
                         c( seq(1, 3, 1),  rep("NA", 7), seq(1, 5, 1), rep("NA", 5) ))

# Making colnames and rownames
colnames(ex_df) <- 1:dim(ex_df)[2]
rownames(ex_df) <- 1:dim(ex_df)[1]

# Making an unequal list of dfs, 
# without a common id column
list_of_df      <- apply(ex_df=="NA", 2, ( table) )

এটি ফাংশন অনুসরণ করা হয়

##########################################################
####             The function                        #####
##########################################################


# The function to rbind it
rbind_null_df_lists <- function ( list_of_dfs ) {
  length_df     <- do.call(rbind, (lapply( list_of_dfs, function(x) length(x))))
  max_no        <- max(length_df[,1])
  max_df        <- length_df[max(length_df),]
  name_df       <- names(length_df[length_df== max_no,][1])
  names_list    <- names(list_of_dfs[ name_df][[1]])

  df_dfs <- list()
  for (i in 1:max_no ) {

    df_dfs[[i]]            <- do.call(rbind, lapply(1:length(list_of_dfs), function(x) list_of_dfs[[x]][i]))

  }

  df_cbind               <- do.call( cbind, df_dfs )
  rownames( df_cbind )   <- rownames (length_df)
  colnames( df_cbind )   <- names_list

  df_cbind

}

উদাহরণ চালাচ্ছি

##########################################################
####             Running the example                 #####
##########################################################

rbind_null_df_lists ( list_of_df )

0

আপনার যখন ডিএফএসের একটি তালিকা থাকে এবং একটি কলামে "আইডি" থাকে তবে কয়েকটি তালিকায় কিছু আইডি অনুপস্থিত থাকে, তবে আপনি নিখোঁজ সারি আইডি বা লেবেলের একাধিক ডিএফ যোগ দেওয়ার জন্য হ্রাস / মার্জ এই সংস্করণটি ব্যবহার করতে পারেন:

Reduce(function(x, y) merge(x=x, y=y, by="V1", all.x=T, all.y=T), list_of_dfs)

0

এখানে একটি জেনেরিক মোড়ক রয়েছে যা বাইনারি ফাংশনটিকে বহু-পরামিতি ফাংশনে রূপান্তর করতে ব্যবহার করা যেতে পারে। এই সমাধানটির সুবিধাটি হ'ল এটি খুব সাধারণ এবং কোনও বাইনারি ফাংশনে প্রয়োগ করা যেতে পারে। আপনার কেবল এটি একবার করা দরকার এবং তারপরে আপনি এটি যে কোনও জায়গায় প্রয়োগ করতে পারেন।

ধারণাটি ডেমো করতে, আমি প্রয়োগ করার জন্য সহজ পুনরাবৃত্তি ব্যবহার করি। এটি অবশ্যই আরও মার্জিত উপায়ে প্রয়োগ করা যেতে পারে যা কার্যকরী দৃষ্টান্তের জন্য আর এর ভাল সমর্থন থেকে উপকৃত হয়।

fold_left <- function(f) {
return(function(...) {
    args <- list(...)
    return(function(...){
    iter <- function(result,rest) {
        if (length(rest) == 0) {
            return(result)
        } else {
            return(iter(f(result, rest[[1]], ...), rest[-1]))
        }
    }
    return(iter(args[[1]], args[-1]))
    })
})}

তারপর আপনি কেবল এটা নিয়ে কোনো বাইনারি ফাংশন মোড়ানো এবং প্রথম বন্ধনীর মধ্যে অবস্থানগত পরামিতি (সাধারণত data.frames) এবং দ্বিতীয় বন্ধনীর মধ্যে নামে পরামিতি (যেমন সঙ্গে কল করতে পারেন by =বা suffix =)। যদি কোনও নামযুক্ত প্যারামিটার না থাকে তবে দ্বিতীয় বন্ধনী খালি রাখুন।

merge_all <- fold_left(merge)
merge_all(df1, df2, df3, df4, df5)(by.x = c("var1", "var2"), by.y = c("var1", "var2"))

left_join_all <- fold_left(left_join)
left_join_all(df1, df2, df3, df4, df5)(c("var1", "var2"))
left_join_all(df1, df2, df3, df4, df5)()
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.