ডাটা.ফ্রেম 1-এ সারি সন্ধান করতে দুটি ডাটা.ফ্রেমগুলির সাথে তুলনা করুন যা ডেটাতে উপস্থিত নেই 2 ফ্রেম 2

Question

আমার কাছে নিম্নলিখিত 2 ডেটা ফ্রেম রয়েছে:

a1 <- data.frame(a = 1:5, b=letters[1:5])
a2 <- data.frame(a = 1:3, b=letters[1:3])

আমি সন্ধান করতে চাই a1 সারিটিতে a2 নেই।

এই ধরণের অপারেশনের জন্য কোনও বিল্ট ইন ফাংশন রয়েছে?

(পিএস: আমি এর জন্য একটি সমাধান লিখেছিলাম, যদি কেউ ইতিমধ্যে আরও বেশি কারুকৃত কোড তৈরি করে থাকে তবে আমি কেবল কৌতূহলী)

এখানে আমার সমাধান:

a1 <- data.frame(a = 1:5, b=letters[1:5])
a2 <- data.frame(a = 1:3, b=letters[1:3])

rows.in.a1.that.are.not.in.a2  <- function(a1,a2)
{
    a1.vec <- apply(a1, 1, paste, collapse = "")
    a2.vec <- apply(a2, 1, paste, collapse = "")
    a1.without.a2.rows <- a1[!a1.vec %in% a2.vec,]
    return(a1.without.a2.rows)
}
rows.in.a1.that.are.not.in.a2(a1,a2)

Answer 1

এটি সরাসরি আপনার প্রশ্নের উত্তর দেয় না, তবে এটি আপনাকে সাধারণ উপাদানগুলিকে দেবে। এটি পল মুরেলের প্যাকেজ দিয়ে করা যেতে পারে compare:

library(compare)
a1 <- data.frame(a = 1:5, b = letters[1:5])
a2 <- data.frame(a = 1:3, b = letters[1:3])
comparison <- compare(a1,a2,allowAll=TRUE)
comparison$tM
#  a b
#1 1 a
#2 2 b
#3 3 c

ফাংশনটি compareআপনাকে কী ধরণের তুলনা করার অনুমতি দেয় তা বিবেচনায় অনেক নমনীয়তা দেয় (যেমন প্রতিটি ভেক্টরের উপাদানগুলির ক্রম পরিবর্তন করা, ক্রম পরিবর্তন এবং ভেরিয়েবলের নাম পরিবর্তন করা, ভেরিয়েবলগুলি সংক্ষিপ্ত করা, স্ট্রিংগুলির ক্ষেত্রে পরিবর্তন করা)। এ থেকে, আপনি একজন বা অন্যটির থেকে কী অনুপস্থিত ছিল তা অনুধাবন করতে সক্ষম হওয়া উচিত। উদাহরণস্বরূপ (এটি খুব মার্জিত নয়):

difference <-
   data.frame(lapply(1:ncol(a1),function(i)setdiff(a1[,i],comparison$tM[,i])))
colnames(difference) <- colnames(a1)
difference
#  a b
#1 4 d
#2 5 e

Comments

আমি এই ফাংশন বিভ্রান্তিকর মনে। আমি ভেবেছিলাম এটি আমার পক্ষে কাজ করবে, তবে এটি কেবলমাত্র উপরে দেখানো হিসাবে কাজ করবে বলে মনে হয় যদি একটি সেটে অন্য সেটের সাথে একইরকম মিলে যাওয়া সারি থাকে। এই ক্ষেত্রে বিবেচনা করুন: a2 <- data.frame(a = c(1:3, 1), b = c(letters[1:3], "c"))। a1একই ছেড়ে দিন । এখন তুলনা চেষ্টা করুন। শুধুমাত্র সাধারণ উপাদানগুলির তালিকাবদ্ধ করার সঠিক উপায়টি বিকল্পগুলি পড়ার পরেও আমার কাছে এটি পরিষ্কার নয়।

— হেন্ডি

Answer 2

SQLDF একটি দুর্দান্ত সমাধান সরবরাহ করে

a1 <- data.frame(a = 1:5, b=letters[1:5])
a2 <- data.frame(a = 1:3, b=letters[1:3])

require(sqldf)

a1NotIna2 <- sqldf('SELECT * FROM a1 EXCEPT SELECT * FROM a2')

এবং উভয় ডেটা ফ্রেমে থাকা সারিগুলি:

a1Ina2 <- sqldf('SELECT * FROM a1 INTERSECT SELECT * FROM a2')

হ'ল এই ধরণের তুলনা করার জন্য নতুন সংস্করণে dplyrএকটি ফাংশন রয়েছেanti_join

require(dplyr) 
anti_join(a1,a2)

এবং এর semi_joinমধ্যে সারিগুলি ফিল্টার a1করতেa2

semi_join(a1,a2)

Comments

anti_joinএবং ধন্যবাদ semi_join!

— ড্রাস্টেগা

স্কিএলডিএফ-এর মতো অ্যান্টি_জোঁইন কোনও নাল ডিএফ ফিরিয়ে দেবে এমন কোনও কারণ আছে, তবে একই রকম ফাংশনগুলি (a1, a2) এবং all.equal () এর বিরোধিতা করবে?

— পিট

এখানে কেবল যুক্ত করতে চেয়েছিলেন যে অ্যান্টি_জয়াইন এবং আধা_জয়াইন আমার মতো কিছু ক্ষেত্রে কাজ করবে না। আমি পেয়েছিলাম "ত্রুটি: কলামগুলি অবশ্যই 1 ডে অ্যাটমিক ভেক্টর বা তালিকা" থাকা উচিত আমার ডেটা ফ্রেমের জন্য। সম্ভবত আমি আমার ডেটা প্রক্রিয়া করতে পারি যাতে এই ফাংশনগুলি কাজ করে। স্কোয়াডফ গেটের ঠিক বাইরে কাজ করেছিল!

— অক্ষয় গৌড়

@ অক্ষয়গৌড় এটি একটি ডেটা ফর্ম্যাট বা ডেটা পরিষ্কারের সমস্যা হওয়া উচিত; এসকিএলডিএফ কেবল এসকিউএলএফ হ'ল প্রাক-প্রক্রিয়াজাতকরণের মতো নরমাল ডিবি হ'ল আমরা কেবল ডেটাতে এসকিএল চালাতে পারি।

— stucash

Answer 3

ইন dplyr :

setdiff(a1,a2)

মূলত, setdiff(bigFrame, smallFrame) প্রথম টেবিলে আপনাকে অতিরিক্ত রেকর্ড দেয়।

এসকিউএলভারসে একে বলা হয়

সমস্ত যোগদানের বিকল্প এবং সেট বিষয়গুলির ভাল বর্ণনার জন্য, আমি আজ অবধি একসাথে দেখেছি এমন সেরা সংক্ষিপ্তসারগুলির মধ্যে এটি: http://www.vertabelo.com/blog/technical-articles/sql-joins

তবে এই প্রশ্নে ফিরে যান - setdiff()ওপি'র ডেটা ব্যবহার করার সময় কোডের জন্য ফলাফলগুলি এখানে রয়েছে :

> a1
  a b
1 1 a
2 2 b
3 3 c
4 4 d
5 5 e

> a2
  a b
1 1 a
2 2 b
3 3 c

> setdiff(a1,a2)
  a b
1 4 d
2 5 e

বা এমনকি anti_join(a1,a2)আপনি একই ফলাফল পাবেন।
আরও তথ্যের জন্য: https://www.rstudio.com/wp-content/uploads/2015/02/data-wrangling-cheatsheet.pdf

Comments

যেহেতু ওপি এতে নেই a1এমন আইটেমগুলির জন্য জিজ্ঞাসা করেছে a2, আপনি কি এর মতো কিছু ব্যবহার করতে চান না semi_join(a1, a2, by = c('a','b'))? "রিকার্ড" এর উত্তরে আমি দেখতে পাচ্ছি যে semi_joinএটি প্রস্তাবিত ছিল।

— স্টিভ

নিশ্চিত! আরেকটি দুর্দান্ত পছন্দ; বিশেষত যদি আপনার কাছে কেবল যোগদানের কী এবং আলাদা কলামের নাম সহ ডেটাফ্রেম থাকে।

— leerssej

সেটডিফ লুব্রিড :: হ'ল সেটডিফ এবং লাইব্রেরি থেকে নয় (ডিপিপ্লায়ার)

— মেটেলশা

@mtelesha - হুম, জন্য দস্তাবেজ এবং সোর্স কোড dplyr প্রদর্শনী সেখানে হচ্ছে: ( dplyr.tidyverse.org/reference/setops.html , github.com/tidyverse/dplyr/blob/master/R/sets। )। অতিরিক্তভাবে, dplyr গ্রন্থাগারটি লোড করা হলেও setdiff()এটি দুটি ভেক্টরের উপর ভিত্তি করে বেস ফাংশনটি মাস্কিংয়ের প্রতিবেদন করে: stat.ethz.ch/R-manual/R-devel/library/base/html/sets.html । হতে পারে আপনি লোড lubridate পর গ্রন্থাগার dplyr এবং এটি tabcomplete তালিকা উৎস যেমন পরামর্শ করা হয়?

— লেয়ারসেজ

সেখানে lubridate এবং dplyr বিরোধ হয়, দেখুন github.com/tidyverse/lubridate/issues/693

— slhck

Answer 4

এটি অবশ্যই এই নির্দিষ্ট উদ্দেশ্যে দক্ষ নয়, তবে আমি এই পরিস্থিতিতে প্রায়শই যা করি তা হ'ল প্রতিটি ডাটা.ফ্রেমে সূচক ভেরিয়েবল সন্নিবেশ করা এবং তারপরে মার্জ করা:

a1$included_a1 <- TRUE
a2$included_a2 <- TRUE
res <- merge(a1, a2, all=TRUE)

অন্তর্ভুক্ত_এ 1 এর অনুপস্থিত মানগুলি দ্রষ্টব্য করবে যে 1 টিতে কোন সারিগুলি অনুপস্থিত রয়েছে। একইভাবে a2 এর জন্য।

আপনার সমাধানের সাথে একটি সমস্যা হ'ল কলামের আদেশগুলি মেলাতে হবে। আর একটি সমস্যা হ'ল পরিস্থিতিগুলি কল্পনা করা সহজ যেখানে সত্যগুলি পৃথক হলে সারিগুলি একই হিসাবে কোড করা হয়। মার্জ ব্যবহারের সুবিধা হ'ল আপনি ভাল ত্রুটি যাচাই করে নিচ্ছেন যা ভাল সমাধানের জন্য প্রয়োজনীয়।

Comments

সুতরাং ... একটি অনুপস্থিত মান সন্ধানের জন্য, আপনি অন্য একটি অনুপস্থিত মান তৈরি করেন ... আপনি কীভাবে অনুপস্থিত মান (গুলি) খুঁজে পাবেন included_a1? : - /

— লুই ম্যাডডক্স

is.na () এবং সাবসেট, বা dplyr :: ফিল্টার ব্যবহার করুন

— এডুয়ার্ডো লিওনি

একটি নতুন লাইব্রেরি ইনস্টল না করে উপায় শেখানোর জন্য আপনাকে ধন্যবাদ!

— রডরিগো

Answer 5

আমার একই সমস্যা হওয়ার পরে আমি একটি প্যাকেজ ( https://github.com/alexsanjoseph/compareDF ) লিখেছি ।

  > df1 <- data.frame(a = 1:5, b=letters[1:5], row = 1:5)
  > df2 <- data.frame(a = 1:3, b=letters[1:3], row = 1:3)
  > df_compare = compare_df(df1, df2, "row")

  > df_compare$comparison_df
    row chng_type a b
  1   4         + 4 d
  2   5         + 5 e

আরও জটিল উদাহরণ:

library(compareDF)
df1 = data.frame(id1 = c("Mazda RX4", "Mazda RX4 Wag", "Datsun 710",
                         "Hornet 4 Drive", "Duster 360", "Merc 240D"),
                 id2 = c("Maz", "Maz", "Dat", "Hor", "Dus", "Mer"),
                 hp = c(110, 110, 181, 110, 245, 62),
                 cyl = c(6, 6, 4, 6, 8, 4),
                 qsec = c(16.46, 17.02, 33.00, 19.44, 15.84, 20.00))

df2 = data.frame(id1 = c("Mazda RX4", "Mazda RX4 Wag", "Datsun 710",
                         "Hornet 4 Drive", " Hornet Sportabout", "Valiant"),
                 id2 = c("Maz", "Maz", "Dat", "Hor", "Dus", "Val"),
                 hp = c(110, 110, 93, 110, 175, 105),
                 cyl = c(6, 6, 4, 6, 8, 6),
                 qsec = c(16.46, 17.02, 18.61, 19.44, 17.02, 20.22))

> df_compare$comparison_df
    grp chng_type                id1 id2  hp cyl  qsec
  1   1         -  Hornet Sportabout Dus 175   8 17.02
  2   2         +         Datsun 710 Dat 181   4 33.00
  3   2         -         Datsun 710 Dat  93   4 18.61
  4   3         +         Duster 360 Dus 245   8 15.84
  5   7         +          Merc 240D Mer  62   4 20.00
  6   8         -            Valiant Val 105   6 20.22

প্যাকেজটিতে দ্রুত চেক করার জন্য একটি html_output কমান্ডও রয়েছে

df_compare $ html_output

Comments

আপনার তুলনা ডিএফটি আমার যা প্রয়োজন তা হ'ল, এবং ছোট সেটগুলি দিয়ে একটি ভাল কাজ করেছেন ever তবুও: 1) 3 কলাম সহ একটি সেট 50 মিলিয়ন সারি দিয়ে কাজ করা হয়নি (বলুন) এটি 32 গিগাবাইট র‌্যামের সাথে স্মৃতি থেকে বেরিয়ে আসে। 2) আমি আরও দেখছি এইচটিএমএল লিখতে কিছুটা সময় নেয়, একই আউটপুটটি পাঠ্য ফাইলটিতে পাঠানো যেতে পারে?

— গভীর

1) হ্যাঁ 50 মিলিয়ন সারি হ'ল প্রচুর ডেটা, কেবল স্মৃতিতে রাখা;)। আমি সচেতন যে এটি বড় ডেটাসেটের সাহায্যে দুর্দান্ত নয়, তাই আপনাকে কিছুটা বাছাই করতে হতে পারে। 2) আপনি এইচটিএমএল এ মুদ্রণ এড়াতে আর্গুমেন্ট - সীমা_ html = 0 দিতে পারেন। একই আউটপুটটি তুলনা_আউটপুট $ তুলনা_ডিএফ-এ রয়েছে যা আপনি স্থানীয় আর ফাংশনগুলি ব্যবহার করে কোনও সিএসভি / টেক্সট ফুলে লিখতে পারেন।

— অ্যালেক্স জোসেফ

আপনার উত্তর @ অ্যালেক্স জোসেফের জন্য ধন্যবাদ, আমি এটি ব্যবহার করে দেখাব এবং কীভাবে এটি আপনাকে জানাতে হবে।

— গভীর

: হাই @Alex জোসেফ, পাঠ্য ইনপুট বিন্যাস কাজ করেনি কিন্তু একটি সমস্যার পাওয়া জন্য ধন্যবাদ নীচে উত্থাপিত stackoverflow.com/questions/54880218/...

— ডীপ

এটি বিভিন্ন সংখ্যক কলাম পরিচালনা করতে পারে না। আমি একটি ত্রুটি পেয়েছিThe two data frames have different columns!

— PeyM87

Answer 6

আপনি daffপ্যাকেজটি ব্যবহার করতে পারেন (যা প্যাকেজটি ব্যবহার করে daff.jsলাইব্রেরিটি আবৃত করে ):V8

library(daff)

diff_data(data_ref = a2,
          data = a1)

নিম্নলিখিত পার্থক্য বস্তু উত্পাদন করে:

Daff Comparison: ‘a2’ vs. ‘a1’ 
  First 6 and last 6 patch lines:
   @@   a   b
1 ... ... ...
2       3   c
3 +++   4   d
4 +++   5   e
5 ... ... ...
6 ... ... ...
7       3   c
8 +++   4   d
9 +++   5   e

ছকগুলির জন্য কোপি হাইলাইটার ডিফ ফর্ম্যাটে ডিফের ফর্ম্যাটটি বর্ণনা করা হয়েছে এবং এটি বেশ স্ব-বর্ণনামূলক হওয়া উচিত। +++প্রথম কলামে থাকা লাইনগুলি @@নতুন a1এবং উপস্থিত নেই area2 ।

পার্থক্য অবজেক্টটি patch_data()ডকুমেন্টেশন উদ্দেশ্যে ব্যবহার করে পার্থক্যটি সংরক্ষণ করতে write_diff()বা ব্যবহার করে তফাতটি কল্পনা করতে ব্যবহার করা যেতে পারেrender_diff() :

render_diff(
    diff_data(data_ref = a2,
              data = a1)
)

একটি ঝরঝরে এইচটিএমএল আউটপুট উত্পন্ন করে:

Answer 7

diffobjপ্যাকেজ ব্যবহার :

library(diffobj)

diffPrint(a1, a2)
diffObj(a1, a2)

Answer 8

আমি অভিযোজিত mergeএই কার্যকারিতাটি পেতে ফাংশনটি । বৃহত্তর ডেটাফ্রেমে এটি সম্পূর্ণ সংশ্লেষের সমাধানের চেয়ে কম মেমরি ব্যবহার করে। এবং আমি কী কলামগুলির নাম দিয়ে খেলতে পারি।

আরেকটি সমাধান হ'ল গ্রন্থাগারটি ব্যবহার করা prob।

#  Derived from src/library/base/R/merge.R
#  Part of the R package, http://www.R-project.org
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  A copy of the GNU General Public License is available at
#  http://www.r-project.org/Licenses/

XinY <-
    function(x, y, by = intersect(names(x), names(y)), by.x = by, by.y = by,
             notin = FALSE, incomparables = NULL,
             ...)
{
    fix.by <- function(by, df)
    {
        ## fix up 'by' to be a valid set of cols by number: 0 is row.names
        if(is.null(by)) by <- numeric(0L)
        by <- as.vector(by)
        nc <- ncol(df)
        if(is.character(by))
            by <- match(by, c("row.names", names(df))) - 1L
        else if(is.numeric(by)) {
            if(any(by < 0L) || any(by > nc))
                stop("'by' must match numbers of columns")
        } else if(is.logical(by)) {
            if(length(by) != nc) stop("'by' must match number of columns")
            by <- seq_along(by)[by]
        } else stop("'by' must specify column(s) as numbers, names or logical")
        if(any(is.na(by))) stop("'by' must specify valid column(s)")
        unique(by)
    }

    nx <- nrow(x <- as.data.frame(x)); ny <- nrow(y <- as.data.frame(y))
    by.x <- fix.by(by.x, x)
    by.y <- fix.by(by.y, y)
    if((l.b <- length(by.x)) != length(by.y))
        stop("'by.x' and 'by.y' specify different numbers of columns")
    if(l.b == 0L) {
        ## was: stop("no columns to match on")
        ## returns x
        x
    }
    else {
        if(any(by.x == 0L)) {
            x <- cbind(Row.names = I(row.names(x)), x)
            by.x <- by.x + 1L
        }
        if(any(by.y == 0L)) {
            y <- cbind(Row.names = I(row.names(y)), y)
            by.y <- by.y + 1L
        }
        ## create keys from 'by' columns:
        if(l.b == 1L) {                  # (be faster)
            bx <- x[, by.x]; if(is.factor(bx)) bx <- as.character(bx)
            by <- y[, by.y]; if(is.factor(by)) by <- as.character(by)
        } else {
            ## Do these together for consistency in as.character.
            ## Use same set of names.
            bx <- x[, by.x, drop=FALSE]; by <- y[, by.y, drop=FALSE]
            names(bx) <- names(by) <- paste("V", seq_len(ncol(bx)), sep="")
            bz <- do.call("paste", c(rbind(bx, by), sep = "\r"))
            bx <- bz[seq_len(nx)]
            by <- bz[nx + seq_len(ny)]
        }
        comm <- match(bx, by, 0L)
        if (notin) {
            res <- x[comm == 0,]
        } else {
            res <- x[comm > 0,]
        }
    }
    ## avoid a copy
    ## row.names(res) <- NULL
    attr(res, "row.names") <- .set_row_names(nrow(res))
    res
}


XnotinY <-
    function(x, y, by = intersect(names(x), names(y)), by.x = by, by.y = by,
             notin = TRUE, incomparables = NULL,
             ...)
{
    XinY(x,y,by,by.x,by.y,notin,incomparables)
}

Answer 9

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

a1 <- data.frame(a = 1:5, b=letters[1:5])
a2 <- data.frame(a = 1:3, b=letters[1:3])
rows.in.a1.that.are.not.in.a2  <- function(a1,a2)
{
    a1.vec <- apply(a1, 1, paste, collapse = "")
    a2.vec <- apply(a2, 1, paste, collapse = "")
    a1.without.a2.rows <- a1[!a1.vec %in% a2.vec,]
    return(a1.without.a2.rows)
}

library(data.table)
setDT(a1)
setDT(a2)

# no duplicates - as in example code
r <- fsetdiff(a1, a2)
all.equal(r, rows.in.a1.that.are.not.in.a2(a1,a2))
#[1] TRUE

# handling duplicates - make some duplicates
a1 <- rbind(a1, a1, a1)
a2 <- rbind(a2, a2, a2)
r <- fsetdiff(a1, a2, all = TRUE)
all.equal(r, rows.in.a1.that.are.not.in.a2(a1,a2))
#[1] TRUE

এটিতে ডেটা.ট্যাবিলিটি 1.9.8+ দরকার

Answer 10

হতে পারে এটি খুব সরল, তবে আমি এই সমাধানটি ব্যবহার করেছি এবং যখন আমার কাছে একটি প্রাথমিক কী থাকে যা আমি ডেটার সেটগুলি তুলনা করতে ব্যবহার করতে পারি তখন আমি এটি খুব দরকারী মনে করি। আশা করি এটি সাহায্য করতে পারে।

a1 <- data.frame(a = 1:5, b = letters[1:5])
a2 <- data.frame(a = 1:3, b = letters[1:3])
different.names <- (!a1$a %in% a2$a)
not.in.a2 <- a1[different.names,]

Comments

ওপি ইতিমধ্যে যা চেষ্টা করেছিল তার থেকে এটি কীভাবে আলাদা? আপনি পুরো সারিটির পরিবর্তে একক কলামের তুলনা করতে

— টালের

Answer 11

প্লাইয়ারে ম্যাচ_ডিএফ-এর ভিত্তিতে আর একটি সমাধান। এখানে প্লাইয়ের ম্যাচ_ডিএফ:

match_df <- function (x, y, on = NULL) 
{
    if (is.null(on)) {
        on <- intersect(names(x), names(y))
        message("Matching on: ", paste(on, collapse = ", "))
    }
    keys <- join.keys(x, y, on)
    x[keys$x %in% keys$y, , drop = FALSE]
}

আমরা এটিকে অবহেলা করতে সংশোধন করতে পারি:

library(plyr)
negate_match_df <- function (x, y, on = NULL) 
{
    if (is.null(on)) {
        on <- intersect(names(x), names(y))
        message("Matching on: ", paste(on, collapse = ", "))
    }
    keys <- join.keys(x, y, on)
    x[!(keys$x %in% keys$y), , drop = FALSE]
}

তারপর:

diff <- negate_match_df(a1,a2)

Answer 12

ব্যবহার subset:

missing<-subset(a1, !(a %in% a2$a))

Comments

এই উত্তরটি ওপির দৃশ্যের জন্য কাজ করে। যখন ভেরিয়েবল "a" দুটি ডেটাফ্রেম ("a1" এবং "a2") এর সাথে মেলে, তবে ভেরিয়েবল "বি" মিলবে না তখন আরও সাধারণ ক্ষেত্রে কী হবে?

— ব্রায়ান এফ

Answer 13

নিম্নলিখিত কোড দুটি data.tableএবং fastmatchবর্ধিত গতির জন্য ব্যবহার করে ।

library("data.table")
library("fastmatch")

a1 <- setDT(data.frame(a = 1:5, b=letters[1:5]))
a2 <- setDT(data.frame(a = 1:3, b=letters[1:3]))

compare_rows <- a1$a %fin% a2$a
# the %fin% function comes from the `fastmatch` package

added_rows <- a1[which(compare_rows == FALSE)]

added_rows

#    a b
# 1: 4 d
# 2: 5 e