add resize!, keepat!, pop!, popfist!, popat!

NEWS.md

@@ -36,6 +36,10 @@
 * Add `allcombinations` function that returns a data frame created
   from all combinations of the passed vectors
   ([#3031](https://github.com/JuliaData/DataFrames.jl/pull/3031))
+* Add `keepat!` and `pop!`, `popfirst!`, `popat!`
+   ([#3047](https://github.com/JuliaData/DataFrames.jl/pull/3047))
+* In `deleteat!` allow unsorted or duplicate indices passed
+   ([#3047](https://github.com/JuliaData/DataFrames.jl/pull/3047))
 
 ## Previously announced breaking changes
 

docs/src/lib/functions.md

@@ -144,9 +144,13 @@ empty
 empty!
 filter
 filter!
+keepat!
 first
 last
 only
+pop!
+popat!
+popfirst!
 nonunique
 subset
 subset!

src/DataFrames.jl

@@ -105,6 +105,14 @@ else
     export only
 end
 
+if isdefined(Base, :keepat!)  # Introduced in 1.7.0
+    import Base.keepat!
+else
+    # TODO: uncomment when keepat! is added to Compat.jl
+    # import Compat.keepat!
+    export keepat!
+end
+
 if VERSION >= v"1.3"
     using Base.Threads: @spawn
 else

src/dataframe/dataframe.jl

@@ -769,9 +769,8 @@ end
 
 Delete rows specified by `inds` from a `DataFrame` `df` in place and return it.
 
-Internally `deleteat!` is called for all columns so `inds` must be:
-a vector of sorted and unique integers, a boolean vector, an integer,
-or `Not` wrapping any valid selector.
+`inds` do not have to be sorted nor unique. Non-unique elements of `inds`
+are de-duplicated before deleting rows.
 
 # Examples
 ```jldoctest
@@ -793,7 +792,7 @@ julia> deleteat!(df, 2)
    2 │     3      6
 ```
 """
-function Base.deleteat!(df::DataFrame, inds)
+function Base.deleteat!(df::DataFrame, inds::AbstractVector)
     if !isempty(inds) && size(df, 2) == 0
         throw(BoundsError(df, (inds, :)))
     end
@@ -808,6 +807,8 @@ function Base.deleteat!(df::DataFrame, inds)
     return _deleteat!_helper(df, inds)
 end
 
+Base.deleteat!(df::DataFrame, inds::Integer) = deleteat!(df, Int[inds])
+
 function Base.deleteat!(df::DataFrame, inds::AbstractVector{Bool})
     if length(inds) != size(df, 1)
         throw(BoundsError(df, (inds, :)))
@@ -822,7 +823,34 @@ end
 
 Base.deleteat!(df::DataFrame, inds::Not) = deleteat!(df, axes(df, 1)[inds])
 
-function _deleteat!_helper(df::DataFrame, drop)
+function _isincreasing(v::AbstractVector)
+    length(v) < 2 && return true
+    last = v[begin]
+    for i in firstindex(v)+1:lastindex(v)
+        cur = @inbounds x[i]
+        cur > last || return false
+        last = cur
+    end
+    return true
+end
+
+function _uniquesorted(v::AbstractVector)
+    x = sort(v)
+    # here we know that length of v is at least 2
+    last = v[begin]
+    u = eltype(v)[last]
+    for i in firstindex(v)+1:lastindex(v)
+        cur = @inbounds x[i]
+        cur == last && continue
+        push!(u, cur)
+        last = cur
+    end
+    return u
+end
+
+function _deleteat!_helper(df::DataFrame,
+                           drop_raw::AbstractVector{<:Union{Signed, Unsigned}})
+    drop = _isincreasing(drop_raw) ? drop_raw : _uniquesorted(drop_raw)
     cols = _columns(df)
     isempty(cols) && return df
 
@@ -846,6 +874,34 @@ function _deleteat!_helper(df::DataFrame, drop)
     return df
 end
 
+"""
+    keepat!(df::DataFrame, inds)
+
+Delete rows at all indices not specified by `inds` from a `DataFrame` `df`
+in place and return it.
+
+# Examples
+```jldoctest
+julia> df = DataFrame(a=1:3, b=4:6)
+3×2 DataFrame
+ Row │ a      b
+     │ Int64  Int64
+─────┼──────────────
+   1 │     1      4
+   2 │     2      5
+   3 │     3      6
+
+julia> keepat!(df, [1, 3])
+2×2 DataFrame
+ Row │ a      b
+     │ Int64  Int64
+─────┼──────────────
+   1 │     1      4
+   2 │     3      6
+```
+"""
+keepat!(df::DataFrame, inds) = deleteat!(df, Not(inds))
+
 """
     empty!(df::DataFrame)
 
@@ -856,6 +912,41 @@ function Base.empty!(df::DataFrame)
     return df
 end
 
+"""
+    resize!(df::DataFrame, n::Integer)
+
+Resize `df` to have `n` rows by calling `resize!` on all columns of `df`.
+"""
+function Base.resize!(df::DataFrame, n::Integer)
+    foreach(col -> resize!(col, n), eachcol(df))
+    return df
+end
+
+"""
+    pop!(df::DataFrame)
+
+Remove the last row from `df` and return a `NamedTuple` created from this row.
+"""
+pop!(df::DataFrame) = popat!(df, nrow(df))
+
+"""
+    popfirst!(df::DataFrame)
+
+Remove the first row from `df` and return a `NamedTuple` created from this row.
+"""
+popfirst!(df::DataFrame) = popat!(df, 1)
+
+"""
+    popat!(df::DataFrame, i::Integer)
+
+Remove the `i`-th row from `df` and return a `NamedTuple` created from this row.
+"""
+function popat!(df::DataFrame, i::Integer)
+    nt = NamedTuple(df[i, :])
+    deleteat!(df, i)
+    return nt
+end
+
 ##############################################################################
 ##
 ## hcat!