Типы

DataFrames.AbstractDataFrame
DataFrames.AsTable
DataFrames.DataFrame
DataFrames.DataFrameColumns
DataFrames.DataFrameRow
DataFrames.DataFrameRows
DataFrames.GroupKey
DataFrames.GroupKeys
DataFrames.GroupedDataFrame
DataFrames.RepeatedVector
DataFrames.StackedVector
DataFrames.SubDataFrame

Структура иерархии типов

AbstractDataFrame — это абстрактный тип, который предоставляет интерфейс для типов фреймов данных. Он не является полностью универсальным интерфейсом для работы с табличными данными; для этого служат интерфейсы, определенные в Tables.jl.

DataFrame — это самый базовый подтип AbstractDataFrame, в котором хранится набор столбцов в виде объектов AbstractVector. Индексирование всех хранящихся столбцов должно начинаться с 1. Кроме того, все функции в API DataFrames.jl собирают (collect) переданные исходные столбцы AbstractRange перед их сохранением в DataFrame.

SubDataFrame — это подтип AbstractDataFrame, выступающий в качестве представления объекта DataFrame. В нем хранится только ссылка на родительский объект DataFrame и информация о выбранных из него строках и столбцах (в виде целочисленных индексов, ссылающихся на родительский объект). Как правило, он создается с помощью функции view или возвращается в результате обращения по индексу к объекту GroupedDataFrame.

GroupedDataFrame — это тип, в котором хранится результат операции группирования применительно к AbstractDataFrame. Он должен создаваться в результате вызова функции groupby.

DataFrameRow — это представление одной строки в AbstractDataFrame. В нем хранятся только ссылка на родительский объект DataFrame и информация о выбранных из него строке и столбцах (в виде целочисленных индексов, ссылающихся на родительский объект). Тип DataFrameRow поддерживает итерацию по ячейкам строки и действует так же, как тип NamedTuple, но позволяет изменять данные, хранящиеся в родительском объекте DataFrame, и в нем отражаются изменения, внесенные в родительский объект после создания представления. Как правило, объекты типа DataFrameRow возвращаются при вызове функции eachrow либо при обращении к отдельной строке объекта DataFrame или SubDataFrame посредством функции getindex или view.

Функция eachrow возвращает значение типа DataFrameRows, которое служит итератором по строкам объекта AbstractDataFrame, возвращающим объекты DataFrameRow. DataFrameRows — это подтип типа AbstractVector, который поддерживает его интерфейс, но предназначен только для чтения.

Аналогичным образом, функция eachcol возвращает значение типа DataFrameColumns, которое не относится к типу AbstractVector, но по большей части поддерживает его API. Основные отличия заключаются в том, что он доступен только для чтения и что функция keys возвращает вектор символов (Symbol) (а не целых чисел, как для обычных векторов).

Обратите внимание, что типы DataFrameRows и DataFrameColumns не экспортируются и их экземпляры должны создаваться не напрямую, а с помощью функций eachrow и eachcol.

Типы RepeatedVector и StackedVector являются подтипами типа AbstractVector и поддерживают его интерфейс, но предназначены только для чтения. Обратите внимание, что они не экспортируются и их экземпляры не должны создаваться напрямую. Они представляют столбцы объекта DataFrame, возвращаемые функций stack с аргументом view=true.

ByRow — это особый тип, используемый в операциях выборки для указания на то, что заключенная функция должна применяться к каждому элементу (строке) выборки.

AsTable — это особый тип, используемый в операциях выборки для указания на то, что столбцы, выбираемые заключенным селектором, должны передаваться в виде NamedTuple в функцию, или на то, что возвращаемое значение преобразования должно быть развернуто в несколько столбцов.

Принципы работы со столбцами `DataFrame`

При создании объекта DataFrame по умолчанию столбцы копируются. Чтобы отключить такое поведение, присвойте именованному аргументу copycols значение false. Исключением является случай, когда в качестве столбца передается объект AbstractRange. При таком варианте он всегда собирается в Vector.

Столбцы также копируют функции, преобразующие DataFrame для получения нового объекта DataFrame, если не передан аргумент copycols=false (он доступен только для функций, которые могут выполнить преобразование, не копируя столбцы). Примерами таких функций являются vcat, hcat, filter, dropmissing, getindex, copy или упомянутый ранее конструктор DataFrame.

Универсальный конструктор с одним аргументом DataFrame(table) по умолчанию предполагает copycols=nothing, то есть столбцы копируются, если только аргумент table не указывает на то, что делать этого не нужно (для этого исходная таблица заключается в Tables.CopiedColumns). В CSV.jl это делается при вызове CSV.read(file, DataFrame), так как столбцы создаются только в целях использования в конструкторе DataFrame. Другой пример — Arrow.Table. Данные объекта Arrow по своей сути неизменяемые, поэтому столбцы никак нельзя изменить случайно. Для изменения данных объекта Arrow необходимо материализовать столбцы, что можно сделать с помощью DataFrame(arrow_table, copycols=true).

В свою очередь, функции, создающие представление объекта DataFrame, по определению не копируют столбцы и поэтому требуют особой осторожности. Сюда относятся функции view, которая возвращает SubDataFrame или DataFrameRow, и groupby, которая возвращает GroupedDataFrame.

Частичным исключением из этого правила является функция stack с аргументом view=true, которая создает объект DataFrame, содержащий представления столбцов исходного объекта DataFrame.

Выполняемые на месте функции, имена которых заканчиваются на ! (например, sort! или dropmissing!, setindex!, push!, append!), могут изменять векторы столбцов DataFrame, которые они принимают в качестве аргумента. Эти функции можно безопасно вызывать вследствие описанных выше правил, за исключением случаев, когда используется представление DataFrame (созданное с помощью SubDataFrame, DataFrameRow или GroupedDataFrame). В последнем случае вызов такой функции для родительского объекта может повредить представление, из-за чего могут возникать ошибки, возвращаться неверные данные без предупреждения или даже происходить аварийное завершение работы Julia. Такая же опасность существует при создании объекта DataFrame с использованием столбцов другого объекта DataFrame без копирования (например, при передаче аргумента copycols=false в таких функциях, как DataFrame или hcat).

Доступ к столбцу col объекта DataFrame df можно получить напрямую одним из следующих способов (это может быть полезно, например, для предотвращения копирования в коде, требующем максимальной производительности):

посредством функции getproperty с использованием синтаксиса df.col;
посредством функции getindex с использованием синтаксиса df[!, :col] (но не df[:, :col], который предполагает копирование);
путем создания объекта DataFrameColumns с помощью функции eachcol;
путем вызова функции parent для представления столбца объекта DataFrame, например parent(@view df[:, :col]);
путем сохранения ссылки на столбец перед созданием объекта DataFrame с аргументом copycols=false.

Столбец, полученный из DataFrame с помощью одного из перечисленных выше методов, следует изменять с особой осторожностью по следующим причинам.

Изменение размера вектора столбцов приведет к повреждению родительского объекта DataFrame и всех связанных представлений, так как методы проверяют длину столбца только при его добавлении в DataFrame, а затем предполагают, что длина всех столбцов одинаковая.
Изменение порядка значений в векторе столбцов (например, с помощью sort!) нарушит согласованность строк с другими столбцами, что также повлияет на представления (если они есть).
Изменение значений в векторе столбцов допускается при условии, что он не используется в качестве столбца группирования в объекте GroupedDataFrame, созданном на основе DataFrame.

Спецификации типов

# DataFrames.AbstractDataFrame — Type

AbstractDataFrame

Абстрактный тип, для которого все конкретные типы предоставляют интерфейс для работы с табличными данными.

AbstractDataFrame является двумерной таблицей с символами (Symbol) или строками для имен столбцов.

DataFrames.jl определяет два типа, которые являются подтипами AbstractDataFrame: DataFrame и SubDataFrame.

Индексирование и трансляция

AbstractDataFrame можно индексировать, передавая два индекса, указывающие селекторы строк и столбцов. Допустимые индексы представляют собой надмножество индексов, которые можно использовать для стандартных массивов. Для доступа к одному столбцу AbstractDataFrame также можно использовать функции getproperty и setproperty!. Столбцы можно выбирать с помощью целых чисел, символов (Symbol) или строк. При трансляции поведение AbstractDataFrame аналогично Matrix.

Подробное описание getindex, setindex!, getproperty, setproperty!, трансляции и присваивания трансляции для фреймов данных приведено в разделе Индексирование руководства.

# DataFrames.AsTable — Type

AsTable(cols)

Тип, имеющий особое значение в операциях выбора source => transformation => destination, поддерживаемых функциями combine, select, select!, transform, transform!, subset и subset!.

Если AsTable(cols) используется в позиции source, это означает, что столбцы, выбранные заключенным в оболочку селектором cols, должны быть переданы функции как NamedTuple.

Если AsTable используется в позиции destination, это означает, что результатом операции transformation является вектор контейнеров (или один контейнер, если используется ByRow(transformation)), который должен быть расширен на несколько столбцов с использованием keys для получения имен столбцов.

Примеры

julia> df1 = DataFrame(a=1:3, b=11:13)
3×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1     11
   2 │     2     12
   3 │     3     13

julia> df2 = select(df1, AsTable([:a, :b]) => ByRow(identity))
3×1 DataFrame
 Row │ a_b_identity
     │ NamedTuple…
─────┼─────────────────
   1 │ (a = 1, b = 11)
   2 │ (a = 2, b = 12)
   3 │ (a = 3, b = 13)

julia> select(df2, :a_b_identity => AsTable)
3×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1     11
   2 │     2     12
   3 │     3     13

julia> select(df1, AsTable([:a, :b]) => ByRow(nt -> map(x -> x^2, nt)) => AsTable)
3×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1    121
   2 │     4    144
   3 │     9    169

# DataFrames.DataFrame — Type

DataFrame <: AbstractDataFrame

AbstractDataFrame, хранящий набор именованных столбцов.

Столбцы обычно представляют собой хранящиеся в памяти AbstractVector, в частности Vector, PooledVector или CategoricalVector.

Конструкторы

DataFrame(pairs::Pair...; makeunique::Bool=false, copycols::Bool=true)
DataFrame(pairs::AbstractVector{<:Pair}; makeunique::Bool=false, copycols::Bool=true)
DataFrame(ds::AbstractDict; copycols::Bool=true)
DataFrame(; kwargs..., copycols::Bool=true)

DataFrame(table; copycols::Union{Bool, Nothing}=nothing)
DataFrame(table, names::AbstractVector;
          makeunique::Bool=false, copycols::Union{Bool, Nothing}=nothing)
DataFrame(columns::AbstractVecOrMat, names::AbstractVector;
          makeunique::Bool=false, copycols::Bool=true)

DataFrame(::DataFrameRow; copycols::Bool=true)
DataFrame(::GroupedDataFrame; copycols::Bool=true, keepkeys::Bool=true)

Именованные аргументы

copycols: должны ли копироваться векторы, переданные как столбцы; по умолчанию задано значение true, и векторы копируются; если задано false, конструктор будет по-прежнему копировать переданные столбцы, если невозможно создать DataFrame без материализации новых столбцов. Обратите внимание на значение по умолчанию copycols=nothing в совместимом с Tables.jl конструкторе. Оно указано, поскольку некоторые типы входных таблиц, возможно, уже создали копии столбцов, или столбцы могут быть неизменяемыми, в этом случае столбцы не копируются по умолчанию. Для принудительного копирования в таких случаях или для получения изменяемых столбцов из неизменяемой входной таблицы (например, Arrow.Table), передайте copycols=true явным образом.
makeunique: если задано значение false (по умолчанию), возникает ошибка.

(обратите внимание, что не все конструкторы поддерживают эти именованные аргументы)

Сведения о поведении различных конструкторов

Допускается передача вектора пар (Pair), списка пар (Pair) в качестве позиционных аргументов или списка именованных аргументов. В этом случае каждая пара рассматривается как сопоставление имени столбца со значением столбца, а имя столбца должно быть символом (Symbol) или строкой. В качестве альтернативы конструктору может быть передан словарь, в этом случае его записи считаются определяющими пары имени столбца и значения столбца. Если словарь является Dict, имена столбцов будут отсортированы в возвращаемом DataFrame.

Во всех описанных выше конструкторах значение столбца может быть вектором, который используется как есть, или объектом любого другого типа (кроме AbstractArray). В последнем случае переданное значение автоматически повторяется для заполнения нового вектора соответствующей длины. Как правило, значения, хранящиеся в Ref или 0-мерном массиве AbstractArray, распаковываются и обрабатываются одинаково.

Также разрешается передавать в качестве первого аргумента вектор векторов или матрицу. В этом случае второй аргумент должен быть вектором символов (Symbol) или строк, указывающим имена столбцов, или символом :auto для автоматического создания имен столбцов x1, x2 и т. д. Обратите внимание, что в этом случае если первым аргументом является матрица и copycols=false, столбцы созданного DataFrame будут представлять собой столбцы исходной матрицы.

Если конструктору DataFrame передается единственный позиционный аргумент, предполагается, что он имеет тип, реализующий интерфейс Tables.jl, с помощью которого материализуется возвращаемый DataFrame.

Если передаются два позиционных аргумента, где вторым аргументом является AbstractVector, первый аргумент считается таблицей, как описано в предыдущем абзаце, а имена столбцов результирующего фрейма данных берутся из вектора, передаваемого в качестве второго позиционного аргумента.

Наконец, можно построить DataFrame из DataFrameRow или GroupedDataFrame. В последнем случае именованный аргумент keepkeys указывает, должен ли результирующий DataFrame содержать группирующие столбцы передаваемого GroupedDataFrame, а порядок строк в результате соответствовать порядку групп в передаваемом GroupedDataFrame.

Примечания

Конструктор DataFrame по умолчанию копирует все переданные ему векторы столбцов. Передайте именованный аргумент copycols=false (если поддерживается), чтобы повторно использовать векторы без их копирования.

По умолчанию при обнаружении дубликатов в именах столбцов будет выдана ошибка. Передайте именованный аргумент makeunique=true (если поддерживается), чтобы принимать повторяющиеся имена, и в этом случае они будут иметь суффикс _i (i, начиная с 1 для первого повторяющегося имени).

Если AbstractRange передается в конструктор DataFrame в качестве столбца, он всегда собирается в Vector (даже если copycols=false). Как правило, значения AbstractRange всегда материализуются в Vector всеми функциями в DataFrames.jl перед сохранением в DataFrame.

DataFrame может хранить только столбцы, использующие индексирование на основе 1. Попытка сохранить вектор с использованием нестандартного индексирования приведет к ошибке.

Тип DataFrame позволяет типам столбцов варьироваться и динамически изменяться и после его создания. Поэтому DataFrame не являются стабильными по типу. Для критически важного кода, требующего стабильности типов, либо используйте функциональность, предоставляемую функциями select/transform/combine, функции Tables.columntable и Tables.namedtupleiterator, барьерные функции, либо предоставьте утверждения типов для переменных, которые содержат столбцы, извлеченные из DataFrame.

Метаданные: эта функция сохраняет все метаданные на уровне таблиц и столбцов. Особый случай: если передается GroupedDataFrame, сохраняются только метаданные в стиле :note из родительского объекта GroupedDataFrame.

Примеры

julia> DataFrame((a=[1, 2], b=[3, 4])) # конструктор таблиц Tables.jl
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      3
   2 │     2      4

julia> DataFrame([(a=1, b=0), (a=2, b=0)]) # конструктор таблиц Tables.jl
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

julia> DataFrame("a" => 1:2, "b" => 0) # конструктор пар
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

julia> DataFrame([:a => 1:2, :b => 0]) # конструктор вектора пар
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

julia> DataFrame(Dict(:a => 1:2, :b => 0)) # конструктор словаря
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

julia> DataFrame(a=1:2, b=0) # конструктор именованных аргументов
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

julia> DataFrame([[1, 2], [0, 0]], [:a, :b]) # конструктор вектора векторов
2×2 DataFrame
 Row │ a      b
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

julia> DataFrame([1 0; 2 0], :auto) # конструктор матриц
2×2 DataFrame
 Row │ x1     x2
     │ Int64  Int64
─────┼──────────────
   1 │     1      0
   2 │     2      0

# DataFrames.DataFrameRow — Type

DataFrameRow{<:AbstractDataFrame, <:AbstractIndex}

Представление одной строки AbstractDataFrame.

DataFrameRow возвращается функциями getindex или view, когда запрашивается одна строка и выборка столбцов, или при итерации результата вызова функции eachrow.

Конструктор DataFrameRow также можно вызывать напрямую:

DataFrameRow(parent::AbstractDataFrame, row::Integer, cols=:)

DataFrameRow поддерживает интерфейс итерации и поэтому может передаваться функциям, ожидающим коллекцию в качестве аргумента. Его типом элемента всегда является Any.

Индексирование является одномерным, как указание столбца DataFrame. Вы также можете получить доступ к данным в DataFrameRow с помощью функций getproperty и setproperty! и преобразовать его в Tuple, NamedTuple или Vector, используя соответствующие функции.

Если выборка столбцов в родительском фрейме данных передается в виде : (двоеточие), DataFrameRow всегда будет содержать все столбцы из родительского фрейма, даже если они были добавлены или удалены после его создания.

Примеры

julia> df = DataFrame(a=repeat([1, 2], outer=[2]),
                      b=repeat(["a", "b"], inner=[2]),
                      c=1:4)
4×3 DataFrame
 Row │ a      b       c
     │ Int64  String  Int64
─────┼──────────────────────
   1 │     1  a           1
   2 │     2  a           2
   3 │     1  b           3
   4 │     2  b           4

julia> df[1, :]
DataFrameRow
 Row │ a      b       c
     │ Int64  String  Int64
─────┼──────────────────────
   1 │     1  a           1

julia> @view df[end, [:a]]
DataFrameRow
 Row │ a
     │ Int64
─────┼───────
   4 │     2

julia> eachrow(df)[1]
DataFrameRow
 Row │ a      b       c
     │ Int64  String  Int64
─────┼──────────────────────
   1 │     1  a           1

julia> Tuple(df[1, :])
(1, "a", 1)

julia> NamedTuple(df[1, :])
(a = 1, b = "a", c = 1)

julia> Vector(df[1, :])
3-element Vector{Any}:
 1
  "a"
 1

# DataFrames.GroupedDataFrame — Type

GroupedDataFrame

Результат операции groupby с AbstractDataFrame; представление для AbstractDataFrame, сгруппированного по строкам.

Не предназначен для построения напрямую. См. описание groupby.

Получить имена столбцов, используемых для создания GroupedDataFrame, можно с помощью функции groupcols. Аналогично функция groupindices возвращает вектор индексов групп для каждой строки родительского фрейма данных.

После создания GroupedDataFrame отражает группировку строк, которая была допустима на момент его создания. Таким образом, группирующие столбцы родительского фрейма данных не должны изменяться, а строки не должны добавляться в него или удаляться из него. Чтобы защитить пользователя от подобных случаев, если количество строк в родительском фрейме данных изменится, при попытке использовать GroupedDataFrame возникнет ошибка. Однако можно добавлять столбцы в родительский фрейм данных или удалять их из него без объявления недействительности GroupedDataFrame при условии, что столбцы, используемые для группировки, не изменятся.

# DataFrames.GroupKey — Type

GroupKey{T<:GroupedDataFrame}

Ключ для одной из групп GroupedDataFrame. Содержит значения соответствующих группирующих столбцов и действует аналогично NamedTuple, однако его использование для индексирования GroupedDataFrame более эффективно, чем использование эквивалентных Tuple и NamedTuple, и гораздо эффективнее, чем использование эквивалентного AbstractDict.

Экземпляры этого типа возвращаются функцией keys(::GroupedDataFrame) и не предназначены для построения напрямую.

Индексировать поля GroupKey можно с помощью целого числа, символа (Symbol) или строки. С помощью функции getproperty можно также получить доступ к данным в GroupKey . GroupKey можно преобразовать в Tuple, NamedTuple, Vector или Dict. При преобразовании в Dict ключи Dict являются Symbol.

Дополнительные сведения см. в описании keys(::GroupedDataFrame).

# DataFrames.GroupKeys — Type

GroupKeys{T<:GroupedDataFrame} <: AbstractVector{GroupKey{T}}

Вектор, содержащий все объекты GroupKey для заданного GroupedDataFrame.

Дополнительные сведения см. в описании keys(::GroupedDataFrame).

# DataFrames.SubDataFrame — Type

SubDataFrame{<:AbstractDataFrame, <:AbstractIndex, <:AbstractVector{Int}} <: AbstractDataFrame

Представление AbstractDataFrame. Оно возвращается при вызове функции view для AbstractDataFrame, если указаны коллекции строк и столбцов.

SubDataFrame представляет собой AbstractDataFrame, поэтому следует ожидать, что большинство функций DataFrame должны работать. В число таких методов входят describe, summary, nrow, size, by, stack и join.

Если выборка столбцов в родительском фрейме данных передается в виде : (двоеточие), SubDataFrame всегда будет содержать все столбцы из родительского фрейма, даже если они были добавлены или удалены после его создания.

Примеры

julia> df = DataFrame(a=repeat([1, 2, 3, 4], outer=[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 │     2      1      2
   3 │     3      2      3
   4 │     4      1      4
   5 │     1      2      5
   6 │     2      1      6
   7 │     3      2      7
   8 │     4      1      8

julia> sdf1 = view(df, :, 2:3) # разделение столбца на подмножества
8×2 SubDataFrame
 Row │ b      c
     │ Int64  Int64
─────┼──────────────
   1 │     2      1
   2 │     1      2
   3 │     2      3
   4 │     1      4
   5 │     2      5
   6 │     1      6
   7 │     2      7
   8 │     1      8

julia> sdf2 = @view df[end:-1:1, [1, 3]]  # разделение строки и столбца на подмножества
8×2 SubDataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     4      8
   2 │     3      7
   3 │     2      6
   4 │     1      5
   5 │     4      4
   6 │     3      3
   7 │     2      2
   8 │     1      1

julia> sdf3 = groupby(df, :a)[1]  # при индексировании GroupedDataFrame возвращается SubDataFrame
2×3 SubDataFrame
 Row │ a      b      c
     │ Int64  Int64  Int64
─────┼─────────────────────
   1 │     1      2      1
   2 │     1      2      5

# DataFrames.DataFrameRows — Type

DataFrameRows{D<:AbstractDataFrame} <: AbstractVector{DataFrameRow}

Итератор по строкам AbstractDataFrame, где каждая строка представлена как DataFrameRow.

Значение этого типа возвращается функцией eachrow.

# DataFrames.DataFrameColumns — Type

DataFrameColumns{<:AbstractDataFrame}

Объект, подобный вектору, который позволяет выполнять итерацию по столбцам AbstractDataFrame.

Индексирование в объектах DataFrameColumns с использованием целого числа, Symbol или строки возвращает соответствующий столбец (без копирования). Индексирование в объектах DataFrameColumns с использованием селектора нескольких столбцов возвращает являющийся подмножеством объект DataFrameColumns с новым родителем, содержащим только выбранные столбцы (без копирования).

DataFrameColumns поддерживает большую часть API AbstractVector. Основные отличия заключаются в том, что он доступен только для чтения и что функция keys возвращает вектор символов (Symbol) (а не целых чисел, как для обычных векторов).

В частности, поддерживаются функции findnext, findprev, findfirst, findlast и findall, и в функциях findnext и findprev разрешается передавать целое число, строку или символ (Symbol) в качестве эталонного индекса.

# DataFrames.RepeatedVector — Type

RepeatedVector{T} <: AbstractVector{T}

AbstractVector является представлением для другого AbstractVector с повторяющимися элементами.

ПРИМЕЧАНИЕ. Не экспортируется.

Конструктор

RepeatedVector(parent::AbstractVector, inner::Int, outer::Int)

Аргументы

parent: AbstractVector, который повторяется
inner: количество повторений каждого элемента
outer: количество повторений всего вектора после расширения с помощью inner

inner и outer имеют то же значение, что и аналогично именуемые аргументы для функции repeat.

Примеры

RepeatedVector([1, 2], 3, 1)   # [1, 1, 1, 2, 2, 2]
RepeatedVector([1, 2], 1, 3)   # [1, 2, 1, 2, 1, 2]
RepeatedVector([1, 2], 2, 2)   # [1, 1, 2, 2, 1, 1, 2, 2]

# DataFrames.StackedVector — Type

StackedVector <: AbstractVector

AbstractVector, который является линейным, конкатенированным представлением для другого набора AbstractVectors.

ПРИМЕЧАНИЕ. Не экспортируется.

Конструктор

StackedVector(d::AbstractVector)

Аргументы

d...: один или несколько AbstractVectors

Примеры

StackedVector(Any[[1, 2], [9, 10], [11, 12]])  # [1, 2, 9, 10, 11, 12]