Копирование или клонирование коллекции в Julia

Я создал одномерный массив (вектор) в Julia, а именно a=[1, 2, 3, 4, 5]. Затем я хочу создать новый вектор b, где b имеет точно такие же элементы в a, i.e b=[1, 2, 3, 4, 5].

Кажется, что непосредственно использовать b = a просто создать указатель для исходной коллекции, что означает, что если я изменяю b и a изменчиво, модификация также будет отражена в a. Например, если я использую !pop(b), то b=[1, 2, 3, 4] и a=[1, 2, 3, 4].

Мне интересно, есть ли официальная функция, чтобы просто копировать или клонировать коллекцию, изменение которой в b не произойдет в a. Я считаю, что решение использует b = collect(a). Я был бы признателен, если кто-то предоставит некоторые другие подходы.

ОТВЕТЫ

Ответ 1

b=copy(a)

Должен делать то, что вы хотите.

methods(copy) предоставит вам список методов для copy, который расскажет вам, какие типы a будут работать.

julia> methods(copy)
# 32 methods for generic function "copy":
copy(r::Range{T}) at range.jl:324
copy(e::Expr) at expr.jl:34
copy(s::SymbolNode) at expr.jl:38
copy(x::Union{AbstractString,DataType,Function,LambdaStaticData,Number,QuoteNode,Symbol,TopNode,Tuple,Union}) at operators.jl:194
copy(V::SubArray{T,N,P<:AbstractArray{T,N},I<:Tuple{Vararg{Union{AbstractArray{T,1},Colon,Int64}}},LD}) at subarray.jl:29
copy(a::Array{T,N}) at array.jl:100
copy(M::SymTridiagonal{T}) at linalg/tridiag.jl:63
copy(M::Tridiagonal{T}) at linalg/tridiag.jl:320
copy{T,S}(A::LowerTriangular{T,S}) at linalg/triangular.jl:36
copy{T,S}(A::Base.LinAlg.UnitLowerTriangular{T,S}) at linalg/triangular.jl:36
copy{T,S}(A::UpperTriangular{T,S}) at linalg/triangular.jl:36
copy{T,S}(A::Base.LinAlg.UnitUpperTriangular{T,S}) at linalg/triangular.jl:36
copy{T,S}(A::Symmetric{T,S}) at linalg/symmetric.jl:38
copy{T,S}(A::Hermitian{T,S}) at linalg/symmetric.jl:39
copy(M::Bidiagonal{T}) at linalg/bidiag.jl:113
copy(S::SparseMatrixCSC{Tv,Ti<:Integer}) at sparse/sparsematrix.jl:184
copy{Tv<:Float64}(A::Base.SparseMatrix.CHOLMOD.Sparse{Tv<:Float64}, stype::Integer, mode::Integer) at sparse/cholmod.jl:583
copy(A::Base.SparseMatrix.CHOLMOD.Dense{T<:Union{Complex{Float64},Float64}}) at sparse/cholmod.jl:1068
copy(A::Base.SparseMatrix.CHOLMOD.Sparse{Tv<:Union{Complex{Float64},Float64}}) at sparse/cholmod.jl:1069
copy(a::AbstractArray{T,N}) at abstractarray.jl:349
copy(s::IntSet) at intset.jl:34
copy(o::ObjectIdDict) at dict.jl:358
copy(d::Dict{K,V}) at dict.jl:414
copy(a::Associative{K,V}) at dict.jl:204
copy(s::Set{T}) at set.jl:35
copy(b::Base.AbstractIOBuffer{T<:AbstractArray{UInt8,1}}) at iobuffer.jl:38
copy(r::Regex) at regex.jl:65
copy(::Base.DevNullStream) at process.jl:98
copy(C::Base.LinAlg.Cholesky{T,S<:AbstractArray{T,2}}) at linalg/cholesky.jl:160
copy(C::Base.LinAlg.CholeskyPivoted{T,S<:AbstractArray{T,2}}) at linalg/cholesky.jl:161
copy(J::UniformScaling{T<:Number}) at linalg/uniformscaling.jl:17
copy(A::Base.SparseMatrix.CHOLMOD.Factor{Tv}) at sparse/cholmod.jl:1070

Ответ 2

Вы можете использовать функции copy и deepcopy:

help?> copy
search: copy copy! copysign deepcopy unsafe_copy! cospi complex Complex complex64 complex32 complex128 complement

  copy(x)

  Create a shallow copy of x: the outer structure is copied, but not all internal values. For example, copying an
  array produces a new array with identically-same elements as the original.

help?> deepcopy
search: deepcopy

  deepcopy(x)

  Create a deep copy of x: everything is copied recursively, resulting in a fully independent object. For example,
  deep-copying an array produces a new array whose elements are deep copies of the original elements. Calling deepcopy
  on an object should generally have the same effect as serializing and then deserializing it.

  As a special case, functions can only be actually deep-copied if they are anonymous, otherwise they are just copied.
  The difference is only relevant in the case of closures, i.e. functions which may contain hidden internal
  references.

  While it isn't normally necessary, user-defined types can override the default deepcopy behavior by defining a
  specialized version of the function deepcopy_internal(x::T, dict::ObjectIdDict) (which shouldn't otherwise be used),
  where T is the type to be specialized for, and dict keeps track of objects copied so far within the recursion.
  Within the definition, deepcopy_internal should be used in place of deepcopy, and the dict variable should be
  updated as appropriate before returning.

Вот так:

julia> a = Any[1, 2, 3, [4, 5, 6]]
4-element Array{Any,1}:
 1       
 2       
 3       
  [4,5,6]

julia> b = copy(a); c = deepcopy(a);

julia> a[4][1] = 42;

julia> b    # copied
4-element Array{Any,1}:
 1
 2
 3
  [42,5,6]

julia> c    # deep copied
4-element Array{Any,1}:
 1
 2
 3
  [4,5,6]

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

Ответ 3

@SalchiPapa

Извините, у меня просто дополнительный вопрос, но у меня недостаточно баллов, чтобы оставить комментарий. Вы дали хороший пример. Однако, если вместо a[4][1] = 42; Я делаю a[3] = 90, тогда я получаю

julia> a[3] = 90
90

julia> a
4-element Array{Any,1}:
  1          
  2          
 90          
   [42, 5, 6]

julia> b
4-element Array{Any,1}:
 1          
 2          
 3          
  [42, 5, 6]

Так почему же эта модификация не скопирована в b?