Removing NULL elements from a list

Question

mylist <- list(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
    123, NULL, 456)

> mylist
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

[[7]]
NULL

[[8]]
NULL

[[9]]
NULL

[[10]]
NULL

[[11]]
[1] 123

[[12]]
NULL

[[13]]
[1] 456

My list has 13 elements, 11 of which are NULL. I would like to remove them, but preserve the indices of the elements that are nonempty.

mylist2 = mylist[-which(sapply(mylist, is.null))]
> mylist2
[[1]]
[1] 123

[[2]]
[1] 456

This removes the NULL elements just fine, but I don't want the nonempty elements to be reindexed, i.e, I want mylist2 to look something like this, where the indices of the nonempty entries are preserved.

> mylist2
[[11]]
[1] 123

[[13]]
[1] 456

Someone may find a way, but I think you are falling into the "Why is it printing that way" trap. Those index numbers are not the names of your list elements. There are no names. Check `names(mylist)`. So they are just helpers showing where in the list the elements are. That's why you're having trouble telling R to return the 11th position of a list with only two elements. You can try naming the the list as the answer below. — Pierre L, Oct 07 '15 at 23:49
IMO this answer should be updated to @Hayward-Oblad's purrr solution below. Either `list %>% discard(is.null)` or `list %>% discard(~ length(.x) == 0)`. — geotheory, Dec 06 '19 at 13:43

Josh O'Brien · Accepted Answer · 2015-10-07T23:58:05.527

130

The closest you'll be able to get is to first name the list elements and then remove the NULLs.

names(x) <- seq_along(x)

## Using some higher-order convenience functions
Filter(Negate(is.null), x)
# $`11`
# [1] 123
# 
# $`13`
# [1] 456

# Or, using a slightly more standard R idiom
x[sapply(x, is.null)] <- NULL
x
# $`11`
# [1] 123
# 
# $`13`
# [1] 456

edited Oct 07 '15 at 23:58

answered Oct 07 '15 at 23:53

Josh O'Brien

159,210
26
366
455

22

or `x <- x[!sapply(x,is.null)]` – xm1 Jul 11 '20 at 00:19
2

@xm1's answer is better since the right hand side expression returns the list without the `NULL`s hence can be written into a convenience function like this `remove_null_lst <- function(x) x[!sapply(x, is.null)]` – Prashant Bharadwaj Apr 01 '21 at 22:01

F. Privé · Answer 2 · 2020-02-13T21:08:27.390

65

Simply use mylist[lengths(mylist) != 0].

Function lengths() was introduced in R 3.2.0 (April 2015).

edited Feb 13 '20 at 21:08

answered Aug 23 '18 at 16:02

F. Privé

11,423
2
27
78

1

Users stuck with even older R versions can use `vapply(mylist, length, 1L)`, it's ever-so-slightly vaster (and maybe harder to read to the untrained eye) – MichaelChirico Jul 27 '19 at 11:31

score 53 · Answer 3 · edited Oct 21 '19 at 18:58

The purrr package, included in Tidyverse, has elegant and fast functions for working with lists:

require(tidyverse)

# this works
compact(mylist)

# or this
mylist %>% discard(is.null)

# or this
# pipe "my_list" data object into function "keep()", make lambda function inside "keep()" to return TRUE FALSE.
mylist %>% keep( ~ !is.null(.) )

All above options are from Purrr. Output is:

[[1]] 
[1] 123

[[2]] 
[1] 456

Note: compact() was in plyr, but dplyr superseded plyr, and compact() stayed around but moved to purrr. Anyway, all the functions are within the parent package tidyverse.

Here's a link to the Purrr cheat sheet download:

https://rstudio.com/resources/cheatsheets/

Or to view the Purrr cheatsheet directly in a browser:

https://evoldyn.gitlab.io/evomics-2018/ref-sheets/R_purrr.pdf

David Rodriguez Lores · Answer 4 · 2018-01-30T10:34:20.470

30

There's a function that automatically removes all the null entries of a list, and if the list is named, it maintains the names of the non-null entries.

This function is called compact from the package plyr.

l <- list( NULL, NULL, foo, bar)
names(l) <- c( "one", "two", "three", "four" )

plyr::compact(l)

If you want to preserve the indexes of the non-null entries, you can name the list as it is done in the post before and then compact your list:

names(l) <- seq_along(l)
plyr::compact(l)

edited Jan 30 '18 at 10:34

answered Jan 30 '18 at 10:29

David Rodriguez Lores

459
4
8

12

For completeness: purrr::compact() seems to do the same job. – Gabi Mar 13 '18 at 00:55

score 6 · Answer 5 · answered Oct 07 '15 at 23:49

If you want to keep the names you can do

a <- list(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
          123, NULL, 456)
non_null_names <- which(!sapply(a, is.null))
a <- a[non_null_names]
names(a) <- non_null_names
a

You can then access the elements like so

a[['11']]
num <- 11
a[[as.character(num)]]
a[[as.character(11)]]
a$`11`

You can't get them in the neat [[11]], [[13]] notation, though, because those represent numerical indices.

This is the closest to what you want that can actually be done though :) — Felipe Gerard, Oct 07 '15 at 23:50

score 6 · Answer 6 · answered Apr 14 '19 at 07:19

6

This solution works with nested list as well

rlist::list.clean(myNestedlist ,recursive = T)

answered Apr 14 '19 at 07:19

Adam Lee Perelman

820
8
9

Perfect! I was looking for this. – Nip Apr 24 '21 at 21:13

bramtayl · Answer 7 · 2015-10-08T02:37:43.133

5

Here it is with convenient chaining notation

library(magrittr)

mylist %>%
  setNames(seq_along(.)) %>%
  Filter(. %>% is.null %>% `!`, .)

edited Oct 08 '15 at 02:37

answered Oct 07 '15 at 23:52

bramtayl

4,004
2
11
18

7

`Filter(Negate(is.null), setNames(L,seq_along(L)))` is pretty easy to read. – thelatemail Oct 07 '15 at 23:56
Ok, fixed the issue. Negate != `!` – bramtayl Oct 08 '15 at 04:27

score 4 · Answer 8 · answered Aug 06 '18 at 19:46

4

here's a very simple way to do it using only base R functions:

names(mylist) <- 1:length(mylist)
mylist2 <- mylist[which(!sapply(mylist, is.null))]

answered Aug 06 '18 at 19:46

itsmisterbrown

471
4
3

Removing NULL elements from a list

8 Answers8

Linked

Related