Supprimer les lignes avec tous ou certains NAs (valeurs manquantes) dans les données.cadre

Je voudrais supprimer les lignes dans ce bloc de données qui:

a) contenir NAs à travers toutes les colonnes. Ci-dessous mon exemple bloc de données. 

             gene hsap mmul mmus rnor cfam
1 ENSG00000208234    0   NA   NA   NA   NA
2 ENSG00000199674    0   2    2    2    2
3 ENSG00000221622    0   NA   NA   NA   NA
4 ENSG00000207604    0   NA   NA   1    2
5 ENSG00000207431    0   NA   NA   NA   NA
6 ENSG00000221312    0   1    2    3    2

En gros, je voudrais faire un bloc de données telles que les suivantes.

             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
6 ENSG00000221312    0   1    2    3    2

b) contenir NAs en seulement quelques colonnes, donc je peux aussi obtenir ce résultat:

             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
4 ENSG00000207604    0   NA   NA   1    2
6 ENSG00000221312    0   1    2    3    2
InformationsquelleAutor Benoit B. | 2011-02-01
  1. 962

    Également vérifier complet.cas :

    > final[complete.cases(final), ]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
6 ENSG00000221312    0    1    2    3    2

    na.omit est plus juste de retirer tous les NAs'. complete.cases permet la sélection partielle en incluant seulement certaines colonnes de la dataframe:

    > final[complete.cases(final[ , 5:6]),]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
4 ENSG00000207604    0   NA   NA    1    2
6 ENSG00000221312    0    1    2    3    2

    Votre solution ne peut pas travailler. Si vous insistez sur l'utilisation de is.na, alors vous devez faire quelque chose comme:

    > final[rowSums(is.na(final[ , 5:6])) == 0, ]
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
4 ENSG00000207604    0   NA   NA    1    2
6 ENSG00000221312    0    1    2    3    2

    mais en utilisant complete.cases est beaucoup plus clair et plus rapide.

    • Quelle est l'importance de la virgule dans final[complete.cases(final),]?
    • Vous devez sélectionner les lignes, pas de colonnes. Sinon, comment le feriez-vous?
    • Est-il une simple négation de complete.cases? Si je voulais garder les lignes avec NAs lieu de les jeter? final[ ! complete.cases(final),] ne pas coopérer...
    • Je peux confirmer que complet.cas() est environ trois fois plus rapide que na.omettre(), bien que les deux sont franchement très lente.
    • avec dplyr, il sera probablement avec filtre, comme dans le df %>% filtre(est.na(a)) etc.
    • Il est assez courant de ne sélectionnez les colonnes pour lesquelles nous nous sommes assurés de terminer les cas, ce qui rend l'usage de la virgule de plus en plus évidents: pour le deuxième exemple, comparer final[complete.cases(final[ , 5:6]), 5:6] ou peut-être plus utilement final[complete.cases(final[ , 5:6]), c(1,5:6)]; on peut également sélectionner par nom par exemple selected.names <- c("gene", "rnor", "cfam"); final[complete.cases(final[ , selected.names]), selected.names] (Probablement pas utile pour vous, pas plus, mais peut-être que pour beaucoup de débutants de la lecture de ce Q)
    • final est dataframe variable?
    • en effet, il est.
    • Est-il un moyen quelconque de ces méthodes à pas de conserver les numéros de ligne? En gros si il y a 5 lignes et il supprime la ligne 3, puis l'ensemble de ces méthodes produisent un tableau avec les numéros de ligne: 1, 2, 4, 5 au lieu de 1 -4 .
    • J'ai juste couru final[ !complete.cases(final), ] sur la version 3.5.1 et il fonctionne très bien: garder toutes les lignes qui ont un ou plusieurs NAs.

    InformationsquelleAutor Joris Meys
  2. 232

    Essayer na.omit(your.data.frame). Quant à la seconde question, essayez de poster une autre question (pour plus de clarté).

    • na.omettre gouttes les lignes, mais conserve les numéros de ligne. Comment voulez-vous résoudre ce problème de manière qu'il est correctement numérotées?
    • si vous n'avez pas de soins sur les numéros de ligne, il suffit de faire rownames(x) <- NULL.
    • veuillez noter que na.omit() gouttes lignes qui contiennent NA dans n'importe quelle colonne
    InformationsquelleAutor Roman Luštrik
  3. 86

    tidyr a une nouvelle fonction drop_na: 

    library(tidyr)
df %>% drop_na()
#              gene hsap mmul mmus rnor cfam
# 2 ENSG00000199674    0    2    2    2    2
# 6 ENSG00000221312    0    1    2    3    2
df %>% drop_na(rnor, cfam)
#              gene hsap mmul mmus rnor cfam
# 2 ENSG00000199674    0    2    2    2    2
# 4 ENSG00000207604    0   NA   NA    1    2
# 6 ENSG00000221312    0    1    2    3    2
    • Il n'y a pas de lien réel entre les tuyaux et drop_na. Par exemple, df %>% drop_na(), df %>% na.omit() et drop_na(df) sont essentiellement équivalentes.
    • Je suis en désaccord. na.omit ajoute des informations supplémentaires comme les indices de omis cas, et - plus important encore - est ne vous permet pas de sélectionner les colonnes - c'est là que drop_na brille.
    • Bien sûr, mon point est que, non de qui n'a rien à voir avec les pipes. Vous pouvez utiliser na.omit avec ou sans tuyaux, tout comme vous pouvez utiliser drop_na avec ou sans tuyaux.
    • Vrai, rien à voir avec les pipes à tous. drop_na() est une fonction comme les autres et, comme tels, peuvent être appelés directement ou à l'aide d'un tuyau. Malheureusement, drop_na(), contrairement aux autres moyens mentionnés, ne peut pas être utilisé sur de zoo ou de la xts types d'objet. Cela pourrait être un problème pour certains.
    • Bon, alors j'ai édité la réponse de sorte qu'il ne mentionne pas les tuyaux.
    InformationsquelleAutor lukeA
  4. 85

    Je préfère la façon suivante pour vérifier si les lignes contiennent tout NAs:

    row.has.na <- apply(final, 1, function(x){any(is.na(x))})

    Cela renvoie logique de vecteur avec des valeurs indiquant s'il existe une NA dans une rangée. Vous pouvez l'utiliser pour voir comment un grand nombre de lignes que vous aurez à déposer:

    sum(row.has.na)

    et, éventuellement, de les déposer

    final.filtered <- final[!row.has.na,]

    Pour le filtrage de lignes avec une certaine partie de NAs, il devient un peu plus délicat (par exemple, vous pouvez nourrir à la finale de la[,5:6] " à "appliquer").
    Généralement, Joris Meys' solution semble être la plus élégante.

    • C'est extrêmement lent. Beaucoup plus lent que par exemple le susmentionné terminée.cas (la) solution. Au moins, dans mon cas, sur la xts de données.
    • rowSum(!is.na(final)) semble mieux adapté que apply()
    InformationsquelleAutor donshikin
  5. 42

    Une autre option si vous souhaitez plus de contrôle sur la façon dont les lignes sont tenues pour non valides est

    final <- final[!(is.na(final$rnor)) | !(is.na(rawdata$cfam)),]

    À l'aide de la ci-dessus, ce:

                 gene hsap mmul mmus rnor cfam
1 ENSG00000208234    0   NA   NA   NA   2
2 ENSG00000199674    0   2    2    2    2
3 ENSG00000221622    0   NA   NA   2   NA
4 ENSG00000207604    0   NA   NA   1    2
5 ENSG00000207431    0   NA   NA   NA   NA
6 ENSG00000221312    0   1    2    3    2

    Devient:

                 gene hsap mmul mmus rnor cfam
1 ENSG00000208234    0   NA   NA   NA   2
2 ENSG00000199674    0   2    2    2    2
3 ENSG00000221622    0   NA   NA   2   NA
4 ENSG00000207604    0   NA   NA   1    2
6 ENSG00000221312    0   1    2    3    2

    ...où seule la ligne 5 est supprimée, puisqu'elle est la seule ligne contenant un serveur NAs à deux rnor ET cfam. La logique booléenne peut ensuite être modifiés pour s'adapter à des exigences spécifiques.

    • mais comment pouvez-vous utiliser cette option si vous souhaitez vérifier le nombre de colonnes, sans taper de chacun, pouvez-vous utiliser une gamme de finale[,4:100]?
    InformationsquelleAutor getting-there
  6. 36

    Si vous souhaitez garder le contrôle sur la façon dont beaucoup de NAs sont valables pour chaque ligne, essayez cette fonction. Pour beaucoup de l'enquête d'ensembles de données, trop de vide question réponses peuvent ruiner les résultats. Donc, ils sont supprimés après un certain seuil. Cette fonction vous permet de choisir combien de sar la ligne peut avoir avant qu'il soit supprimé:

    delete.na <- function(DF, n=0) {
  DF[rowSums(is.na(DF)) <= n,]
}

    Par défaut, il permettra d'éliminer tous les NAs:

    delete.na(final)
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
6 ENSG00000221312    0    1    2    3    2

    Ou spécifier le nombre maximum de NAs permis:

    delete.na(final, 2)
             gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0    2    2    2    2
4 ENSG00000207604    0   NA   NA    1    2
6 ENSG00000221312    0    1    2    3    2
    InformationsquelleAutor Pierre Lafortune
  7. 30

    Si la performance est une priorité, l'utilisation data.table et na.omit() avec l'option param cols=.

    na.omettre.les données.la table est le plus rapide sur mon indice de référence (voir ci-dessous), que ce soit pour toutes les colonnes ou pour sélectionner les colonnes (OP question de la partie 2).

    Si vous ne souhaitez pas utiliser data.table, utilisez complete.cases().

    Sur une vanille data.frame, complet.cas est plus rapide que na.omettre() ou dplyr::drop_na(). Notez que na.omit.data.frame ne prend pas en charge cols=.

    Résultat de référence

    Voici une comparaison de base (bleu), dplyr (rose), et data.table (jaune) les méthodes de l'abandon de tout ou sélectionnez les observations manquantes, sur les dataset de 1 million d'observations de 20 variables numériques indépendants de 5% la probabilité d'être en manque, et un sous-ensemble de 4 variables pour la partie 2.

    Vos résultats peuvent varier en fonction de la longueur, la largeur et la densité de votre jeu de données.

    Remarque échelle logarithmique sur l'axe des y.

    Supprimer les lignes avec tous ou certains NAs (valeurs manquantes) dans les données.cadre

    De référence de script

    #-------  Adjust these assumptions for your own use case  ------------
row_size   <- 1e6L 
col_size   <- 20    # not including ID column
p_missing  <- 0.05   # likelihood of missing observation (except ID col)
col_subset <- 18:21  # second part of question: filter on select columns
#-------  System info for benchmark  ----------------------------------
R.version # R version 3.4.3 (2017-11-30), platform = x86_64-w64-mingw32
library(data.table); packageVersion('data.table') # 1.10.4.3
library(dplyr);      packageVersion('dplyr')      # 0.7.4
library(tidyr);      packageVersion('tidyr')      # 0.8.0
library(microbenchmark)
#-------  Example dataset using above assumptions  --------------------
fakeData <- function(m, n, p){
set.seed(123)
m <-  matrix(runif(m*n), nrow=m, ncol=n)
m[m<p] <- NA
return(m)
}
df <- cbind( data.frame(id = paste0('ID',seq(row_size)), 
stringsAsFactors = FALSE),
data.frame(fakeData(row_size, col_size, p_missing) )
)
dt <- data.table(df)
par(las=3, mfcol=c(1,2), mar=c(22,4,1,1)+0.1)
boxplot(
microbenchmark(
df[complete.cases(df), ],
na.omit(df),
df %>% drop_na,
dt[complete.cases(dt), ],
na.omit(dt)
), xlab='', 
main = 'Performance: Drop any NA observation',
col=c(rep('lightblue',2),'salmon',rep('beige',2))
)
boxplot(
microbenchmark(
df[complete.cases(df[,col_subset]), ],
#na.omit(df), # col subset not supported in na.omit.data.frame
df %>% drop_na(col_subset),
dt[complete.cases(dt[,col_subset,with=FALSE]), ],
na.omit(dt, cols=col_subset) # see ?na.omit.data.table
), xlab='', 
main = 'Performance: Drop NA obs. in select cols',
col=c('lightblue','salmon',rep('beige',2))
)
    InformationsquelleAutor C8H10N4O2
  8. 17

    À l'aide de dplyr paquet que l'on peut filtrer NA comme suit:

    dplyr::filter(df,  !is.na(columnname))
    InformationsquelleAutor Raminsu
  9. 16

    Revenir les lignes qui ont au moins UN non-NA de valeur.

    final[rowSums(is.na(final))<length(final),]

    Revenir les lignes qui ont au moins DEUX non-NA de valeur.

    final[rowSums(is.na(final))<(length(final)-1),]
    InformationsquelleAutor Leo
  10. 14

    Pour votre première question, j'ai un code que je suis à l'aise avec se débarrasser de tous les NAs. Merci pour @Gregor pour le rendre plus simple.

    final[!(rowSums(is.na(final))),]

    Pour la deuxième question, le code est juste une alternance à partir de la solution précédente.

    final[as.logical((rowSums(is.na(final))-5)),]

    Avis de l'-5 est le nombre de colonnes de vos données. Cela permettra d'éliminer les lignes avec toutes les NAs, depuis le rowSums ajoute jusqu'à 5 et ils deviennent des zéros après la soustraction. Cette fois, comme.logique est nécessaire.

    • final[comme.logique((rowSums(est.na(final))-ncol(final))),] pour une réponse universelle
    InformationsquelleAutor LegitMe
  11. 13

    Nous pouvons également utiliser la fonction de sous-ensemble pour cela.

    finalData<-subset(data,!(is.na(data["mmul"]) | is.na(data["rnor"])))

    Cela donnera uniquement les lignes qui n'ont pas de NA dans les deux mmul et rnor

    InformationsquelleAutor Ramya Ural
  12. 9

    Je suis un synthétiseur:). Ici, j'ai combiné les réponses en une seule fonction:

    #' keep rows that have a certain number (range) of NAs anywhere/somewhere and delete others
#' @param df a data frame
#' @param col restrict to the columns where you would like to search for NA; eg, 3, c(3), 2:5, "place", c("place","age")
#' \cr default is NULL, search for all columns
#' @param n integer or vector, 0, c(3,5), number/range of NAs allowed.
#' \cr If a number, the exact number of NAs kept
#' \cr Range includes both ends 3<=n<=5
#' \cr Range could be -Inf, Inf
#' @return returns a new df with rows that have NA(s) removed
#' @export
ez.na.keep = function(df, col=NULL, n=0){
if (!is.null(col)) {
# R converts a single row/col to a vector if the parameter col has only one col
# see https://radfordneal.wordpress.com/2008/08/20/design-flaws-in-r-2-%E2%80%94-dropped-dimensions/#comments
df.temp = df[,col,drop=FALSE]
} else {
df.temp = df
}
if (length(n)==1){
if (n==0) {
# simply call complete.cases which might be faster
result = df[complete.cases(df.temp),]
} else {
# credit: http://stackoverflow.com/a/30461945/2292993
log <- apply(df.temp, 2, is.na)
logindex <- apply(log, 1, function(x) sum(x) == n)
result = df[logindex, ]
}
}
if (length(n)==2){
min = n[1]; max = n[2]
log <- apply(df.temp, 2, is.na)
logindex <- apply(log, 1, function(x) {sum(x) >= min && sum(x) <= max})
result = df[logindex, ]
}
return(result)
}
    InformationsquelleAutor Jerry T
  13. 8

    En supposant dat que votre dataframe, le résultat attendu peut être réalisé en utilisant

    1.rowSums

    > dat[!rowSums((is.na(dat))),]
gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
6 ENSG00000221312    0   1    2    3    2

    2.lapply

    > dat[!Reduce('|',lapply(dat,is.na)),]
gene hsap mmul mmus rnor cfam
2 ENSG00000199674    0   2    2    2    2
6 ENSG00000221312    0   1    2    3    2
    InformationsquelleAutor Prradep
  14. 4
    delete.dirt <- function(DF, dart=c('NA')) {
dirty_rows <- apply(DF, 1, function(r) !any(r %in% dart))
DF <- DF[dirty_rows, ]
}
mydata <- delete.dirt(mydata)

    Au-dessus de la fonction supprime toutes les lignes de la trame de données qui a NA dans la colonne et renvoie les données qui en résultent. Si vous voulez vérifier pour plusieurs valeurs comme NA et ? changement dart=c('NA') en fonction de param pour dart=c('NA', '?')

    InformationsquelleAutor sapy
  15. 3

    Ma conjecture est que cela pourrait être plus élégamment résolu de cette façon

      m <- matrix(1:25, ncol = 5)
m[c(1, 6, 13, 25)] <- NA
df <- data.frame(m)
library(dplyr) 
df %>%
filter_all(any_vars(is.na(.)))
#>   X1 X2 X3 X4 X5
#> 1 NA NA 11 16 21
#> 2  3  8 NA 18 23
#> 3  5 10 15 20 NA
    • cela permettra de conserver les lignes avec NA. Je pense que ce que l'OP veut, c'est: df %>% filter_all(all_vars(!is.na(.)))
    InformationsquelleAutor Joni Hoppen
  16. 2

    Une approche qui est à la fois général et des rendements assez lisible le code est d'utiliser le filter de la fonction et de ses variantes dans le dplyr paquet (filter_all, filter_at, filter_if):

    library(dplyr)
vars_to_check <- c("rnor", "cfam")
# Filter a specific list of columns to keep only non-missing entries
df %>% 
filter_at(.vars = vars(one_of(vars_to_check)),
~ !is.na(.))
# Filter all the columns to exclude NA
df %>% 
filter_all(~ !is.na(.))
# Filter only numeric columns
df %>%
filter_if(is.numeric,
~ !is.na(.))
    InformationsquelleAutor bschneidr