What ways are there for cleaning an R environment from objects?

I know I can use ls() and rm() to see and remove objects that exist in my environment.

However, when dealing with "old" .RData file, one needs to sometimes pick an environment a part to find what to keep an开发者_如何学Pythond what to leave out.

What I would like to do, is to have a GUI like interface to allow me to see the objects, sort them (for example, by there size), and remove the ones I don't need (for example, by a check-box interface). Since I imagine such a system is not currently implemented in R, what ways do exist? What do you use for cleaning old .RData files?

Thanks,

Tal

I never create .RData files. If you are practicing reproducible research (and you should be!) you should be able to source in R files to go from input data files to all outputs.

When you have operations that take a long time it makes sense to cache them. If often use a construct like:

 if (file.exists("cache.rdata")) { 
    load("cache.rdata")
 } else {
    # do stuff ...
    save(..., file = "cache.rdata")
 }

This allows you to work quickly from cached files, and when you need to recalculate from scratch you can just delete all the rdata files in your working directory.

Basic solution is to load your data, remove what you don't want and save as new, clean data.

Another way to handle this situation is to control loaded RData by loading it to own environment

sandbox <- new.env()
load("some_old.RData", sandbox)

Now you can see what is inside

ls(sandbox)
sapply(ls(sandbox), function(x) object.size(get(x,sandbox)))

Then you have several posibilities:

• write what you want to new RData: save(A, B, file="clean.RData", envir=sandbox)
• remove what you don't want from environment rm(x, z, u, envir=sandbox)
• make copy of variables you want in global workspace and remove sandbox

I usually do something similar to third option. Load my data, do some checks, transformation, copy final data to global workspace and remove environments.

You could always implement what you want. So

1. Load the data
   vars <- load("some_old.RData")
2. Get sizes
   vars_size <- sapply(vars, function(x) object.size(get(x)))
3. Order them
   vars <- vars[order(vars_size, decreasing=TRUE)]
vars_size <- vars_size [order(vars_size, decreasing=TRUE)]
4. Make dialog box (depends on OS, here is Windows)
   vars_with_size <- paste(vars,vars_size)
vars_to_save <- select.list(vars_with_size, multiple=TRUE)
5. Remove what you don't want
   rm(vars[!vars_with_size%in%vars_to_save])

To nice form of object size I use solution based on getAnywhere(print.object_size)

pretty_size <- function(x) {
    ifelse(x >= 1024^3, paste(round(x/1024^3, 1L), "Gb"),
    ifelse(x >= 1024^2, paste(round(x/1024^2, 1L), "Mb"),
    ifelse(x >= 1024  , paste(round(x/1024, 1L), "Kb"),
                        paste(x, "bytes")
    )))
}

Then in 4. one can use paste(vars, pretty_size(vars_size))

You may want to check out the RGtk2 package. You can very easily create an interface with Glade Interface Designer and then attach whatever R commands you want to it.

If you want a good starting point where to "steal" ideas on how to use RGtk2, install the rattle package and run rattle();. Then look at the source code and start making your own interface :)

I may have a go at it and see if I can come out with something simple.

EDIT: this is a quick and dirty piece of code that you can play with. The big problem with it is that for whatever reason the rm instruction does not get executed, but I'm not sure why... I know that it is the central instruction, but at least the interface works! :D

TODO:

• Make rm work
• I put all the variables in the remObjEnv environment. It should not be listed in the current variable and it should be removed when the window is closed
• The list will only show objects in the global environment, anything inside other environment won't be shown, but that's easy enough to implement
• probably there's some other bug I haven't thought of :D

Enjoy

# Our environment
remObjEnv <<- new.env()

# Various required libraries
require("RGtk2")

remObjEnv$createModel <- function()
    {
    # create the array of data and fill it in
    remObjEnv$objList <- NULL
    objs <- objects(globalenv())

    for (o in objs)
        remObjEnv$objList[[length(remObjEnv$objList)+1]] <- list(object = o, 
            type = typeof(get(o)),
            size = object.size(get(o)))

    # create list store
    model <- gtkListStoreNew("gchararray", "gchararray", "gint")

    # add items 
    for (i in 1:length(remObjEnv$objList))
        {
        iter <- model$append()$iter

        model$set(iter,
              0, remObjEnv$objList[[i]]$object,
              1, remObjEnv$objList[[i]]$type,
              2, remObjEnv$objList[[i]]$size)
        }

    return(model)
    }

remObjEnv$addColumns <- function(treeview)
    {
    colNames <- c("Name", "Type", "Size (bytes)")

    model <- treeview$getModel()

    for (n in 1:length(colNames))
        {
        renderer <- gtkCellRendererTextNew()
        renderer$setData("column", n-1)
        treeview$insertColumnWithAttributes(-1, colNames[n], renderer, text=n-1)
        }
    }

# Builds the list. 
# I seem to have some problems in correctly build treeviews from glade files
# so we'll just do it by hand :)
remObjEnv$buildTreeView <- function()
    {   
    # create model
    model <- remObjEnv$createModel()
    # create tree view
    remObjEnv$treeview <- gtkTreeViewNewWithModel(model)

    remObjEnv$treeview$setRulesHint(TRUE)
    remObjEnv$treeview$getSelection()$setMode("single")

    remObjEnv$addColumns(remObjEnv$treeview)
    remObjEnv$vbox$packStart(remObjEnv$treeview, TRUE, TRUE, 0)
    }

remObjEnv$delObj <- function(widget, treeview)
    {
    model <- treeview$getModel()
    selection <- treeview$getSelection()
    selected <- selection$getSelected()
    if (selected[[1]])
        {
        iter <- selected$iter
        path <- model$getPath(iter)
            i <- path$getIndices()[[1]]
            model$remove(iter)
        }

    obj <- as.character(remObjEnv$objList[[i+1]]$object)
    rm(obj)
    }

# The list of the current objects
remObjEnv$objList <- NULL

# Create the GUI.
remObjEnv$window <- gtkWindowNew("toplevel", show = FALSE)
gtkWindowSetTitle(remObjEnv$window, "R Object Remover")
gtkWindowSetDefaultSize(remObjEnv$window, 500, 300)
remObjEnv$vbox <- gtkVBoxNew(FALSE, 5)
remObjEnv$window$add(remObjEnv$vbox)

# Build the treeview
remObjEnv$buildTreeView()

remObjEnv$button <- gtkButtonNewWithLabel("Delete selected object")
gSignalConnect(remObjEnv$button, "clicked", remObjEnv$delObj, remObjEnv$treeview)
remObjEnv$vbox$packStart(remObjEnv$button, TRUE, TRUE, 0)

remObjEnv$window$showAll()

Once you've figured out what you want to keep, you can use the function -keep- from package gdata does what its name suggests.

a <- 1
b <- 2
library(gdata)
keep(a, all = TRUE, sure = TRUE)

See help(keep) for details on the -all- and -sure- options.

all: whether hidden objects (beginning with a .) should be removed, unless explicitly kept.
sure: whether to perform the removal, otherwise return names of objects that would have been removed.

This function is so useful that I'm surprised it isn't part of R itself.

The OS X gui does have such a thing, it's called the Workspace Browser. Quite handy.

I've also wished for an interface that shows the session dependency between objects, i.e. if I start from a plot() and work backwards to find all the objects that were used to create it. This would require parsing the history.

It doesn't have checkboxes to delete with, rather you select the file(s) then click delete. However, the solution below is pretty easy to implement:

library(gWidgets)
options(guiToolkit="RGtk2")

## make data frame with files
out <- lapply((x <- list.files()), file.info)
out <- do.call("rbind", out)
out <- data.frame(name=x, size=as.integer(out$size), ## more attributes?
                  stringsAsFactors=FALSE)
## set up GUI
w <- gwindow("Browse directory")
g <- ggroup(cont=w, horizontal=FALSE)
tbl <- gtable(out, cont=g, multiple=TRUE)
size(tbl) <- c(400,400)
deleteThem <- gbutton("delete", cont=g)
enabled(deleteThem) <- FALSE
## add handlers
addHandlerClicked(tbl, handler=function(h,...) {
  enabled(deleteThem) <- (length(svalue(h$obj, index=TRUE)) > 0)
})

addHandlerClicked(deleteThem, handler=function(h,...) {
  inds <- svalue(tbl, index=TRUE)
  files <- tbl[inds,1]
  print(files)                          # replace with rm?
})

The poor guy answer could be :

ls()
# spot the rank of the variables you want to remove, for example 10 to 25 
rm(list= ls()[[10:25]])
# repeat until satisfied

To clean the complete environment you can try:

rm(list(ls())