Функции
Поддержка многопоточности
По умолчанию некоторые операции в DataFrames.jl автоматически используют несколько потоков, если есть такая возможность. Этот механизм основан на задачах и реализован с помощью макроса @spawn
из модуля Base Julia. Функции, которые принимают пользовательские функции и могут выполнять их параллельно, принимают именованный аргумент threads
, который позволяет отключать многопоточность, если переданная функция требует последовательного выполнения или не является потокобезопасной.
Вот список операций, в настоящее время использующих многопоточность:
-
конструктор
DataFrame
с аргументомcopycols=true
, а также рекурсивно все вызывающие его функции, напримерcopy
; -
getindex
при выборе нескольких столбцов; -
groupby
(как в случае, когда требуется хэширование, так и в случае, когда применяется первый путь, использующийDataAPI.refpool
); -
функции
*join
для составления выходного фрейма данных (но не для нахождения соответствующих строк в объединенных фреймах данных, по крайней мере пока); -
combine
,select[!]
иtransform[!]
для объектовGroupedDataFrame
при выполнении любого из следующих условий:-
выполняется несколько преобразований (для каждого из которых порождается отдельная задача);
-
преобразование создает одну строку для каждой группы, и переданное представление является пользовательской функцией (то есть не предназначено для стандартных сверток, для которых применяются оптимизированные однопоточные методы);
-
-
dropmissing
, если в переданном фрейме данных более одного столбца и задан аргументview=false
(для разделения отдельных столбцов на подмножества порождаются отдельные задачи).
Как правило, для использования многопоточности требуется версия Julia не ниже 1.4, а процесс Julia должен запускаться более чем с одним потоком. Для некоторых операций многопоточность активируется только в том случае, если в обрабатываемом фрейме данных достаточно строк (конкретное пороговое значение точно не определено и может измениться в будущем).
Кроме операций из приведенного выше списка, для которых многопоточность используется автоматически, все функции из пакета DataFrames.jl, изменяющий фрейм данных, не являются потокобезопасными. Это означает, что, хотя их можно вызывать из любого потока, вызывающая сторона должна гарантировать, что объект DataFrame
не будет изменяться каким-либо потоком, пока его используют другие (либо для чтения, либо для записи). Один и тот же объект DataFrame
можно безопасно использовать из других потоков при условии, что он не изменяется.
Создание фреймов данных
#
DataAPI.allcombinations
— Function
allcombinations(DataFrame, pairs::Pair...)
allcombinations(DataFrame; kwargs...)
Create a DataFrame
from all combinations of values in passed arguments. The first passed values vary fastest.
Arguments associating a column name with values to expand can be specified either as Pair
s passed as positional arguments, or as keyword arguments. Column names must be Symbol
s or strings and must be unique.
Column value can be a vector which is consumed as is or an object of any other type (except AbstractArray
). In the latter case the passed value is treated as having length one for expansion. As a particular rule values stored in a Ref
or a 0
-dimensional AbstractArray
are unwrapped and treated as having length one.
See also: crossjoin
can be used to get the cartesian product of rows from passed data frames.
Examples
julia> allcombinations(DataFrame, a=1:2, b='a':'c')
6×2 DataFrame
Row │ a b
│ Int64 Char
─────┼─────────────
1 │ 1 a
2 │ 2 a
3 │ 1 b
4 │ 2 b
5 │ 1 c
6 │ 2 c
julia> allcombinations(DataFrame, "a" => 1:2, "b" => 'a':'c', "c" => "const")
6×3 DataFrame
Row │ a b c
│ Int64 Char String
─────┼─────────────────────
1 │ 1 a const
2 │ 2 a const
3 │ 1 b const
4 │ 2 b const
5 │ 1 c const
6 │ 2 c const
#
Base.copy
— Function
copy(df::DataFrame; copycols::Bool=true)
Copy data frame df
. If copycols=true
(the default), return a new DataFrame
holding copies of column vectors in df
. If copycols=false
, return a new DataFrame
sharing column vectors with df
.
Metadata: this function preserves all table-level and column-level metadata.
copy(dfr::DataFrameRow)
Construct a NamedTuple
with the same contents as the DataFrameRow
. This method returns a NamedTuple
so that the returned object is not affected by changes to the parent data frame of which dfr
is a view.
copy(key::GroupKey)
Construct a NamedTuple
with the same contents as the GroupKey
.
#
Base.similar
— Function
similar(df::AbstractDataFrame, rows::Integer=nrow(df))
Создает новый DataFrame
с теми же именами столбцов и типами элементов столбцов, что и у df
. Необязательный второй аргумент может быть предоставлен для запроса количества строк, отличного от количества строк, представленных в df
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Сводная информация
#
DataAPI.describe
— Function
describe(df::AbstractDataFrame; cols=:)
describe(df::AbstractDataFrame, stats::Union{Symbol, Pair}...; cols=:)
Return descriptive statistics for a data frame as a new DataFrame
where each row represents a variable and each column a summary statistic.
Arguments
-
df
: theAbstractDataFrame
-
stats::Union{Symbol, Pair}...
: the summary statistics to report. Arguments can be:-
A symbol from the list
:mean
,:std
,:min
,:q25
,:median
,:q75
,:max
,:sum
,:eltype
,:nunique
,:nuniqueall
,:first
,:last
,:nnonmissing
, and:nmissing
. The default statistics used are:mean
,:min
,:median
,:max
,:nmissing
, and:eltype
. -
:detailed
as the onlySymbol
argument to return all statistics except:first
,:last
,:sum
,:nuniqueall
, and:nnonmissing
. -
:all
as the onlySymbol
argument to return all statistics. -
A
function => name
pair wherename
is aSymbol
or string. This will create a column of summary statistics with the provided name.
-
-
cols
: a keyword argument allowing to select only a subset or transformation of columns fromdf
to describe. Can be any column selector or transformation accepted byselect
.
Details
For Real
columns, compute the mean, standard deviation, minimum, first quantile, median, third quantile, and maximum. If a column does not derive from Real
, describe
will attempt to calculate all statistics, using nothing
as a fall-back in the case of an error.
When stats
contains :nunique
, describe
will report the number of unique values in a column. If a column’s base type derives from Real
, :nunique
will return nothing
s. Use :nuniqueall
to report the number of unique values in all columns.
Missing values are filtered in the calculation of all statistics, however the column :nmissing
will report the number of missing values of that variable and :nnonmissing
the number of non-missing values.
If custom functions are provided, they are called repeatedly with the vector corresponding to each column as the only argument. For columns allowing for missing values, the vector is wrapped in a call to skipmissing
: custom functions must therefore support such objects (and not only vectors), and cannot access missing values.
Metadata: this function drops all metadata.
Examples
julia> df = DataFrame(i=1:10, x=0.1:0.1:1.0, y='a':'j');
julia> describe(df)
3×7 DataFrame
Row │ variable mean min median max nmissing eltype
│ Symbol Union… Any Union… Any Int64 DataType
─────┼────────────────────────────────────────────────────────
1 │ i 5.5 1 5.5 10 0 Int64
2 │ x 0.55 0.1 0.55 1.0 0 Float64
3 │ y a j 0 Char
julia> describe(df, :min, :max)
3×3 DataFrame
Row │ variable min max
│ Symbol Any Any
─────┼────────────────────
1 │ i 1 10
2 │ x 0.1 1.0
3 │ y a j
julia> describe(df, :min, sum => :sum)
3×3 DataFrame
Row │ variable min sum
│ Symbol Any Union…
─────┼───────────────────────
1 │ i 1 55
2 │ x 0.1 5.5
3 │ y a
julia> describe(df, :min, sum => :sum, cols=:x)
1×3 DataFrame
Row │ variable min sum
│ Symbol Float64 Float64
─────┼────────────────────────────
1 │ x 0.1 5.5
#
Base.isempty
— Function
isempty(df::AbstractDataFrame)
Возвращает true
, если фрейм данных df
не содержит строк. Возвращает false
в противном случае.
#
Base.ndims
— Function
ndims(::AbstractDataFrame)
ndims(::Type{<:AbstractDataFrame})
Возвращает количество измерений фрейма данных, которое всегда равно 2
.
ndims(::DataFrameRow) ndims(::Type{<:DataFrameRow})
Возвращает количество измерений строки фрейма данных, которое всегда равно 1
.
#
DataAPI.rownumber
— Function
rownumber(dfr::DataFrameRow)
Return a row number in the AbstractDataFrame
that dfr
was created from.
Note that this differs from the first element in the tuple returned by parentindices
. The latter gives the row number in the parent(dfr)
, which is the source DataFrame
where data that dfr
gives access to is stored.
Examples
julia> df = DataFrame(reshape(1:12, 3, 4), :auto)
3×4 DataFrame
Row │ x1 x2 x3 x4
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 4 7 10
2 │ 2 5 8 11
3 │ 3 6 9 12
julia> dfr = df[2, :]
DataFrameRow
Row │ x1 x2 x3 x4
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
2 │ 2 5 8 11
julia> rownumber(dfr)
2
julia> parentindices(dfr)
(2, Base.OneTo(4))
julia> parent(dfr)
3×4 DataFrame
Row │ x1 x2 x3 x4
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 4 7 10
2 │ 2 5 8 11
3 │ 3 6 9 12
julia> dfv = @view df[2:3, 1:3]
2×3 SubDataFrame
Row │ x1 x2 x3
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 2 5 8
2 │ 3 6 9
julia> dfrv = dfv[2, :]
DataFrameRow
Row │ x1 x2 x3
│ Int64 Int64 Int64
─────┼─────────────────────
3 │ 3 6 9
julia> rownumber(dfrv)
2
julia> parentindices(dfrv)
(3, 1:3)
julia> parent(dfrv)
3×4 DataFrame
Row │ x1 x2 x3 x4
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 4 7 10
2 │ 2 5 8 11
3 │ 3 6 9 12
#
Base.show
— Function
show([io::IO, ]df::AbstractDataFrame;
allrows::Bool = !get(io, :limit, false),
allcols::Bool = !get(io, :limit, false),
allgroups::Bool = !get(io, :limit, false),
rowlabel::Symbol = :Row,
summary::Bool = true,
eltypes::Bool = true,
truncate::Int = 32,
kwargs...)
Отрисовывает фрейм данных в поток ввода-вывода. Выбор конкретного визуального представления зависит от ширины дисплея.
Если io
пропущен, результат выводится в stdout
и allrows
, allcols
и allgroups
по умолчанию имеют значение false
.
Аргументы
-
io::IO
: поток ввода-вывода, в который будет выведено значениеdf
. -
df::AbstractDataFrame
: выводимый фрейм данных. -
allrows::Bool
: нужно ли выводить все строки, а не подмножество, соответствующее высоте устройства. По умолчанию используется только в том случае, если дляio
не задано ограничение (limit
) свойстваIOContext
. -
allcols::Bool
: нужно ли выводить все столбцы, а не подмножество, соответствующее ширине устройства. По умолчанию используется только в том случае, если дляio
не задано ограничение (limit
) свойстваIOContext
. -
allgroups::Bool
: нужно ли выводить все группы, а не первую и последнюю, когдаdf
являетсяGroupedDataFrame
. По умолчанию используется только в том случае, если дляio
не задано свойствоIOContext
limit
. -
rowlabel::Symbol = :Row
: метка, используемая для столбца с номерами строк. -
summary::Bool = true
: нужно ли выводить краткое строковое описание фрейма данных. -
eltypes::Bool = true
: нужно ли выводить типы столбцов под именами столбцов. -
truncate::Int = 32
: максимальная ширина дисплея, которую может использовать вывод перед усечением (в смыслеtextwidth
, без учета…
). Еслиtruncate
имеет значение 0 или меньше, усечение не применяется. -
kwargs...
: сюда можно передать любой именованный аргумент, поддерживаемый функциейpretty_table
пакета PrettyTables.jl, чтобы настроить вывод.
Примеры
julia> using DataFrames
julia> df = DataFrame(A=1:3, B=["x", "y", "z"]);
julia> show(df, show_row_number=false)
3×2 DataFrame
A B
Int64 String
───────────────
1 x
2 y
3 z
show(io::IO, mime::MIME, df::AbstractDataFrame)
Отрисовывает фрейм данных в поток ввода-вывода в типе MIME mime
.
Аргументы
-
io::IO
: поток ввода-вывода, в который будет выведено значениеdf
. -
mime::MIME
: поддерживаются следующие типы MIME:"text/plain"
,"text/html"
,"text/latex"
,"text/csv"
,"text/tab-separated-values"
(последние два типа MIME не поддерживают отображение значений#undef
). -
df::AbstractDataFrame
: выводимый фрейм данных.
Дополнительно выбранные типы MIME поддерживают передачу следующих именованных аргументов:
-
Тип MIME
"text/plain"
принимает все перечисленные именованные аргументы, и их поведение идентично дляshow(::IO, ::AbstractDataFrame)
. -
Тип MIME
"text/html"
принимает следующие именованные аргументы:-
eltypes::Bool = true
: нужно ли выводить типы столбцов под именами столбцов. -
summary::Bool = true
: нужно ли выводить краткое строковое описание фрейма данных. -
max_column_width::AbstractString = ""
: максимальная ширина столбца. Это должна быть строка, содержащая допустимую длину CSS. Например, если передать значение 100px, ширина всех столбцов будет ограничена 100 пикселями. Если значение пусто, столбцы будут отрисовываться без ограничений. -
kwargs...
: сюда можно передать любой именованный аргумент, поддерживаемый функциейpretty_table
пакета PrettyTables.jl, чтобы настроить вывод.
-
Примеры
julia> show(stdout, MIME("text/latex"), DataFrame(A=1:3, B=["x", "y", "z"]))
\begin{tabular}{r|cc}
& A & B\
\hline
& Int64 & String\
\hline
1 & 1 & x \
2 & 2 & y \
3 & 3 & z \
\end{tabular}
14
julia> show(stdout, MIME("text/csv"), DataFrame(A=1:3, B=["x", "y", "z"]))
"A","B"
1,"x"
2,"y"
3,"z"
#
Base.size
— Function
size(df::AbstractDataFrame[, dim])
Возвращает кортеж, содержащий количество строк и столбцов df
. При желании можно указать измерение dim
, где 1
соответствует строкам, а 2
— столбцам.
Примеры
julia> df = DataFrame(a=1:3, b='a':'c');
julia> size(df)
(3, 2)
julia> size(df, 1)
3
size(dfr::DataFrameRow[, dim])
Возвращает 1 кортеж, содержащий количество элементов dfr
. Если указано необязательное измерение dim
, оно должно быть 1
, а количество элементов возвращается непосредственно в виде числа.
См. также описание length
Примеры
julia> dfr = DataFrame(a=1:3, b='a':'c')[1, :]
DataFrameRow
Row │ a b
│ Int64 Char
─────┼─────────────
1 │ 1 a
julia> size(dfr)
(2,)
julia> size(dfr, 1)
2
Работа с именами столбцов
#
Base.names
— Function
names(df::AbstractDataFrame, cols=:)
names(df::DataFrameRow, cols=:)
names(df::GroupedDataFrame, cols=:)
names(df::DataFrameRows, cols=:)
names(df::DataFrameColumns, cols=:)
names(df::GroupKey)
Возвращает только что выделенный Vector{String}
имен столбцов, содержащихся в df
.
Если передан cols
, ограничьте возвращаемые имена столбцов теми, что соответствуют селектору (это полезно, в частности, при использовании регулярных выражений, Cols
, Not
и Between
). cols
может представлять собой:
-
любой селектор столбцов (символ (
Symbol
), строку или целое число;:
,Cols
,All
,Between
,Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел); эти селекторы строк документированы в разделе важных правил в части Индексирование руководства по DataFrames.jl -
тип (
Type
), в этом случае возвращаются имена столбцов,eltype
которых является подтипомT
-
предикат функции (
Function
), принимающий имя столбца в виде строки и возвращающийtrue
для столбцов, которые должны быть сохранены
См. также описание функции propertynames
, которая возвращает Vector{Symbol}
.
Примеры
julia> df = DataFrame(x1=[1, missing, missing], x2=[3, 2, 4], x3=[3, missing, 2], x4=Union{Int, Missing}[2, 4, 4])
3×4 DataFrame
Row │ x1 x2 x3 x4
│ Int64? Int64 Int64? Int64?
─────┼─────────────────────────────────
1 │ 1 3 3 2
2 │ missing 2 missing 4
3 │ missing 4 2 4
julia> names(df)
4-element Vector{String}:
"x1"
"x2"
"x3"
"x4"
julia> names(df, Int) # выбор столбцов с типом элемента Int
1-element Vector{String}:
"x2"
julia> names(df, x -> x[end] == '2') # выбор столбцов, для которых последний символ в их имени равен 2
1-element Vector{String}:
"x2"
julia> fun(col) = sum(skipmissing(col)) >= 10
fun (generic function with 1 method)
julia> names(df, fun.(eachcol(df))) # выбор столбцов, сумма элементов которых не меньше 10
1-element Vector{String}:
"x4"
julia> names(df, eltype.(eachcol(df)) .>: Missing) # выбор столбцов, допускающих отсутствующие значения
3-element Vector{String}:
"x1"
"x3"
"x4"
julia> names(df, any.(ismissing, eachcol(df))) # выбор столбцов, содержащих отсутствующие значения
2-element Vector{String}:
"x1"
"x3"
#
Base.propertynames
— Function
propertynames(df::AbstractDataFrame)
Возвращает только что выделенный Vector{Symbol}
имен столбцов, содержащихся в df
.
#
DataFrames.rename
— Function
rename(df::AbstractDataFrame, vals::AbstractVector{Symbol};
makeunique::Bool=false)
rename(df::AbstractDataFrame, vals::AbstractVector{<:AbstractString};
makeunique::Bool=false)
rename(df::AbstractDataFrame, (from => to)::Pair...)
rename(df::AbstractDataFrame, d::AbstractDict)
rename(df::AbstractDataFrame, d::AbstractVector{<:Pair})
rename(f::Function, df::AbstractDataFrame)
Создает новый фрейм данных, который является копией df
с измененными именами столбцов. Каждое имя может быть изменено не более одного раза. Допускается перестановка имен.
Аргументы
-
df
:AbstractDataFrame
; если этоSubDataFrame
, переименование разрешено только в том случае, если он был создан с использованием:
в качестве селектора столбцов. -
d
:AbstractDict
илиAbstractVector
пар (Pair
), которые сопоставляют исходные имена или номера столбцов с новыми именами. -
f
: функция, которая для каждого столбца принимает старое имя в виде строки (String
) и возвращает новое имя, которое преобразуется в символ (Symbol
). -
vals
: новые имена столбцов в виде вектора символов (Symbol
) или строк (AbstractString
) той же длины, что и количество столбцов вdf
. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
(i
, начиная с 1 для первого повторяющегося имени).
Если в rename
передаются пары (как позиционные аргументы, в словаре или векторе), то:
-
значение
from
может бытьSymbol
,AbstractString
илиInteger
; -
значение
to
может бытьSymbol
илиAbstractString
.
Смешивание символов и строк в to
и from
не допускается.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные на уровне столбцов в стиле :note
считаются прикрепленными к номеру столбца: когда столбец переименовывается, его метаданные в стиле :note
становятся связанными с его новым именем.
См. также описание rename!
.
Примеры
julia> df = DataFrame(i=1, x=2, y=3)
1×3 DataFrame
Row │ i x y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename(df, [:a, :b, :c])
1×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename(df, :i => "A", :x => "X")
1×3 DataFrame
Row │ A X y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename(df, :x => :y, :y => :x)
1×3 DataFrame
Row │ i y x
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename(df, [1 => :A, 2 => :X])
1×3 DataFrame
Row │ A X y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename(df, Dict("i" => "A", "x" => "X"))
1×3 DataFrame
Row │ A X y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename(uppercase, df)
1×3 DataFrame
Row │ I X Y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
#
DataFrames.rename!
— Function
rename!(df::AbstractDataFrame, vals::AbstractVector{Symbol};
makeunique::Bool=false)
rename!(df::AbstractDataFrame, vals::AbstractVector{<:AbstractString};
makeunique::Bool=false)
rename!(df::AbstractDataFrame, (from => to)::Pair...)
rename!(df::AbstractDataFrame, d::AbstractDict)
rename!(df::AbstractDataFrame, d::AbstractVector{<:Pair})
rename!(f::Function, df::AbstractDataFrame)
Переименовывает столбцы df
на месте. Каждое имя может быть изменено не более одного раза. Допускается перестановка имен.
Аргументы
-
df
:AbstractDataFrame
. -
d
:AbstractDict
илиAbstractVector
пар (Pair
), которые сопоставляют исходные имена или номера столбцов с новыми именами. -
f
: функция, которая для каждого столбца принимает старое имя в виде строки (String
) и возвращает новое имя, которое преобразуется в символ (Symbol
). -
vals
: новые имена столбцов в виде вектора символов (Symbol
) или строк (AbstractString
) той же длины, что и количество столбцов вdf
. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
(i
, начиная с 1 для первого повторяющегося имени).
Если в rename!
передаются пары (как позиционные аргументы, в словаре или векторе), то:
-
значение
from
может бытьSymbol
,AbstractString
илиInteger
; -
значение
to
может бытьSymbol
илиAbstractString
.
Смешивание символов и строк в to
и from
не допускается.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные, имеющие другие стили, удаляются (из родительского фрейма данных, если df
является SubDataFrame
). Метаданные на уровне столбцов в стиле :note
считаются прикрепленными к номеру столбца: когда столбец переименовывается, его метаданные в стиле :note
становятся связанными с его новым именем.
См. также описание rename
.
Примеры
julia> df = DataFrame(i=1, x=2, y=3)
1×3 DataFrame
Row │ i x y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename!(df, Dict(:i => "A", :x => "X"))
1×3 DataFrame
Row │ A X y
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename!(df, [:a, :b, :c])
1×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename!(df, [:a, :b, :a])
ERROR: ArgumentError: Duplicate variable names: :a. Pass makeunique=true to make them unique using a suffix automatically.
julia> rename!(df, [:a, :b, :a], makeunique=true)
1×3 DataFrame
Row │ a b a_1
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
julia> rename!(uppercase, df)
1×3 DataFrame
Row │ A B A_1
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
Изменение и преобразование фреймов данных и сгруппированных фреймов данных
#
Base.append!
— Function
append!(df::DataFrame, df2::AbstractDataFrame; cols::Symbol=:setequal,
promote::Bool=(cols in [:union, :subset]))
append!(df::DataFrame, table; cols::Symbol=:setequal,
promote::Bool=(cols in [:union, :subset]))
Добавляет строки df2
в конец df
. Если второй аргумент table
не является AbstractDataFrame
, он преобразуется с помощью DataFrame(table, copycols=false)
и только затем добавляется.
Точное поведение append!
зависит от аргумента cols
.
-
Если
cols == :setequal
(по умолчанию),df2
должен содержать именно те же столбцы, что иdf
(но, возможно, в другом порядке). -
Если
cols == :orderequal
,df2
должна содержать те же столбцы в том же порядке (дляAbstractDict
этот параметр требует, чтобыkeys(row)
совпадал сpropertynames(df)
в целях поддержки упорядоченных словарей. Однако еслиdf2
является словарем (Dict
), возникает ошибка, так как это неупорядоченная коллекция). -
Если
cols == :intersect
,df2
должен содержать больше столбцов, чемdf
, но все имена столбцов, имеющиеся вdf
, должны присутствовать и вdf2
, и только они используются. -
Если
cols == :subset
,append!
действует как для:intersect
, но если какой-то столбец отсутствует вdf2
, отсутствующее (missing
) значение отправляется вdf
. -
Если
cols == :union
,append!
добавляет столбцы, отсутствующие вdf
, которые присутствуют вdf2
, для столбцов, присутствующих вdf
, но отсутствующих вdf2
, отправляется значениеmissing
.
Если promote=true
и тип элемента столбца, присутствующего в df
, запрещает использовать тип отправляемого элемента, новый столбец с продвинутым типом элемента, разрешающим этот тип, выделяется заново и сохраняется в df
. Если promote=false
, возникает ошибка .
Из этого правила есть следующие исключения.
-
Если
df
не имеет столбцов, к нему добавляются копии столбцов изdf2
. -
Если
df2
не имеет столбцов, вызовappend!
оставляетdf
без изменений.
Обратите внимание, что append!
нельзя использовать для DataFrame
, содержащего столбцы, которые являются псевдонимами (одинаковыми при сравнении ===
).
Метаданные: метаданные на уровне таблиц в стиле :note
и метаданные на уровне столбцов в стиле :note
для столбцов, присутствующих в df
, сохраняются. При добавлении новых столбцов их метаданные в стиле :note
копируются из добавляемой таблицы. Другие метаданные удаляются.
См. также: использование push!
для добавления отдельных строк к фрейму данных, prepend!
для добавления таблицы в начало и vcat
для вертикальной конкатенации фреймов данных.
Примеры
julia> df1 = DataFrame(A=1:3, B=1:3)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
julia> df2 = DataFrame(A=4.0:6.0, B=4:6)
3×2 DataFrame
Row │ A B
│ Float64 Int64
─────┼────────────────
1 │ 4.0 4
2 │ 5.0 5
3 │ 6.0 6
julia> append!(df1, df2);
julia> df1
6×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
4 │ 4 4
5 │ 5 5
6 │ 6 6
#
DataFrames.combine
— Function
combine(df::AbstractDataFrame, args...;
renamecols::Bool=true, threads::Bool=true)
combine(f::Callable, df::AbstractDataFrame;
renamecols::Bool=true, threads::Bool=true)
combine(gd::GroupedDataFrame, args...;
keepkeys::Bool=true, ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
combine(f::Base.Callable, gd::GroupedDataFrame;
keepkeys::Bool=true, ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
Создает новый фрейм данных, содержащий столбцы из df
или gd
, указанные с помощью args
, и возвращает его. Результат может содержать любое количество строк, которое определяется значениями, возвращаемыми переданными преобразованиями.
Ниже подробно описаны и сопоставлены общие правила для всех функций преобразования, поддерживаемых DataFrames.jl.
Все эти операции поддерживаются как для AbstractDataFrame
(при пропуске шагов разделения и объединения), так и для GroupedDataFrame
. Технически AbstractDataFrame
считается сгруппированным без столбцов (это означает, что у него есть одна группа или ни одной, если он пуст). Единственное отличие заключается в том, что в этом случае именованные аргументы keepkeys
и ungroup
(описанные ниже) не поддерживаются, и всегда возвращается фрейм данных, поскольку в этом случае нет шагов разделения и объединения.
Чтобы выполнять операции с группами, сначала нужно создать объект GroupedDataFrame
из фрейма данных с помощью функции groupby
, которая принимает два аргумента: (1) фрейм данных, который нужно сгруппировать, и (2) набор столбцов, по которым осуществляется группировка.
Затем можно применить операции к каждой группе с помощью одной из следующих функций:
-
combine
: не накладывает ограничений на количество возвращаемых строк в каждой группе; возвращаемые значения конкатенируются по вертикали в соответствии с порядком групп вGroupedDataFrame
; обычно используется для вычисления сводной статистики по группам; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
select
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая только новые вычисленные столбцы;select!
является версией на месте дляselect
; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
transform
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая все столбцы из исходного фрейма и новые вычисленные столбцы;transform!
является версией на месте дляtransform
; существующие столбцы в исходном фрейме данных помещаются первыми в результат.
Особый случай: если передается GroupedDataFrame
без групп, результат операции определяется путем выполнения одного вызова функции преобразования с переданным ей аргументом с нулем строк. Выходные данные этой операции используются только для определения количества и типа созданных столбцов, но результат не содержит строк.
Все эти функции принимают спецификацию одной или нескольких функций для применения к каждому подмножеству DataFrame
. Эта спецификация может иметь следующий вид:
-
Стандартные селекторы столбцов (целые числа, символы (
Symbol
), строки, векторы целых чисел, векторы символов (Symbol
), векторы строк,All
,Cols
,:
,Between
,Not
и регулярные выражения). -
Пара
cols => function
, указывающая, что функцию (function
) следует вызывать с позиционными аргументами, содержащими столбцыcols
, которые могут быть любым допустимым селектором столбцов. В этом случае имя целевого столбца генерируется автоматически и предполагается, что функция (function
) возвращает единичное значение или вектор. Сгенерированное имя создается путем конкатенации имени исходного столбца и имени функции (function
) по умолчанию (см. примеры ниже). -
Форма
cols => function => target_cols
, дополнительно явно указывающая целевой столбец или столбцы, которые должны быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. Кроме того, это может быть функция (Function
), которая принимает в качестве аргумента строку или вектор строк, содержащие имена столбцов, выбранные с помощьюcols
, и возвращает имена целевых столбцов (допускаются все принятые типы, кромеAsTable
). -
Пара
col => target_cols
, которая переименовывает столбецcol
вtarget_cols
, который должен быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. -
Независимые от столбцов операции
function => target_cols
или простоfunction
для конкретных функций (function
), где входные столбцы опущены; безtarget_cols
новый столбец имеет то же имя, что иfunction
, в противном случае должен быть одним именем (какSymbol
или строка). Поддерживаются следующие функции (function
).-
nrow
для эффективного вычисления количества строк в каждой группе. -
proprow
для эффективного вычисления доли строк в каждой группе. -
eachindex
для возврата вектора, содержащего номер каждой строки в каждой группе. -
groupindices
для возврата номера группы.
-
-
Векторы или матрицы, содержащие преобразования, заданные синтаксисом
Pair
, описываются в пунктах 2—5. -
Функция, которая будет вызвана с
SubDataFrame
, соответствующим каждой группе, если обрабатываетсяGroupedDataFrame
, или с самим фреймом данных, если обрабатываетсяAbstractDataFrame
. Эту форму не рекомендуется использовать из-за ее низкой производительности, за исключением случаев, когда количество групп невелико или обрабатывается очень большое количество столбцов (в этом случаеSubDataFrame
позволяет избежать чрезмерной компиляции).
Примечание. Если передается выражение вида x => y
, то, за исключением специального вспомогательного вида nrow => target_cols
, оно всегда интерпретируется как cols => function
. В частности, следующее выражение function => target_cols
не является допустимой спецификацией преобразования.
Примечание. Если cols
или target_cols
являются All
, Cols
, Between
или Not
, поддерживается трансляция с использованием .=>
, и она эквивалентна трансляции результата names(df, cols)
или names(df, target_cols)
. Это работает, как будто трансляция произошла после замены селектора выбранными именами столбцов в области фрейма данных.
Все функции имеют два типа сигнатур. Один из них принимает GroupedDataFrame
в качестве первого аргумента и произвольное количество преобразований, описанных выше, в качестве последующих аргументов. Второй тип сигнатуры — это когда в качестве первого аргумента передается Function
или Type
и GroupedDataFrame
в качестве второго аргумента (аналогично map
).
Есть особое правило: если при использовании синтаксисов cols => function
и cols => function => target_cols
cols
заключен в объект AsTable
, NamedTuple
, содержащий столбцы, выбранные с помощью cols
, передается функции (function
). Дополнительные сведения см. в документации по DataFrames.table_transformation
, где также рассматриваются вопросы производительности.
Результат, который может возвращать функция (function
), определяется значением target_cols
.
-
Если
cols
иtarget_cols
опущены (передается толькоfunction
), при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
будет создано несколько столбцов. При возврате любого другого значения создается один столбец. -
Если
target_cols
является символом (Symbol
) или строкой, предполагается, что функция возвратит один столбец. В этом случае при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
возникнет ошибка. -
Если
target_cols
является вектором символов (Symbol
) или строк илиAsTable
, предполагается, что функция (function
) возвратит несколько столбцов. Если функция (function
) возвращает какой-либо элемент изAbstractDataFrame
,NamedTuple
,DataFrameRow
,Tables.AbstractRow
,AbstractMatrix
, применяется правило, описанное в пункте 1 выше. Если функция (function
) возвращаетAbstractVector
, каждый элемент этого вектора должен поддерживать функциюkeys
, которая должна возвращать коллекциюSymbol
, строк или целых чисел. Возвращаемое значениеkeys
должно быть одинаковым для всех элементов. Затем создается столько столбцов, сколько элементов содержится в возвращаемом значении функцииkeys
. Еслиtarget_cols
являетсяAsTable
, их имена задаются равными именам ключей, за исключением случаев, когдаkeys
возвращает целые числа, тогда они получают префиксx
(таким образом, имена столбцов будут выглядеть какx1
,x2
и т. д.). Еслиtarget_cols
является вектором символов (Symbol
) или строк, имена столбцов, созданные на основе приведенных выше правил, игнорируются и заменяютсяtarget_cols
(в этом случае количество столбцов должно совпадать с длинойtarget_cols
). Еслиfun
возвращает значение любого другого типа, предполагается, что это таблица, соответствующая API Tables.jl, и для нее вызывается функцияTables.columntable
для получения результирующих столбцов и их имен. Имена сохраняются, когдаtarget_cols
являетсяAsTable
, и заменяются, еслиtarget_cols
является вектором символов (Symbol
) или строк.
Во всех этих случаях функция (function
) может возвращать как одну строку, так и несколько. Как правило, значения, заключенные в Ref
или 0
-мерный массив AbstractArray
, распаковываются и после этого считаются одной строкой.
select
/select!
и transform
/transform!
всегда возвращают фрейм данных с количеством и порядком строк, точно таким же, как у исходного (даже если в GroupedDataFrame
был изменен порядок групп), за исключением случаев, когда в результирующем фрейме данных нет столбцов (в этом случае результат не содержит строк).
Для combine
строки в возвращаемом объекте отображаются в порядке групп в GroupedDataFrame
. Функции могут возвращать произвольное количество строк для каждой группы, но тип возвращаемого объекта и количество и имена столбцов должны быть одинаковыми для всех групп, за исключением случаев, когда возвращаются DataFrame()
или NamedTuple()
, тогда заданная группа пропускается.
Допускается смешивать единичные значения и векторы, если запрашивается несколько преобразований. В этом случае такое значение будет повторяться, чтобы соответствовать длине столбцов, указанных в возвращаемых векторах.
Чтобы применить функцию (function
) к каждой строке, а не ко всем столбцам, ее можно заключить в структуру ByRow
. cols
может быть любым синтаксисом индексирования столбцов. Тогда функции (function
) будет передан один аргумент для каждого из столбцов, указанных с помощью cols
, или NamedTuple
, если указанные столбцы заключены в AsTable
. Если используется ByRow
, cols
может выбрать пустой набор столбцов, тогда function
вызывается для каждой строки без аргументов, и передается пустой NamedTuple
, если в AsTable
заключен пустой набор столбцов.
Если передается коллекция имен столбцов, то принимаются запросы дублирующихся имен столбцов в целевом фрейме данных (например, допускается select!(df, [:a], :, r"a")
), и используется только первое вхождение. В частности, используется следующий синтаксис для перемещения столбца :col
в первую позицию во фрейме данных — select!(df, :col, :)
. Напротив, имена выходных столбцов в операциях переименования, преобразования и выбора одного столбца должны быть уникальными, поэтому, например, select!(df, :a, :a => :a)
или select!(df, :a, :a => ByRow(sin) => :a)
недопустимы.
В общем случае столбцы, возвращаемые преобразованиями, сохраняются в целевом фрейме данных без копирования. Исключением из этого правила являются случаи, когда столбцы из исходного фрейма данных повторно используются в целевом фрейме данных. Это можно сделать с помощью таких выражений, как: :x1
, [:x1, :x2]
, :x1 => :x2
, :x1 => identity => :x2
или :x1 => (x -> @view x[inds])
(обратите внимание, что в последнем случае исходный столбец используется повторно косвенным образом через представление). В таких случаях поведение зависит от значения именованного аргумента copycols
:
-
если
copycols=true
, в результате таких преобразований всегда создается копия исходного столбца или его представления; -
если
copycols=false
, копии создаются только для того, чтобы избежать многократного хранения одного и того же столбца в целевом фрейме данных. Точнее, при первом использовании столбца копирование не производится, но при каждом последующем повторном использовании исходного столбца (при сравнении с использованием===
, которое исключает представления исходных столбцов) создается копия.
Обратите внимание, что при выполнении transform!
или select!
предполагается, что copycols=false
.
Если df
является SubDataFrame
и copycols=true
, возвращается DataFrame
и применяются те же правила копирования, что и для входных данных DataFrame
: это означает, в частности, что выбранные столбцы будут скопированы. При copycols=false
SubDataFrame
возвращается без копирования столбцов, и в этом случае преобразование или переименование столбцов не допускается.
Если передается GroupedDataFrame
и threads=true
(по умолчанию), для каждого указанного преобразования порождается отдельная задача. Затем каждое преобразование порождает столько задач, сколько потоков доступно в Julia, и разделяет обработку групп между ними (однако в настоящее время преобразования с оптимизированной реализацией, такие как sum
, и преобразования, возвращающие несколько строк, используют одну задачу для всех групп). Это позволяет выполнять параллельную работу, если среда Julia была запущена с несколькими потоками. Поэтому передаваемые функции преобразования не должны изменять глобальные переменные (то есть они должны быть чистыми), использовать блокировки для управления параллельным доступом, либо следует передать threads=false
, чтобы отключить многопоточность. В будущем параллелизм может быть распространен и на другие случаи, так что это требование справедливо и для входных данных DataFrame
.
Для повышения производительности операций некоторые преобразования используют оптимизированную реализацию. Дополнительные сведения см. в описании DataFrames.table_transformation
.
Именованные аргументы
-
renamecols::Bool=true
: должны ли автоматически генерируемые имена столбцов в формеcols => function
включать название функций преобразования, или нет. -
keepkeys::Bool=true
: должны ли группирующие столбцыgd
сохраняться в возвращаемом фрейме данных. -
ungroup::Bool=true
: должно ли возвращаемое значение операции сgd
быть фреймом данных илиGroupedDataFrame
. -
threads::Bool=true
: могут ли преобразования осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значениеfalse
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Метаданные: эта функция распространяет метаданные на уровне таблиц в стиле :note
. Метаданные на уровне столбцов в стиле :note
распространяются в следующих случаях: а) один столбец преобразуется в один столбец, при этом имя столбца не изменяется (это относится ко всем операциям выбора столбца), или б) один столбец преобразуется с помощью identity
или copy
в один столбец даже при изменении имени столбца (сюда относится и переименование столбца). Особый случай для GroupedDataFrame
: если вывод имеет то же имя, что и группирующий столбец, и keepkeys=true
, метаданные берутся из исходного группирующего столбца.
Примеры
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> combine(df, :a => sum, nrow, renamecols=false)
1×2 DataFrame
Row │ a nrow
│ Int64 Int64
─────┼──────────────
1 │ 6 3
julia> combine(df, :a => ByRow(sin) => :c, :b)
3×2 DataFrame
Row │ c b
│ Float64 Int64
─────┼─────────────────
1 │ 0.841471 4
2 │ 0.909297 5
3 │ 0.14112 6
julia> combine(df, :, [:a, :b] => (a, b) -> a .+ b .- sum(b)/length(b))
3×3 DataFrame
Row │ a b a_b_function
│ Int64 Int64 Float64
─────┼────────────────────────────
1 │ 1 4 0.0
2 │ 2 5 2.0
3 │ 3 6 4.0
julia> combine(df, All() .=> [minimum maximum])
1×4 DataFrame
Row │ a_minimum b_minimum a_maximum b_maximum
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────────────────────
1 │ 1 4 3 6
julia> using Statistics
julia> combine(df, AsTable(:) => ByRow(mean), renamecols=false)
3×1 DataFrame
Row │ a_b
│ Float64
─────┼─────────
1 │ 2.5
2 │ 3.5
3 │ 4.5
julia> combine(df, AsTable(:) => ByRow(mean) => x -> join(x, "_"))
3×1 DataFrame
Row │ a_b
│ Float64
─────┼─────────
1 │ 2.5
2 │ 3.5
3 │ 4.5
julia> combine(first, df)
1×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
julia> df = DataFrame(a=1:3, b=4:6, c=7:9)
3×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 4 7
2 │ 2 5 8
3 │ 3 6 9
julia> combine(df, AsTable(:) => ByRow(x -> (mean=mean(x), std=std(x))) => :stats,
AsTable(:) => ByRow(x -> (mean=mean(x), std=std(x))) => AsTable)
3×3 DataFrame
Row │ stats mean std
│ NamedTup… Float64 Float64
─────┼───────────────────────────────────────────
1 │ (mean = 4.0, std = 3.0) 4.0 3.0
2 │ (mean = 5.0, std = 3.0) 5.0 3.0
3 │ (mean = 6.0, std = 3.0) 6.0 3.0
julia> df = DataFrame(a=repeat([1, 2, 3, 4], outer=[2]),
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> combine(gd, :c => sum, nrow)
4×3 DataFrame
Row │ a c_sum nrow
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 2
2 │ 2 8 2
3 │ 3 10 2
4 │ 4 12 2
julia> combine(gd, :c => sum, nrow, ungroup=false)
GroupedDataFrame with 4 groups based on key: a
First Group (1 row): a = 1
Row │ a c_sum nrow
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 2
⋮
Last Group (1 row): a = 4
Row │ a c_sum nrow
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 4 12 2
julia> combine(gd) do d # синтаксис do для более медленного варианта
sum(d.c)
end
4×2 DataFrame
Row │ a x1
│ Int64 Int64
─────┼──────────────
1 │ 1 6
2 │ 2 8
3 │ 3 10
4 │ 4 12
julia> combine(gd, :c => (x -> sum(log, x)) => :sum_log_c) # указание имени для целевого столбца
4×2 DataFrame
Row │ a sum_log_c
│ Int64 Float64
─────┼──────────────────
1 │ 1 1.60944
2 │ 2 2.48491
3 │ 3 3.04452
4 │ 4 3.46574
julia> combine(gd, [:b, :c] .=> sum) # передача вектора пар
4×3 DataFrame
Row │ a b_sum c_sum
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 4 6
2 │ 2 2 8
3 │ 3 4 10
4 │ 4 2 12
julia> combine(gd) do sdf # удаление группы при возврате DataFrame()
sdf.c[1] != 1 ? sdf : DataFrame()
end
6×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 2 1 2
2 │ 2 1 6
3 │ 3 2 3
4 │ 3 2 7
5 │ 4 1 4
6 │ 4 1 8
автоматическое разделение, переименование и сохранение ключей
julia> df = DataFrame(a=repeat([1, 2, 3, 4], outer=[2]),
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> combine(gd, :b => :b1, :c => :c1, [:b, :c] => +, keepkeys=false)
8×3 DataFrame
Row │ b1 c1 b_c_+
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 2 1 3
2 │ 2 5 7
3 │ 1 2 3
4 │ 1 6 7
5 │ 2 3 5
6 │ 2 7 9
7 │ 1 4 5
8 │ 1 8 9
трансляция и расширение столбцов
julia> df = DataFrame(a=repeat([1, 2, 3, 4], outer=[2]),
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> combine(gd, :b, AsTable([:b, :c]) => ByRow(extrema) => [:min, :max])
8×4 DataFrame
Row │ a b min max
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 2 1 2
2 │ 1 2 2 5
3 │ 2 1 1 2
4 │ 2 1 1 6
5 │ 3 2 2 3
6 │ 3 2 2 7
7 │ 4 1 1 4
8 │ 4 1 1 8
julia> combine(gd, [:b, :c] .=> Ref) # предотвращение распределения вектора по нескольким строкам
4×3 DataFrame
Row │ a b_Ref c_Ref
│ Int64 SubArray… SubArray…
─────┼─────────────────────────────
1 │ 1 [2, 2] [1, 5]
2 │ 2 [1, 1] [2, 6]
3 │ 3 [2, 2] [3, 7]
4 │ 4 [1, 1] [4, 8]
julia> combine(gd, AsTable(Not(:a)) => Ref) # защита результата
4×2 DataFrame
Row │ a b_c_Ref
│ Int64 NamedTup…
─────┼─────────────────────────────────
1 │ 1 (b = [2, 2], c = [1, 5])
2 │ 2 (b = [1, 1], c = [2, 6])
3 │ 3 (b = [2, 2], c = [3, 7])
4 │ 4 (b = [1, 1], c = [4, 8])
julia> combine(gd, :, AsTable(Not(:a)) => sum, renamecols=false)
8×4 DataFrame
Row │ a b c b_c
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 2 1 3
2 │ 1 2 5 7
3 │ 2 1 2 3
4 │ 2 1 6 7
5 │ 3 2 3 5
6 │ 3 2 7 9
7 │ 4 1 4 5
8 │ 4 1 8 9
#
DataFrames.fillcombinations
— Function
fillcombinations(df::AbstractDataFrame, indexcols;
allowduplicates::Bool=false,
fill=missing)
Создает все сочетания уровней столбцов indexcols
во фрейме данных df
. Уровни и их порядок определяются функцией levels
(т. е. уникальные значения, отсортированные лексикографически по умолчанию, или пользовательский набор уровней для, например, столбцов CategoricalArray
) в дополнение к отсутствующим (missing
), если они есть.
Для сочетаний indexcols
, отсутствующих в df
, эти столбцы заполняются значением fill
(missing
по умолчанию).
Если allowduplicates=false
(по умолчанию), indexcols
могут содержать только уникальные сочетания значений indexcols
. Если allowduplicates=true
допускается использование дубликатов.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(x=1:2, y='a':'b', z=["x", "y"])
2×3 DataFrame
Row │ x y z
│ Int64 Char String
─────┼─────────────────────
1 │ 1 a x
2 │ 2 b y
julia> fillcombinations(df, [:x, :y])
4×3 DataFrame
Row │ x y z
│ Int64 Char String?
─────┼──────────────────────
1 │ 1 a x
2 │ 2 a missing
3 │ 1 b missing
4 │ 2 b y
julia> fillcombinations(df, [:y, :z], fill=0)
4×3 DataFrame
Row │ x y z
│ Int64? Char String
─────┼──────────────────────
1 │ 1 a x
2 │ 0 b x
3 │ 0 a y
4 │ 2 b y
#
DataFrames.flatten
— Function
flatten(df::AbstractDataFrame, cols; scalar::Type=Union{})
Если столбцы cols
фрейма данных df
имеют итерируемые элементы, которые определяют length
(например, вектор (Vector
) векторов (Vector
)), возвращается DataFrame
, где каждый элемент каждого col
в cols
сглажен, означая, что столбец, соответствующий col
, становится более длинным вектором, в котором исходные записи конкатенированы. Элементы строки i
для df
в столбцах, отличных от cols
, будут повторяться в соответствии с длиной df[i, col]
. Поэтому эти длины должны быть одинаковыми для каждого col
в cols
, иначе возникнет ошибка. Обратите внимание, что эти элементы не копируются, поэтому если они являются изменяемыми, их изменение в возвращаемом DataFrame
повлияет на df
.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если передается scalar
, значения, имеющие этот тип в сглаженных столбцах, рассматриваются как скаляры и транслируются столько раз, сколько необходимо для соответствия длине значений, хранящихся в других столбцах. Если все значения в строке являются скалярами, создается одна строка.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df1 = DataFrame(a=[1, 2], b=[[1, 2], [3, 4]], c=[[5, 6], [7, 8]])
2×3 DataFrame
Row │ a b c
│ Int64 Array… Array…
─────┼───────────────────────
1 │ 1 [1, 2] [5, 6]
2 │ 2 [3, 4] [7, 8]
julia> flatten(df1, :b)
4×3 DataFrame
Row │ a b c
│ Int64 Int64 Array…
─────┼──────────────────────
1 │ 1 1 [5, 6]
2 │ 1 2 [5, 6]
3 │ 2 3 [7, 8]
4 │ 2 4 [7, 8]
julia> flatten(df1, [:b, :c])
4×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 1 5
2 │ 1 2 6
3 │ 2 3 7
4 │ 2 4 8
julia> df2 = DataFrame(a=[1, 2], b=[("p", "q"), ("r", "s")])
2×2 DataFrame
Row │ a b
│ Int64 Tuple…
─────┼───────────────────
1 │ 1 ("p", "q")
2 │ 2 ("r", "s")
julia> flatten(df2, :b)
4×2 DataFrame
Row │ a b
│ Int64 String
─────┼───────────────
1 │ 1 p
2 │ 1 q
3 │ 2 r
4 │ 2 s
julia> df3 = DataFrame(a=[1, 2], b=[[1, 2], [3, 4]], c=[[5, 6], [7]])
2×3 DataFrame
Row │ a b c
│ Int64 Array… Array…
─────┼───────────────────────
1 │ 1 [1, 2] [5, 6]
2 │ 2 [3, 4] [7]
julia> flatten(df3, [:b, :c])
ERROR: ArgumentError: Lengths of iterables stored in columns :b and :c are not the same in row 2
julia> df4 = DataFrame(a=[1, 2, 3],
b=[[1, 2], missing, missing],
c=[[5, 6], missing, [7, 8]])
3×3 DataFrame
Row │ a b c
│ Int64 Array…? Array…?
─────┼─────────────────────────
1 │ 1 [1, 2] [5, 6]
2 │ 2 missing missing
3 │ 3 missing [7, 8]
julia> flatten(df4, [:b, :c], scalar=Missing)
5×3 DataFrame
Row │ a b c
│ Int64 Int64? Int64?
─────┼─────────────────────────
1 │ 1 1 5
2 │ 1 2 6
3 │ 2 missing missing
4 │ 3 missing 7
5 │ 3 missing 8
#
Base.hcat
— Function
hcat(df::AbstractDataFrame...;
makeunique::Bool=false, copycols::Bool=true)
Выполняет горизонтальную конкатенацию фреймов данных.
Если makeunique=false
(по умолчанию), имена столбцов передаваемых объектов должны быть уникальными. Если makeunique=true
, к повторяющимся именам столбцов добавляется суффикс _i
(i
, начиная с 1 для первого повторяющегося имени).
Если copycols=true
(по умолчанию), DataFrame
, возвращаемый hcat
, будет содержать скопированные столбцы из исходных фреймов данных. Если copycols=false
, он будет содержать столбцы в том виде, в каком они хранятся в исходном фрейме данных (без копирования). Этот параметр следует использовать с осторожностью, так как изменение столбцов в исходных или возвращаемых DataFrame
может привести к повреждению другого объекта.
Метаданные: функция hcat
распространяет метаданные на уровне таблиц в стиле :note
для ключей, присутствующих во всех передаваемых фреймах данных и имеющих одинаковое значение. Она распространяет метаданные на уровне столбцов в стиле :note
.
Пример
julia> df1 = DataFrame(A=1:3, B=1:3)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
julia> df2 = DataFrame(A=4:6, B=4:6)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 4 4
2 │ 5 5
3 │ 6 6
julia> df3 = hcat(df1, df2, makeunique=true)
3×4 DataFrame
Row │ A B A_1 B_1
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 1 4 4
2 │ 2 2 5 5
3 │ 3 3 6 6
julia> df3.A === df1.A
false
julia> df3 = hcat(df1, df2, makeunique=true, copycols=false);
julia> df3.A === df1.A
true
#
Base.insert!
— Function
insert!(df::DataFrame, index::Integer, row::Union{Tuple, AbstractArray}; promote::Bool=false)
insert!(df::DataFrame, index::Integer, row::Union{DataFrameRow, NamedTuple,
AbstractDict, Tables.AbstractRow};
cols::Symbol=:setequal, promote::Bool=(cols in [:union, :subset]))
Добавляет одну строку в df
в позиции index
на месте, принимая значения из row
. index
должен быть целым числом от 1
до nrow(df)+1
.
Типы столбцов df
сохраняются, а новые значения при необходимости преобразуются. При сбое преобразования возникает ошибка.
Если row
не является ни DataFrameRow
, ни NamedTuple
, ни AbstractDict
, она должна быть Tuple
или AbstractArray
, и столбцы сопоставляются в порядке появления. В этом случае row
должна содержать столько же элементов, сколько столбцов в df
.
Если строка (row
) является DataFrameRow
, NamedTuple
, AbstractDict
или Tables.AbstractRow
, значения в row
сопоставляются со столбцами в df
на основе имен. Точное поведение зависит от значения аргумента cols
, а именно:
-
Если
cols == :setequal
(по умолчанию),row
должна содержать те же столбцы, что иdf
(но, возможно, в другом порядке). -
Если
cols == :orderequal
,row
должна содержать те же столбцы в том же порядке (дляAbstractDict
этот параметр требует, чтобыkeys(row)
совпадал сpropertynames(df)
в целях поддержки упорядоченных словарей. Однако еслиrow
является словарем (Dict
), возникает ошибка, так как это неупорядоченная коллекция). -
Если
cols == :intersect
,row
должна содержать больше столбцов, чемdf
, но все имена столбцов, имеющиеся вdf
, должны присутствовать и вrow
, и только они используются для заполнения новой строки вdf
. -
Если
cols == :subset
, действует как для:intersect
, но если какой-то столбец отсутствует вrow
, отсутствующее (missing
) значение отправляется вdf
. -
Если
cols == :union
, столбцы, отсутствующие вdf
, которые присутствуют вrow
, добавляются вdf
(с использованиемmissing
для существующих строк), и значениеmissing
отправляется в столбцы, отсутствующие вrow
, которые присутствуют вdf
.
Если promote=true
и тип элемента столбца, присутствующего в df
, запрещает использовать тип отправляемого элемента, новый столбец с продвинутым типом элемента, разрешающим этот тип, выделяется заново и сохраняется в df
. Если promote=false
, возникает ошибка .
В отдельном случае, если df
не имеет столбцов и row
является NamedTuple
, DataFrameRow
, или Tables.AbstractRow
, столбцы создаются для всех значений в row
с использованием их имен и порядка.
Обратите внимание, что эта функция не должна использоваться для DataFrame
, содержащего столбцы, которые являются псевдонимами (одинаковыми при сравнении ===
).
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
См. также описание push!
, pushfirst!
Примеры
julia> df = DataFrame(A='a':'c', B=1:3)
3×2 DataFrame
Row │ A B
│ Char Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
julia> insert!(df, 2, (true, false), promote=true)
4×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ a 1
2 │ true 0
3 │ b 2
4 │ c 3
julia> insert!(df, 5, df[1, :])
5×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ a 1
2 │ true 0
3 │ b 2
4 │ c 3
5 │ a 1
julia> insert!(df, 1, (C="something", A=11, B=12), cols=:intersect)
6×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ 11 12
2 │ a 1
3 │ true 0
4 │ b 2
5 │ c 3
6 │ a 1
julia> insert!(df, 7, Dict(:A=>1.0, :C=>1.0), cols=:union)
7×3 DataFrame
Row │ A B C
│ Any Int64? Float64?
─────┼──────────────────────────
1 │ 11 12 missing
2 │ a 1 missing
3 │ true 0 missing
4 │ b 2 missing
5 │ c 3 missing
6 │ a 1 missing
7 │ 1.0 missing 1.0
julia> insert!(df, 3, NamedTuple(), cols=:subset)
8×3 DataFrame
Row │ A B C
│ Any Int64? Float64?
─────┼─────────────────────────────
1 │ 11 12 missing
2 │ a 1 missing
3 │ missing missing missing
4 │ true 0 missing
5 │ b 2 missing
6 │ c 3 missing
7 │ a 1 missing
8 │ 1.0 missing 1.0
#
DataFrames.insertcols
— Function
insertcols(df::AbstractDataFrame[, col], (name=>val)::Pair...;
after::Bool=false, makeunique::Bool=false, copycols::Bool=true)
Вставляет столбец в копию фрейма данных df
с помощью функции insertcols!
и возвращает созданный фрейм данных.
Если col
не указан, он задается как ncol(df)+1
(столбец вставляется как последний столбец).
Аргументы
-
df
: фрейм данных, в который будут добавлены столбцы. -
col
: позиция, в которую будет вставлен столбец, переданная как целое число, или имя столбца (строка илиSymbol
); столбец, выбранный с помощьюcol
, и следующие за ним столбцы сдвигаются вправо вdf
после операции. -
name
: имя нового столбца. -
val
:AbstractVector
, задающий содержимое нового столбца, или значение любого типа, отличного отAbstractArray
, которое будет повторяться для заполнения нового вектора. Как правило, значения, хранящиеся вRef
или0
-мерном массивеAbstractArray
, остаются без оболочки и обрабатываются одинаково. -
after
: еслиtrue
, столбцы вставляются послеcol
. -
makeunique
: определяет, что делать, еслиname
уже существует вdf
. Если имеет значениеfalse
, возникает ошибка. Если имеет значениеtrue
, будет создано уникальное имя путем добавления суффикса. -
copycols
: должны ли копироваться векторы, переданные как столбцы.
Если val
— это AbstractRange
, вставляется результат collect(val)
.
Если df
— это SubDataFrame
, он должен быть создан с использованием :
в качестве селектора столбцов (в противном случае возникнет ошибка). В этом случае именованный аргумент copycols
игнорируется (т. е. добавленный столбец всегда копируется), и столбец родительского фрейма данных заполняется отсутствующими (missing
) строками, отфильтрованными с помощью df
.
Если df
— это DataFrame
, в котором нет столбцов, и передаются только значения, отличные от AbstractVector
, он используется для создания одноэлементного столбца. Если df
— это DataFrame
, в котором нет столбцов, и передается как минимум один AbstractVector
, его длина используется для определения количества элементов во всех созданных столбцах. Во всех других случаях количество строк во всех созданных столбцах должно соответствовать nrow(df)
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
См. также описание insertcols!
.
Примеры
julia> df = DataFrame(a=1:3)
3×1 DataFrame
Row │ a
│ Int64
─────┼───────
1 │ 1
2 │ 2
3 │ 3
julia> insertcols(df, 1, :b => 'a':'c')
3×2 DataFrame
Row │ b a
│ Char Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
julia> insertcols(df, :c => 2:4, :c => 3:5, makeunique=true)
3×3 DataFrame
Row │ a c c_1
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 3
2 │ 2 3 4
3 │ 3 4 5
julia> insertcols(df, :a, :d => 7:9, after=true)
3×2 DataFrame
Row │ a d
│ Int64 Int64
─────┼──────────────
1 │ 1 7
2 │ 2 8
3 │ 3 9
#
DataFrames.insertcols!
— Function
insertcols!(df::AbstractDataFrame[, col], (name=>val)::Pair...;
after::Bool=false, makeunique::Bool=false, copycols::Bool=true)
Вставляет столбец во фрейм данных на месте. Возвращает обновленный фрейм данных.
Если col
не указан, он задается как ncol(df)+1
(столбец вставляется как последний столбец).
Аргументы
-
df
: фрейм данных, в который будут добавлены столбцы. -
col
: позиция, в которую будет вставлен столбец, переданная как целое число, или имя столбца (строка илиSymbol
); столбец, выбранный с помощьюcol
, и следующие за ним столбцы сдвигаются вправо вdf
после операции. -
name
: имя нового столбца. -
val
:AbstractVector
, задающий содержимое нового столбца, или значение любого типа, отличного отAbstractArray
, которое будет повторяться для заполнения нового вектора. Как правило, значения, хранящиеся вRef
или0
-мерном массивеAbstractArray
, остаются без оболочки и обрабатываются одинаково. -
after
: еслиtrue
, столбцы вставляются послеcol
. -
makeunique
: определяет, что делать, еслиname
уже существует вdf
. Если имеет значениеfalse
, возникает ошибка. Если имеет значениеtrue
, будет создано уникальное имя путем добавления суффикса. -
copycols
: должны ли копироваться векторы, переданные как столбцы.
Если val
— это AbstractRange
, вставляется результат collect(val)
.
Если df
— это SubDataFrame
, он должен быть создан с использованием :
в качестве селектора столбцов (в противном случае возникнет ошибка). В этом случае именованный аргумент copycols
игнорируется (т. е. добавленный столбец всегда копируется), и столбец родительского фрейма данных заполняется отсутствующими (missing
) строками, отфильтрованными с помощью df
.
Если df
— это DataFrame
, в котором нет столбцов, и передаются только значения, отличные от AbstractVector
, он используется для создания одноэлементного столбца. Если df
— это DataFrame
, в котором нет столбцов, и передается как минимум один AbstractVector
, его длина используется для определения количества элементов во всех созданных столбцах. Во всех других случаях количество строк во всех созданных столбцах должно соответствовать nrow(df)
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные, имеющие другие стили, удаляются (из родительского фрейма данных, если df
является SubDataFrame
).
См. также описание insertcols
.
Примеры
julia> df = DataFrame(a=1:3)
3×1 DataFrame
Row │ a
│ Int64
─────┼───────
1 │ 1
2 │ 2
3 │ 3
julia> insertcols!(df, 1, :b => 'a':'c')
3×2 DataFrame
Row │ b a
│ Char Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
julia> insertcols!(df, 2, :c => 2:4, :c => 3:5, makeunique=true)
3×4 DataFrame
Row │ b c c_1 a
│ Char Int64 Int64 Int64
─────┼───────────────────────────
1 │ a 2 3 1
2 │ b 3 4 2
3 │ c 4 5 3
julia> insertcols!(df, :b, :d => 7:9, after=true)
3×5 DataFrame
Row │ b d c c_1 a
│ Char Int64 Int64 Int64 Int64
─────┼──────────────────────────────────
1 │ a 7 2 3 1
2 │ b 8 3 4 2
3 │ c 9 4 5 3
#
Base.invpermute!
— Function
invpermute!(df::AbstractDataFrame, p)
Аналогична permute!
, но применяется перестановка, обратная заданной.
invpermute!
выдаст корректный результат, даже если некоторые столбцы переданного фрейма данных или перестановки p
идентичны (проверены с помощью ===
). В противном случае, если два столбца имеют общую часть памяти, но не идентичны (например, являются разными представлениями одного и того же родительского вектора), результат invpermute!
может быть неверным.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные, имеющие другие стили, удаляются (из родительского фрейма данных, если df
является SubDataFrame
).
Примеры
julia> df = DataFrame(a=1:5, b=6:10, c=11:15)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 11
2 │ 2 7 12
3 │ 3 8 13
4 │ 4 9 14
5 │ 5 10 15
julia> permute!(df, [5, 3, 1, 2, 4])
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 5 10 15
2 │ 3 8 13
3 │ 1 6 11
4 │ 2 7 12
5 │ 4 9 14
julia> invpermute!(df, [5, 3, 1, 2, 4])
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 11
2 │ 2 7 12
3 │ 3 8 13
4 │ 4 9 14
5 │ 5 10 15
#
DataFrames.mapcols
— Function
mapcols(f::Union{Function, Type}, df::AbstractDataFrame)
Возвращает DataFrame
, в котором каждый столбец df
преобразуется с помощью функции f
. Функция f
должна возвращать объекты AbstractVector
с одинаковой длиной или скаляры (скалярами считаются все значения, отличные от AbstractVector
).
Обратите внимание, что mapcols
гарантирует, что столбцы из df
не будут повторно использоваться в возвращаемом DataFrame
. Если f
возвращает аргумент, он копируется перед сохранением.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(x=1:4, y=11:14)
4×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 11
2 │ 2 12
3 │ 3 13
4 │ 4 14
julia> mapcols(x -> x.^2, df)
4×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 121
2 │ 4 144
3 │ 9 169
4 │ 16 196
#
DataFrames.mapcols!
— Function
mapcols!(f::Union{Function, Type}, df::DataFrame)
Обновляет DataFrame
на месте, где каждый столбец df
преобразуется с помощью функции f
. Функция f
должна возвращать объекты AbstractVector
с одинаковой длиной или скаляры (скалярами считаются все значения, отличные от AbstractVector
).
Обратите внимание, что mapcols!
повторно использует столбцы из df
, если они возвращены функцией f
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(x=1:4, y=11:14)
4×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 11
2 │ 2 12
3 │ 3 13
4 │ 4 14
julia> mapcols!(x -> x.^2, df);
julia> df
4×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 121
2 │ 4 144
3 │ 9 169
4 │ 16 196
#
Base.permute!
— Function
permute!(df::AbstractDataFrame, p)
Перестанавливает фрейм данных df
на месте в соответствии с перестановкой p
. Если p
не является перестановкой, возникает ошибка ArgumentError
.
Чтобы возвратить новый фрейм данных вместо перестановки df
на месте, используйте df[p, :]
.
permute!
выдаст корректный результат, даже если некоторые столбцы переданного фрейма данных или перестановки p
идентичны (проверены с помощью ===
). В противном случае, если два столбца имеют общую часть памяти, но не идентичны (например, являются разными представлениями одного и того же родительского вектора), результат permute!
может быть неверным.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные, имеющие другие стили, удаляются (из родительского фрейма данных, если df
является SubDataFrame
).
Примеры
julia> df = DataFrame(a=1:5, b=6:10, c=11:15)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 11
2 │ 2 7 12
3 │ 3 8 13
4 │ 4 9 14
5 │ 5 10 15
julia> permute!(df, [5, 3, 1, 2, 4])
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 5 10 15
2 │ 3 8 13
3 │ 1 6 11
4 │ 2 7 12
5 │ 4 9 14
#
Base.prepend!
— Function
prepend!(df::DataFrame, df2::AbstractDataFrame; cols::Symbol=:setequal,
promote::Bool=(cols in [:union, :subset]))
prepend!(df::DataFrame, table; cols::Symbol=:setequal,
promote::Bool=(cols in [:union, :subset]))
Add the rows of df2
to the beginning of df
. If the second argument table
is not an AbstractDataFrame
then it is converted using DataFrame(table, copycols=false)
before being prepended.
The exact behavior of prepend!
depends on the cols
argument:
-
If
cols == :setequal
(this is the default) thendf2
must contain exactly the same columns asdf
(but possibly in a different order). -
If
cols == :orderequal
thendf2
must contain the same columns in the same order (forAbstractDict
this option requires thatkeys(row)
matchespropertynames(df)
to allow for support of ordered dicts; however, ifdf2
is aDict
an error is thrown as it is an unordered collection). -
If
cols == :intersect
thendf2
may contain more columns thandf
, but all column names that are present indf
must be present indf2
and only these are used. -
If
cols == :subset
thenappend!
behaves like for:intersect
but if some column is missing indf2
then amissing
value is pushed todf
. -
If
cols == :union
thenappend!
adds columns missing indf
that are present indf2
, for columns present indf
but missing indf2
amissing
value is pushed.
If promote=true
and element type of a column present in df
does not allow the type of a pushed argument then a new column with a promoted element type allowing it is freshly allocated and stored in df
. If promote=false
an error is thrown.
The above rule has the following exceptions:
-
If
df
has no columns then copies of columns fromdf2
are added to it. -
If
df2
has no columns then callingprepend!
leavesdf
unchanged.
Please note that prepend!
must not be used on a DataFrame
that contains columns that are aliases (equal when compared with ===
).
Metadata: table-level :note
-style metadata and column-level :note
-style metadata for columns present in df
are preserved. If new columns are added their :note
-style metadata is copied from the appended table. Other metadata is dropped.
See also: use pushfirst!
to add individual rows at the beginning of a data frame, append!
to add a table at the end, and vcat
to vertically concatenate data frames.
Examples
julia> df1 = DataFrame(A=1:3, B=1:3)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
julia> df2 = DataFrame(A=4.0:6.0, B=4:6)
3×2 DataFrame
Row │ A B
│ Float64 Int64
─────┼────────────────
1 │ 4.0 4
2 │ 5.0 5
3 │ 6.0 6
julia> prepend!(df1, df2);
julia> df1
6×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 4 4
2 │ 5 5
3 │ 6 6
4 │ 1 1
5 │ 2 2
6 │ 3 3
#
Base.push!
— Function
push!(df::DataFrame, row::Union{Tuple, AbstractArray}; promote::Bool=false)
push!(df::DataFrame, row::Union{DataFrameRow, NamedTuple, AbstractDict,
Tables.AbstractRow};
cols::Symbol=:setequal, promote::Bool=(cols in [:union, :subset]))
Add one row at the end of df
in-place, taking the values from row
.
Column types of df
are preserved, and new values are converted if necessary. An error is thrown if conversion fails.
If row
is neither a DataFrameRow
, NamedTuple
nor AbstractDict
then it must be a Tuple
or an AbstractArray
and columns are matched by order of appearance. In this case row
must contain the same number of elements as the number of columns in df
.
If row
is a DataFrameRow
, NamedTuple
, AbstractDict
, or Tables.AbstractRow
then values in row
are matched to columns in df
based on names. The exact behavior depends on the cols
argument value in the following way:
-
If
cols == :setequal
(this is the default) thenrow
must contain exactly the same columns asdf
(but possibly in a different order). -
If
cols == :orderequal
thenrow
must contain the same columns in the same order (forAbstractDict
this option requires thatkeys(row)
matchespropertynames(df)
to allow for support of ordered dicts; however, ifrow
is aDict
an error is thrown as it is an unordered collection). -
If
cols == :intersect
thenrow
may contain more columns thandf
, but all column names that are present indf
must be present inrow
and only they are used to populate a new row indf
. -
If
cols == :subset
then the behavior is like for:intersect
but if some column is missing inrow
then amissing
value is pushed todf
. -
If
cols == :union
then columns missing indf
that are present inrow
are added todf
(usingmissing
for existing rows) and amissing
value is pushed to columns missing inrow
that are present indf
.
If promote=true
and element type of a column present in df
does not allow the type of a pushed argument then a new column with a promoted element type allowing it is freshly allocated and stored in df
. If promote=false
an error is thrown.
As a special case, if df
has no columns and row
is a NamedTuple
, DataFrameRow
, or Tables.AbstractRow
, columns are created for all values in row
, using their names and order.
Please note that this function must not be used on a DataFrame
that contains columns that are aliases (equal when compared with ===
).
Metadata: this function preserves table-level and column-level :note
-style metadata.
See also: pushfirst!
, insert!
Examples
julia> df = DataFrame(A='a':'c', B=1:3)
3×2 DataFrame
Row │ A B
│ Char Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
julia> push!(df, (true, false), promote=true)
4×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
4 │ true 0
julia> push!(df, df[1, :])
5×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
4 │ true 0
5 │ a 1
julia> push!(df, (C="something", A=11, B=12), cols=:intersect)
6×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
4 │ true 0
5 │ a 1
6 │ 11 12
julia> push!(df, Dict(:A=>1.0, :C=>1.0), cols=:union)
7×3 DataFrame
Row │ A B C
│ Any Int64? Float64?
─────┼──────────────────────────
1 │ a 1 missing
2 │ b 2 missing
3 │ c 3 missing
4 │ true 0 missing
5 │ a 1 missing
6 │ 11 12 missing
7 │ 1.0 missing 1.0
julia> push!(df, NamedTuple(), cols=:subset)
8×3 DataFrame
Row │ A B C
│ Any Int64? Float64?
─────┼─────────────────────────────
1 │ a 1 missing
2 │ b 2 missing
3 │ c 3 missing
4 │ true 0 missing
5 │ a 1 missing
6 │ 11 12 missing
7 │ 1.0 missing 1.0
8 │ missing missing missing
#
Base.pushfirst!
— Function
pushfirst!(df::DataFrame, row::Union{Tuple, AbstractArray}; promote::Bool=false)
pushfirst!(df::DataFrame, row::Union{DataFrameRow, NamedTuple, AbstractDict,
Tables.AbstractRow};
cols::Symbol=:setequal, promote::Bool=(cols in [:union, :subset]))
Добавляет одну строку в начало df
на месте, принимая значения из row
.
Типы столбцов df
сохраняются, а новые значения при необходимости преобразуются. При сбое преобразования возникает ошибка.
Если row
не является ни DataFrameRow
, ни NamedTuple
, ни AbstractDict
, она должна быть Tuple
или AbstractArray
, и столбцы сопоставляются в порядке появления. В этом случае row
должна содержать столько же элементов, сколько столбцов в df
.
Если строка (row
) является DataFrameRow
, NamedTuple
, AbstractDict
или Tables.AbstractRow
, значения в row
сопоставляются со столбцами в df
на основе имен. Точное поведение зависит от значения аргумента cols
, а именно:
-
Если
cols == :setequal
(по умолчанию),row
должна содержать те же столбцы, что иdf
(но, возможно, в другом порядке). -
Если
cols == :orderequal
,row
должна содержать те же столбцы в том же порядке (дляAbstractDict
этот параметр требует, чтобыkeys(row)
совпадал сpropertynames(df)
в целях поддержки упорядоченных словарей. Однако еслиrow
является словарем (Dict
), возникает ошибка, так как это неупорядоченная коллекция). -
Если
cols == :intersect
,row
должна содержать больше столбцов, чемdf
, но все имена столбцов, имеющиеся вdf
, должны присутствовать и вrow
, и только они используются для заполнения новой строки вdf
. -
Если
cols == :subset
, действует как для:intersect
, но если какой-то столбец отсутствует вrow
, отсутствующее (missing
) значение отправляется вdf
. -
Если
cols == :union
, столбцы, отсутствующие вdf
, которые присутствуют вrow
, добавляются вdf
(с использованиемmissing
для существующих строк), и значениеmissing
отправляется в столбцы, отсутствующие вrow
, которые присутствуют вdf
.
Если promote=true
и тип элемента столбца, присутствующего в df
, запрещает использовать тип отправляемого элемента, новый столбец с продвинутым типом элемента, разрешающим этот тип, выделяется заново и сохраняется в df
. Если promote=false
, возникает ошибка .
В отдельном случае, если df
не имеет столбцов и row
является NamedTuple
, DataFrameRow
, или Tables.AbstractRow
, столбцы создаются для всех значений в row
с использованием их имен и порядка.
Обратите внимание, что эта функция не должна использоваться для DataFrame
, содержащего столбцы, которые являются псевдонимами (одинаковыми при сравнении ===
).
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(A='a':'c', B=1:3)
3×2 DataFrame
Row │ A B
│ Char Int64
─────┼─────────────
1 │ a 1
2 │ b 2
3 │ c 3
julia> pushfirst!(df, (true, false), promote=true)
4×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ true 0
2 │ a 1
3 │ b 2
4 │ c 3
julia> pushfirst!(df, df[1, :])
5×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ true 0
2 │ true 0
3 │ a 1
4 │ b 2
5 │ c 3
julia> pushfirst!(df, (C="something", A=11, B=12), cols=:intersect)
6×2 DataFrame
Row │ A B
│ Any Int64
─────┼─────────────
1 │ 11 12
2 │ true 0
3 │ true 0
4 │ a 1
5 │ b 2
6 │ c 3
julia> pushfirst!(df, Dict(:A=>1.0, :C=>1.0), cols=:union)
7×3 DataFrame
Row │ A B C
│ Any Int64? Float64?
─────┼──────────────────────────
1 │ 1.0 missing 1.0
2 │ 11 12 missing
3 │ true 0 missing
4 │ true 0 missing
5 │ a 1 missing
6 │ b 2 missing
7 │ c 3 missing
julia> pushfirst!(df, NamedTuple(), cols=:subset)
8×3 DataFrame
Row │ A B C
│ Any Int64? Float64?
─────┼─────────────────────────────
1 │ missing missing missing
2 │ 1.0 missing 1.0
3 │ 11 12 missing
4 │ true 0 missing
5 │ true 0 missing
6 │ a 1 missing
7 │ b 2 missing
8 │ c 3 missing
#
Base.reduce
— Function
reduce(::typeof(vcat),
dfs::Union{AbstractVector{<:AbstractDataFrame},
Tuple{AbstractDataFrame, Vararg{AbstractDataFrame}}};
cols::Union{Symbol, AbstractVector{Symbol},
AbstractVector{<:AbstractString}}=:setequal,
source::Union{Nothing, Symbol, AbstractString,
Pair{<:Union{Symbol, AbstractString}, <:AbstractVector}}=nothing,
init::AbstractDataFrame=DataFrame())
Эффективно упрощает заданный вектор или кортеж AbstractDataFrame
с помощью vcat
.
См. docstring vcat
с описанием именованных аргументов cols
и source
.
Именованный аргумент init
представляет собой начальное значение для использования в упрощениях. Он должен быть фреймом данных без строк. Он не учитывается ни при вычислении значения исходного (source
) столбца, ни при определении метаданных создаваемого фрейма данных.
Порядок, имена и типы столбцов результирующего DataFrame
, а также поведение именованных аргументов cols
и source
следуют правилам, указанным для vcat
фреймов AbstractDataFrame
.
Метаданные: функция vcat
распространяет метаданные на уровне таблиц в стиле :note
для ключей, присутствующих во всех передаваемых фреймах данных и имеющих одинаковое значение. Функция vcat
распространяет метаданные на уровне столбцов в стиле :note
для ключей, присутствующих во всех передаваемых фреймах данных, содержащих этот столбец, и имеющих одинаковое значение.
Пример
julia> df1 = DataFrame(A=1:3, B=1:3)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
julia> df2 = DataFrame(A=4:6, B=4:6)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 4 4
2 │ 5 5
3 │ 6 6
julia> df3 = DataFrame(A=7:9, C=7:9)
3×2 DataFrame
Row │ A C
│ Int64 Int64
─────┼──────────────
1 │ 7 7
2 │ 8 8
3 │ 9 9
julia> reduce(vcat, (df1, df2))
6×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
4 │ 4 4
5 │ 5 5
6 │ 6 6
julia> reduce(vcat, [df1, df2, df3], cols=:union, source=:source)
9×4 DataFrame
Row │ A B C source
│ Int64 Int64? Int64? Int64
─────┼─────────────────────────────────
1 │ 1 1 missing 1
2 │ 2 2 missing 1
3 │ 3 3 missing 1
4 │ 4 4 missing 2
5 │ 5 5 missing 2
6 │ 6 6 missing 2
7 │ 7 missing 7 3
8 │ 8 missing 8 3
9 │ 9 missing 9 3
#
Base.repeat
— Function
repeat(df::AbstractDataFrame; inner::Integer = 1, outer::Integer = 1)
Создает фрейм данных, повторяя строки в df
. inner
указывает количество повторений каждой строки, а outer
указывает количество повторений полного набора строк.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Пример
julia> df = DataFrame(a=1:2, b=3:4)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
julia> repeat(df, inner=2, outer=3)
12×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 1 3
3 │ 2 4
4 │ 2 4
5 │ 1 3
6 │ 1 3
7 │ 2 4
8 │ 2 4
9 │ 1 3
10 │ 1 3
11 │ 2 4
12 │ 2 4
repeat(df::AbstractDataFrame, count::Integer)
Создает фрейм данных, повторяя каждую строку в df
столько раз, сколько указано с помощью count
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Пример
julia> df = DataFrame(a=1:2, b=3:4)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
julia> repeat(df, 2)
4×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
3 │ 1 3
4 │ 2 4
#
DataFrames.repeat!
— Function
repeat!(df::DataFrame; inner::Integer=1, outer::Integer=1)
Обновляет фрейм данных df
на месте, повторяя его строки. inner
указывает количество повторений каждой строки, а outer
указывает количество повторений полного набора строк. Столбцы df
являются только что выделенными.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Пример
julia> df = DataFrame(a=1:2, b=3:4)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
julia> repeat!(df, inner=2, outer=3);
julia> df
12×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 1 3
3 │ 2 4
4 │ 2 4
5 │ 1 3
6 │ 1 3
7 │ 2 4
8 │ 2 4
9 │ 1 3
10 │ 1 3
11 │ 2 4
12 │ 2 4
repeat!(df::DataFrame, count::Integer)
Обновляет фрейм данных df
на месте, повторяя его строки столько раз, сколько указано с помощью count
. Столбцы df
являются только что выделенными.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Пример
julia> df = DataFrame(a=1:2, b=3:4)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
julia> repeat(df, 2)
4×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
3 │ 1 3
4 │ 2 4
#
Base.reverse
— Function
reverse(df::AbstractDataFrame, start=1, stop=nrow(df))
Return a data frame containing the rows in df
in reversed order. If start
and stop
are provided, only rows in the start:stop
range are affected.
Metadata: this function preserves table-level and column-level :note
-style metadata.
Examples
julia> df = DataFrame(a=1:5, b=6:10, c=11:15)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 11
2 │ 2 7 12
3 │ 3 8 13
4 │ 4 9 14
5 │ 5 10 15
julia> reverse(df)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 5 10 15
2 │ 4 9 14
3 │ 3 8 13
4 │ 2 7 12
5 │ 1 6 11
julia> reverse(df, 2, 3)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 11
2 │ 3 8 13
3 │ 2 7 12
4 │ 4 9 14
5 │ 5 10 15
#
Base.reverse!
— Function
reverse!(df::AbstractDataFrame, start=1, stop=nrow(df))
Mutate data frame in-place to reverse its row order. If start
and stop
are provided, only rows in the start:stop
range are affected.
reverse!
will produce a correct result even if some columns of passed data frame are identical (checked with ===
). Otherwise, if two columns share some part of memory but are not identical (e.g. are different views of the same parent vector) then reverse!
result might be incorrect.
Metadata: this function preserves table-level and column-level :note
-style metadata.
Metadata having other styles is dropped (from parent data frame when df
is a SubDataFrame
).
Examples
julia> df = DataFrame(a=1:5, b=6:10, c=11:15)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 6 11
2 │ 2 7 12
3 │ 3 8 13
4 │ 4 9 14
5 │ 5 10 15
julia> reverse!(df)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 5 10 15
2 │ 4 9 14
3 │ 3 8 13
4 │ 2 7 12
5 │ 1 6 11
julia> reverse!(df, 2, 3)
5×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 5 10 15
2 │ 3 8 13
3 │ 4 9 14
4 │ 2 7 12
5 │ 1 6 11
#
DataFrames.select
— Function
select(df::AbstractDataFrame, args...;
copycols::Bool=true, renamecols::Bool=true, threads::Bool=true)
select(args::Callable, df::DataFrame;
renamecols::Bool=true, threads::Bool=true)
select(gd::GroupedDataFrame, args...;
copycols::Bool=true, keepkeys::Bool=true, ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
select(f::Base.Callable, gd::GroupedDataFrame;
copycols::Bool=true, keepkeys::Bool=true, ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
Создает новый фрейм данных, содержащий столбцы из df
или gd
, указанные с помощью args
, и возвращает его. Результат гарантированно имеет то же количество строк, что и df
, за исключением ситуаций, когда ни один столбец не выбран (в этом случае результат не содержит строк).
Ниже подробно описаны и сопоставлены общие правила для всех функций преобразования, поддерживаемых DataFrames.jl.
Все эти операции поддерживаются как для AbstractDataFrame
(при пропуске шагов разделения и объединения), так и для GroupedDataFrame
. Технически AbstractDataFrame
считается сгруппированным без столбцов (это означает, что у него есть одна группа или ни одной, если он пуст). Единственное отличие заключается в том, что в этом случае именованные аргументы keepkeys
и ungroup
(описанные ниже) не поддерживаются, и всегда возвращается фрейм данных, поскольку в этом случае нет шагов разделения и объединения.
Чтобы выполнять операции с группами, сначала нужно создать объект GroupedDataFrame
из фрейма данных с помощью функции groupby
, которая принимает два аргумента: (1) фрейм данных, который нужно сгруппировать, и (2) набор столбцов, по которым осуществляется группировка.
Затем можно применить операции к каждой группе с помощью одной из следующих функций:
-
combine
: не накладывает ограничений на количество возвращаемых строк в каждой группе; возвращаемые значения конкатенируются по вертикали в соответствии с порядком групп вGroupedDataFrame
; обычно используется для вычисления сводной статистики по группам; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
select
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая только новые вычисленные столбцы;select!
является версией на месте дляselect
; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
transform
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая все столбцы из исходного фрейма и новые вычисленные столбцы;transform!
является версией на месте дляtransform
; существующие столбцы в исходном фрейме данных помещаются первыми в результат.
Особый случай: если передается GroupedDataFrame
без групп, результат операции определяется путем выполнения одного вызова функции преобразования с переданным ей аргументом с нулем строк. Выходные данные этой операции используются только для определения количества и типа созданных столбцов, но результат не содержит строк.
Все эти функции принимают спецификацию одной или нескольких функций для применения к каждому подмножеству DataFrame
. Эта спецификация может иметь следующий вид:
-
Стандартные селекторы столбцов (целые числа, символы (
Symbol
), строки, векторы целых чисел, векторы символов (Symbol
), векторы строк,All
,Cols
,:
,Between
,Not
и регулярные выражения). -
Пара
cols => function
, указывающая, что функцию (function
) следует вызывать с позиционными аргументами, содержащими столбцыcols
, которые могут быть любым допустимым селектором столбцов. В этом случае имя целевого столбца генерируется автоматически и предполагается, что функция (function
) возвращает единичное значение или вектор. Сгенерированное имя создается путем конкатенации имени исходного столбца и имени функции (function
) по умолчанию (см. примеры ниже). -
Форма
cols => function => target_cols
, дополнительно явно указывающая целевой столбец или столбцы, которые должны быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. Кроме того, это может быть функция (Function
), которая принимает в качестве аргумента строку или вектор строк, содержащие имена столбцов, выбранные с помощьюcols
, и возвращает имена целевых столбцов (допускаются все принятые типы, кромеAsTable
). -
Пара
col => target_cols
, которая переименовывает столбецcol
вtarget_cols
, который должен быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. -
Независимые от столбцов операции
function => target_cols
или простоfunction
для конкретных функций (function
), где входные столбцы опущены; безtarget_cols
новый столбец имеет то же имя, что иfunction
, в противном случае должен быть одним именем (какSymbol
или строка). Поддерживаются следующие функции (function
).-
nrow
для эффективного вычисления количества строк в каждой группе. -
proprow
для эффективного вычисления доли строк в каждой группе. -
eachindex
для возврата вектора, содержащего номер каждой строки в каждой группе. -
groupindices
для возврата номера группы.
-
-
Векторы или матрицы, содержащие преобразования, заданные синтаксисом
Pair
, описываются в пунктах 2—5. -
Функция, которая будет вызвана с
SubDataFrame
, соответствующим каждой группе, если обрабатываетсяGroupedDataFrame
, или с самим фреймом данных, если обрабатываетсяAbstractDataFrame
. Эту форму не рекомендуется использовать из-за ее низкой производительности, за исключением случаев, когда количество групп невелико или обрабатывается очень большое количество столбцов (в этом случаеSubDataFrame
позволяет избежать чрезмерной компиляции).
Примечание. Если передается выражение вида x => y
, то, за исключением специального вспомогательного вида nrow => target_cols
, оно всегда интерпретируется как cols => function
. В частности, следующее выражение function => target_cols
не является допустимой спецификацией преобразования.
Примечание. Если cols
или target_cols
являются All
, Cols
, Between
или Not
, поддерживается трансляция с использованием .=>
, и она эквивалентна трансляции результата names(df, cols)
или names(df, target_cols)
. Это работает, как будто трансляция произошла после замены селектора выбранными именами столбцов в области фрейма данных.
Все функции имеют два типа сигнатур. Один из них принимает GroupedDataFrame
в качестве первого аргумента и произвольное количество преобразований, описанных выше, в качестве последующих аргументов. Второй тип сигнатуры — это когда в качестве первого аргумента передается Function
или Type
и GroupedDataFrame
в качестве второго аргумента (аналогично map
).
Есть особое правило: если при использовании синтаксисов cols => function
и cols => function => target_cols
cols
заключен в объект AsTable
, NamedTuple
, содержащий столбцы, выбранные с помощью cols
, передается function
. Дополнительные сведения см. в документации по DataFrames.table_transformation
, где также рассматриваются вопросы производительности.
Результат, который может возвращать функция (function
), определяется значением target_cols
.
-
Если
cols
иtarget_cols
опущены (передается толькоfunction
), при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
будет создано несколько столбцов. При возврате любого другого значения создается один столбец. -
Если
target_cols
является символом (Symbol
) или строкой, предполагается, что функция возвратит один столбец. В этом случае при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
возникнет ошибка. -
Если
target_cols
является вектором символов (Symbol
) или строк илиAsTable
, предполагается, что функция (function
) возвратит несколько столбцов. Если функция (function
) возвращает какой-либо элемент изAbstractDataFrame
,NamedTuple
,DataFrameRow
,Tables.AbstractRow
,AbstractMatrix
, применяется правило, описанное в пункте 1 выше. Если функция (function
) возвращаетAbstractVector
, каждый элемент этого вектора должен поддерживать функциюkeys
, которая должна возвращать коллекциюSymbol
, строк или целых чисел. Возвращаемое значениеkeys
должно быть одинаковым для всех элементов. Затем создается столько столбцов, сколько элементов содержится в возвращаемом значении функцииkeys
. Еслиtarget_cols
являетсяAsTable
, их имена задаются равными именам ключей, за исключением случаев, когдаkeys
возвращает целые числа, тогда они получают префиксx
(таким образом, имена столбцов будут выглядеть какx1
,x2
и т. д.). Еслиtarget_cols
является вектором символов (Symbol
) или строк, имена столбцов, созданные на основе приведенных выше правил, игнорируются и заменяютсяtarget_cols
(в этом случае количество столбцов должно совпадать с длинойtarget_cols
). Еслиfun
возвращает значение любого другого типа, предполагается, что это таблица, соответствующая API Tables.jl, и для нее вызывается функцияTables.columntable
для получения результирующих столбцов и их имен. Имена сохраняются, когдаtarget_cols
являетсяAsTable
, и заменяются, еслиtarget_cols
является вектором символов (Symbol
) или строк.
Во всех этих случаях функция (function
) может возвращать как одну строку, так и несколько. Как правило, значения, заключенные в Ref
или 0
-мерный массив AbstractArray
, распаковываются и после этого считаются одной строкой.
select
/select!
и transform
/transform!
всегда возвращают фрейм данных с количеством и порядком строк, точно таким же, как у исходного (даже если в GroupedDataFrame
был изменен порядок групп), за исключением случаев, когда в результирующем фрейме данных нет столбцов (в этом случае результат не содержит строк).
Для combine
строки в возвращаемом объекте отображаются в порядке групп в GroupedDataFrame
. Функции могут возвращать произвольное количество строк для каждой группы, но тип возвращаемого объекта и количество и имена столбцов должны быть одинаковыми для всех групп, за исключением случаев, когда возвращаются DataFrame()
или NamedTuple()
, тогда заданная группа пропускается.
Допускается смешивать единичные значения и векторы, если запрашивается несколько преобразований. В этом случае такое значение будет повторяться, чтобы соответствовать длине столбцов, указанных в возвращаемых векторах.
Чтобы применить функцию (function
) к каждой строке, а не ко всем столбцам, ее можно заключить в структуру ByRow
. cols
может быть любым синтаксисом индексирования столбцов. Тогда функции (function
) будет передан один аргумент для каждого из столбцов, указанных с помощью cols
, или NamedTuple
, если указанные столбцы заключены в AsTable
. Если используется ByRow
, cols
может выбрать пустой набор столбцов, тогда function
вызывается для каждой строки без аргументов, и передается пустой NamedTuple
, если в AsTable
заключен пустой набор столбцов.
Если передается коллекция имен столбцов, то принимаются запросы дублирующихся имен столбцов в целевом фрейме данных (например, допускается select!(df, [:a], :, r"a")
), и используется только первое вхождение. В частности, используется следующий синтаксис для перемещения столбца :col
в первую позицию во фрейме данных — select!(df, :col, :)
. Напротив, имена выходных столбцов в операциях переименования, преобразования и выбора одного столбца должны быть уникальными, поэтому, например, select!(df, :a, :a => :a)
или select!(df, :a, :a => ByRow(sin) => :a)
недопустимы.
В общем случае столбцы, возвращаемые преобразованиями, сохраняются в целевом фрейме данных без копирования. Исключением из этого правила являются случаи, когда столбцы из исходного фрейма данных повторно используются в целевом фрейме данных. Это можно сделать с помощью таких выражений, как: :x1
, [:x1, :x2]
, :x1 => :x2
, :x1 => identity => :x2
или :x1 => (x -> @view x[inds])
(обратите внимание, что в последнем случае исходный столбец используется повторно косвенным образом через представление). В таких случаях поведение зависит от значения именованного аргумента copycols
:
-
если
copycols=true
, в результате таких преобразований всегда создается копия исходного столбца или его представления; -
если
copycols=false
, копии создаются только для того, чтобы избежать многократного хранения одного и того же столбца в целевом фрейме данных. Точнее, при первом использовании столбца копирование не производится, но при каждом последующем повторном использовании исходного столбца (при сравнении с использованием===
, которое исключает представления исходных столбцов) создается копия.
Обратите внимание, что при выполнении transform!
или select!
предполагается, что copycols=false
.
Если df
является SubDataFrame
и copycols=true
, возвращается DataFrame
и применяются те же правила копирования, что и для входных данных DataFrame
: это означает, в частности, что выбранные столбцы будут скопированы. При copycols=false
SubDataFrame
возвращается без копирования столбцов, и в этом случае преобразование или переименование столбцов не допускается.
Если передается GroupedDataFrame
и threads=true
(по умолчанию), для каждого указанного преобразования порождается отдельная задача. Затем каждое преобразование порождает столько задач, сколько потоков доступно в Julia, и разделяет обработку групп между ними (однако в настоящее время преобразования с оптимизированной реализацией, такие как sum
, и преобразования, возвращающие несколько строк, используют одну задачу для всех групп). Это позволяет выполнять параллельную работу, если среда Julia была запущена с несколькими потоками. Поэтому передаваемые функции преобразования не должны изменять глобальные переменные (то есть они должны быть чистыми), использовать блокировки для управления параллельным доступом, либо следует передать threads=false
, чтобы отключить многопоточность. В будущем параллелизм может быть распространен и на другие случаи, так что это требование справедливо и для входных данных DataFrame
.
Для повышения производительности операций некоторые преобразования используют оптимизированную реализацию. Дополнительные сведения см. в описании DataFrames.table_transformation
.
Именованные аргументы
-
copycols::Bool=true
: следует ли копировать столбцы исходного фрейма данных, если к ним не применены преобразования. -
renamecols::Bool=true
: должны ли автоматически генерируемые имена столбцов в формеcols => function
включать название функций преобразования, или нет. -
keepkeys::Bool=true
: должны ли группирующие столбцыgd
сохраняться в возвращаемом фрейме данных. -
ungroup::Bool=true
: должно ли возвращаемое значение операции сgd
быть фреймом данных илиGroupedDataFrame
. -
threads::Bool=true
: могут ли преобразования осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значениеfalse
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Метаданные: эта функция распространяет метаданные на уровне таблиц в стиле :note
. Метаданные на уровне столбцов в стиле :note
распространяются в следующих случаях: а) один столбец преобразуется в один столбец, при этом имя столбца не изменяется (это относится ко всем операциям выбора столбца), или б) один столбец преобразуется с помощью identity
или copy
в один столбец даже при изменении имени столбца (сюда относится и переименование столбца). Особый случай для GroupedDataFrame
: если вывод имеет то же имя, что и группирующий столбец, и keepkeys=true
, метаданные берутся из исходного группирующего столбца.
Примеры
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> select(df, 2)
3×1 DataFrame
Row │ b
│ Int64
─────┼───────
1 │ 4
2 │ 5
3 │ 6
julia> select(df, :a => ByRow(sin) => :c, :b)
3×2 DataFrame
Row │ c b
│ Float64 Int64
─────┼─────────────────
1 │ 0.841471 4
2 │ 0.909297 5
3 │ 0.14112 6
julia> select(df, :, [:a, :b] => (a, b) -> a .+ b .- sum(b)/length(b))
3×3 DataFrame
Row │ a b a_b_function
│ Int64 Int64 Float64
─────┼────────────────────────────
1 │ 1 4 0.0
2 │ 2 5 2.0
3 │ 3 6 4.0
julia> select(df, All() .=> [minimum maximum])
3×4 DataFrame
Row │ a_minimum b_minimum a_maximum b_maximum
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────────────────────
1 │ 1 4 3 6
2 │ 1 4 3 6
3 │ 1 4 3 6
julia> using Statistics
julia> select(df, AsTable(:) => ByRow(mean), renamecols=false)
3×1 DataFrame
Row │ a_b
│ Float64
─────┼─────────
1 │ 2.5
2 │ 3.5
3 │ 4.5
julia> select(df, AsTable(:) => ByRow(mean) => x -> join(x, "_"))
3×1 DataFrame
Row │ a_b
│ Float64
─────┼─────────
1 │ 2.5
2 │ 3.5
3 │ 4.5
julia> select(first, df)
3×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
2 │ 1 4
3 │ 1 4
julia> df = DataFrame(a=1:3, b=4:6, c=7:9)
3×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 4 7
2 │ 2 5 8
3 │ 3 6 9
julia> select(df, AsTable(:) => ByRow(x -> (mean=mean(x), std=std(x))) => :stats,
AsTable(:) => ByRow(x -> (mean=mean(x), std=std(x))) => AsTable)
3×3 DataFrame
Row │ stats mean std
│ NamedTup… Float64 Float64
─────┼───────────────────────────────────────────
1 │ (mean = 4.0, std = 3.0) 4.0 3.0
2 │ (mean = 5.0, std = 3.0) 5.0 3.0
3 │ (mean = 6.0, std = 3.0) 6.0 3.0
julia> df = DataFrame(a=[1, 1, 1, 2, 2, 1, 1, 2],
b=repeat([2, 1], outer=[4]),
c=1:8)
8×3 DataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 1
2 │ 1 1 2
3 │ 1 2 3
4 │ 2 1 4
5 │ 2 2 5
6 │ 1 1 6
7 │ 1 2 7
8 │ 2 1 8
julia> gd = groupby(df, :a)
GroupedDataFrame with 2 groups based on key: a
First Group (5 rows): a = 1
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 1
2 │ 1 1 2
3 │ 1 2 3
4 │ 1 1 6
5 │ 1 2 7
⋮
Last Group (3 rows): a = 2
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 2 1 4
2 │ 2 2 5
3 │ 2 1 8
указание имени для целевого столбца
julia> df = DataFrame(a=[1, 1, 1, 2, 2, 1, 1, 2],
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> select(gd, :c => (x -> sum(log, x)) => :sum_log_c)
8×2 DataFrame
Row │ a sum_log_c
│ Int64 Float64
─────┼──────────────────
1 │ 1 5.52943
2 │ 1 5.52943
3 │ 1 5.52943
4 │ 2 5.07517
5 │ 2 5.07517
6 │ 1 5.52943
7 │ 1 5.52943
8 │ 2 5.07517
julia> select(gd, [:b, :c] .=> sum) # передача вектора пар
8×3 DataFrame
Row │ a b_sum c_sum
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 8 19
2 │ 1 8 19
3 │ 1 8 19
4 │ 2 4 17
5 │ 2 4 17
6 │ 1 8 19
7 │ 1 8 19
8 │ 2 4 17
несколько аргументов, переименование и сохранение ключей
julia> df = DataFrame(a=[1, 1, 1, 2, 2, 1, 1, 2],
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> select(gd, :b => :b1, :c => :c1, [:b, :c] => +, keepkeys=false)
8×3 DataFrame
Row │ b1 c1 b_c_+
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 2 1 3
2 │ 1 2 3
3 │ 2 3 5
4 │ 1 4 5
5 │ 2 5 7
6 │ 1 6 7
7 │ 2 7 9
8 │ 1 8 9
трансляция и расширение столбцов
julia> df = DataFrame(a=[1, 1, 1, 2, 2, 1, 1, 2],
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> select(gd, :b, AsTable([:b, :c]) => ByRow(extrema) => [:min, :max])
8×4 DataFrame
Row │ a b min max
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 2 1 2
2 │ 1 1 1 2
3 │ 1 2 2 3
4 │ 2 1 1 4
5 │ 2 2 2 5
6 │ 1 1 1 6
7 │ 1 2 2 7
8 │ 2 1 1 8
julia> select(gd, :, AsTable(Not(:a)) => sum, renamecols=false)
8×4 DataFrame
Row │ a b c b_c
│ Int64 Int64 Int64 Int64
─────┼────────────────────────────
1 │ 1 2 1 3
2 │ 1 1 2 3
3 │ 1 2 3 5
4 │ 2 1 4 5
5 │ 2 2 5 7
6 │ 1 1 6 7
7 │ 1 2 7 9
8 │ 2 1 8 9
независимые от столбцов операции
julia> df = DataFrame(a=[1, 1, 1, 2, 2, 1, 1, 2],
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a);
julia> select(gd, nrow, proprow, groupindices, eachindex)
8×5 DataFrame
Row │ a nrow proprow groupindices eachindex
│ Int64 Int64 Float64 Int64 Int64
─────┼────────────────────────────────────────────────
1 │ 1 5 0.625 1 1
2 │ 1 5 0.625 1 2
3 │ 1 5 0.625 1 3
4 │ 2 3 0.375 2 1
5 │ 2 3 0.375 2 2
6 │ 1 5 0.625 1 4
7 │ 1 5 0.625 1 5
8 │ 2 3 0.375 2 3
#
DataFrames.select!
— Function
select!(df::AbstractDataFrame, args...;
renamecols::Bool=true, threads::Bool=true)
select!(args::Base.Callable, df::DataFrame;
renamecols::Bool=true, threads::Bool=true)
select!(gd::GroupedDataFrame, args...; ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
select!(f::Base.Callable, gd::GroupedDataFrame; ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
Изменяет df
или gd
на месте для сохранения только столбцов или преобразований, указанных с помощью args...
, и возвращает его. Результат гарантированно имеет то же количество строк, что и df
или родитель gd
, за исключением ситуаций, когда ни один столбец не выбран (в этом случае результат не содержит строк).
Если передается SubDataFrame
или GroupedDataFrame{SubDataFrame}
, родительский фрейм данных обновляется с помощью столбцов, созданных args...
, следуя тем же правилам, что и при индексировании:
-
для существующих столбцов отфильтрованные строки заполняются значениями, присутствующими в старых столбцах
-
для новых столбцов (что допустимо, только если
SubDataFrame
был создан с помощью:
в качестве селектора столбцов) отфильтрованные строки заполняются отсутствующими (missing
) значениями -
отброшенных столбцов (допускаются, только если
SubDataFrame
был создан с помощью:
в качестве селектора столбцов), которые удаляются, -
если
SubDataFrame
не был создан с помощью:
в качестве селектора столбцов,select!
разрешен только в том случае, если преобразования сохраняют точно такую же последовательность имен столбцов, что и в переданномdf
.
Если передается GroupedDataFrame
, он обновляется, чтобы отразить новые строки своего обновленного родителя. Если существуют независимые объекты GroupedDataFrame
, созданные на основе одного и того же родительского фрейма данных, они могут быть повреждены.
Ниже подробно описаны и сопоставлены общие правила для всех функций преобразования, поддерживаемых DataFrames.jl.
Все эти операции поддерживаются как для AbstractDataFrame
(при пропуске шагов разделения и объединения), так и для GroupedDataFrame
. Технически AbstractDataFrame
считается сгруппированным без столбцов (это означает, что у него есть одна группа или ни одной, если он пуст). Единственное отличие заключается в том, что в этом случае именованные аргументы keepkeys
и ungroup
(описанные ниже) не поддерживаются, и всегда возвращается фрейм данных, поскольку в этом случае нет шагов разделения и объединения.
Чтобы выполнять операции с группами, сначала нужно создать объект GroupedDataFrame
из фрейма данных с помощью функции groupby
, которая принимает два аргумента: (1) фрейм данных, который нужно сгруппировать, и (2) набор столбцов, по которым осуществляется группировка.
Затем можно применить операции к каждой группе с помощью одной из следующих функций:
-
combine
: не накладывает ограничений на количество возвращаемых строк в каждой группе; возвращаемые значения конкатенируются по вертикали в соответствии с порядком групп вGroupedDataFrame
; обычно используется для вычисления сводной статистики по группам; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
select
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая только новые вычисленные столбцы;select!
является версией на месте дляselect
; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
transform
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая все столбцы из исходного фрейма и новые вычисленные столбцы;transform!
является версией на месте дляtransform
; существующие столбцы в исходном фрейме данных помещаются первыми в результат.
Особый случай: если передается GroupedDataFrame
без групп, результат операции определяется путем выполнения одного вызова функции преобразования с переданным ей аргументом с нулем строк. Выходные данные этой операции используются только для определения количества и типа созданных столбцов, но результат не содержит строк.
Все эти функции принимают спецификацию одной или нескольких функций для применения к каждому подмножеству DataFrame
. Эта спецификация может иметь следующий вид:
-
Стандартные селекторы столбцов (целые числа, символы (
Symbol
), строки, векторы целых чисел, векторы символов (Symbol
), векторы строк,All
,Cols
,:
,Between
,Not
и регулярные выражения). -
Пара
cols => function
, указывающая, что функцию (function
) следует вызывать с позиционными аргументами, содержащими столбцыcols
, которые могут быть любым допустимым селектором столбцов. В этом случае имя целевого столбца генерируется автоматически и предполагается, что функция (function
) возвращает единичное значение или вектор. Сгенерированное имя создается путем конкатенации имени исходного столбца и имени функции (function
) по умолчанию (см. примеры ниже). -
Форма
cols => function => target_cols
, дополнительно явно указывающая целевой столбец или столбцы, которые должны быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. Кроме того, это может быть функция (Function
), которая принимает в качестве аргумента строку или вектор строк, содержащие имена столбцов, выбранные с помощьюcols
, и возвращает имена целевых столбцов (допускаются все принятые типы, кромеAsTable
). -
Пара
col => target_cols
, которая переименовывает столбецcol
вtarget_cols
, который должен быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. -
Независимые от столбцов операции
function => target_cols
или простоfunction
для конкретных функций (function
), где входные столбцы опущены; безtarget_cols
новый столбец имеет то же имя, что иfunction
, в противном случае должен быть одним именем (какSymbol
или строка). Поддерживаются следующие функции (function
).-
nrow
для эффективного вычисления количества строк в каждой группе. -
proprow
для эффективного вычисления доли строк в каждой группе. -
eachindex
для возврата вектора, содержащего номер каждой строки в каждой группе. -
groupindices
для возврата номера группы.
-
-
Векторы или матрицы, содержащие преобразования, заданные синтаксисом
Pair
, описываются в пунктах 2—5. -
Функция, которая будет вызвана с
SubDataFrame
, соответствующим каждой группе, если обрабатываетсяGroupedDataFrame
, или с самим фреймом данных, если обрабатываетсяAbstractDataFrame
. Эту форму не рекомендуется использовать из-за ее низкой производительности, за исключением случаев, когда количество групп невелико или обрабатывается очень большое количество столбцов (в этом случаеSubDataFrame
позволяет избежать чрезмерной компиляции).
Примечание. Если передается выражение вида x => y
, то, за исключением специального вспомогательного вида nrow => target_cols
, оно всегда интерпретируется как cols => function
. В частности, следующее выражение function => target_cols
не является допустимой спецификацией преобразования.
Примечание. Если cols
или target_cols
являются All
, Cols
, Between
или Not
, поддерживается трансляция с использованием .=>
, и она эквивалентна трансляции результата names(df, cols)
или names(df, target_cols)
. Это работает, как будто трансляция произошла после замены селектора выбранными именами столбцов в области фрейма данных.
Все функции имеют два типа сигнатур. Один из них принимает GroupedDataFrame
в качестве первого аргумента и произвольное количество преобразований, описанных выше, в качестве последующих аргументов. Второй тип сигнатуры — это когда в качестве первого аргумента передается Function
или Type
и GroupedDataFrame
в качестве второго аргумента (аналогично map
).
Есть особое правило: если при использовании синтаксисов cols => function
и cols => function => target_cols
cols
заключен в объект AsTable
, NamedTuple
, содержащий столбцы, выбранные с помощью cols
, передается function
. Дополнительные сведения см. в документации по DataFrames.table_transformation
, где также рассматриваются вопросы производительности.
Результат, который может возвращать функция (function
), определяется значением target_cols
.
-
Если
cols
иtarget_cols
опущены (передается толькоfunction
), при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
будет создано несколько столбцов. При возврате любого другого значения создается один столбец. -
Если
target_cols
является символом (Symbol
) или строкой, предполагается, что функция возвратит один столбец. В этом случае при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
возникнет ошибка. -
Если
target_cols
является вектором символов (Symbol
) или строк илиAsTable
, предполагается, что функция (function
) возвратит несколько столбцов. Если функция (function
) возвращает какой-либо элемент изAbstractDataFrame
,NamedTuple
,DataFrameRow
,Tables.AbstractRow
,AbstractMatrix
, применяется правило, описанное в пункте 1 выше. Если функция (function
) возвращаетAbstractVector
, каждый элемент этого вектора должен поддерживать функциюkeys
, которая должна возвращать коллекциюSymbol
, строк или целых чисел. Возвращаемое значениеkeys
должно быть одинаковым для всех элементов. Затем создается столько столбцов, сколько элементов содержится в возвращаемом значении функцииkeys
. Еслиtarget_cols
являетсяAsTable
, их имена задаются равными именам ключей, за исключением случаев, когдаkeys
возвращает целые числа, тогда они получают префиксx
(таким образом, имена столбцов будут выглядеть какx1
,x2
и т. д.). Еслиtarget_cols
является вектором символов (Symbol
) или строк, имена столбцов, созданные на основе приведенных выше правил, игнорируются и заменяютсяtarget_cols
(в этом случае количество столбцов должно совпадать с длинойtarget_cols
). Еслиfun
возвращает значение любого другого типа, предполагается, что это таблица, соответствующая API Tables.jl, и для нее вызывается функцияTables.columntable
для получения результирующих столбцов и их имен. Имена сохраняются, когдаtarget_cols
являетсяAsTable
, и заменяются, еслиtarget_cols
является вектором символов (Symbol
) или строк.
Во всех этих случаях функция (function
) может возвращать как одну строку, так и несколько. Как правило, значения, заключенные в Ref
или 0
-мерный массив AbstractArray
, распаковываются и после этого считаются одной строкой.
select
/select!
и transform
/transform!
всегда возвращают фрейм данных с количеством и порядком строк, точно таким же, как у исходного (даже если в GroupedDataFrame
был изменен порядок групп), за исключением случаев, когда в результирующем фрейме данных нет столбцов (в этом случае результат не содержит строк).
Для combine
строки в возвращаемом объекте отображаются в порядке групп в GroupedDataFrame
. Функции могут возвращать произвольное количество строк для каждой группы, но тип возвращаемого объекта и количество и имена столбцов должны быть одинаковыми для всех групп, за исключением случаев, когда возвращаются DataFrame()
или NamedTuple()
, тогда заданная группа пропускается.
Допускается смешивать единичные значения и векторы, если запрашивается несколько преобразований. В этом случае такое значение будет повторяться, чтобы соответствовать длине столбцов, указанных в возвращаемых векторах.
Чтобы применить функцию (function
) к каждой строке, а не ко всем столбцам, ее можно заключить в структуру ByRow
. cols
может быть любым синтаксисом индексирования столбцов. Тогда функции (function
) будет передан один аргумент для каждого из столбцов, указанных с помощью cols
, или NamedTuple
, если указанные столбцы заключены в AsTable
. Если используется ByRow
, cols
может выбрать пустой набор столбцов, тогда function
вызывается для каждой строки без аргументов, и передается пустой NamedTuple
, если в AsTable
заключен пустой набор столбцов.
Если передается коллекция имен столбцов, то принимаются запросы дублирующихся имен столбцов в целевом фрейме данных (например, допускается select!(df, [:a], :, r"a")
), и используется только первое вхождение. В частности, используется следующий синтаксис для перемещения столбца :col
в первую позицию во фрейме данных — select!(df, :col, :)
. Напротив, имена выходных столбцов в операциях переименования, преобразования и выбора одного столбца должны быть уникальными, поэтому, например, select!(df, :a, :a => :a)
или select!(df, :a, :a => ByRow(sin) => :a)
недопустимы.
В общем случае столбцы, возвращаемые преобразованиями, сохраняются в целевом фрейме данных без копирования. Исключением из этого правила являются случаи, когда столбцы из исходного фрейма данных повторно используются в целевом фрейме данных. Это можно сделать с помощью таких выражений, как: :x1
, [:x1, :x2]
, :x1 => :x2
, :x1 => identity => :x2
или :x1 => (x -> @view x[inds])
(обратите внимание, что в последнем случае исходный столбец используется повторно косвенным образом через представление). В таких случаях поведение зависит от значения именованного аргумента copycols
:
-
если
copycols=true
, в результате таких преобразований всегда создается копия исходного столбца или его представления; -
если
copycols=false
, копии создаются только для того, чтобы избежать многократного хранения одного и того же столбца в целевом фрейме данных. Точнее, при первом использовании столбца копирование не производится, но при каждом последующем повторном использовании исходного столбца (при сравнении с использованием===
, которое исключает представления исходных столбцов) создается копия.
Обратите внимание, что при выполнении transform!
или select!
предполагается, что copycols=false
.
Если df
является SubDataFrame
и copycols=true
, возвращается DataFrame
и применяются те же правила копирования, что и для входных данных DataFrame
: это означает, в частности, что выбранные столбцы будут скопированы. При copycols=false
SubDataFrame
возвращается без копирования столбцов, и в этом случае преобразование или переименование столбцов не допускается.
Если передается GroupedDataFrame
и threads=true
(по умолчанию), для каждого указанного преобразования порождается отдельная задача. Затем каждое преобразование порождает столько задач, сколько потоков доступно в Julia, и разделяет обработку групп между ними (однако в настоящее время преобразования с оптимизированной реализацией, такие как sum
, и преобразования, возвращающие несколько строк, используют одну задачу для всех групп). Это позволяет выполнять параллельную работу, если среда Julia была запущена с несколькими потоками. Поэтому передаваемые функции преобразования не должны изменять глобальные переменные (то есть они должны быть чистыми), использовать блокировки для управления параллельным доступом, либо следует передать threads=false
, чтобы отключить многопоточность. В будущем параллелизм может быть распространен и на другие случаи, так что это требование справедливо и для входных данных DataFrame
.
Для повышения производительности операций некоторые преобразования используют оптимизированную реализацию. Дополнительные сведения см. в описании DataFrames.table_transformation
.
Именованные аргументы
-
renamecols::Bool=true
: должны ли автоматически генерируемые имена столбцов в формеcols => function
включать название функций преобразования, или нет. -
ungroup::Bool=true
: должно ли возвращаемое значение операции сgd
быть фреймом данных илиGroupedDataFrame
. -
threads::Bool=true
: могут ли преобразования осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значениеfalse
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Метаданные: эта функция распространяет метаданные на уровне таблиц в стиле :note
. Метаданные на уровне столбцов в стиле :note
распространяются в следующих случаях: а) один столбец преобразуется в один столбец, при этом имя столбца не изменяется (это относится ко всем операциям выбора столбца), или б) один столбец преобразуется с помощью identity
или copy
в один столбец даже при изменении имени столбца (сюда относится и переименование столбца). Особый случай для GroupedDataFrame
: если вывод имеет то же имя, что и группирующий столбец, и keepkeys=true
, метаданные берутся из исходного группирующего столбца.
Примеры см. в описании select
.
#
Random.shuffle
— Function
shuffle([rng=GLOBAL_RNG,] df::AbstractDataFrame)
Возвращает копию df
со случайно перестановленными строками. Необязательный аргумент rng
указывает генератор случайных чисел.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> using Random
julia> rng = MersenneTwister(1234);
julia> shuffle(rng, DataFrame(a=1:5, b=1:5))
5×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 2 2
2 │ 1 1
3 │ 4 4
4 │ 3 3
5 │ 5 5
#
Random.shuffle!
— Function
shuffle!([rng=GLOBAL_RNG,] df::AbstractDataFrame)
Выполняет случайную перестановку строк df
на месте. Необязательный аргумент rng
указывает генератор случайных чисел.
shuffle!
выдаст корректный результат, даже если некоторые столбцы переданного фрейма данных идентичны (проверены с помощью ===
). В противном случае, если два столбца имеют общую часть памяти, но не идентичны (например, являются разными представлениями одного и того же родительского вектора), результат shuffle!
может быть неверным.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные, имеющие другие стили, удаляются (из родительского фрейма данных, если df
является SubDataFrame
).
Примеры
julia> using Random
julia> rng = MersenneTwister(1234);
julia> shuffle!(rng, DataFrame(a=1:5, b=1:5))
5×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 2 2
2 │ 1 1
3 │ 4 4
4 │ 3 3
5 │ 5 5
#
DataFrames.table_transformation
— Function
table_transformation(df_sel::AbstractDataFrame, fun)
Это функция, вызываемая при запросе AsTable(...) => fun
. Аргумент df_sel
представляет собой фрейм данных, хранящий столбцы, выбранные с помощью селектора AsTable(...)
.
По умолчанию он вызывает default_table_transformation
. Однако разрешается добавлять специальные методы для определенных типов fun
, если результат совпадает с тем, что выдает default_table_transformation
, за исключением того, что разрешается выполнять преобразование eltype
результирующих векторов или продвижение типов значений, которые согласованы с promote_type
.
Гарантируется, что df_sel
имеет как минимум один столбец.
Основное назначение специальных методов table_transformation
— обеспечить более эффективную, чем заданную по умолчанию, реализацию запрошенного преобразования fun
.
В будущем эта функция может стать частью общедоступного API пакета DataFrames.jl. Сейчас она должна рассматриваться как экспериментальная.
Быстрые пути реализованы в пакете DataFrames.jl для следующих функций fun
:
-
sum
,ByRow(sum)
,ByRow(sum∘skipmissing)
-
length
,ByRow(length)
,ByRow(length∘skipmissing)
-
mean
,ByRow(mean)
,ByRow(mean∘skipmissing)
-
ByRow(var)
,ByRow(var∘skipmissing)
-
ByRow(std)
,ByRow(std∘skipmissing)
-
ByRow(median)
,ByRow(median∘skipmissing)
-
minimum
,ByRow(minimum)
,ByRow(minimum∘skipmissing)
-
maximum
,ByRow(maximum)
,ByRow(maximum∘skipmissing)
-
fun∘collect
иByRow(fun∘collect)
, гдеfun
является любой функцией
Обратите внимание, что для повышения производительности ByRow(sum)
, ByRow(sum∘skipmissing)
, ByRow(mean)
и ByRow(mean∘skipmissing)
выполняют все операции в целевом типе элемента. В некоторых очень редких случаях (например, смешивание очень больших значений Int64
и значений Float64
) может быть получен результат, отличный от того, который мог бы получен при вызове функции вне DataFrames.jl. Чтобы избежать этой потери точности, следует использовать анонимную функцию, например вместо ByRow(sum)
использовать ByRow(x -> sum(x))
. Однако в целом для таких сценариев не следует рассматривать даже стандартные функции агрегирования, чтобы получить надежный результат, и пользователям рекомендуется перейти на вычисления с более высокой точностью. Ниже приведен пример случая, когда стандартная функция sum
затрагивается обсуждаемой ситуацией.
julia> sum(Any[typemax(Int), typemax(Int), 1.0]) -1.0 julia> sum(Any[1.0, typemax(Int), typemax(Int)]) 1.8446744073709552e19
#
DataFrames.transform
— Function
transform(df::AbstractDataFrame, args...;
copycols::Bool=true, renamecols::Bool=true, threads::Bool=true)
transform(f::Callable, df::DataFrame;
renamecols::Bool=true, threads::Bool=true)
transform(gd::GroupedDataFrame, args...;
copycols::Bool=true, keepkeys::Bool=true, ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
transform(f::Base.Callable, gd::GroupedDataFrame;
copycols::Bool=true, keepkeys::Bool=true, ungroup::Bool=true,
renamecols::Bool=true, threads::Bool=true)
Создает новый фрейм данных, содержащий столбцы из df
или gd
, а также столбцы, указанные с помощью args
, и возвращает его. Результат гарантированно имеет то же количество строк, что и df
. Функция эквивалентна select(df, :, args...)
или select(gd, :, args...)
.
Ниже подробно описаны и сопоставлены общие правила для всех функций преобразования, поддерживаемых DataFrames.jl.
Все эти операции поддерживаются как для AbstractDataFrame
(при пропуске шагов разделения и объединения), так и для GroupedDataFrame
. Технически AbstractDataFrame
считается сгруппированным без столбцов (это означает, что у него есть одна группа или ни одной, если он пуст). Единственное отличие заключается в том, что в этом случае именованные аргументы keepkeys
и ungroup
(описанные ниже) не поддерживаются, и всегда возвращается фрейм данных, поскольку в этом случае нет шагов разделения и объединения.
Чтобы выполнять операции с группами, сначала нужно создать объект GroupedDataFrame
из фрейма данных с помощью функции groupby
, которая принимает два аргумента: (1) фрейм данных, который нужно сгруппировать, и (2) набор столбцов, по которым осуществляется группировка.
Затем можно применить операции к каждой группе с помощью одной из следующих функций:
-
combine
: не накладывает ограничений на количество возвращаемых строк в каждой группе; возвращаемые значения конкатенируются по вертикали в соответствии с порядком групп вGroupedDataFrame
; обычно используется для вычисления сводной статистики по группам; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
select
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая только новые вычисленные столбцы;select!
является версией на месте дляselect
; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
transform
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая все столбцы из исходного фрейма и новые вычисленные столбцы;transform!
является версией на месте дляtransform
; существующие столбцы в исходном фрейме данных помещаются первыми в результат.
Особый случай: если передается GroupedDataFrame
без групп, результат операции определяется путем выполнения одного вызова функции преобразования с переданным ей аргументом с нулем строк. Выходные данные этой операции используются только для определения количества и типа созданных столбцов, но результат не содержит строк.
Все эти функции принимают спецификацию одной или нескольких функций для применения к каждому подмножеству DataFrame
. Эта спецификация может иметь следующий вид:
-
Стандартные селекторы столбцов (целые числа, символы (
Symbol
), строки, векторы целых чисел, векторы символов (Symbol
), векторы строк,All
,Cols
,:
,Between
,Not
и регулярные выражения). -
Пара
cols => function
, указывающая, что функцию (function
) следует вызывать с позиционными аргументами, содержащими столбцыcols
, которые могут быть любым допустимым селектором столбцов. В этом случае имя целевого столбца генерируется автоматически и предполагается, что функция (function
) возвращает единичное значение или вектор. Сгенерированное имя создается путем конкатенации имени исходного столбца и имени функции (function
) по умолчанию (см. примеры ниже). -
Форма
cols => function => target_cols
, дополнительно явно указывающая целевой столбец или столбцы, которые должны быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. Кроме того, это может быть функция (Function
), которая принимает в качестве аргумента строку или вектор строк, содержащие имена столбцов, выбранные с помощьюcols
, и возвращает имена целевых столбцов (допускаются все принятые типы, кромеAsTable
). -
Пара
col => target_cols
, которая переименовывает столбецcol
вtarget_cols
, который должен быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. -
Независимые от столбцов операции
function => target_cols
или простоfunction
для конкретных функций (function
), где входные столбцы опущены; безtarget_cols
новый столбец имеет то же имя, что иfunction
, в противном случае должен быть одним именем (какSymbol
или строка). Поддерживаются следующие функции (function
).-
nrow
для эффективного вычисления количества строк в каждой группе. -
proprow
для эффективного вычисления доли строк в каждой группе. -
eachindex
для возврата вектора, содержащего номер каждой строки в каждой группе. -
groupindices
для возврата номера группы.
-
-
Векторы или матрицы, содержащие преобразования, заданные синтаксисом
Pair
, описываются в пунктах 2—5. -
Функция, которая будет вызвана с
SubDataFrame
, соответствующим каждой группе, если обрабатываетсяGroupedDataFrame
, или с самим фреймом данных, если обрабатываетсяAbstractDataFrame
. Эту форму не рекомендуется использовать из-за ее низкой производительности, за исключением случаев, когда количество групп невелико или обрабатывается очень большое количество столбцов (в этом случаеSubDataFrame
позволяет избежать чрезмерной компиляции).
Примечание. Если передается выражение вида x => y
, то, за исключением специального вспомогательного вида nrow => target_cols
, оно всегда интерпретируется как cols => function
. В частности, следующее выражение function => target_cols
не является допустимой спецификацией преобразования.
Примечание. Если cols
или target_cols
являются All
, Cols
, Between
или Not
, поддерживается трансляция с использованием .=>
, и она эквивалентна трансляции результата names(df, cols)
или names(df, target_cols)
. Это работает, как будто трансляция произошла после замены селектора выбранными именами столбцов в области фрейма данных.
Все функции имеют два типа сигнатур. Один из них принимает GroupedDataFrame
в качестве первого аргумента и произвольное количество преобразований, описанных выше, в качестве последующих аргументов. Второй тип сигнатуры — это когда в качестве первого аргумента передается Function
или Type
и GroupedDataFrame
в качестве второго аргумента (аналогично map
).
Есть особое правило: если при использовании синтаксисов cols => function
и cols => function => target_cols
cols
заключен в объект AsTable
, NamedTuple
, содержащий столбцы, выбранные с помощью cols
, передается function
. Дополнительные сведения см. в документации по DataFrames.table_transformation
, где также рассматриваются вопросы производительности.
Результат, который может возвращать функция (function
), определяется значением target_cols
.
-
Если
cols
иtarget_cols
опущены (передается толькоfunction
), при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
будет создано несколько столбцов. При возврате любого другого значения создается один столбец. -
Если
target_cols
является символом (Symbol
) или строкой, предполагается, что функция возвратит один столбец. В этом случае при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
возникнет ошибка. -
Если
target_cols
является вектором символов (Symbol
) или строк илиAsTable
, предполагается, что функция (function
) возвратит несколько столбцов. Если функция (function
) возвращает какой-либо элемент изAbstractDataFrame
,NamedTuple
,DataFrameRow
,Tables.AbstractRow
,AbstractMatrix
, применяется правило, описанное в пункте 1 выше. Если функция (function
) возвращаетAbstractVector
, каждый элемент этого вектора должен поддерживать функциюkeys
, которая должна возвращать коллекциюSymbol
, строк или целых чисел. Возвращаемое значениеkeys
должно быть одинаковым для всех элементов. Затем создается столько столбцов, сколько элементов содержится в возвращаемом значении функцииkeys
. Еслиtarget_cols
являетсяAsTable
, их имена задаются равными именам ключей, за исключением случаев, когдаkeys
возвращает целые числа, тогда они получают префиксx
(таким образом, имена столбцов будут выглядеть какx1
,x2
и т. д.). Еслиtarget_cols
является вектором символов (Symbol
) или строк, имена столбцов, созданные на основе приведенных выше правил, игнорируются и заменяютсяtarget_cols
(в этом случае количество столбцов должно совпадать с длинойtarget_cols
). Еслиfun
возвращает значение любого другого типа, предполагается, что это таблица, соответствующая API Tables.jl, и для нее вызывается функцияTables.columntable
для получения результирующих столбцов и их имен. Имена сохраняются, когдаtarget_cols
являетсяAsTable
, и заменяются, еслиtarget_cols
является вектором символов (Symbol
) или строк.
Во всех этих случаях функция (function
) может возвращать как одну строку, так и несколько. Как правило, значения, заключенные в Ref
или 0
-мерный массив AbstractArray
, распаковываются и после этого считаются одной строкой.
select
/select!
и transform
/transform!
всегда возвращают фрейм данных с количеством и порядком строк, точно таким же, как у исходного (даже если в GroupedDataFrame
был изменен порядок групп), за исключением случаев, когда в результирующем фрейме данных нет столбцов (в этом случае результат не содержит строк).
Для combine
строки в возвращаемом объекте отображаются в порядке групп в GroupedDataFrame
. Функции могут возвращать произвольное количество строк для каждой группы, но тип возвращаемого объекта и количество и имена столбцов должны быть одинаковыми для всех групп, за исключением случаев, когда возвращаются DataFrame()
или NamedTuple()
, тогда заданная группа пропускается.
Допускается смешивать единичные значения и векторы, если запрашивается несколько преобразований. В этом случае такое значение будет повторяться, чтобы соответствовать длине столбцов, указанных в возвращаемых векторах.
Чтобы применить функцию (function
) к каждой строке, а не ко всем столбцам, ее можно заключить в структуру ByRow
. cols
может быть любым синтаксисом индексирования столбцов. Тогда функции (function
) будет передан один аргумент для каждого из столбцов, указанных с помощью cols
, или NamedTuple
, если указанные столбцы заключены в AsTable
. Если используется ByRow
, cols
может выбрать пустой набор столбцов, тогда function
вызывается для каждой строки без аргументов, и передается пустой NamedTuple
, если в AsTable
заключен пустой набор столбцов.
Если передается коллекция имен столбцов, то принимаются запросы дублирующихся имен столбцов в целевом фрейме данных (например, допускается select!(df, [:a], :, r"a")
), и используется только первое вхождение. В частности, используется следующий синтаксис для перемещения столбца :col
в первую позицию во фрейме данных — select!(df, :col, :)
. Напротив, имена выходных столбцов в операциях переименования, преобразования и выбора одного столбца должны быть уникальными, поэтому, например, select!(df, :a, :a => :a)
или select!(df, :a, :a => ByRow(sin) => :a)
недопустимы.
В общем случае столбцы, возвращаемые преобразованиями, сохраняются в целевом фрейме данных без копирования. Исключением из этого правила являются случаи, когда столбцы из исходного фрейма данных повторно используются в целевом фрейме данных. Это можно сделать с помощью таких выражений, как: :x1
, [:x1, :x2]
, :x1 => :x2
, :x1 => identity => :x2
или :x1 => (x -> @view x[inds])
(обратите внимание, что в последнем случае исходный столбец используется повторно косвенным образом через представление). В таких случаях поведение зависит от значения именованного аргумента copycols
:
-
если
copycols=true
, в результате таких преобразований всегда создается копия исходного столбца или его представления; -
если
copycols=false
, копии создаются только для того, чтобы избежать многократного хранения одного и того же столбца в целевом фрейме данных. Точнее, при первом использовании столбца копирование не производится, но при каждом последующем повторном использовании исходного столбца (при сравнении с использованием===
, которое исключает представления исходных столбцов) создается копия.
Обратите внимание, что при выполнении transform!
или select!
предполагается, что copycols=false
.
Если df
является SubDataFrame
и copycols=true
, возвращается DataFrame
и применяются те же правила копирования, что и для входных данных DataFrame
: это означает, в частности, что выбранные столбцы будут скопированы. При copycols=false
SubDataFrame
возвращается без копирования столбцов, и в этом случае преобразование или переименование столбцов не допускается.
Если передается GroupedDataFrame
и threads=true
(по умолчанию), для каждого указанного преобразования порождается отдельная задача. Затем каждое преобразование порождает столько задач, сколько потоков доступно в Julia, и разделяет обработку групп между ними (однако в настоящее время преобразования с оптимизированной реализацией, такие как sum
, и преобразования, возвращающие несколько строк, используют одну задачу для всех групп). Это позволяет выполнять параллельную работу, если среда Julia была запущена с несколькими потоками. Поэтому передаваемые функции преобразования не должны изменять глобальные переменные (то есть они должны быть чистыми), использовать блокировки для управления параллельным доступом, либо следует передать threads=false
, чтобы отключить многопоточность. В будущем параллелизм может быть распространен и на другие случаи, так что это требование справедливо и для входных данных DataFrame
.
Для повышения производительности операций некоторые преобразования используют оптимизированную реализацию. Дополнительные сведения см. в описании DataFrames.table_transformation
.
Именованные аргументы
-
copycols::Bool=true
: следует ли копировать столбцы исходного фрейма данных, если к ним не применены преобразования. -
renamecols::Bool=true
: должны ли автоматически генерируемые имена столбцов в формеcols => function
включать название функций преобразования, или нет. -
keepkeys::Bool=true
: должны ли группирующие столбцыgd
сохраняться в возвращаемом фрейме данных. -
ungroup::Bool=true
: должно ли возвращаемое значение операции сgd
быть фреймом данных илиGroupedDataFrame
. -
threads::Bool=true
: могут ли преобразования осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значениеfalse
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Обратите внимание, что когда первым аргументом является GroupedDataFrame
, требуется keepkeys=false
, чтобы возвращать другое значение для группирующего столбца.
Метаданные: эта функция распространяет метаданные на уровне таблиц в стиле :note
. Метаданные на уровне столбцов в стиле :note
распространяются в следующих случаях: а) один столбец преобразуется в один столбец, при этом имя столбца не изменяется (это относится ко всем операциям выбора столбца), или б) один столбец преобразуется с помощью identity
или copy
в один столбец даже при изменении имени столбца (сюда относится и переименование столбца). Особый случай для GroupedDataFrame
: если вывод имеет то же имя, что и группирующий столбец, и keepkeys=true
, метаданные берутся из исходного группирующего столбца.
Примеры
julia> gdf = groupby(DataFrame(x=1:2), :x)
GroupedDataFrame with 2 groups based on key: x
First Group (1 row): x = 1
Row │ x
│ Int64
─────┼───────
1 │ 1
⋮
Last Group (1 row): x = 2
Row │ x
│ Int64
─────┼───────
1 │ 2
julia> transform(gdf, x -> (x=10,), keepkeys=false)
2×1 DataFrame
Row │ x
│ Int64
─────┼───────
1 │ 10
2 │ 10
julia> transform(gdf, x -> (x=10,), keepkeys=true)
ERROR: ArgumentError: column :x in returned data frame is not equal to grouping key :x
Дополнительные примеры см. в описании select
.
#
DataFrames.transform!
— Function
transform!(df::AbstractDataFrame, args...;
renamecols::Bool=true, threads::Bool=true)
transform!(args::Callable, df::AbstractDataFrame;
renamecols::Bool=true, threads::Bool=true)
transform!(gd::GroupedDataFrame, args...;
ungroup::Bool=true, renamecols::Bool=true, threads::Bool=true)
transform!(f::Base.Callable, gd::GroupedDataFrame;
ungroup::Bool=true, renamecols::Bool=true, threads::Bool=true)
Изменяет df
или gd
на месте для добавления столбцов, указанных с помощью args...
, и возвращает его. Результат гарантированно имеет то же количество строк, что и df
или Функция эквивалентна select!(df, :, args...)
или select!(gd, :, args...)
, за исключением того, что при каждом переименовании столбца создается копия.
Ниже подробно описаны и сопоставлены общие правила для всех функций преобразования, поддерживаемых DataFrames.jl.
Все эти операции поддерживаются как для AbstractDataFrame
(при пропуске шагов разделения и объединения), так и для GroupedDataFrame
. Технически AbstractDataFrame
считается сгруппированным без столбцов (это означает, что у него есть одна группа или ни одной, если он пуст). Единственное отличие заключается в том, что в этом случае именованные аргументы keepkeys
и ungroup
(описанные ниже) не поддерживаются, и всегда возвращается фрейм данных, поскольку в этом случае нет шагов разделения и объединения.
Чтобы выполнять операции с группами, сначала нужно создать объект GroupedDataFrame
из фрейма данных с помощью функции groupby
, которая принимает два аргумента: (1) фрейм данных, который нужно сгруппировать, и (2) набор столбцов, по которым осуществляется группировка.
Затем можно применить операции к каждой группе с помощью одной из следующих функций:
-
combine
: не накладывает ограничений на количество возвращаемых строк в каждой группе; возвращаемые значения конкатенируются по вертикали в соответствии с порядком групп вGroupedDataFrame
; обычно используется для вычисления сводной статистики по группам; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
select
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая только новые вычисленные столбцы;select!
является версией на месте дляselect
; дляGroupedDataFrame
, если группирующие столбцы сохраняются, они помещаются первыми в результат; -
transform
: возвращает фрейм данных с количеством и порядком строк, точно таким же, как в исходном фрейме данных, включая все столбцы из исходного фрейма и новые вычисленные столбцы;transform!
является версией на месте дляtransform
; существующие столбцы в исходном фрейме данных помещаются первыми в результат.
Особый случай: если передается GroupedDataFrame
без групп, результат операции определяется путем выполнения одного вызова функции преобразования с переданным ей аргументом с нулем строк. Выходные данные этой операции используются только для определения количества и типа созданных столбцов, но результат не содержит строк.
Все эти функции принимают спецификацию одной или нескольких функций для применения к каждому подмножеству DataFrame
. Эта спецификация может иметь следующий вид:
-
Стандартные селекторы столбцов (целые числа, символы (
Symbol
), строки, векторы целых чисел, векторы символов (Symbol
), векторы строк,All
,Cols
,:
,Between
,Not
и регулярные выражения). -
Пара
cols => function
, указывающая, что функцию (function
) следует вызывать с позиционными аргументами, содержащими столбцыcols
, которые могут быть любым допустимым селектором столбцов. В этом случае имя целевого столбца генерируется автоматически и предполагается, что функция (function
) возвращает единичное значение или вектор. Сгенерированное имя создается путем конкатенации имени исходного столбца и имени функции (function
) по умолчанию (см. примеры ниже). -
Форма
cols => function => target_cols
, дополнительно явно указывающая целевой столбец или столбцы, которые должны быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. Кроме того, это может быть функция (Function
), которая принимает в качестве аргумента строку или вектор строк, содержащие имена столбцов, выбранные с помощьюcols
, и возвращает имена целевых столбцов (допускаются все принятые типы, кромеAsTable
). -
Пара
col => target_cols
, которая переименовывает столбецcol
вtarget_cols
, который должен быть одним именем (какSymbol
или строка), вектором имен илиAsTable
. -
Независимые от столбцов операции
function => target_cols
или простоfunction
для конкретных функций (function
), где входные столбцы опущены; безtarget_cols
новый столбец имеет то же имя, что иfunction
, в противном случае должен быть одним именем (какSymbol
или строка). Поддерживаются следующие функции (function
).-
nrow
для эффективного вычисления количества строк в каждой группе. -
proprow
для эффективного вычисления доли строк в каждой группе. -
eachindex
для возврата вектора, содержащего номер каждой строки в каждой группе. -
groupindices
для возврата номера группы.
-
-
Векторы или матрицы, содержащие преобразования, заданные синтаксисом
Pair
, описываются в пунктах 2—5. -
Функция, которая будет вызвана с
SubDataFrame
, соответствующим каждой группе, если обрабатываетсяGroupedDataFrame
, или с самим фреймом данных, если обрабатываетсяAbstractDataFrame
. Эту форму не рекомендуется использовать из-за ее низкой производительности, за исключением случаев, когда количество групп невелико или обрабатывается очень большое количество столбцов (в этом случаеSubDataFrame
позволяет избежать чрезмерной компиляции).
Примечание. Если передается выражение вида x => y
, то, за исключением специального вспомогательного вида nrow => target_cols
, оно всегда интерпретируется как cols => function
. В частности, следующее выражение function => target_cols
не является допустимой спецификацией преобразования.
Примечание. Если cols
или target_cols
являются All
, Cols
, Between
или Not
, поддерживается трансляция с использованием .=>
, и она эквивалентна трансляции результата names(df, cols)
или names(df, target_cols)
. Это работает, как будто трансляция произошла после замены селектора выбранными именами столбцов в области фрейма данных.
Все функции имеют два типа сигнатур. Один из них принимает GroupedDataFrame
в качестве первого аргумента и произвольное количество преобразований, описанных выше, в качестве последующих аргументов. Второй тип сигнатуры — это когда в качестве первого аргумента передается Function
или Type
и GroupedDataFrame
в качестве второго аргумента (аналогично map
).
Есть особое правило: если при использовании синтаксисов cols => function
и cols => function => target_cols
cols
заключен в объект AsTable
, NamedTuple
, содержащий столбцы, выбранные с помощью cols
, передается function
. Дополнительные сведения см. в документации по DataFrames.table_transformation
, где также рассматриваются вопросы производительности.
Результат, который может возвращать функция (function
), определяется значением target_cols
.
-
Если
cols
иtarget_cols
опущены (передается толькоfunction
), при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
будет создано несколько столбцов. При возврате любого другого значения создается один столбец. -
Если
target_cols
является символом (Symbol
) или строкой, предполагается, что функция возвратит один столбец. В этом случае при возврате фрейма данных, матрицы,NamedTuple
,Tables.AbstractRow
илиDataFrameRow
возникнет ошибка. -
Если
target_cols
является вектором символов (Symbol
) или строк илиAsTable
, предполагается, что функция (function
) возвратит несколько столбцов. Если функция (function
) возвращает какой-либо элемент изAbstractDataFrame
,NamedTuple
,DataFrameRow
,Tables.AbstractRow
,AbstractMatrix
, применяется правило, описанное в пункте 1 выше. Если функция (function
) возвращаетAbstractVector
, каждый элемент этого вектора должен поддерживать функциюkeys
, которая должна возвращать коллекциюSymbol
, строк или целых чисел. Возвращаемое значениеkeys
должно быть одинаковым для всех элементов. Затем создается столько столбцов, сколько элементов содержится в возвращаемом значении функцииkeys
. Еслиtarget_cols
являетсяAsTable
, их имена задаются равными именам ключей, за исключением случаев, когдаkeys
возвращает целые числа, тогда они получают префиксx
(таким образом, имена столбцов будут выглядеть какx1
,x2
и т. д.). Еслиtarget_cols
является вектором символов (Symbol
) или строк, имена столбцов, созданные на основе приведенных выше правил, игнорируются и заменяютсяtarget_cols
(в этом случае количество столбцов должно совпадать с длинойtarget_cols
). Еслиfun
возвращает значение любого другого типа, предполагается, что это таблица, соответствующая API Tables.jl, и для нее вызывается функцияTables.columntable
для получения результирующих столбцов и их имен. Имена сохраняются, когдаtarget_cols
являетсяAsTable
, и заменяются, еслиtarget_cols
является вектором символов (Symbol
) или строк.
Во всех этих случаях функция (function
) может возвращать как одну строку, так и несколько. Как правило, значения, заключенные в Ref
или 0
-мерный массив AbstractArray
, распаковываются и после этого считаются одной строкой.
select
/select!
и transform
/transform!
всегда возвращают фрейм данных с количеством и порядком строк, точно таким же, как у исходного (даже если в GroupedDataFrame
был изменен порядок групп), за исключением случаев, когда в результирующем фрейме данных нет столбцов (в этом случае результат не содержит строк).
Для combine
строки в возвращаемом объекте отображаются в порядке групп в GroupedDataFrame
. Функции могут возвращать произвольное количество строк для каждой группы, но тип возвращаемого объекта и количество и имена столбцов должны быть одинаковыми для всех групп, за исключением случаев, когда возвращаются DataFrame()
или NamedTuple()
, тогда заданная группа пропускается.
Допускается смешивать единичные значения и векторы, если запрашивается несколько преобразований. В этом случае такое значение будет повторяться, чтобы соответствовать длине столбцов, указанных в возвращаемых векторах.
Чтобы применить функцию (function
) к каждой строке, а не ко всем столбцам, ее можно заключить в структуру ByRow
. cols
может быть любым синтаксисом индексирования столбцов. Тогда функции (function
) будет передан один аргумент для каждого из столбцов, указанных с помощью cols
, или NamedTuple
, если указанные столбцы заключены в AsTable
. Если используется ByRow
, cols
может выбрать пустой набор столбцов, тогда function
вызывается для каждой строки без аргументов, и передается пустой NamedTuple
, если в AsTable
заключен пустой набор столбцов.
Если передается коллекция имен столбцов, то принимаются запросы дублирующихся имен столбцов в целевом фрейме данных (например, допускается select!(df, [:a], :, r"a")
), и используется только первое вхождение. В частности, используется следующий синтаксис для перемещения столбца :col
в первую позицию во фрейме данных — select!(df, :col, :)
. Напротив, имена выходных столбцов в операциях переименования, преобразования и выбора одного столбца должны быть уникальными, поэтому, например, select!(df, :a, :a => :a)
или select!(df, :a, :a => ByRow(sin) => :a)
недопустимы.
В общем случае столбцы, возвращаемые преобразованиями, сохраняются в целевом фрейме данных без копирования. Исключением из этого правила являются случаи, когда столбцы из исходного фрейма данных повторно используются в целевом фрейме данных. Это можно сделать с помощью таких выражений, как: :x1
, [:x1, :x2]
, :x1 => :x2
, :x1 => identity => :x2
или :x1 => (x -> @view x[inds])
(обратите внимание, что в последнем случае исходный столбец используется повторно косвенным образом через представление). В таких случаях поведение зависит от значения именованного аргумента copycols
:
-
если
copycols=true
, в результате таких преобразований всегда создается копия исходного столбца или его представления; -
если
copycols=false
, копии создаются только для того, чтобы избежать многократного хранения одного и того же столбца в целевом фрейме данных. Точнее, при первом использовании столбца копирование не производится, но при каждом последующем повторном использовании исходного столбца (при сравнении с использованием===
, которое исключает представления исходных столбцов) создается копия.
Обратите внимание, что при выполнении transform!
или select!
предполагается, что copycols=false
.
Если df
является SubDataFrame
и copycols=true
, возвращается DataFrame
и применяются те же правила копирования, что и для входных данных DataFrame
: это означает, в частности, что выбранные столбцы будут скопированы. При copycols=false
SubDataFrame
возвращается без копирования столбцов, и в этом случае преобразование или переименование столбцов не допускается.
Если передается GroupedDataFrame
и threads=true
(по умолчанию), для каждого указанного преобразования порождается отдельная задача. Затем каждое преобразование порождает столько задач, сколько потоков доступно в Julia, и разделяет обработку групп между ними (однако в настоящее время преобразования с оптимизированной реализацией, такие как sum
, и преобразования, возвращающие несколько строк, используют одну задачу для всех групп). Это позволяет выполнять параллельную работу, если среда Julia была запущена с несколькими потоками. Поэтому передаваемые функции преобразования не должны изменять глобальные переменные (то есть они должны быть чистыми), использовать блокировки для управления параллельным доступом, либо следует передать threads=false
, чтобы отключить многопоточность. В будущем параллелизм может быть распространен и на другие случаи, так что это требование справедливо и для входных данных DataFrame
.
Для повышения производительности операций некоторые преобразования используют оптимизированную реализацию. Дополнительные сведения см. в описании DataFrames.table_transformation
.
Именованные аргументы
-
renamecols::Bool=true
: должны ли автоматически генерируемые имена столбцов в формеcols => function
включать название функций преобразования, или нет. -
ungroup::Bool=true
: должно ли возвращаемое значение операции сgd
быть фреймом данных илиGroupedDataFrame
. -
threads::Bool=true
: могут ли преобразования осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значениеfalse
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Метаданные: эта функция распространяет метаданные на уровне таблиц в стиле :note
. Метаданные на уровне столбцов в стиле :note
распространяются в следующих случаях: а) один столбец преобразуется в один столбец, при этом имя столбца не изменяется (это относится ко всем операциям выбора столбца), или б) один столбец преобразуется с помощью identity
или copy
в один столбец даже при изменении имени столбца (сюда относится и переименование столбца). Особый случай для GroupedDataFrame
: если вывод имеет то же имя, что и группирующий столбец, и keepkeys=true
, метаданные берутся из исходного группирующего столбца.
Примеры см. в описании select
.
#
Base.vcat
— Function
vcat(dfs::AbstractDataFrame...;
cols::Union{Symbol, AbstractVector{Symbol},
AbstractVector{<:AbstractString}}=:setequal,
source::Union{Nothing, Symbol, AbstractString,
Pair{<:Union{Symbol, AbstractString}, <:AbstractVector}}=nothing)
Выполняет вертикальную конкатенацию AbstractDataFrame
.
Именованный аргумент cols
определяет столбцы в возвращаемом фрейме данных.
-
:setequal
: требует, чтобы все фреймы данных имели одинаковые имена столбцов без учета порядка. Если они появляются в разных порядках, используется порядок первого предоставленного фрейма данных. -
:orderequal
: требует, чтобы все фреймы данных имели одинаковые имена столбцов и находились в одинаковом порядке. -
:intersect
: сохраняются только столбцы, присутствующие во всех предоставленных фреймах данных. Если пересечение пусто, возвращается пустой фрейм данных. -
:union
: сохраняются столбцы, присутствующие как минимум в одном из предоставленных фреймов данных. Столбцы, отсутствующие в некоторых фреймах данных, заполняютсяmissing
, где это необходимо. -
Вектор
Symbol
или строк: сохраняются только перечисленные столбцы. Столбцы, отсутствующие в некоторых фреймах данных, заполняютсяmissing
, где это необходимо.
Именованный аргумент source
, если не nothing
(по умолчанию), указывает дополнительный столбец, который будет добавлен в последнюю позицию результирующего фрейма данных, который будет идентифицировать исходный фрейм данных. Это может быть Symbol
или AbstractString
, в этом случае идентификатором будет номер переданного исходного фрейма данных, или пара (Pair
), состоящая из Symbol
или AbstractString
и вектора, задающего идентификаторы фреймов данных (которые не обязательно должны быть уникальными). Имя исходного столбца не должно присутствовать ни в одном исходном фрейме данных.
Порядок столбцов определяется порядком их появления во включенных фреймах данных. Поиск осуществляется по заголовку первого фрейма данных, затем второго и т. д.
Типы элементов столбцов определяются с помощью promote_type
, как и в случае с vcat
для AbstractVector
.
vcat
игнорирует пустые фреймы данных при формировании результата (за исключением метаданных), что позволяет инициализировать пустой фрейм данных в начале цикла и выполнять его вертикальную конкатенацию (vcat
).
Метаданные: функция vcat
распространяет метаданные на уровне таблиц в стиле :note
для ключей, присутствующих во всех передаваемых фреймах данных и имеющих одинаковое значение. Функция vcat
распространяет метаданные на уровне столбцов в стиле :note
для ключей, присутствующих во всех передаваемых фреймах данных, содержащих этот столбец, и имеющих одинаковое значение.
Пример
julia> df1 = DataFrame(A=1:3, B=1:3)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
julia> df2 = DataFrame(A=4:6, B=4:6)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 4 4
2 │ 5 5
3 │ 6 6
julia> df3 = DataFrame(A=7:9, C=7:9)
3×2 DataFrame
Row │ A C
│ Int64 Int64
─────┼──────────────
1 │ 7 7
2 │ 8 8
3 │ 9 9
julia> df4 = DataFrame()
0×0 DataFrame
julia> vcat(df1, df2)
6×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
4 │ 4 4
5 │ 5 5
6 │ 6 6
julia> vcat(df1, df3, cols=:union)
6×3 DataFrame
Row │ A B C
│ Int64 Int64? Int64?
─────┼─────────────────────────
1 │ 1 1 missing
2 │ 2 2 missing
3 │ 3 3 missing
4 │ 7 missing 7
5 │ 8 missing 8
6 │ 9 missing 9
julia> vcat(df1, df3, cols=:intersect)
6×1 DataFrame
Row │ A
│ Int64
─────┼───────
1 │ 1
2 │ 2
3 │ 3
4 │ 7
5 │ 8
6 │ 9
julia> vcat(df4, df1)
3×2 DataFrame
Row │ A B
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 3
julia> vcat(df1, df2, df3, df4, cols=:union, source="source")
9×4 DataFrame
Row │ A B C source
│ Int64 Int64? Int64? Int64
─────┼─────────────────────────────────
1 │ 1 1 missing 1
2 │ 2 2 missing 1
3 │ 3 3 missing 1
4 │ 4 4 missing 2
5 │ 5 5 missing 2
6 │ 6 6 missing 2
7 │ 7 missing 7 3
8 │ 8 missing 8 3
9 │ 9 missing 9 3
julia> vcat(df1, df2, df4, df3, cols=:union, source=:source => 'a':'d')
9×4 DataFrame
Row │ A B C source
│ Int64 Int64? Int64? Char
─────┼─────────────────────────────────
1 │ 1 1 missing a
2 │ 2 2 missing a
3 │ 3 3 missing a
4 │ 4 4 missing b
5 │ 5 5 missing b
6 │ 6 6 missing b
7 │ 7 missing 7 d
8 │ 8 missing 8 d
9 │ 9 missing 9 d
Изменение формы фреймов данных с высокой на широкую и наоборот
#
Base.stack
— Function
stack(df::AbstractDataFrame[, measure_vars[, id_vars] ];
variable_name=:variable, value_name=:value,
view::Bool=false, variable_eltype::Type=String)
Выполняет наложение фрейма данных df
, т. е. преобразует его из широкого формата в длинный.
Возвращает длинноформатный DataFrame
, содержащий столбцы для каждого id_vars
, столбец value_name
(:value
по умолчанию), содержащий значения наложенных столбцов (measure_vars
), и столбец variable_name
(:variable
по умолчанию) — вектор, содержащий имя соответствующей переменной measure_vars
.
Если view=true
, возвращает многослойное представление фрейма данных (длинный формат). Результатом является представление, поскольку столбцы представляют собой особые AbstractVectors
, которые возвращают представления в исходный фрейм данных.
Аргументы
-
df
: AbstractDataFrame для наложения. -
measure_vars
: столбцы для наложения (переменные измерения), в виде селектора столбцов (символ (Symbol
), строка или целое число;:
,Cols
,All
,Between
,Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). Еслиmeasure_vars
илиid_vars
не заданы, дляmeasure_vars
по умолчанию используются все столбцы с плавающей запятой. -
id_vars
: столбцы указателей, которые повторяются при наложении, в виде селектора столбцов (символ (Symbol
), строка или целое число;:
,Cols
,All
,Between
,Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). По умолчанию используются все переменные, которые не являютсяmeasure_vars
. -
variable_name
: имя (Symbol
или строка) нового наложенного столбца, в котором будут храниться имена каждой переменнойmeasure_vars
. -
value_name
: имя (Symbol
или строка) нового наложенного столбца, содержащего значения из каждой переменнойmeasure_vars
. -
view
: должен ли наложенный фрейм данных быть представлением, а не содержать только что выделенные векторы. -
variable_eltype
: определяет тип элемента столбцаvariable_name
. По умолчанию создаетсяPooledArray{String}
. Еслиvariable_eltype=Symbol
, создаетсяPooledVector{Symbol}
, а еслиvariable_eltype=CategoricalValue{String}
, создаетсяCategoricalArray{String}
(при необходимости сначала следует вызыватьusing CategoricalArrays
). При передаче любого другого типаT
будет создан столбецPooledVector{T}
, если он поддерживает преобразование изString
. Еслиview=true
, создаетсяRepeatedVector{T}
.
Метаданные: метаданные на уровне таблиц в стиле :note
и метаданные на уровне столбцов в стиле :note
для столбцов указателей.
Примеры
julia> df = DataFrame(a=repeat(1:3, inner=2),
b=repeat(1:2, inner=3),
c=repeat(1:1, inner=6),
d=repeat(1:6, inner=1),
e=string.('a':'f'))
6×5 DataFrame
Row │ a b c d e
│ Int64 Int64 Int64 Int64 String
─────┼────────────────────────────────────
1 │ 1 1 1 1 a
2 │ 1 1 1 2 b
3 │ 2 1 1 3 c
4 │ 2 2 1 4 d
5 │ 3 2 1 5 e
6 │ 3 2 1 6 f
julia> stack(df, [:c, :d])
12×5 DataFrame
Row │ a b e variable value
│ Int64 Int64 String String Int64
─────┼───────────────────────────────────────
1 │ 1 1 a c 1
2 │ 1 1 b c 1
3 │ 2 1 c c 1
4 │ 2 2 d c 1
5 │ 3 2 e c 1
6 │ 3 2 f c 1
7 │ 1 1 a d 1
8 │ 1 1 b d 2
9 │ 2 1 c d 3
10 │ 2 2 d d 4
11 │ 3 2 e d 5
12 │ 3 2 f d 6
julia> stack(df, [:c, :d], [:a])
12×3 DataFrame
Row │ a variable value
│ Int64 String Int64
─────┼────────────────────────
1 │ 1 c 1
2 │ 1 c 1
3 │ 2 c 1
4 │ 2 c 1
5 │ 3 c 1
6 │ 3 c 1
7 │ 1 d 1
8 │ 1 d 2
9 │ 2 d 3
10 │ 2 d 4
11 │ 3 d 5
12 │ 3 d 6
julia> stack(df, Not([:a, :b, :e]))
12×5 DataFrame
Row │ a b e variable value
│ Int64 Int64 String String Int64
─────┼───────────────────────────────────────
1 │ 1 1 a c 1
2 │ 1 1 b c 1
3 │ 2 1 c c 1
4 │ 2 2 d c 1
5 │ 3 2 e c 1
6 │ 3 2 f c 1
7 │ 1 1 a d 1
8 │ 1 1 b d 2
9 │ 2 1 c d 3
10 │ 2 2 d d 4
11 │ 3 2 e d 5
12 │ 3 2 f d 6
julia> stack(df, Not([:a, :b, :e]), variable_name=:somemeasure)
12×5 DataFrame
Row │ a b e somemeasure value
│ Int64 Int64 String String Int64
─────┼──────────────────────────────────────────
1 │ 1 1 a c 1
2 │ 1 1 b c 1
3 │ 2 1 c c 1
4 │ 2 2 d c 1
5 │ 3 2 e c 1
6 │ 3 2 f c 1
7 │ 1 1 a d 1
8 │ 1 1 b d 2
9 │ 2 1 c d 3
10 │ 2 2 d d 4
11 │ 3 2 e d 5
12 │ 3 2 f d 6
#
DataFrames.unstack
— Function
unstack(df::AbstractDataFrame, rowkeys, colkey, value;
renamecols::Function=identity, allowmissing::Bool=false,
combine=only, fill=missing, threads::Bool=true)
unstack(df::AbstractDataFrame, colkey, value;
renamecols::Function=identity, allowmissing::Bool=false,
combine=only, fill=missing, threads::Bool=true)
unstack(df::AbstractDataFrame;
renamecols::Function=identity, allowmissing::Bool=false,
combine=only, fill=missing, threads::Bool=true)
Отменяет наложение фрейма данных df
, т. е. преобразует его из длинного формата в широкий.
Ключи строк и столбцов упорядочиваются в порядке их первого появления.
Позиционные аргументы
-
df
: AbstractDataFrame, для которого будет отменено наложение -
rowkeys
: столбцы с уникальным ключом для каждой строки. Если не задан, поиск ключа осуществляется путем группировки по всему, что не являетсяcolkey
илиvalue
. Это может быть любой селектор столбцов (символ (Symbol
), строка или целое число;:
,Cols
,All
,Between
,Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). Еслиrowkeys
не содержит столбцов, предполагается, что все строки имеют одинаковый ключ. -
colkey
: столбец (Symbol
, строка или целое число) содержащий имена столбцов в широком формате, по умолчанию имеет значение:variable
. -
values
: столбец, хранящий значения (Symbol
, строка или целое число), по умолчанию имеет значение:value
.
Именованные аргументы
-
renamecols
: функция, вызываемая для каждого уникального значения вcolkey
. Она должна возвращать имя создаваемого столбца (обычно в виде строки илиSymbol
). Дубликаты в результирующих именах при преобразовании вSymbol
не допускаются. По умолчанию преобразования не выполняются. -
allowmissing
: еслиfalse
(по умолчанию), возникает ошибка, еслиcolkey
содержит значенияmissing
. Еслиtrue
, создается столбец, ссылающийся на отсутствующее (missing
) значение. -
combine
: еслиonly
(по умолчанию), возникает ошибка, если сочетаниеrowkeys
иcolkey
содержит повторяющиеся записи. В противном случае передаваемое значение должно быть функцией, которая вызывается для представления вектора, содержащего все элементы для каждого сочетанияrowkeys
иcolkey
, присутствующих в данных. -
fill
: этим значением заполняются сочетания отсутствующих строк или столбцов. Аргумент по умолчанию —missing
. Если столбецvalue
являетсяCategoricalVector
иfill
не задано значениеmissing
, то, чтобы неналоженные столбцы значений также являлисьCategoricalVector
,fill
должен быть передан какCategoricalValue
. -
threads
: может ли функцияcombine
выполняться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Задано значениеfalse
, если дляcombine
требуется последовательное выполнение или он не является потокобезопасным.
Метаданные: метаданные на уровне таблиц в стиле :note
и метаданные на уровне столбцов в стиле :note
для столбцов ключей строк сохраняются.
Нерекомендуемые аргументы
-
Именованный аргумент
allowduplicates
устарел. Вместо него следует использовать именованный аргументcombine
. Эквивалентомallowduplicates=true
являетсяcombine=last
, а эквивалентомallowduplicates=false
—combine=only
(по умолчанию).
Примеры
julia> wide = DataFrame(id=1:6,
a=repeat(1:3, inner=2),
b=repeat(1.0:2.0, inner=3),
c=repeat(1.0:1.0, inner=6),
d=repeat(1.0:3.0, inner=2))
6×5 DataFrame
Row │ id a b c d
│ Int64 Int64 Float64 Float64 Float64
─────┼─────────────────────────────────────────
1 │ 1 1 1.0 1.0 1.0
2 │ 2 1 1.0 1.0 1.0
3 │ 3 2 1.0 1.0 2.0
4 │ 4 2 2.0 1.0 2.0
5 │ 5 3 2.0 1.0 3.0
6 │ 6 3 2.0 1.0 3.0
julia> long = stack(wide)
18×4 DataFrame
Row │ id a variable value
│ Int64 Int64 String Float64
─────┼─────────────────────────────────
1 │ 1 1 b 1.0
2 │ 2 1 b 1.0
3 │ 3 2 b 1.0
4 │ 4 2 b 2.0
5 │ 5 3 b 2.0
6 │ 6 3 b 2.0
7 │ 1 1 c 1.0
8 │ 2 1 c 1.0
⋮ │ ⋮ ⋮ ⋮ ⋮
12 │ 6 3 c 1.0
13 │ 1 1 d 1.0
14 │ 2 1 d 1.0
15 │ 3 2 d 2.0
16 │ 4 2 d 2.0
17 │ 5 3 d 3.0
18 │ 6 3 d 3.0
3 rows omitted
julia> unstack(long)
6×5 DataFrame
Row │ id a b c d
│ Int64 Int64 Float64? Float64? Float64?
─────┼────────────────────────────────────────────
1 │ 1 1 1.0 1.0 1.0
2 │ 2 1 1.0 1.0 1.0
3 │ 3 2 1.0 1.0 2.0
4 │ 4 2 2.0 1.0 2.0
5 │ 5 3 2.0 1.0 3.0
6 │ 6 3 2.0 1.0 3.0
julia> unstack(long, :variable, :value)
6×5 DataFrame
Row │ id a b c d
│ Int64 Int64 Float64? Float64? Float64?
─────┼────────────────────────────────────────────
1 │ 1 1 1.0 1.0 1.0
2 │ 2 1 1.0 1.0 1.0
3 │ 3 2 1.0 1.0 2.0
4 │ 4 2 2.0 1.0 2.0
5 │ 5 3 2.0 1.0 3.0
6 │ 6 3 2.0 1.0 3.0
julia> unstack(long, :id, :variable, :value)
6×4 DataFrame
Row │ id b c d
│ Int64 Float64? Float64? Float64?
─────┼─────────────────────────────────────
1 │ 1 1.0 1.0 1.0
2 │ 2 1.0 1.0 1.0
3 │ 3 1.0 1.0 2.0
4 │ 4 2.0 1.0 2.0
5 │ 5 2.0 1.0 3.0
6 │ 6 2.0 1.0 3.0
julia> unstack(long, [:id, :a], :variable, :value)
6×5 DataFrame
Row │ id a b c d
│ Int64 Int64 Float64? Float64? Float64?
─────┼────────────────────────────────────────────
1 │ 1 1 1.0 1.0 1.0
2 │ 2 1 1.0 1.0 1.0
3 │ 3 2 1.0 1.0 2.0
4 │ 4 2 2.0 1.0 2.0
5 │ 5 3 2.0 1.0 3.0
6 │ 6 3 2.0 1.0 3.0
julia> unstack(long, :id, :variable, :value, renamecols=x->Symbol(:_, x))
6×4 DataFrame
Row │ id _b _c _d
│ Int64 Float64? Float64? Float64?
─────┼─────────────────────────────────────
1 │ 1 1.0 1.0 1.0
2 │ 2 1.0 1.0 1.0
3 │ 3 1.0 1.0 2.0
4 │ 4 2.0 1.0 2.0
5 │ 5 2.0 1.0 3.0
6 │ 6 2.0 1.0 3.0
Обратите внимание, что между приведенными выше расширенными результатами есть некоторые различия.
julia> df = DataFrame(id=["1", "1", "2"],
variable=["Var1", "Var2", "Var1"],
value=[1, 2, 3])
3×3 DataFrame
Row │ id variable value
│ String String Int64
─────┼─────────────────────────
1 │ 1 Var1 1
2 │ 1 Var2 2
3 │ 2 Var1 3
julia> unstack(df, :variable, :value, fill=0)
2×3 DataFrame
Row │ id Var1 Var2
│ String Int64 Int64
─────┼──────────────────────
1 │ 1 1 2
2 │ 2 3 0
julia> df = DataFrame(cols=["a", "a", "b"], values=[1, 2, 4])
3×2 DataFrame
Row │ cols values
│ String Int64
─────┼────────────────
1 │ a 1
2 │ a 2
3 │ b 4
julia> unstack(df, :cols, :values, combine=copy)
1×2 DataFrame
Row │ a b
│ Array…? Array…?
─────┼──────────────────
1 │ [1, 2] [4]
julia> unstack(df, :cols, :values, combine=sum)
1×2 DataFrame
Row │ a b
│ Int64? Int64?
─────┼────────────────
1 │ 3 4
#
Base.permutedims
— Function
permutedims(df::AbstractDataFrame,
[src_namescol::Union{Int, Symbol, AbstractString}],
[dest_namescol::Union{Symbol, AbstractString}];
makeunique::Bool=false, strict::Bool=true)
Поворачивает df
на бок, чтобы строки стали столбцами, а значения в столбце, проиндексированном с помощью src_namescol
, стали именами новых столбцов. В результирующем DataFrame
имена столбцов df
станут первым столбцом с именем, указанным с помощью dest_namescol
.
Аргументы
-
df
:AbstractDataFrame
-
src_namescol
: столбец, который станет первым заголовком. Если не указан, имена столбцов:x1
,:x2
и т. д. генерируются автоматически. -
dest_namescol
: имя первого столбца в возвращаемомDataFrame
. По умолчанию используется то же имя, что и уsrc_namescol
. Не поддерживается, еслиsrc_namescol
является вектором или опущен. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
(i
, начиная с 1 для первого повторяющегося имени). Не поддерживается, еслиsrc_namescol
опущен. -
strict
: если задано значениеtrue
(по умолчанию), возникает ошибка, если все значения, содержащиеся вsrc_namescol
, не являютсяSymbol
или все являютсяAbstractString
либо могут быть преобразованы вString
с помощьюconvert
. Еслиfalse
все значения принимаются и будут изменены в строки с помощью функцииstring
. Не поддерживается, еслиsrc_namescol
является вектором или опущен.
Примечание. Типы элементов столбцов в результирующем DataFrame
(кроме первого столбца, если он создан из имен столбцов df
, который всегда имеет тип элемента String
) будут зависеть от типов элементов всех входных столбцов на основе результата promote_type
. То есть если исходный фрейм данных содержит столбцы Int
и Float64
, результирующие столбцы будут иметь тип элемента Float64
. Если в источнике есть столбцы Int
и String
, результирующие столбцы будут иметь тип элемента Any
.
Метаданные: метаданные на уровне таблиц в стиле :note
сохраняются, а метаданные на уровне столбцов удаляются.
Примеры
julia> df = DataFrame(a=1:2, b=3:4)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 3
2 │ 2 4
julia> permutedims(df)
2×2 DataFrame
Row │ x1 x2
│ Int64 Int64
─────┼──────────────
1 │ 1 2
2 │ 3 4
julia> permutedims(df, [:p, :q])
2×2 DataFrame
Row │ p q
│ Int64 Int64
─────┼──────────────
1 │ 1 2
2 │ 3 4
julia> df1 = DataFrame(a=["x", "y"], b=[1.0, 2.0], c=[3, 4], d=[true, false])
2×4 DataFrame
Row │ a b c d
│ String Float64 Int64 Bool
─────┼───────────────────────────────
1 │ x 1.0 3 true
2 │ y 2.0 4 false
julia> permutedims(df1, 1) # запомните типы столбцов
3×3 DataFrame
Row │ a x y
│ String Float64 Float64
─────┼──────────────────────────
1 │ b 1.0 2.0
2 │ c 3.0 4.0
3 │ d 1.0 0.0
julia> df2 = DataFrame(a=["x", "y"], b=[1, "two"], c=[3, 4], d=[true, false])
2×4 DataFrame
Row │ a b c d
│ String Any Int64 Bool
─────┼───────────────────────────
1 │ x 1 3 true
2 │ y two 4 false
julia> permutedims(df2, 1, "different_name")
3×3 DataFrame
Row │ different_name x y
│ String Any Any
─────┼─────────────────────────────
1 │ b 1 two
2 │ c 3 4
3 │ d true false
Сортировка
#
Base.issorted
— Function
issorted(df::AbstractDataFrame, cols=All();
lt::Union{Function, AbstractVector{<:Function}}=isless,
by::Union{Function, AbstractVector{<:Function}}=identity,
rev::Union{Bool, AbstractVector{Bool}}=false,
order::Union{Ordering, AbstractVector{<:Ordering}}=Forward,
checkunique::Bool=false)
Проверяет, отсортирован ли фрейм данных df
по столбцам cols
. Проверка сортировки по нескольким столбцам выполняется лексикографически.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). Если cols
не выбирает столбцы, проверьте, сортируется ли df
по всем столбцам (это поведение устарело и будет изменено в будущих версиях).
Если rev
имеет значение true
, выполняется обратная сортировка. Чтобы включить обратную сортировку только для некоторых столбцов, передайте order(c, rev=true)
в cols
, где c
соответствует индексу столбца (см. пример ниже).
Поскольку при наличии повторяющихся элементов допустимы несколько порядков сортировки, ключевое слово checkunique
позволяет обнаруживать подобные ситуации. Если checkunique
является true
и найдены повторяющиеся элементы, возникнет ошибка. Использование ключевого слова checkunique
поддерживается, только если не используются ключевые слова by
и lt
. Аналогично, использование предложений order(...)
, которые задают by
или lt
, не поддерживается, но допускается указание rev
.
С помощью ключевого слова by
можно задать функцию, которая будет применяться к каждому элементу перед сравнением. С помощью ключевого слова lt
можно указать пользовательскую функцию «меньше чем». Если указать и by
, и lt
, функция lt
применяется к результату функции by
.
Именованные аргументы, указывающие порядок сортировки (rev
, lt
или by
) могут представлять собой одно значение или вектор длиной, равной количеству столбцов, с которыми выполняется операция. Если передается одно значение, оно применяется ко всем столбцам. Если передается вектор, каждая запись применяется к столбцу в соответствующей позиции в cols
.
Примеры
julia> df = DataFrame(a=[1, 2, 3, 4], b=[4, 3, 2, 1])
4×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
2 │ 2 3
3 │ 3 2
4 │ 4 1
julia> issorted(df)
true
julia> issorted(df, :a)
true
julia> issorted(df, :b)
false
julia> issorted(df, :b, rev=true)
true
#
DataFrames.order
— Function
order(col::ColumnIndex; kwargs...)
Задает порядок сортировки для столбца col
во фрейме данных. kwargs
могут быть lt
, by
, rev
и order
со значениями, соответствующими правилам, определенным в sort!
.
Примеры
julia> df = DataFrame(x=[-3, -1, 0, 2, 4], y=1:5)
5×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ -3 1
2 │ -1 2
3 │ 0 3
4 │ 2 4
5 │ 4 5
julia> sort(df, order(:x, rev=true))
5×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 4 5
2 │ 2 4
3 │ 0 3
4 │ -1 2
5 │ -3 1
julia> sort(df, order(:x, by=abs))
5×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 0 3
2 │ -1 2
3 │ 2 4
4 │ -3 1
5 │ 4 5
#
Base.sort
— Function
sort(df::AbstractDataFrame, cols=All();
alg::Union{Algorithm, Nothing}=nothing,
lt::Union{Function, AbstractVector{<:Function}}=isless,
by::Union{Function, AbstractVector{<:Function}}=identity,
rev::Union{Bool, AbstractVector{Bool}}=false,
order::Union{Ordering, AbstractVector{<:Ordering}}=Forward,
view::Bool=false,
checkunique::Bool=false)
Возвращает фрейм данных, содержащий строки в df
, отсортированном по столбцам cols
. Сортировка по нескольким столбцам выполняется лексикографически.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). Если cols
не выбирает столбцы, сортирует df
по всем столбцам (это поведение устарело и будет изменено в будущих версиях).
Если rev
имеет значение true
, выполняется обратная сортировка. Чтобы включить обратную сортировку только для некоторых столбцов, передайте order(c, rev=true)
в cols
, где c
соответствует индексу столбца (см. пример ниже).
Поскольку при наличии повторяющихся элементов допустимы несколько порядков сортировки, ключевое слово checkunique
позволяет обнаруживать подобные ситуации. Если checkunique
является true
и найдены повторяющиеся элементы, возникнет ошибка. Использование ключевого слова checkunique
поддерживается, только если не используются ключевые слова by
и lt
. Аналогично, использование предложений order(...)
, которые задают by
или lt
, не поддерживается, но допускается указание rev
.
С помощью ключевого слова by
можно задать функцию, которая будет применяться к каждому элементу перед сравнением. С помощью ключевого слова lt
можно указать пользовательскую функцию «меньше чем». Если указать и by
, и lt
, функция lt
применяется к результату функции by
.
Именованные аргументы, указывающие порядок сортировки (rev
, lt
или by
) могут представлять собой одно значение или вектор длиной, равной количеству столбцов, с которыми выполняется операция. Если передается одно значение, оно применяется ко всем столбцам. Если передается вектор, каждая запись применяется к столбцу в соответствующей позиции в cols
.
Если alg
имеет значение nothing
(по умолчанию), наиболее подходящий алгоритм выбирается автоматически среди TimSort
, MergeSort
и RadixSort
в зависимости от типа сортирующих столбцов и количества строк в df
.
Если view=false
, возвращается только что выделенный DataFrame
. Если view=true
, возвращается представление SubDataFrame
для df
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 2 a
4 │ 1 b
julia> sort(df, :x)
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 1 c
2 │ 1 b
3 │ 2 a
4 │ 3 b
julia> sort(df, [:x, :y])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 1 b
2 │ 1 c
3 │ 2 a
4 │ 3 b
julia> sort(df, [:x, :y], rev=true)
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
3 │ 1 c
4 │ 1 b
julia> sort(df, [:x, order(:y, rev=true)])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 1 c
2 │ 1 b
3 │ 2 a
4 │ 3 b
#
Base.sort!
— Function
sort!(df::AbstractDataFrame, cols=All();
alg::Union{Algorithm, Nothing}=nothing,
lt::Union{Function, AbstractVector{<:Function}}=isless,
by::Union{Function, AbstractVector{<:Function}}=identity,
rev::Union{Bool, AbstractVector{Bool}}=false,
order::Union{Ordering, AbstractVector{<:Ordering}}=Forward,
checkunique::Bool=false)
Сортирует фрейм данных df
по столбцам cols
, переставляя его строки на месте. Сортировка по нескольким столбцам выполняется лексикографически.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). Если cols
не выбирает столбцы, сортирует df
по всем столбцам (это поведение устарело и будет изменено в будущих версиях).
Если rev
имеет значение true
, выполняется обратная сортировка. Чтобы включить обратную сортировку только для некоторых столбцов, передайте order(c, rev=true)
в cols
, где c
соответствует индексу столбца (см. пример ниже).
Поскольку при наличии повторяющихся элементов допустимы несколько порядков сортировки, ключевое слово checkunique
позволяет обнаруживать подобные ситуации. Если checkunique
является true
и найдены повторяющиеся элементы, возникнет ошибка. Использование ключевого слова checkunique
поддерживается, только если не используются ключевые слова by
и lt
. Аналогично, использование предложений order(...)
, которые задают by
или lt
, не поддерживается, но допускается указание rev
.
С помощью ключевого слова by
можно задать функцию, которая будет применяться к каждому элементу перед сравнением. С помощью ключевого слова lt
можно указать пользовательскую функцию «меньше чем». Если указать и by
, и lt
, функция lt
применяется к результату функции by
.
Именованные аргументы, указывающие порядок сортировки (rev
, lt
или by
) могут представлять собой одно значение или вектор длиной, равной количеству столбцов, с которыми выполняется операция. Если передается одно значение, оно применяется ко всем столбцам. Если передается вектор, каждая запись применяется к столбцу в соответствующей позиции в cols
.
Если alg
имеет значение nothing
(по умолчанию), наиболее подходящий алгоритм выбирается автоматически среди TimSort
, MergeSort
и RadixSort
в зависимости от типа сортирующих столбцов и количества строк в df
.
sort!
выдаст корректный результат, даже если некоторые столбцы переданного фрейма данных идентичны (проверены с помощью ===
). В противном случае, если два столбца имеют общую часть памяти, но не идентичны (например, являются разными представлениями одного и того же родительского вектора), результат sort!
может быть неверным.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Метаданные, имеющие другие стили, удаляются (из родительского фрейма данных, если df
является SubDataFrame
).
Примеры
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 2 a
4 │ 1 b
julia> sort!(df, :x)
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 1 c
2 │ 1 b
3 │ 2 a
4 │ 3 b
julia> sort!(df, [:x, :y])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 1 b
2 │ 1 c
3 │ 2 a
4 │ 3 b
julia> sort!(df, [:x, :y], rev=true)
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
3 │ 1 c
4 │ 1 b
julia> sort!(df, [:x, order(:y, rev=true)])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 1 c
2 │ 1 b
3 │ 2 a
4 │ 3 b
#
Base.sortperm
— Function
sortperm(df::AbstractDataFrame, cols=All();
alg::Union{Algorithm, Nothing}=nothing,
lt::Union{Function, AbstractVector{<:Function}}=isless,
by::Union{Function, AbstractVector{<:Function}}=identity,
rev::Union{Bool, AbstractVector{Bool}}=false,
order::Union{Ordering, AbstractVector{<:Ordering}}=Forward,
checkunique::Bool=false)
Возвращает вектор перестановки индексов строк фрейма данных df
, который располагает их в отсортированном порядке в соответствии со столбцами cols
. Упорядочение по нескольким столбцам выполняется лексикографически.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). Если cols
не выбирает ни одного столбца, возвращается вектор перестановок, основанный на сортировке всех столбцов (это поведение устарело и будет изменено в будущих версиях).
Если rev
имеет значение true
, выполняется обратная сортировка. Чтобы включить обратную сортировку только для некоторых столбцов, передайте order(c, rev=true)
в cols
, где c
соответствует индексу столбца (см. пример ниже).
Поскольку при наличии повторяющихся элементов допустимы несколько порядков сортировки, ключевое слово checkunique
позволяет обнаруживать подобные ситуации. Если checkunique
является true
и найдены повторяющиеся элементы, возникнет ошибка. Использование ключевого слова checkunique
поддерживается, только если не используются ключевые слова by
и lt
. Аналогично, использование предложений order(...)
, которые задают by
или lt
, не поддерживается, но допускается указание rev
.
С помощью ключевого слова by
можно задать функцию, которая будет применяться к каждому элементу перед сравнением. С помощью ключевого слова lt
можно указать пользовательскую функцию «меньше чем». Если указать и by
, и lt
, функция lt
применяется к результату функции by
.
Именованные аргументы, указывающие порядок сортировки (rev
, lt
или by
) могут представлять собой одно значение или вектор длиной, равной количеству столбцов, с которыми выполняется операция. Если передается одно значение, оно применяется ко всем столбцам. Если передается вектор, каждая запись применяется к столбцу в соответствующей позиции в cols
.
Если alg
имеет значение nothing
(по умолчанию), наиболее подходящий алгоритм выбирается автоматически среди TimSort
, MergeSort
и RadixSort
в зависимости от типа сортирующих столбцов и количества строк в df
.
Примеры
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 2 a
4 │ 1 b
julia> sortperm(df, :x)
4-element Vector{Int64}:
2
4
3
1
julia> sortperm(df, [:x, :y])
4-element Vector{Int64}:
4
2
3
1
julia> sortperm(df, [:x, :y], rev=true)
4-element Vector{Int64}:
1
3
2
4
julia> sortperm(df, [:x, order(:y, rev=true)])
4-element Vector{Int64}:
2
4
3
1
Объединение
#
DataAPI.antijoin
— Function
antijoin(df1, df2; on, makeunique=false, validate=(false, false), matchmissing=:error)
Выполняет антисоединение двух объектов фрейма данных и возвращает DataFrame
, содержащий результат. Антисоединение возвращает подмножество строк df1
, которые не совпадают с ключами в df2
.
Порядок строк в результате сохраняется из df1
.
Аргументы
-
df1
,df2
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). Вместо имени можно использовать пару именleft=>right
в случае, когда ключ имеет разные имена вdf1
иdf2
(разрешается смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: игнорируется, так как столбцы не добавляются к столбцамdf1
(он предоставляется для согласованности с другими функциями). -
validate
: следует ли проверять, что столбцы, переданные в качестве аргументаon
, определяют уникальные ключи в каждом входном фрейме данных (в соответствии сisequal
). Может быть кортежем или парой, первый элемент которой указывает, запускать ли проверку дляdf1
, а второй — дляdf2
. По умолчанию проверка не выполняется. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения сопоставляются; если имеет значение:notequal
, отсутствующие значения удаляются в столбцахon
df2
.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
При объединении категориальных столбцов on
, отличающихся упорядочением уровней, упорядочение левого фрейма данных имеет приоритет над упорядочением правого фрейма данных.
Метаданные: метаданные на уровне таблиц и метаданные на уровне столбцов в стиле :note
принимаются из df1
.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> antijoin(name, job, on = :ID)
1×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 3 Joe Blogs
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> antijoin(name, job2, on = :ID => :identifier)
1×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 3 Joe Blogs
julia> antijoin(name, job2, on = [:ID => :identifier])
1×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 3 Joe Blogs
#
DataAPI.crossjoin
— Function
crossjoin(df1::AbstractDataFrame, df2::AbstractDataFrame;
makeunique::Bool=false, renamecols=identity => identity)
crossjoin(df1, df2, dfs...; makeunique = false)
Выполняет перекрестное соединение двух или более объектов фрейма данных и возвращает DataFrame
, содержащий результат. Перекрестное соединение возвращает декартово произведение строк из всех переданных фреймов данных, где первый переданный фрейм данных присваивается измерению, которое изменяется медленнее всего, а последний фрейм данных присваивается измерению, которое изменяется быстрее всего.
Аргументы
-
df1
,df2
,dfs...
: соединяемыеAbstractDataFrames
Именованные аргументы
-
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен в столбцах, по которым не выполнено соединение; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
, (i
, начиная с 1 для первого повторяющегося имени). -
renamecols
: пара (Pair
), указывающая, как должны быть переименованы столбцы левого и правого фреймов данных в результирующем фрейме данных. Каждый элемент пары может представлять собой строку, или может быть передан символ (Symbol
), в этом случае он добавляется к исходному имени столбца. В качестве альтернативы можно передать функцию, в этом случае она применяется к каждому имени столбца, которое передается ей в виде строки (String
).
Если передается более двух фреймов данных, соединение выполняется рекурсивно с левой ассоциативностью.
Метаданные: метаданные на уровне таблиц в стиле :note
сохраняются только для ключей, которые определены во всех передаваемых таблицах и имеют одинаковое значение. Метаданные на уровне столбцов в стиле :note
сохраняются из обеих таблиц.
Примеры
julia> df1 = DataFrame(X=1:3)
3×1 DataFrame
Row │ X
│ Int64
─────┼───────
1 │ 1
2 │ 2
3 │ 3
julia> df2 = DataFrame(Y=["a", "b"])
2×1 DataFrame
Row │ Y
│ String
─────┼────────
1 │ a
2 │ b
julia> crossjoin(df1, df2)
6×2 DataFrame
Row │ X Y
│ Int64 String
─────┼───────────────
1 │ 1 a
2 │ 1 b
3 │ 2 a
4 │ 2 b
5 │ 3 a
6 │ 3 b
#
DataAPI.innerjoin
— Function
innerjoin(df1, df2; on, makeunique=false, validate=(false, false),
renamecols=(identity => identity), matchmissing=:error,
order=:undefined)
innerjoin(df1, df2, dfs...; on, makeunique=false,
validate=(false, false), matchmissing=:error,
order=:undefined)
Выполняет внутреннее соединение двух или более объектов фрейма данных и возвращает DataFrame
, содержащий результат. Внутреннее соединение включает строки с ключами, которые совпадают во всех переданных фреймах данных.
В возвращаемом фрейме данных тип столбцов, по которым соединяются фреймы данных, определяется типом этих столбцов в df1
. Такое поведение может измениться в будущих выпусках.
Аргументы
-
df1
,df2
,dfs...
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). При соединении только двух фреймов данных вместо имени можно использовать пару именleft=>right
в случае, кода когда ключ имеет разные имена вdf1
иdf2
(разрешено смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен в столбцах, по которым не выполнено соединение; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
, (i
, начиная с 1 для первого повторяющегося имени). -
validate
: следует ли проверять, что столбцы, переданные в качестве аргументаon
, определяют уникальные ключи в каждом входном фрейме данных (в соответствии сisequal
). Может быть кортежем или парой, первый элемент которой указывает, запускать ли проверку дляdf1
, а второй — дляdf2
. По умолчанию проверка не выполняется. -
renamecols
: пара (Pair
), указывающая, как должны быть переименованы столбцы левого и правого фреймов данных в результирующем фрейме данных. Каждый элемент пары может представлять собой строку, или может быть передан символ (Symbol
), в этом случае он добавляется к исходному имени столбца. В качестве альтернативы можно передать функцию, в этом случае она применяется к каждому имени столбца, которое передается ей в виде строки (String
). Обратите внимание, чтоrenamecols
не влияет на столбцыon
, имена которых всегда берутся из левого фрейма данных и остаются неизменными. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения сопоставляются; если имеет значение:notequal
, отсутствующие значения удаляются в столбцахdf1
иdf2
on
. -
order
: если:undefined
(по умолчанию), порядок строк в результате не определен и может измениться в будущих выпусках. Если:left
, сохраняется порядок строк из левого фрейма данных. Если:right
, сохраняется порядок строк из правого фрейма данных.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
При объединении категориальных столбцов on
, отличающихся упорядочением уровней, упорядочение левого фрейма данных имеет приоритет над упорядочением правого фрейма данных.
Если передается более двух фреймов данных, соединение выполняется рекурсивно с левой ассоциативностью. В этом случае именованный аргумент validate
применяется рекурсивно с левой ассоциативностью.
Метаданные: метаданные на уровне таблиц в стиле :note
и метаданные на уровне столбцов в стиле :note
для столбцов ключей сохраняются только для ключей, которые определены во всех передаваемых таблицах и имеют одинаковое значение. Метаданные на уровне столбцов в стиле :note
сохраняются для всех остальных столбцов.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> innerjoin(name, job, on = :ID)
2×3 DataFrame
Row │ ID Name Job
│ Int64 String String
─────┼─────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> innerjoin(name, job2, on = :ID => :identifier, renamecols = "_left" => "_right")
2×3 DataFrame
Row │ ID Name_left Job_right
│ Int64 String String
─────┼─────────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
julia> innerjoin(name, job2, on = [:ID => :identifier], renamecols = uppercase => lowercase)
2×3 DataFrame
Row │ ID NAME job
│ Int64 String String
─────┼─────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
#
DataAPI.leftjoin
— Function
leftjoin(df1, df2; on, makeunique=false, source=nothing, validate=(false, false),
renamecols=(identity => identity), matchmissing=:error, order=:undefined)
Выполняет левое соединение двух объектов фрейма данных и возвращает DataFrame
, содержащий результат. Левое соединение включает все строки из df1
.
В возвращаемом фрейме данных тип столбцов, по которым соединяются фреймы данных, определяется типом этих столбцов в df1
. Такое поведение может измениться в будущих выпусках.
Аргументы
-
df1
,df2
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). Вместо имени можно использовать пару именleft=>right
в случае, когда ключ имеет разные имена вdf1
иdf2
(разрешается смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен в столбцах, по которым не выполнено соединение; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
, (i
, начиная с 1 для первого повторяющегося имени). -
source
: значение по умолчанию —nothing
. ЕслиSymbol
или строка, добавляет столбец указателя с заданным именем, чтобы определить, появилась ли строка только вdf1
("left_only"
) или в обоих ("both"
). Если имя уже используется, имя столбца будет изменено, еслиmakeunique=true
. -
validate
: следует ли проверять, что столбцы, переданные в качестве аргументаon
, определяют уникальные ключи в каждом входном фрейме данных (в соответствии сisequal
). Может быть кортежем или парой, первый элемент которой указывает, запускать ли проверку дляdf1
, а второй — дляdf2
. По умолчанию проверка не выполняется. -
renamecols
: пара (Pair
), указывающая, как должны быть переименованы столбцы левого и правого фреймов данных в результирующем фрейме данных. Каждый элемент пары может представлять собой строку, или может быть передан символ (Symbol
), в этом случае он добавляется к исходному имени столбца. В качестве альтернативы можно передать функцию, в этом случае она применяется к каждому имени столбца, которое передается ей в виде строки (String
). Обратите внимание, чтоrenamecols
не влияет на столбцыon
, имена которых всегда берутся из левого фрейма данных и остаются неизменными. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения сопоставляются; если имеет значение:notequal
, отсутствующие значения удаляются в столбцахon
df2
. -
order
: если:undefined
(по умолчанию), порядок строк в результате не определен и может измениться в будущих выпусках. Если:left
, сохраняется порядок строк из левого фрейма данных. Если:right
, сохраняется порядок строк строк из правого фрейма данных (несовпадающие строки помещаются в конец).
Все столбцы возвращаемого фрейма данных будут поддерживать отсутствующие значения.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
При объединении категориальных столбцов on
, отличающихся упорядочением уровней, упорядочение левого фрейма данных имеет приоритет над упорядочением правого фрейма данных.
Метаданные: метаданные на уровне таблиц и метаданные на уровне столбцов в стиле :note
принимаются из df1
(включая столбцы ключей), за исключением столбцов, добавленных в него из df2
, метаданные на уровне столбцов в стиле :note
которого принимаются из df2
.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> leftjoin(name, job, on = :ID)
3×3 DataFrame
Row │ ID Name Job
│ Int64 String String?
─────┼───────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> leftjoin(name, job2, on = :ID => :identifier, renamecols = "_left" => "_right")
3×3 DataFrame
Row │ ID Name_left Job_right
│ Int64 String String?
─────┼─────────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
julia> leftjoin(name, job2, on = [:ID => :identifier], renamecols = uppercase => lowercase)
3×3 DataFrame
Row │ ID NAME job
│ Int64 String String?
─────┼───────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
#
DataFrames.leftjoin!
— Function
leftjoin!(df1, df2; on, makeunique=false, source=nothing,
matchmissing=:error)
Выполняет левое соединение двух объектов фрейма данных, обновляя df1
присоединенными столбцами из df2
.
Левое соединение включает все строки из df1
и не затрагивает все строки и столбцы из df1
. . Обратите внимание, что каждая строка в df1
должна иметь не более одного совпадения в df2
. В противном случае, эта функция не сможет выполнить соединение на месте, поскольку потребуется добавить новые строки в df1
.
Аргументы
-
df1
,df2
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). Вместо имени можно использовать пару именleft=>right
в случае, когда ключ имеет разные имена вdf1
иdf2
(разрешается смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен в столбцах, по которым не выполнено соединение; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
, (i
, начиная с 1 для первого повторяющегося имени). -
source
: значение по умолчанию —nothing
. ЕслиSymbol
или строка, добавляет столбец указателя с заданным именем, чтобы определить, появилась ли строка только вdf1
("left_only"
) или в обоих ("both"
). Если имя уже используется, имя столбца будет изменено, еслиmakeunique=true
. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения сопоставляются; если имеет значение:notequal
, отсутствующие значения удаляются в столбцахon
df2
.
Столбцы, добавленные в df1
из df2
, будут поддерживать отсутствующие значения.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
Метаданные: метаданные на уровне таблиц и метаданные на уровне столбцов в стиле :note
принимаются из df1
(включая столбцы ключей), за исключением столбцов, добавленных в него из df2
, метаданные на уровне столбцов в стиле :note
которого принимаются из df2
.
См. также описание leftjoin
.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> leftjoin!(name, job, on = :ID)
3×3 DataFrame
Row │ ID Name Job
│ Int64 String String?
─────┼───────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> leftjoin!(name, job2, on = :ID => :identifier, makeunique=true, source=:source)
3×5 DataFrame
Row │ ID Name Job Job_1 source
│ Int64 String String? String? String
─────┼───────────────────────────────────────────────
1 │ 1 John Doe Lawyer Lawyer both
2 │ 2 Jane Doe Doctor Doctor both
3 │ 3 Joe Blogs missing missing left_only
#
DataAPI.outerjoin
— Function
outerjoin(df1, df2; on, makeunique=false, source=nothing, validate=(false, false),
renamecols=(identity => identity), matchmissing=:error, order=:undefined)
outerjoin(df1, df2, dfs...; on, makeunique = false,
validate = (false, false), matchmissing=:error, order=:undefined)
Выполняет внешнее соединение двух или более объектов фрейма данных и возвращает DataFrame
, содержащий результат. Внешнее соединение включает строки с ключами, которые появляются во всех переданных фреймах данных.
Порядок строк в результате не определен и может измениться в будущих выпусках.
В возвращаемом фрейме данных тип столбцов, по которым соединяются фреймы данных, определяется типом элемента этих столбцов в df1
и df2
. Это поведение может измениться в будущих выпусках.
Аргументы
-
df1
,df2
,dfs...
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). При соединении только двух фреймов данных вместо имени можно использовать пару именleft=>right
в случае, кода когда ключ имеет разные имена вdf1
иdf2
(разрешено смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен в столбцах, по которым не выполнено соединение; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
, (i
, начиная с 1 для первого повторяющегося имени). -
source
: значение по умолчанию —nothing
. ЕслиSymbol
или строка, добавляет столбец указателя с заданным именем, чтобы определить, появилась ли строка только вdf1
("left_only"
), только вdf2
("right_only"
) или в обоих ("both"
). Если имя уже используется, имя столбца будет изменено, еслиmakeunique=true
. Этот аргумент поддерживается только при соединении двух фреймов данных. -
validate
: следует ли проверять, что столбцы, переданные в качестве аргументаon
, определяют уникальные ключи в каждом входном фрейме данных (в соответствии сisequal
). Может быть кортежем или парой, первый элемент которой указывает, запускать ли проверку дляdf1
, а второй — дляdf2
. По умолчанию проверка не выполняется. -
renamecols
: пара (Pair
), указывающая, как должны быть переименованы столбцы левого и правого фреймов данных в результирующем фрейме данных. Каждый элемент пары может представлять собой строку, или может быть передан символ (Symbol
), в этом случае он добавляется к исходному имени столбца. В качестве альтернативы можно передать функцию, в этом случае она применяется к каждому имени столбца, которое передается ей в виде строки (String
). Обратите внимание, чтоrenamecols
не влияет на столбцыon
, имена которых всегда берутся из левого фрейма данных и остаются неизменными. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения совпадают. -
order
: если:undefined
(по умолчанию), порядок строк в результате не определен и может измениться в будущих выпусках. Если:left
, сохраняется порядок строк из левого фрейма данных (несовпадающие строки помещаются в конец). Если:right
, сохраняется порядок строк из правого фрейма данных. (несовпадающие строки помещаются в конец).
Все столбцы возвращаемого фрейма данных будут поддерживать отсутствующие значения.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
При объединении категориальных столбцов on
, отличающихся упорядочением уровней, упорядочение левого фрейма данных имеет приоритет над упорядочением правого фрейма данных.
Если передается более двух фреймов данных, соединение выполняется рекурсивно с левой ассоциативностью. В этом случае именованный аргумент indicator
не поддерживается, и именованный аргумент validate
применяется рекурсивно с левой ассоциативностью.
Метаданные: метаданные на уровне таблиц в стиле :note
и метаданные на уровне столбцов в стиле :note
для столбцов ключей сохраняются только для ключей, которые определены во всех передаваемых таблицах и имеют одинаковое значение. Метаданные на уровне столбцов в стиле :note
сохраняются для всех остальных столбцов.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> outerjoin(name, job, on = :ID)
4×3 DataFrame
Row │ ID Name Job
│ Int64 String? String?
─────┼───────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
4 │ 4 missing Farmer
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> outerjoin(name, job2, on = :ID => :identifier, renamecols = "_left" => "_right")
4×3 DataFrame
Row │ ID Name_left Job_right
│ Int64 String? String?
─────┼─────────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
4 │ 4 missing Farmer
julia> outerjoin(name, job2, on = [:ID => :identifier], renamecols = uppercase => lowercase)
4×3 DataFrame
Row │ ID NAME job
│ Int64 String? String?
─────┼───────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 3 Joe Blogs missing
4 │ 4 missing Farmer
#
DataAPI.rightjoin
— Function
rightjoin(df1, df2; on, makeunique=false, source=nothing,
validate=(false, false), renamecols=(identity => identity),
matchmissing=:error, order=:undefined)
Выполняет правое соединение двух объектов фрейма данных и возвращает DataFrame
, содержащий результат. Правое соединение включает все строки из df2
.
Порядок строк в результате не определен и может измениться в будущих выпусках.
В возвращаемом фрейме данных тип столбцов, по которым соединяются фреймы данных, определяется типом этих столбцов в df2
. Такое поведение может измениться в будущих выпусках.
Аргументы
-
df1
,df2
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). Вместо имени можно использовать пару именleft=>right
в случае, когда ключ имеет разные имена вdf1
иdf2
(разрешается смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: если задано значениеfalse
(по умолчанию), возникает ошибка при обнаружении повторяющихся имен в столбцах, по которым не выполнено соединение; если задано значениеtrue
, к повторяющимся именам добавляется суффикс_i
, (i
, начиная с 1 для первого повторяющегося имени). -
source
: значение по умолчанию —nothing
. ЕслиSymbol
или строка, добавляет столбец указателя с заданным именем, чтобы определить, появилась ли строка только вdf2
("right_only"
) или в обоих ("both"
). Если имя уже используется, имя столбца будет изменено, еслиmakeunique=true
. -
validate
: следует ли проверять, что столбцы, переданные в качестве аргументаon
, определяют уникальные ключи в каждом входном фрейме данных (в соответствии сisequal
). Может быть кортежем или парой, первый элемент которой указывает, запускать ли проверку дляdf1
, а второй — дляdf2
. По умолчанию проверка не выполняется. -
renamecols
: пара (Pair
), указывающая, как должны быть переименованы столбцы левого и правого фреймов данных в результирующем фрейме данных. Каждый элемент пары может представлять собой строку, или может быть передан символ (Symbol
), в этом случае он добавляется к исходному имени столбца. В качестве альтернативы можно передать функцию, в этом случае она применяется к каждому имени столбца, которое передается ей в виде строки (String
). Обратите внимание, чтоrenamecols
не влияет на столбцыon
, имена которых всегда берутся из левого фрейма данных и остаются неизменными. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения сопоставляются; если имеет значение:notequal
, отсутствующие значения удаляются в столбцахon
df1
. -
order
: если:undefined
(по умолчанию), порядок строк в результате не определен и может измениться в будущих выпусках. Если:left
, сохраняется порядок строк из левого фрейма данных (несовпадающие строки помещаются в конец). Если:right
, сохраняется порядок строк из правого фрейма данных.
Все столбцы возвращаемого фрейма данных будут поддерживать отсутствующие значения.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
При объединении категориальных столбцов on
, отличающихся упорядочением уровней, упорядочение левого фрейма данных имеет приоритет над упорядочением правого фрейма данных.
Метаданные: метаданные на уровне таблиц и метаданные на уровне столбцов в стиле :note
принимаются из df2
(включая столбцы ключей), за исключением столбцов, добавленных в него из df1
, метаданные на уровне столбцов в стиле :note
которого принимаются из df1
.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> rightjoin(name, job, on = :ID)
3×3 DataFrame
Row │ ID Name Job
│ Int64 String? String
─────┼─────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 4 missing Farmer
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> rightjoin(name, job2, on = :ID => :identifier, renamecols = "_left" => "_right")
3×3 DataFrame
Row │ ID Name_left Job_right
│ Int64 String? String
─────┼─────────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 4 missing Farmer
julia> rightjoin(name, job2, on = [:ID => :identifier], renamecols = uppercase => lowercase)
3×3 DataFrame
Row │ ID NAME job
│ Int64 String? String
─────┼─────────────────────────
1 │ 1 John Doe Lawyer
2 │ 2 Jane Doe Doctor
3 │ 4 missing Farmer
#
DataAPI.semijoin
— Function
semijoin(df1, df2; on, makeunique=false, validate=(false, false), matchmissing=:error)
Выполняет полусоединение двух объектов фрейма данных и возвращает DataFrame
, содержащий результат. Полусоединение возвращает подмножество строк df1
, которые совпадают с ключами в df2
.
Порядок строк в результате сохраняется из df1
.
Аргументы
-
df1
,df2
: соединяемыеAbstractDataFrames
Именованные аргументы
-
on
: имена ключевых столбцов, по которым следует соединить фреймы данных. Это может быть одно имя или вектор имен (для соединения по нескольким столбцам). Вместо имени можно использовать пару именleft=>right
в случае, когда ключ имеет разные имена вdf1
иdf2
(разрешается смешивать имена и пары имен в векторе). Значения ключей сравниваются с помощьюisequal
.on
является обязательным аргументом. -
makeunique
: игнорируется, так как столбцы не добавляются к столбцамdf1
(он предоставляется для согласованности с другими функциями). -
indicator
: значение по умолчанию —nothing
. ЕслиSymbol
или строка, добавляет категориальный столбец указателя с заданным именем, чтобы определить, появилась ли строка только вdf1
("left_only"
), только вdf2
("right_only"
) или в обоих ("both"
). Если имя уже используется, имя столбца будет изменено, еслиmakeunique=true
. -
validate
: следует ли проверять, что столбцы, переданные в качестве аргументаon
, определяют уникальные ключи в каждом входном фрейме данных (в соответствии сisequal
). Может быть кортежем или парой, первый элемент которой указывает, запускать ли проверку дляdf1
, а второй — дляdf2
. По умолчанию проверка не выполняется. -
matchmissing
: если имеет значение:error
, возникает ошибка, еслиmissing
присутствует в столбцахon
; если имеет значение:equal
,missing
разрешено и отсутствующие значения сопоставляются; если имеет значение:notequal
, отсутствующие значения удаляются в столбцахon
df2
.
Не допускается соединение по столбцам, содержащим NaN
или -0.0
в вещественной или мнимой частях числа. Чтобы выполнить соединение по таким значениям, используйте CategoricalArrays.jl и преобразуйте столбец, содержащий такие значения, в CategoricalVector
.
При объединении категориальных столбцов on
, отличающихся упорядочением уровней, упорядочение левого фрейма данных имеет приоритет над упорядочением правого фрейма данных.
Метаданные: метаданные на уровне таблиц и метаданные на уровне столбцов в стиле :note
принимаются из df1
.
Примеры
julia> name = DataFrame(ID=[1, 2, 3], Name=["John Doe", "Jane Doe", "Joe Blogs"])
3×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼──────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
3 │ 3 Joe Blogs
julia> job = DataFrame(ID=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ ID Job
│ Int64 String
─────┼───────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> semijoin(name, job, on = :ID)
2×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼─────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
julia> job2 = DataFrame(identifier=[1, 2, 4], Job=["Lawyer", "Doctor", "Farmer"])
3×2 DataFrame
Row │ identifier Job
│ Int64 String
─────┼────────────────────
1 │ 1 Lawyer
2 │ 2 Doctor
3 │ 4 Farmer
julia> semijoin(name, job2, on = :ID => :identifier)
2×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼─────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
julia> semijoin(name, job2, on = [:ID => :identifier])
2×2 DataFrame
Row │ ID Name
│ Int64 String
─────┼─────────────────
1 │ 1 John Doe
2 │ 2 Jane Doe
Группирование
#
Base.get
— Function
get(gd::GroupedDataFrame, key, default)
Get a group based on the values of the grouping columns.
key
may be a GroupKey
, NamedTuple
or Tuple
of grouping column values (in the same order as the cols
argument to groupby
). It may also be an AbstractDict
, in which case the order of the arguments does not matter.
Examples
julia> df = DataFrame(a=repeat([:foo, :bar, :baz], outer=[2]),
b=repeat([2, 1], outer=[3]),
c=1:6);
julia> gd = groupby(df, :a)
GroupedDataFrame with 3 groups based on key: a
First Group (2 rows): a = :foo
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ foo 2 1
2 │ foo 1 4
⋮
Last Group (2 rows): a = :baz
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ baz 2 3
2 │ baz 1 6
julia> get(gd, (a=:bar,), nothing)
2×3 SubDataFrame
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ bar 1 2
2 │ bar 2 5
julia> get(gd, (:baz,), nothing)
2×3 SubDataFrame
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ baz 2 3
2 │ baz 1 6
julia> get(gd, (:qux,), nothing)
#
DataFrames.groupby
— Function
groupby(d::AbstractDataFrame, cols;
sort::Union{Bool, Nothing, NamedTuple}=nothing,
skipmissing::Bool=false)
Возвращает GroupedDataFrame
, представляющий представление AbstractDataFrame
, разделенного на группы строк.
Аргументы
-
df
: разделяемыйAbstractDataFrame
-
cols
: столбцы фрейма данных, по которым будет выполняться группировка. Это может быть любой селектор столбцов (символ (Symbol
), строка или целое число;:
,Cols
,All
,Between
,Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел). В частности, если селектор не выбирает столбцы, создаетсяGroupedDataFrame
из одной группы. Особый случай: еслиcols
является одни столбцом или вектором столбцов, он может содержать столбцы, заключенные в функциюorder
, которая будет использоваться для определения порядка групп, еслиsort
имеет значениеtrue
илиNamedTuple
(еслиsort
имеет значениеfalse
, при передачеorder
возникнет ошибка; еслиsort
имеет значениеnothing
, он задается какtrue
при передачеorder
). -
sort
: еслиsort=true
, сортирует группы согласно значениям группирующих столбцовcols
; еслиsort=false
, группы создаются в порядке их появления вdf
; еслиsort=nothing
(по умолчанию), выбирается самый быстрый доступный алгоритм группировки, и в связи с этим порядок групп в результате не определен и может измениться в будущих выпусках. Ниже приведено описание текущей реализации. Кроме того,sort
может бытьNamedTuple
и иметь некоторые или все поляalg
,lt
,by
,rev
иorder
. В этом случае группы сортируются, и их порядок соответствует порядкуsortperm
. -
skipmissing
: пропускать ли группы с отсутствующими (missing
) значениями в одном из группирующих столбцовcols
.
Подробные сведения
Итератор по GroupedDataFrame
возвращает представление SubDataFrame
для каждого группирования в df
. В каждой группе сохраняется порядок строк в df
.
GroupedDataFrame
также поддерживает индексирование по группам, select
, transform
и combine
(которое применяет функцию к каждой группе и объединяет результат во фрейм данных).
GroupedDataFrame
также поддерживает интерфейс словаря. Ключи представляют собой объекты GroupKey
, возвращаемые функцией keys(::GroupedDataFrame)
, которая также может быть использована для получения значений группирующих столбцов для каждой группы. Tuples
и NamedTuple
, содержащие значения группирующих столбцов (в том же порядке, что и аргумент cols
), также принимаются в качестве индексов. И, наконец, AbstractDict
можно использовать для индексации в сгруппированный фрейм данных, где ключи являются именами столбцов фрейма данных. В этом случае порядок ключей не имеет значения.
В текущей реализации, если группы sort=nothing
упорядочиваются в порядке появления значений в группирующих столбцах, за исключением случаев, когда все группирующие столбцы предоставляют не nothing
DataAPI.refpool
, то порядок групп следует порядку значений, возвращаемых DataAPI.refpool
. Частное применение этого правила: если все cols
являются CategoricalVector
, группы всегда сортируются. Целочисленные столбцы с узким диапазоном также используют эту оптимизацию, поэтому порядок групп при группировке по целочисленным столбцам не определен. Столбец считается целочисленным при выборе алгоритма группировки, если его eltype
является подтипом Union{Missing, Real}
, все его элементы либо отсутствуют (missing
), либо проходят тест isinteger
, ни один из них не равен -0.0
.
См. также описание
Примеры
julia> df = DataFrame(a=repeat([1, 2, 3, 4], outer=[2]),
b=repeat([2, 1], outer=[4]),
c=1:8);
julia> gd = groupby(df, :a)
GroupedDataFrame with 4 groups based on key: a
First Group (2 rows): a = 1
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 1
2 │ 1 2 5
⋮
Last Group (2 rows): a = 4
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 4 1 4
2 │ 4 1 8
julia> gd[1]
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 1
2 │ 1 2 5
julia> last(gd)
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 4 1 4
2 │ 4 1 8
julia> gd[(a=3,)]
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 3 2 3
2 │ 3 2 7
julia> gd[Dict("a" => 3)]
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 3 2 3
2 │ 3 2 7
julia> gd[(3,)]
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 3 2 3
2 │ 3 2 7
julia> k = first(keys(gd))
GroupKey: (a = 1,)
julia> gd[k]
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 1
2 │ 1 2 5
julia> for g in gd
println(g)
end
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 1 2 1
2 │ 1 2 5
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 2 1 2
2 │ 2 1 6
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 3 2 3
2 │ 3 2 7
2×3 SubDataFrame
Row │ a b c
│ Int64 Int64 Int64
─────┼─────────────────────
1 │ 4 1 4
2 │ 4 1 8
#
DataFrames.groupcols
— Function
groupcols(gd::GroupedDataFrame)
Возвращает вектор Symbol
имен столбцов в parent(gd)
, используемой для группировки.
#
DataFrames.groupindices
— Function
groupindices(gd::GroupedDataFrame)
Возвращает вектор индексов групп для каждой строки parent(gd)
.
Строкам, появляющимся в группе gd[i]
, присваивается индекс i
. Строкам, отсутствующим в любых группах, присваивается missing
(это может произойти, если skipmissing=true
было передано при создании gd
, или если gd
является подмножеством из более крупного GroupedDataFrame
).
Синтаксис groupindices => target_col_name
(или просто groupindices
без без указания имени целевого столбца) также поддерживается в мини-языке преобразования при передаче GroupedDataFrame
функциям преобразования (combine
, select
и т. д.).
Примеры
julia> df = DataFrame(id=["a", "c", "b", "b", "a"])
5×1 DataFrame
Row │ id
│ String
─────┼────────
1 │ a
2 │ c
3 │ b
4 │ b
5 │ a
julia> gdf = groupby(df, :id);
julia> combine(gdf, groupindices)
3×2 DataFrame
Row │ id groupindices
│ String Int64
─────┼──────────────────────
1 │ a 1
2 │ c 2
3 │ b 3
julia> select(gdf, groupindices => :gid)
5×2 DataFrame
Row │ id gid
│ String Int64
─────┼───────────────
1 │ a 1
2 │ c 2
3 │ b 3
4 │ b 3
5 │ a 1
#
Base.keys
— Function
keys(gd::GroupedDataFrame)
Get the set of keys for each group of the GroupedDataFrame
gd
as a GroupKeys
object. Each key is a GroupKey
, which behaves like a NamedTuple
holding the values of the grouping columns for a given group. Unlike the equivalent Tuple
, NamedTuple
, and AbstractDict
, these keys can be used to index into gd
efficiently. The ordering of the keys is identical to the ordering of the groups of gd
under iteration and integer indexing.
Examples
julia> df = DataFrame(a=repeat([:foo, :bar, :baz], outer=[4]),
b=repeat([2, 1], outer=[6]),
c=1:12);
julia> gd = groupby(df, [:a, :b])
GroupedDataFrame with 6 groups based on keys: a, b
First Group (2 rows): a = :foo, b = 2
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ foo 2 1
2 │ foo 2 7
⋮
Last Group (2 rows): a = :baz, b = 1
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ baz 1 6
2 │ baz 1 12
julia> keys(gd)
6-element DataFrames.GroupKeys{GroupedDataFrame{DataFrame}}:
GroupKey: (a = :foo, b = 2)
GroupKey: (a = :bar, b = 1)
GroupKey: (a = :baz, b = 2)
GroupKey: (a = :foo, b = 1)
GroupKey: (a = :bar, b = 2)
GroupKey: (a = :baz, b = 1)
julia> k = keys(gd)[1]
GroupKey: (a = :foo, b = 2)
julia> keys(k)
2-element Vector{Symbol}:
:a
:b
julia> values(k) # Same as Tuple(k)
(:foo, 2)
julia> NamedTuple(k)
(a = :foo, b = 2)
julia> k.a
:foo
julia> k[:a]
:foo
julia> k[1]
:foo
Keys can be used as indices to retrieve the corresponding group from their GroupedDataFrame
:
julia> gd[k]
2×3 SubDataFrame
Row │ a b c
│ Symbol Int64 Int64
─────┼──────────────────────
1 │ foo 2 1
2 │ foo 2 7
julia> gd[keys(gd)[1]] == gd[1]
true
keys(dfc::DataFrameColumns)
Get a vector of column names of dfc
as Symbol
s.
#
DataFrames.proprow
— Function
proprow
Вычисляет долю строк, принадлежащих каждой группе, т. е. количество строк, деленное на общее количество строк в GroupedDataFrame
.
Эту функцию можно использовать только в мини-языке преобразования через синтаксис proprow => target_col_name
(или просто proprow
без указания имени целевого столбца) при передаче GroupedDataFrame
функциям преобразования (combine
, select
и т. д.).
Примеры
julia> df = DataFrame(id=["a", "c", "b", "b", "a", "b"])
6×1 DataFrame
Row │ id
│ String
─────┼────────
1 │ a
2 │ c
3 │ b
4 │ b
5 │ a
6 │ b
julia> gdf = groupby(df, :id);
julia> combine(gdf, proprow)
3×2 DataFrame
Row │ id proprow
│ String Float64
─────┼──────────────────
1 │ a 0.333333
2 │ c 0.166667
3 │ b 0.5
julia> select(gdf, proprow => :frac)
6×2 DataFrame
Row │ id frac
│ String Float64
─────┼──────────────────
1 │ a 0.333333
2 │ c 0.166667
3 │ b 0.5
4 │ b 0.5
5 │ a 0.333333
6 │ b 0.5
#
DataFrames.valuecols
— Function
valuecols(gd::GroupedDataFrame)
Возвращает вектор Symbol
имен столбцов в parent(gd)
, не используемой для группировки.
Фильтрация строк
#
Base.allunique
— Function
allunique(df::AbstractDataFrame, cols=:)
Возвращает true
, если ни одна из строк df
не дублируется. Две строки являются дубликатами, если все их столбцы содержат одинаковые значения (согласно isequal
) для всех столбцов в cols
(по умолчанию все столбцы).
Аргументы
-
df
:AbstractDataFrame
-
cols
: селектор, указывающий сравниваемые столбцы или их преобразования. Это может быть любой селектор столбцов или преобразование, принимаемоеselect
.
Примеры
julia> df = DataFrame(i=1:4, x=[1, 2, 1, 2])
4×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
julia> allunique(df)
true
julia> allunique(df, :x)
false
julia> allunique(df, :i => ByRow(isodd))
false
#
Base.deleteat!
— Function
deleteat!(df::DataFrame, inds)
Удаляет компоненты, указанные с помощью inds
, из DataFrame
df
на месте и возвращает его.
Внутренним образом deleteat!
вызывается для всех столбцов, поэтому inds
должен быть вектором отсортированных и уникальных целых чисел, логическим вектором, целым числом или Not
, заключающим в оболочку любой допустимый селектор.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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> deleteat!(df, 2)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
2 │ 3 6
#
Base.empty
— Function
empty(df::AbstractDataFrame)
Создает новый DataFrame
с теми же именами столбцов и типами элементов столбцов, что и df
, но без строк.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
#
Base.empty!
— Function
empty!(df::DataFrame)
Удаляет все строки из df
, делая каждый из его столбцов пустым.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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> empty!(df)
0×2 DataFrame
Row │ a b
│ Int64 Int64
─────┴──────────────
julia> df.a, df.b
(Int64[], Int64[])
#
Base.filter
— Function
filter(fun, df::AbstractDataFrame; view::Bool=false)
filter(cols => fun, df::AbstractDataFrame; view::Bool=false)
Возвращает фрейм данных, содержащий только строки из df
, для которого fun
возвращает true
.
Если cols
не указан, предикату fun
передаются DataFrameRow
. К элементам DataFrameRow
можно получать доступ с помощью точечного синтаксиса или индексирования столбцов внутри fun
.
Если cols
не указан, предикату fun
передаются элементы соответствующих столбцов в виде отдельных позиционных аргументов, если только cols
не является селектором AsTable
. В этом случае передается NamedTuple
этих аргументов. cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел), и дубликаты столбцов разрешены, если передается вектор символов (Symbol
), строк или целых чисел.
Если view=false
, возвращается только что выделенный DataFrame
. Если view=true
, то возвращается представление SubDataFrame
для df
.
Передача cols
приводит к более эффективному выполнению операции для больших фреймов данных.
Этот метод определен, чтобы пакет DataFrames.jl реализовал API Julia для коллекций, но обычно рекомендуется использовать вместо него функцию |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
См. также описание filter!
.
Примеры
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 2 a
4 │ 1 b
julia> filter(row -> row.x > 1, df)
2×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
julia> filter(row -> row["x"] > 1, df)
2×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
julia> filter(:x => x -> x > 1, df)
2×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
julia> filter([:x, :y] => (x, y) -> x == 1 || y == "b", df)
3×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 1 b
julia> filter(AsTable(:) => nt -> nt.x == 1 || nt.y == "b", df)
3×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 1 b
filter(fun, gdf::GroupedDataFrame; ungroup::Bool=false) filter(cols => fun, gdf::GroupedDataFrame; ungroup::Bool=false)
Возвращает только группы в gd
, для которых fun
возвращает true
в виде GroupedDataFrame
, если ungroup=false
(по умолчанию), или в виде фрейма данных, если ungroup=true
.
Если cols
не указан, предикат fun
вызывается с SubDataFrame
для каждой группы.
Если cols
не указан, предикат fun
вызывается для каждой группы с представлениями соответствующих столбцов в виде отдельных позиционных аргументов, если только cols
не является селектором AsTable
. В этом случае передается NamedTuple
этих аргументов. cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел), дубликаты столбцов разрешены, если передается вектор символов (Symbol
), строк или целых чисел.
Этот метод определен, чтобы пакет DataFrames.jl реализовал API Julia для коллекций, но обычно рекомендуется использовать вместо него функцию |
Примеры
julia> df = DataFrame(g=[1, 2], x=['a', 'b']);
julia> gd = groupby(df, :g)
GroupedDataFrame with 2 groups based on key: g
First Group (1 row): g = 1
Row │ g x
│ Int64 Char
─────┼─────────────
1 │ 1 a
⋮
Last Group (1 row): g = 2
Row │ g x
│ Int64 Char
─────┼─────────────
1 │ 2 b
julia> filter(x -> x.x[1] == 'a', gd)
GroupedDataFrame with 1 group based on key: g
First Group (1 row): g = 1
Row │ g x
│ Int64 Char
─────┼─────────────
1 │ 1 a
julia> filter(:x => x -> x[1] == 'a', gd)
GroupedDataFrame with 1 group based on key: g
First Group (1 row): g = 1
Row │ g x
│ Int64 Char
─────┼─────────────
1 │ 1 a
julia> filter(:x => x -> x[1] == 'a', gd, ungroup=true)
1×2 DataFrame
Row │ g x
│ Int64 Char
─────┼─────────────
1 │ 1 a
#
Base.filter!
— Function
filter!(fun, df::AbstractDataFrame)
filter!(cols => fun, df::AbstractDataFrame)
Удаляет строки из фрейма данных df
, для которого fun
возвращает false
.
Если cols
не указан, предикату fun
передаются DataFrameRow
. К элементам DataFrameRow
можно получать доступ с помощью точечного синтаксиса или индексирования столбцов внутри fun
.
Если cols
не указан, предикату fun
передаются элементы соответствующих столбцов в виде отдельных позиционных аргументов, если только cols
не является селектором AsTable
. В этом случае передается NamedTuple
этих аргументов. cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел), и дубликаты столбцов разрешены, если передается вектор символов (Symbol
), строк или целых чисел.
Передача cols
приводит к более эффективному выполнению операции для больших фреймов данных.
Этот метод определен, чтобы пакет DataFrames.jl реализовал API Julia для коллекций, но обычно рекомендуется использовать вместо него функцию |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
См. также описание filter
.
Примеры
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"])
4×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 2 a
4 │ 1 b
julia> filter!(row -> row.x > 1, df)
2×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
julia> filter!(row -> row["x"] > 1, df)
2×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 2 a
julia> filter!(:x => x -> x == 3, df)
1×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"]);
julia> filter!([:x, :y] => (x, y) -> x == 1 || y == "b", df)
3×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 1 b
julia> df = DataFrame(x=[3, 1, 2, 1], y=["b", "c", "a", "b"]);
julia> filter!(AsTable(:) => nt -> nt.x == 1 || nt.y == "b", df)
3×2 DataFrame
Row │ x y
│ Int64 String
─────┼───────────────
1 │ 3 b
2 │ 1 c
3 │ 1 b
#
Base.keepat!
— Function
keepat!(df::DataFrame, inds)
Удаляет строки по всем индексам, не указанным с помощью inds
, из DataFrame
df
на месте и возвращает его.
Внутренним образом deleteat!
вызывается для всех столбцов, поэтому inds
должен быть вектором отсортированных и уникальных целых чисел, логическим вектором, целым числом или Not
, заключающим в оболочку любой допустимый селектор.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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
#
Base.first
— Function
first(df::AbstractDataFrame)
Получает первую строку df
в виде DataFrameRow
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
first(df::AbstractDataFrame, n::Integer; view::Bool=false)
Получает фрейм данных с n
последних строк df
.
Если view=false
, возвращается только что выделенный DataFrame
. Если view=true
, возвращается представление SubDataFrame
для df
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
#
Base.last
— Function
last(df::AbstractDataFrame)
Получает последнюю строку df
в виде DataFrameRow
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
last(df::AbstractDataFrame, n::Integer; view::Bool=false)
Получает фрейм данных с n
последних строк df
.
Если view=false
, возвращается только что выделенный DataFrame
. Если view=true
, возвращается представление SubDataFrame
для df
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
#
DataFrames.nonunique
— Function
nonunique(df::AbstractDataFrame; keep::Symbol=:first)
nonunique(df::AbstractDataFrame, cols; keep::Symbol=:first)
Возвращает Vector{Bool}
, в котором записи true
означают повторяющиеся строки.
Повторяющиеся строки — это строки, для которых по крайней мере еще одна строка содержит одинаковые значения (согласно isequal
) для всех столбцов в cols
(по умолчанию все столбцы). Если keep=:first
(по умолчанию), только первое вхождение набора повторяющихся строк обозначается записью false
. Если keep=:last
(по умолчанию), только последнее вхождение набора повторяющихся строк обозначается записью false
. Если keep=:noduplicates
, только строки без дубликатов обозначаются записью false
.
Аргументы
-
df
:AbstractDataFrame
. -
cols
: селектор, указывающий сравниваемые столбцы или их преобразования. Это может быть любой селектор столбцов или преобразование, принимаемое
функцией select
, которая возвращает хотя бы один столбец, если df
имеет как минимум один столбец.
Примеры
julia> df = DataFrame(i=1:4, x=[1, 2, 1, 2])
4×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
julia> df = vcat(df, df)
8×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
5 │ 1 1
6 │ 2 2
7 │ 3 1
8 │ 4 2
julia> nonunique(df)
8-element Vector{Bool}:
0
0
0
0
1
1
1
1
julia> nonunique(df, keep=:last)
8-element Vector{Bool}:
1
1
1
1
0
0
0
0
julia> nonunique(df, 2)
8-element Vector{Bool}:
0
0
1
1
1
1
1
1
#
Base.Iterators.only
— Function
only(df::AbstractDataFrame)
Если df
содержит одну строку, возвращает его как DataFrameRow
. В противном случае возникает ошибка ArgumentError
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
#
Base.pop!
— Function
pop!(df::DataFrame)
Удаляет последнюю строку из df
и возвращает кортеж (NamedTuple
), созданный из этой строки.
Использование этого метода для очень широких массивов данных может привести к дорогостоящей компиляции. |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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> pop!(df)
(a = 3, b = 6)
julia> df
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
2 │ 2 5
#
Base.popat!
— Function
popat!(df::DataFrame, i::Integer)
Удаляет i
-ю строку из df
и возвращает кортеж (NamedTuple
), созданный из этой строки.
Использование этого метода для очень широких массивов данных может привести к дорогостоящей компиляции. |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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> popat!(df, 2)
(a = 2, b = 5)
julia> df
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
2 │ 3 6
#
Base.popfirst!
— Function
popfirst!(df::DataFrame)
Удаляет первую строку из df
и возвращает NamedTuple
, созданный из этой строки.
Использование этого метода для очень широких массивов данных может привести к дорогостоящей компиляции. |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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> popfirst!(df)
(a = 1, b = 4)
julia> df
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 2 5
2 │ 3 6
#
Base.resize!
— Function
resize!(df::DataFrame, n::Integer)
Изменяет размер df
, чтобы получить n
строк путем вызова функции resize!
для всех столбцов df
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
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> resize!(df, 2)
2×2 DataFrame
Row │ a b
│ Int64 Int64
─────┼──────────────
1 │ 1 4
2 │ 2 5
#
DataFrames.subset
— Function
subset(df::AbstractDataFrame, args...;
skipmissing::Bool=false, view::Bool=false, threads::Bool=true)
subset(gdf::GroupedDataFrame, args...;
skipmissing::Bool=false, view::Bool=false,
ungroup::Bool=true, threads::Bool=true)
Возвращает копию фрейма данных df
или родителя gdf
, содержащую только строки, для которых все значения, полученные преобразованиями args
, для заданной строки имеют значение true
. Все преобразования должны создавать векторы, содержащие true
или false
. Когда первый аргумент является GroupedDataFrame
, преобразования также могут возвращать одно значение true
или false
, что приводит к включению или исключению целой группы.
Если skipmissing=false
(по умолчанию), args
требуются для получения результатов, содержащих только логические (Bool
) значения. Если skipmissing=true
, допускается дополнительное значение missing
, которое рассматривается как false
(т. е. строки, для которых одно из условий возвращает missing
, пропускаются).
Каждый аргумент, передаваемый в args
, может быть любым спецификатором, соответствующим правилам, описанным для select
, с ограничением, что:
-
указание имени целевого столбца недопустимо, поскольку
subset
не создает новых столбцов; -
каждое переданное преобразование должно возвращать скаляр или вектор (возвращение
AbstractDataFrame
,NamedTuple
,DataFrameRow
илиAbstractMatrix
не поддерживается).
Если view=true
, возвращается представление SubDataFrame
вместо DataFrame
.
Если ungroup=false
, результирующий фрейм данных перегруппировывается на основе тех же столбцов группировки, что и gdf
, и возвращается GroupedDataFrame
(с сохранением порядка групп из gdf
).
Если threads=true
(по умолчанию), преобразования могут осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значение false
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Если передается GroupedDataFrame
, он должен включать все группы, присутствующие во фрейме данных parent
, как в select!
.
Обратите внимание, что функция |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(id=1:4, x=[true, false, true, false],
y=[true, true, false, false],
z=[true, true, missing, missing], v=[1, 2, 11, 12])
4×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────────
1 │ 1 true true true 1
2 │ 2 false true true 2
3 │ 3 true false missing 11
4 │ 4 false false missing 12
julia> subset(df, :x)
2×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼────────────────────────────────────
1 │ 1 true true true 1
2 │ 3 true false missing 11
julia> subset(df, :v => x -> x .> 3)
2×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────────
1 │ 3 true false missing 11
2 │ 4 false false missing 12
julia> subset(df, :x, :y => ByRow(!))
1×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼────────────────────────────────────
1 │ 3 true false missing 11
julia> subset(df, :x, :z, skipmissing=true)
1×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────
1 │ 1 true true true 1
julia> subset(df, :x, :z)
ERROR: ArgumentError: missing was returned in condition number 2 but only true or false are allowed; pass skipmissing=true to skip missing values
julia> subset(groupby(df, :y), :v => x -> x .> minimum(x))
2×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────────
1 │ 2 false true true 2
2 │ 4 false false missing 12
julia> subset(groupby(df, :y), :v => x -> minimum(x) > 5)
2×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────────
1 │ 3 true false missing 11
2 │ 4 false false missing 12
#
DataFrames.subset!
— Function
subset!(df::AbstractDataFrame, args...;
skipmissing::Bool=false, threads::Bool=true)
subset!(gdf::GroupedDataFrame{DataFrame}, args...;
skipmissing::Bool=false, ungroup::Bool=true, threads::Bool=true)
Обновляет фрейм данных df
или родитель gdf
на месте так, чтобы он содержал только строки, для которых все значения, полученные преобразованиями args
, для заданной строки имеют значение true
. Все преобразования должны создавать векторы, содержащие true
или false
. Если первый аргумент является GroupedDataFrame
, преобразования также могут возвращать одно значение true
или false
, что приводит к включению или исключению целой группы.
Если skipmissing=false
(по умолчанию), args
требуются для получения результатов, содержащих только логические (Bool
) значения. Если skipmissing=true
, допускается дополнительное значение missing
, которое рассматривается как false
(т. е. строки, для которых одно из условий возвращает missing
, пропускаются).
Каждый аргумент, передаваемый в args
, может быть любым спецификатором, соответствующим правилам, описанным для select
, с ограничением, что:
-
указание имени целевого столбца недопустимо, поскольку
subset!
не создает новых столбцов; -
каждое переданное преобразование должно возвращать скаляр или вектор (возвращение
AbstractDataFrame
,NamedTuple
,DataFrameRow
илиAbstractMatrix
не поддерживается).
Если ungroup=false
, передаваемый GroupedDataFrame
gdf
, обновляется (с сохранением порядка его групп) и возвращается.
Если threads=true
(по умолчанию), преобразования могут осуществляться в отдельных задачах, которые могут выполняться параллельно (возможно, с применением к нескольким строкам или группам одновременно). Тот момент, порождаются ли задачи, и их количество определяется автоматически. Установите значение false
, если некоторые преобразования требуют последовательного выполнения или не являются потокобезопасными.
Если GroupedDataFrame
является подмножеством, он должен включать все группы, присутствующие в родительском (parent
) фрейме данных, как в select!
. В этом случае передаваемый GroupedDataFrame
обновляется так, чтобы иметь правильные группы, после того как его родитель будет обновлен.
Обратите внимание, что функция |
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(id=1:4, x=[true, false, true, false], y=[true, true, false, false])
4×3 DataFrame
Row │ id x y
│ Int64 Bool Bool
─────┼─────────────────────
1 │ 1 true true
2 │ 2 false true
3 │ 3 true false
4 │ 4 false false
julia> subset!(df, :x, :y => ByRow(!));
julia> df
1×3 DataFrame
Row │ id x y
│ Int64 Bool Bool
─────┼────────────────────
1 │ 3 true false
julia> df = DataFrame(id=1:4, y=[true, true, false, false], v=[1, 2, 11, 12]);
julia> subset!(groupby(df, :y), :v => x -> x .> minimum(x));
julia> df
2×3 DataFrame
Row │ id y v
│ Int64 Bool Int64
─────┼─────────────────────
1 │ 2 true 2
2 │ 4 false 12
julia> df = DataFrame(id=1:4, x=[true, false, true, false],
z=[true, true, missing, missing], v=1:4)
4×4 DataFrame
Row │ id x z v
│ Int64 Bool Bool? Int64
─────┼──────────────────────────────
1 │ 1 true true 1
2 │ 2 false true 2
3 │ 3 true missing 3
4 │ 4 false missing 4
julia> subset!(df, :x, :z)
ERROR: ArgumentError: missing was returned in condition number 2 but only true or false are allowed; pass skipmissing=true to skip missing values
julia> subset!(df, :x, :z, skipmissing=true);
julia> df
1×4 DataFrame
Row │ id x z v
│ Int64 Bool Bool? Int64
─────┼───────────────────────────
1 │ 1 true true 1
julia> df = DataFrame(id=1:4, x=[true, false, true, false], y=[true, true, false, false],
z=[true, true, missing, missing], v=[1, 2, 11, 12]);
julia> subset!(groupby(df, :y), :v => x -> x .> minimum(x));
julia> df
2×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────────
1 │ 2 false true true 2
2 │ 4 false false missing 12
julia> df = DataFrame(id=1:4, x=[true, false, true, false], y=[true, true, false, false],
z=[true, true, missing, missing], v=[1, 2, 11, 12]);
julia> subset!(groupby(df, :y), :v => x -> minimum(x) > 5);
julia> df
2×5 DataFrame
Row │ id x y z v
│ Int64 Bool Bool Bool? Int64
─────┼─────────────────────────────────────
1 │ 3 true false missing 11
2 │ 4 false false missing 12
#
Base.unique
— Function
unique(df::AbstractDataFrame; view::Bool=false, keep::Symbol=:first)
unique(df::AbstractDataFrame, cols; view::Bool=false, keep::Symbol=:first)
Возвращает фрейм данных, содержащий только уникальные строки в df
.
Неуникальные (повторяющиеся) строки — это строки, для которых по крайней мере еще одна строка содержит одинаковые значения (согласно isequal
) для всех столбцов в cols
(по умолчанию все столбцы). Если keep=:first
(по умолчанию), сохраняется только первое вхождение набора повторяющихся строк. Если keep=:last
(по умолчанию), сохраняется только последнее вхождение набора повторяющихся строк. Если keep=:noduplicates
, сохраняются только строки без дубликатов.
Если view=false
, возвращается только что выделенный DataFrame
, а если view=true
, возвращается представление SubDataFrame
для df
.
Аргументы
-
df
: AbstractDataFrame. -
cols
: селектор, указывающий сравниваемые столбцы или их преобразования. Это может быть любой селектор столбцов или преобразование, принимаемое
функцией select
, которая возвращает хотя бы один столбец, если df
имеет как минимум один столбец.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(i=1:4, x=[1, 2, 1, 2])
4×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
julia> df = vcat(df, df)
8×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
5 │ 1 1
6 │ 2 2
7 │ 3 1
8 │ 4 2
julia> unique(df) # не изменяет фрейм данных
4×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
julia> unique(df, 2)
2×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
julia> unique(df, keep=:noduplicates)
0×2 DataFrame
Row │ i x
│ Int64 Int64
─────┴──────────────
#
Base.unique!
— Function
unique!(df::AbstractDataFrame; keep::Symbol=:first)
unique!(df::AbstractDataFrame, cols; keep::Symbol=:first)
Обновляет фрейм данных (df
) на месте так, чтобы он содержал только уникальные строки.
Неуникальные (повторяющиеся) строки — это строки, для которых по крайней мере еще одна строка содержит одинаковые значения (согласно isequal
) для всех столбцов в cols
(по умолчанию все столбцы). Если keep=:first
(по умолчанию), сохраняется только первое вхождение набора повторяющихся строк. Если keep=:last
(по умолчанию), сохраняется только последнее вхождение набора повторяющихся строк. Если keep=:noduplicates
, сохраняются только строки без дубликатов.
Аргументы
-
df
: AbstractDataFrame. -
cols
: индикатор столбца (Symbol
,Int
,Vector{Symbol}
,Regex
и т. д.), указывающий сравниваемые столбцы. Это может быть любой селектор столбцов или преобразование, принимаемое функциейselect
, которая возвращает хотя бы один столбец, еслиdf
имеет как минимум один столбец.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(i=1:4, x=[1, 2, 1, 2])
4×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
julia> df = vcat(df, df)
8×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
5 │ 1 1
6 │ 2 2
7 │ 3 1
8 │ 4 2
julia> unique!(copy(df)) # изменяет фрейм данных
4×2 DataFrame
Row │ i x
│ Int64 Int64
─────┼──────────────
1 │ 1 1
2 │ 2 2
3 │ 3 1
4 │ 4 2
julia> unique(df, keep=:noduplicates)
0×2 DataFrame
Row │ i x
│ Int64 Int64
─────┴──────────────
Работа с отсутствующими значениями
#
Missings.allowmissing
— Function
allowmissing(df::AbstractDataFrame, cols=:)
Возвращает копию фрейма данных df
со столбцами cols
, преобразованными в тип элемента Union{T, Missing}
из T
, чтобы обеспечить поддержку отсутствующих значений.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если cols
отсутствует, преобразуются все столбцы во фрейме данных.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(a=[1, 2])
2×1 DataFrame
Row │ a
│ Int64
─────┼───────
1 │ 1
2 │ 2
julia> allowmissing(df)
2×1 DataFrame
Row │ a
│ Int64?
─────┼────────
1 │ 1
2 │ 2
#
DataFrames.allowmissing!
— Function
allowmissing!(df::DataFrame, cols=:)
Преобразует столбцы cols
фрейма данных df
из типа элемента T
в Union{T, Missing}
для поддержки отсутствующих значений.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если cols
отсутствует, преобразуются все столбцы во фрейме данных.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
#
DataFrames.completecases
— Function
completecases(df::AbstractDataFrame, cols=:)
Возвращает логический вектор с записями true
, указывающими строки без отсутствующих значений (завершенные случаи) во фрейме данных df
.
Если указано значение cols
, учитываются только отсутствующие значения в соответствующих столбцах. cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел), который возвращает хотя бы один столбец, если df
имеет как минимум один столбец.
См. также описание dropmissing
и dropmissing!
. Используйте findall(completecases(df))
для получения индексов строк.
Примеры
julia> df = DataFrame(i=1:5,
x=[missing, 4, missing, 2, 1],
y=[missing, missing, "c", "d", "e"])
5×3 DataFrame
Row │ i x y
│ Int64 Int64? String?
─────┼─────────────────────────
1 │ 1 missing missing
2 │ 2 4 missing
3 │ 3 missing c
4 │ 4 2 d
5 │ 5 1 e
julia> completecases(df)
5-element BitVector:
0
0
0
1
1
julia> completecases(df, :x)
5-element BitVector:
0
1
0
1
1
julia> completecases(df, [:x, :y])
5-element BitVector:
0
0
0
1
1
#
Missings.disallowmissing
— Function
disallowmissing(df::AbstractDataFrame, cols=:; error::Bool=true)
Возвращает копию фрейма данных df
со столбцами cols
, преобразованными из типа элемента Union{T, Missing}
в T
, чтобы отменить поддержку отсутствующих значений.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если cols
отсутствует, преобразуются все столбцы во фрейме данных.
Если error=false
, ошибка не возникает, а столбцы, содержащие значение missing
, пропускаются.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(a=Union{Int, Missing}[1, 2])
2×1 DataFrame
Row │ a
│ Int64?
─────┼────────
1 │ 1
2 │ 2
julia> disallowmissing(df)
2×1 DataFrame
Row │ a
│ Int64
─────┼───────
1 │ 1
2 │ 2
julia> df = DataFrame(a=[1, missing])
2×1 DataFrame
Row │ a
│ Int64?
─────┼─────────
1 │ 1
2 │ missing
julia> disallowmissing(df, error=false)
2×1 DataFrame
Row │ a
│ Int64?
─────┼─────────
1 │ 1
2 │ missing
#
DataFrames.disallowmissing!
— Function
disallowmissing!(df::DataFrame, cols=:; error::Bool=true)
Преобразует столбцы cols
фрейма данных df
из типа элемента Union{T, Missing}
в T
, чтобы отменить поддержку отсутствующих значений.
cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если cols
отсутствует, преобразуются все столбцы во фрейме данных.
Если error=false
, ошибка не возникает, а столбцы, содержащие значение missing
, пропускаются.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
#
DataFrames.dropmissing
— Function
dropmissing(df::AbstractDataFrame, cols=:; view::Bool=false, disallowmissing::Bool=!view)
Возвращает фрейм данных, исключающий строки с отсутствующими значениями в df
.
Если указано значение cols
, учитываются только отсутствующие значения в соответствующих столбцах. cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если view=false
, возвращается только что выделенный DataFrame
. Если view=true
, возвращается представление SubDataFrame
для df
. В данном случае disallowmissing
должен иметь значение false
.
Если disallowmissing
имеет значение true
(по умолчанию, когда view
имеет значение false
), столбцы, указанные в cols
, будут преобразованы так, чтобы запрещать отсутствующие значения, с помощью disallowmissing!
.
См. также описание completecases
и dropmissing!
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
Примеры
julia> df = DataFrame(i=1:5,
x=[missing, 4, missing, 2, 1],
y=[missing, missing, "c", "d", "e"])
5×3 DataFrame
Row │ i x y
│ Int64 Int64? String?
─────┼─────────────────────────
1 │ 1 missing missing
2 │ 2 4 missing
3 │ 3 missing c
4 │ 4 2 d
5 │ 5 1 e
julia> dropmissing(df)
2×3 DataFrame
Row │ i x y
│ Int64 Int64 String
─────┼──────────────────────
1 │ 4 2 d
2 │ 5 1 e
julia> dropmissing(df, disallowmissing=false)
2×3 DataFrame
Row │ i x y
│ Int64 Int64? String?
─────┼────────────────────────
1 │ 4 2 d
2 │ 5 1 e
julia> dropmissing(df, :x)
3×3 DataFrame
Row │ i x y
│ Int64 Int64 String?
─────┼───────────────────────
1 │ 2 4 missing
2 │ 4 2 d
3 │ 5 1 e
julia> dropmissing(df, [:x, :y])
2×3 DataFrame
Row │ i x y
│ Int64 Int64 String
─────┼──────────────────────
1 │ 4 2 d
2 │ 5 1 e
#
DataFrames.dropmissing!
— Function
dropmissing!(df::AbstractDataFrame, cols=:; disallowmissing::Bool=true)
Удаляет строки с отсутствующими значениями из фрейма данных df
и возвращает его.
Если указано значение cols
, учитываются только отсутствующие значения в соответствующих столбцах. cols
может представлять собой любой селектор столбцов (символ (Symbol
), строку или целое число; :
, Cols
, All
, Between
, Not
, регулярное выражение или вектор символов (Symbol
), строк или целых чисел).
Если disallowmissing
имеет значение true
(по умолчанию), столбцы cols
преобразуются с помощью disallowmissing!
.
Метаданные: эта функция сохраняет метаданные на уровне таблиц и столбцов в стиле :note
.
См. также описание dropmissing
и completecases
.
julia> df = DataFrame(i=1:5,
x=[missing, 4, missing, 2, 1],
y=[missing, missing, "c", "d", "e"])
5×3 DataFrame
Row │ i x y
│ Int64 Int64? String?
─────┼─────────────────────────
1 │ 1 missing missing
2 │ 2 4 missing
3 │ 3 missing c
4 │ 4 2 d
5 │ 5 1 e
julia> dropmissing!(copy(df))
2×3 DataFrame
Row │ i x y
│ Int64 Int64 String
─────┼──────────────────────
1 │ 4 2 d
2 │ 5 1 e
julia> dropmissing!(copy(df), disallowmissing=false)
2×3 DataFrame
Row │ i x y
│ Int64 Int64? String?
─────┼────────────────────────
1 │ 4 2 d
2 │ 5 1 e
julia> dropmissing!(copy(df), :x)
3×3 DataFrame
Row │ i x y
│ Int64 Int64 String?
─────┼───────────────────────
1 │ 2 4 missing
2 │ 4 2 d
3 │ 5 1 e
julia> dropmissing!(df, [:x, :y])
2×3 DataFrame
Row │ i x y
│ Int64 Int64 String
─────┼──────────────────────
1 │ 4 2 d
2 │ 5 1 e
Итерация
#
Base.eachcol
— Function
eachcol(df::AbstractDataFrame)
Возвращает объект DataFrameColumns
, подобный вектору, который позволяет итерировать AbstractDataFrame
по столбцам.
Индексирование в объектах DataFrameColumns
с использованием целого числа, Symbol
или строки возвращает соответствующий столбец (без копирования). Индексирование в объектах DataFrameColumns
с использованием селектора нескольких столбцов возвращает являющийся подмножеством объект DataFrameColumns
с новым родителем, содержащим только выбранные столбцы (без копирования).
DataFrameColumns
поддерживает большую часть API AbstractVector
. Основные отличия заключаются в том, что он доступен только для чтения и функция keys
возвращает вектор символов (Symbol
) (а не целых чисел, как для обычных векторов).
В частности, поддерживаются функции findnext
, findprev
, findfirst
, findlast
и findall
, и в функциях findnext
и findprev
разрешается передавать целое число, строку или символ (Symbol
) в качестве эталонного индекса.
Примеры
julia> df = DataFrame(x=1:4, y=11:14)
4×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 11
2 │ 2 12
3 │ 3 13
4 │ 4 14
julia> eachcol(df)
4×2 DataFrameColumns
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 11
2 │ 2 12
3 │ 3 13
4 │ 4 14
julia> collect(eachcol(df))
2-element Vector{AbstractVector}:
[1, 2, 3, 4]
[11, 12, 13, 14]
julia> map(eachcol(df)) do col
maximum(col) - minimum(col)
end
2-element Vector{Int64}:
3
3
julia> sum.(eachcol(df))
2-element Vector{Int64}:
10
50
#
Base.eachrow
— Function
eachrow(df::AbstractDataFrame)
Возвращает DataFrameRows
, который построчно итерирует фрейм данных, где каждая строка представлена как DataFrameRow
.
Поскольку DataFrameRow
имеют тип элемента (eltype
) Any
, используйте copy(dfr::DataFrameRow)
, чтобы получить именованный кортеж, который поддерживает итерацию и доступ к свойствам, как DataFrameRow
, но также передает информацию о типах элементов (eltypes
) столбцов df
.
Примеры
julia> df = DataFrame(x=1:4, y=11:14)
4×2 DataFrame
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 11
2 │ 2 12
3 │ 3 13
4 │ 4 14
julia> eachrow(df)
4×2 DataFrameRows
Row │ x y
│ Int64 Int64
─────┼──────────────
1 │ 1 11
2 │ 2 12
3 │ 3 13
4 │ 4 14
julia> copy.(eachrow(df))
4-element Vector{NamedTuple{(:x, :y), Tuple{Int64, Int64}}}:
(x = 1, y = 11)
(x = 2, y = 12)
(x = 3, y = 13)
(x = 4, y = 14)
julia> eachrow(view(df, [4, 3], [2, 1]))
2×2 DataFrameRows
Row │ y x
│ Int64 Int64
─────┼──────────────
1 │ 14 4
2 │ 13 3
#
Base.pairs
— Function
pairs(dfc::DataFrameColumns)
Возвращает итератор пар, связывающих имя каждого столбца dfc
соответствующим вектором столбцов, т. е. name => col
, где name
— имя столбца col
.
#
Base.Iterators.partition
— Function
Iterators.partition(df::AbstractDataFrame, n::Integer)
Выполняет итерацию по фрейму данных df
по n
строк за раз, возвращая каждый блок в виде SubDataFrame
.
Примеры
julia> collect(Iterators.partition(DataFrame(x=1:5), 2))
3-element Vector{SubDataFrame{DataFrame, DataFrames.Index, UnitRange{Int64}}}:
2×1 SubDataFrame
Row │ x
│ Int64
─────┼───────
1 │ 1
2 │ 2
2×1 SubDataFrame
Row │ x
│ Int64
─────┼───────
1 │ 3
2 │ 4
1×1 SubDataFrame
Row │ x
│ Int64
─────┼───────
1 │ 5
Iterators.partition(dfr::DataFrameRows, n::Integer)
Выполняет итерацию по фрейму данных dfr
DataFrameRows
по n
строк за раз, возвращая каждый блок в виде DataFrameRows
в представлении строк родителя dfr
.
Примеры
julia> collect(Iterators.partition(eachrow(DataFrame(x=1:5)), 2))
3-element Vector{DataFrames.DataFrameRows{SubDataFrame{DataFrame, DataFrames.Index, UnitRange{Int64}}}}:
2×1 DataFrameRows
Row │ x
│ Int64
─────┼───────
1 │ 1
2 │ 2
2×1 DataFrameRows
Row │ x
│ Int64
─────┼───────
1 │ 3
2 │ 4
1×1 DataFrameRows
Row │ x
│ Int64
─────┼───────
1 │ 5
Равенство
#
Base.isapprox
— Function
isapprox(df1::AbstractDataFrame, df2::AbstractDataFrame;
rtol::Real=atol>0 ? 0 : √eps, atol::Real=0,
nans::Bool=false, norm::Function=norm)
Неточное сравнение на равенство. df1
и df2
должны иметь одинаковый размер и имена столбцов. Возвращает true
, если isapprox
с заданными именованными аргументами, примененными ко всем парам столбцов, хранящихся в df1
и df2
, возвращает true
.
Метаданные
#
DataAPI.metadata
— Function
metadata(df::AbstractDataFrame, key::AbstractString, [default]; style::Bool=false)
metadata(dfr::DataFrameRow, key::AbstractString, [default]; style::Bool=false)
metadata(dfc::DataFrameColumns, key::AbstractString, [default]; style::Bool=false)
metadata(dfr::DataFrameRows, key::AbstractString, [default]; style::Bool=false)
Return table-level metadata value associated with df
for key key
. If style=true
return a tuple of metadata value and metadata style.
SubDataFrame
and DataFrameRow
expose only :note
-style metadata of their parent.
If default
is passed then return it if key
does not exist; if style=true
return (default, :default)
.
See also: metadatakeys
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> metadatakeys(df)
()
julia> metadata!(df, "name", "example", style=:note);
julia> metadatakeys(df)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> metadata(df, "name")
"example"
julia> metadata(df, "name", style=true)
("example", :note)
julia> deletemetadata!(df, "name");
julia> metadatakeys(df)
()
#
DataAPI.metadatakeys
— Function
metadatakeys(df::AbstractDataFrame)
metadatakeys(dfr::DataFrameRow)
metadatakeys(dfc::DataFrameColumns)
metadatakeys(dfr::DataFrameRows)
Return an iterator of table-level metadata keys which are set in the object.
Values can be accessed using metadata(df, key)
.
SubDataFrame
and DataFrameRow
expose only :note
-style metadata keys of their parent.
See also: metadata
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> metadatakeys(df)
()
julia> metadata!(df, "name", "example", style=:note);
julia> metadatakeys(df)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> metadata(df, "name")
"example"
julia> metadata(df, "name", style=true)
("example", :note)
julia> deletemetadata!(df, "name");
julia> metadatakeys(df)
()
#
DataAPI.metadata!
— Function
metadata!(df::AbstractDataFrame, key::AbstractString, value; style::Symbol=:default)
metadata!(dfr::DataFrameRow, key::AbstractString, value; style::Symbol=:default)
metadata!(dfc::DataFrameColumns, key::AbstractString, value; style::Symbol=:default)
metadata!(dfr::DataFrameRows, key::AbstractString, value; style::Symbol=:default)
Set table-level metadata for object df
for key key
to have value value
and style style
(:default
by default) and return df
.
For SubDataFrame
and DataFrameRow
only :note
-style is allowed. Trying to set a key-value pair for which the key already exists in the parent data frame with another style throws an error.
See also: metadata
, metadatakeys
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> metadatakeys(df)
()
julia> metadata!(df, "name", "example", style=:note);
julia> metadatakeys(df)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> metadata(df, "name")
"example"
julia> metadata(df, "name", style=true)
("example", :note)
julia> deletemetadata!(df, "name");
julia> metadatakeys(df)
()
#
DataAPI.deletemetadata!
— Function
deletemetadata!(df::AbstractDataFrame, key::AbstractString)
deletemetadata!(dfr::DataFrameRow, key::AbstractString)
deletemetadata!(dfc::DataFrameColumns, key::AbstractString)
deletemetadata!(dfr::DataFrameRows, key::AbstractString)
Delete table-level metadata from object df
for key key
and return df
. If key does not exist, return df
without modification.
For SubDataFrame
and DataFrameRow
only :note
-style metadata from their parent can be deleted (as other styles are not propagated to views).
See also: metadata
, metadatakeys
, metadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> metadatakeys(df)
()
julia> metadata!(df, "name", "example", style=:note);
julia> metadatakeys(df)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> metadata(df, "name")
"example"
julia> metadata(df, "name", style=true)
("example", :note)
julia> deletemetadata!(df, "name");
julia> metadatakeys(df)
()
#
DataAPI.emptymetadata!
— Function
emptymetadata!(df::AbstractDataFrame)
emptymetadata!(dfr::DataFrameRow)
emptymetadata!(dfc::DataFrameColumns)
emptymetadata!(dfr::DataFrameRows)
Delete all table-level metadata from object df
.
For SubDataFrame
and DataFrameRow
only :note
-style metadata from their parent can be deleted (as other styles are not propagated to views).
See also: metadata
, metadatakeys
, metadata!
, deletemetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> metadatakeys(df)
()
julia> metadata!(df, "name", "example", style=:note);
julia> metadatakeys(df)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> metadata(df, "name")
"example"
julia> metadata(df, "name", style=true)
("example", :note)
julia> emptymetadata!(df);
julia> metadatakeys(df)
()
#
DataAPI.colmetadata
— Function
colmetadata(df::AbstractDataFrame, col::ColumnIndex, key::AbstractString, [default]; style::Bool=false)
colmetadata(dfr::DataFrameRow, col::ColumnIndex, key::AbstractString, [default]; style::Bool=false)
colmetadata(dfc::DataFrameColumns, col::ColumnIndex, key::AbstractString, [default]; style::Bool=false)
colmetadata(dfr::DataFrameRows, col::ColumnIndex, key::AbstractString, [default]; style::Bool=false)
Return column-level metadata value associated with df
for column col
and key key
.
SubDataFrame
and DataFrameRow
expose only :note
-style metadata of their parent.
If default
is passed then return it if key
does not exist for column col
; if style=true
return (default, :default)
. If col
does not exist in df
always throw an error.
See also: metadata
, metadatakeys
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> colmetadatakeys(df)
()
julia> colmetadata!(df, :a, "name", "example", style=:note);
julia> collect(colmetadatakeys(df))
1-element Vector{Pair{Symbol, Base.KeySet{String, Dict{String, Tuple{Any, Any}}}}}:
:a => ["name"]
julia> colmetadatakeys(df, :a)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> colmetadata(df, :a, "name")
"example"
julia> colmetadata(df, :a, "name", style=true)
("example", :note)
julia> deletecolmetadata!(df, :a, "name");
julia> colmetadatakeys(df)
()
#
DataAPI.colmetadatakeys
— Function
colmetadatakeys(df::AbstractDataFrame, [col::ColumnIndex])
colmetadatakeys(dfr::DataFrameRow, [col::ColumnIndex])
colmetadatakeys(dfc::DataFrameColumns, [col::ColumnIndex])
colmetadatakeys(dfr::DataFrameRows, [col::ColumnIndex])
If col
is passed return an iterator of column-level metadata keys which are set for column col
. If col
is not passed return an iterator of col => colmetadatakeys(x, col)
pairs for all columns that have metadata, where col
are Symbol
.
Values can be accessed using colmetadata(df, col, key)
.
SubDataFrame
and DataFrameRow
expose only :note
-style metadata of their parent.
See also: metadata
, metadatakeys
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadata!
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> colmetadatakeys(df)
()
julia> colmetadata!(df, :a, "name", "example", style=:note);
julia> collect(colmetadatakeys(df))
1-element Vector{Pair{Symbol, Base.KeySet{String, Dict{String, Tuple{Any, Any}}}}}:
:a => ["name"]
julia> colmetadatakeys(df, :a)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> colmetadata(df, :a, "name")
"example"
julia> colmetadata(df, :a, "name", style=true)
("example", :note)
julia> deletecolmetadata!(df, :a, "name");
julia> colmetadatakeys(df)
()
#
DataAPI.colmetadata!
— Function
colmetadata!(df::AbstractDataFrame, col::ColumnIndex, key::AbstractString, value; style::Symbol=:default)
colmetadata!(dfr::DataFrameRow, col::ColumnIndex, key::AbstractString, value; style::Symbol=:default)
colmetadata!(dfc::DataFrameColumns, col::ColumnIndex, key::AbstractString, value; style::Symbol=:default)
colmetadata!(dfr::DataFrameRows, col::ColumnIndex, key::AbstractString, value; style::Symbol=:default)
Set column-level metadata in df
for column col
and key key
to have value value
and style style
(:default
by default) and return df
.
For SubDataFrame
and DataFrameRow
only :note
style is allowed. Trying to set a key-value pair for which the key already exists in the parent data frame with another style throws an error.
See also: metadata
, metadatakeys
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, deletecolmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> colmetadatakeys(df)
()
julia> colmetadata!(df, :a, "name", "example", style=:note);
julia> collect(colmetadatakeys(df))
1-element Vector{Pair{Symbol, Base.KeySet{String, Dict{String, Tuple{Any, Any}}}}}:
:a => ["name"]
julia> colmetadatakeys(df, :a)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> colmetadata(df, :a, "name")
"example"
julia> colmetadata(df, :a, "name", style=true)
("example", :note)
julia> deletecolmetadata!(df, :a, "name");
julia> colmetadatakeys(df)
()
#
DataAPI.deletecolmetadata!
— Function
deletecolmetadata!(df::AbstractDataFrame, col::ColumnIndex, key::AbstractString)
deletecolmetadata!(dfr::DataFrameRow, col::ColumnIndex, key::AbstractString)
deletecolmetadata!(dfc::DataFrameColumns, col::ColumnIndex, key::AbstractString)
deletecolmetadata!(dfr::DataFrameRows, col::ColumnIndex, key::AbstractString)
Delete column-level metadata set in df
for column col
and key key
and return df
.
For SubDataFrame
and DataFrameRow
only :note
-style metadata from their parent can be deleted (as other styles are not propagated to views).
See also: metadata
, metadatakeys
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, emptycolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> colmetadatakeys(df)
()
julia> colmetadata!(df, :a, "name", "example", style=:note);
julia> collect(colmetadatakeys(df))
1-element Vector{Pair{Symbol, Base.KeySet{String, Dict{String, Tuple{Any, Any}}}}}:
:a => ["name"]
julia> colmetadatakeys(df, :a)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> colmetadata(df, :a, "name")
"example"
julia> colmetadata(df, :a, "name", style=true)
("example", :note)
julia> deletecolmetadata!(df, :a, "name");
julia> colmetadatakeys(df)
()
#
DataAPI.emptycolmetadata!
— Function
emptycolmetadata!(df::AbstractDataFrame, [col::ColumnIndex])
emptycolmetadata!(dfr::DataFrameRow, [col::ColumnIndex])
emptycolmetadata!(dfc::DataFrameColumns, [col::ColumnIndex])
emptycolmetadata!(dfr::DataFrameRows, [col::ColumnIndex])
Delete column-level metadata set in df
for column col
and key key
and return df
.
For SubDataFrame
and DataFrameRow
only :note
-style metadata from their parent can be deleted (as other styles are not propagated to views).
See also: metadata
, metadatakeys
, metadata!
, deletemetadata!
, emptymetadata!
, colmetadata
, colmetadatakeys
, colmetadata!
, deletecolmetadata!
.
Examples
julia> df = DataFrame(a=1, b=2);
julia> colmetadata!(df, :a, "name", "example", style=:note);
julia> collect(colmetadatakeys(df))
1-element Vector{Pair{Symbol, Base.KeySet{String, Dict{String, Tuple{Any, Any}}}}}:
:a => ["name"]
julia> colmetadatakeys(df, :a)
KeySet for a Dict{String, Tuple{Any, Any}} with 1 entry. Keys:
"name"
julia> colmetadata(df, :a, "name")
"example"
julia> colmetadata(df, :a, "name", style=true)
("example", :note)
julia> emptycolmetadata!(df, :a);
julia> colmetadatakeys(df)
()