Vergleichen Sie zwei data.frames, um die Zeilen in data.frame 1 zu finden, die in data.frame 2 nicht vorhanden sind

SQLDF bietet eine schöne Lösung

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')

Und die Zeilen, die in beiden data frames:

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

Die neue version von dplyr hat eine Funktion, anti_join für genau diese Art von Vergleiche

require(dplyr) 
anti_join(a1,a2)

Sowie semi_join zum filtern von Zeilen in a1 werden, die auch in a2

semi_join(a1,a2)

InformationsquelleAutor der Antwort Rickard

In dplyr:

setdiff(a1,a2)

Grundsätzlich setdiff(bigFrame, smallFrame) bekommt man die zusätzlichen Datensätze in der ersten Tabelle.

In der SQLverse dies wird als eine

Für gute Beschreibungen aller join-Optionen, und wählen Sie Themen, dies ist eine der besten Zusammenfassungen, die ich gesehen habe zusammengestellt Datum: http://www.vertabelo.com/blog/technical-articles/sql-joins

Aber zurück zu dieser Frage - hier sind die Ergebnisse für die setdiff() - code bei der Verwendung des OP - Daten:

> 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

Oder sogar anti_join(a1,a2) erhalten Sie die gleichen Ergebnisse.

Für mehr info: https://www.rstudio.com/wp-content/uploads/2015/02/data-wrangling-cheatsheet.pdf

InformationsquelleAutor der Antwort leerssej

Ich angepasst, die merge - Funktion verwenden, um diese Funktionalität. Auf größeren dataframes es verbraucht weniger Speicher als die full-merge-Lösung. Und ich kann spielen mit den Namen der wichtigsten Spalten.

Andere Lösung ist die Nutzung der Bibliothek 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)
}

InformationsquelleAutor der Antwort Henrico

Könnten Sie die daff - Paket (das schließt die daff.js - Bibliothek mit der V8 - Paket):

library(daff)

diff_data(data_ref = a2,
          data = a1)

ergibt sich die folgende Differenz Objekt:

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

Den diff-format ist beschrieben in Kopiere highlighter-diff-format für Tabellen und sollte ziemlich selbsterklärend. Die Zeilen mit +++ in der ersten Spalte @@ sind diejenigen, die neu in a1 und nicht in a2.

Den Unterschied-Objekt kann verwendet werden, um patch_data()die zum speichern der Differenz für Zwecke der Dokumentation, mit write_diff() oder visualisieren die Differenz render_diff():

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

erzeugt eine saubere HTML-Ausgabe:

InformationsquelleAutor der Antwort Salim B

Vielleicht ist es zu simpel, aber ich habe diese Lösung und ich finde es sehr nützlich, wenn ich einen primary key, dass ich kann verwenden zum vergleichen von Daten-sets. Hoffe, es kann helfen.

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,]

InformationsquelleAutor der Antwort Kenia Sousa