Come eliminare una riga per riferimento in data.table?

La mia domanda è relativa all'assegnazione per riferimento rispetto alla copia in data.table. Voglio sapere se uno può eliminare le righe per riferimento, simile a

DT[ , someCol := NULL]

Voglio sapere

DT[someRow := NULL, ]

Immagino che ci sia una buona ragione per cui questa funzione non esiste, quindi forse potresti semplicemente indicare una buona alternativa al solito approccio alla copia, come di seguito. In particolare, andando con il mio preferito dall'esempio (data.table),

DT = data.table(x = rep(c("a", "b", "c"), each = 3), y = c(1, 3, 6), v = 1:9)
#      x y v
# [1,] a 1 1
# [2,] a 3 2
# [3,] a 6 3
# [4,] b 1 4
# [5,] b 3 5
# [6,] b 6 6
# [7,] c 1 7
# [8,] c 3 8
# [9,] c 6 9

Di 'che voglio eliminare la prima riga da questo data.table. So che posso fare questo:

DT <- DT[-1, ]

ma spesso potremmo volerlo evitare, perché stiamo copiando l'oggetto (e ciò richiede circa 3 * N di memoria, se N object.size(DT), come indicato qui . Ora ho trovato set(DT, i, j, value). So come impostare valori specifici (come qui: imposta tutto valori nelle righe 1 e 2 e colonne 2 e 3 a zero)

set(DT, 1:2, 2:3, 0) 
DT
#      x y v
# [1,] a 0 0
# [2,] a 0 0
# [3,] a 6 3
# [4,] b 1 4
# [5,] b 3 5
# [6,] b 6 6
# [7,] c 1 7
# [8,] c 3 8
# [9,] c 6 9

Ma come posso cancellare le prime due righe, diciamo? fare

set(DT, 1:2, 1:3, NULL)

imposta l'intero DT su NULL.

La mia conoscenza di SQL è molto limitata, quindi voi ragazzi mi dite: dato data.table utilizza la tecnologia SQL, esiste un equivalente al comando SQL

DELETE FROM table_name
WHERE some_column=some_value

in data.table?

Buona domanda. data.tablenon è ancora possibile eliminare le righe per riferimento.

data.tablepuò aggiungere ed eliminare colonne per riferimento poiché alloca in modo eccessivo il vettore dei puntatori di colonna, come sai. Il piano è fare qualcosa di simile per le file e consentire velocemente inserte delete. Un'eliminazione riga dovrebbe essere utilizzata memmovein C per spostare gli elementi (in ogni colonna) dopo le righe eliminate. L'eliminazione di una riga al centro della tabella sarebbe comunque piuttosto inefficiente rispetto a un database dell'archivio di righe come SQL, che è più adatto all'inserimento e all'eliminazione rapidi delle righe ovunque tali righe siano nella tabella. Tuttavia, sarebbe molto più veloce della copia di un nuovo oggetto di grandi dimensioni senza le righe eliminate.

D'altra parte, poiché i vettori di colonna sarebbero sovrallocati, le righe potrebbero essere inserite (ed eliminate) alla fine , istantaneamente; ad esempio, una serie storica in crescita.

È stato archiviato come problema: elimina le righe per riferimento .

l'approccio che ho adottato al fine di rendere l'utilizzo della memoria simile alla cancellazione sul posto è quello di sottoinsieme di una colonna alla volta ed eliminazione. non veloce come una corretta soluzione memmove in C, ma l'uso della memoria è tutto ciò che mi interessa qui. qualcosa come questo:

DT = data.table(col1 = 1:1e6)
cols = paste0('col', 2:100)
for (col in cols){ DT[, (col) := 1:1e6] }
keep.idxs = sample(1e6, 9e5, FALSE) # keep 90% of entries
DT.subset = data.table(col1 = DT[['col1']][keep.idxs]) # this is the subsetted table
for (col in cols){
  DT.subset[, (col) := DT[[col]][keep.idxs]]
  DT[, (col) := NULL] #delete
}

Ecco una funzione funzionante basata sulla risposta di @ vc273 e sul feedback di @ Frank.

delete <- function(DT, del.idxs) {           # pls note 'del.idxs' vs. 'keep.idxs'
  keep.idxs <- setdiff(DT[, .I], del.idxs);  # select row indexes to keep
  cols = names(DT);
  DT.subset <- data.table(DT[[1]][keep.idxs]); # this is the subsetted table
  setnames(DT.subset, cols[1]);
  for (col in cols[2:length(cols)]) {
    DT.subset[, (col) := DT[[col]][keep.idxs]];
    DT[, (col) := NULL];  # delete
  }
   return(DT.subset);
}

Ed esempio del suo utilizzo:

dat <- delete(dat,del.idxs)   ## Pls note 'del.idxs' instead of 'keep.idxs'

Dove "dat" è un data.table. La rimozione di 14.000 righe da 1,4 milioni di righe richiede 0,25 secondi sul mio laptop.

> dim(dat)
[1] 1419393      25
> system.time(dat <- delete(dat,del.idxs))
   user  system elapsed 
   0.23    0.02    0.25 
> dim(dat)
[1] 1404715      25
> 

PS. Dato che sono nuovo di SO, non ho potuto aggiungere commenti alla discussione di @ vc273 :-(

Invece o cercando di impostare su NULL, prova a impostare su NA (facendo corrispondere il tipo NA per la prima colonna)

set(DT,1:2, 1:3 ,NA_character_)

L'argomento è ancora interessante per molte persone (me incluso).

Che ne dici? Ho usato assignper sostituire il glovalenve il codice descritto in precedenza. Sarebbe meglio catturare l'ambiente originale ma almeno in globalenvesso è efficiente la memoria e si comporta come un cambiamento da ref.

delete <- function(DT, del.idxs) 
{ 
  varname = deparse(substitute(DT))

  keep.idxs <- setdiff(DT[, .I], del.idxs)
  cols = names(DT);
  DT.subset <- data.table(DT[[1]][keep.idxs])
  setnames(DT.subset, cols[1])

  for (col in cols[2:length(cols)]) 
  {
    DT.subset[, (col) := DT[[col]][keep.idxs]]
    DT[, (col) := NULL];  # delete
  }

  assign(varname, DT.subset, envir = globalenv())
  return(invisible())
}

DT = data.table(x = rep(c("a", "b", "c"), each = 3), y = c(1, 3, 6), v = 1:9)
delete(DT, 3)

Ecco alcune strategie che ho usato. Credo che potrebbe arrivare una funzione .ROW. Nessuno di questi approcci di seguito è veloce. Queste sono alcune strategie un po 'oltre i sottoinsiemi o i filtri. Ho provato a pensare come dba solo cercando di ripulire i dati. Come notato sopra, è possibile selezionare o rimuovere le righe in data.table:

data(iris)
iris <- data.table(iris)

iris[3] # Select row three

iris[-3] # Remove row three

You can also use .SD to select or remove rows:

iris[,.SD[3]] # Select row three

iris[,.SD[3:6],by=,.(Species)] # Select row 3 - 6 for each Species

iris[,.SD[-3]] # Remove row three

iris[,.SD[-3:-6],by=,.(Species)] # Remove row 3 - 6 for each Species

Nota: .SD crea un sottoinsieme dei dati originali e consente di fare un bel po 'di lavoro in j o data.table successivo. Vedi https://stackoverflow.com/a/47406952/305675 . Qui ho ordinato le mie iridi per Sepal Length, prendere una Sepal.Length minima, selezionare i primi tre (per Sepal Length) di tutte le specie e restituire tutti i dati di accompagnamento:

iris[order(-Sepal.Length)][Sepal.Length > 3,.SD[1:3],by=,.(Species)]

Gli approcci soprattutto riordinano un data.table in sequenza quando si rimuovono le righe. È possibile trasporre un file data.table e rimuovere o sostituire le vecchie righe che ora sono colonne trasposte. Quando si utilizza ': = NULL' per rimuovere una riga trasposta, viene rimosso anche il nome della colonna successiva:

m_iris <- data.table(t(iris))[,V3:=NULL] # V3 column removed

d_iris <- data.table(t(iris))[,V3:=V2] # V3 column replaced with V2

Quando si traspone data.frame su data.table, è possibile che si desideri rinominare da data.table originale e ripristinare gli attributi della classe in caso di eliminazione. Applicando ": = NULL" a un data.table ora trasposto si creano tutte le classi di caratteri.

m_iris <- data.table(t(d_iris));
setnames(d_iris,names(iris))

d_iris <- data.table(t(m_iris));
setnames(m_iris,names(iris))

Potresti semplicemente voler rimuovere le righe duplicate che puoi fare con o senza una chiave:

d_iris[,Key:=paste0(Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species)]     

d_iris[!duplicated(Key),]

d_iris[!duplicated(paste0(Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species)),]  

È anche possibile aggiungere un contatore incrementale con '.I'. È quindi possibile cercare chiavi o campi duplicati e rimuoverli rimuovendo il record con il contatore. Questo è computazionalmente costoso, ma presenta alcuni vantaggi poiché è possibile stampare le linee da rimuovere.

d_iris[,I:=.I,] # add a counter field

d_iris[,Key:=paste0(Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species)]

for(i in d_iris[duplicated(Key),I]) {print(i)} # See lines with duplicated Key or Field

for(i in d_iris[duplicated(Key),I]) {d_iris <- d_iris[!I == i,]} # Remove lines with duplicated Key or any particular field.

Puoi anche semplicemente riempire una riga con 0 o NA e quindi utilizzare una query i per eliminarli:

 X 
   x v foo
1: c 8   4
2: b 7   2

X[1] <- c(0)

X
   x v foo
1: 0 0   0
2: b 7   2

X[2] <- c(NA)
X
    x  v foo
1:  0  0   0
2: NA NA  NA

X <- X[x != 0,]
X <- X[!is.na(x),]