Juliaでコレクションをコピーまたは複製する

Question

Juliaで1次元配列（ベクトル）を作成しました。つまり、a=[1, 2, 3, 4, 5]です。次に、bという新しいベクトルを作成したいと考えています。bはaと全く同じ要素を持ちます。つまり、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)であることを見つける。私は誰かが他のアプローチを提供してくれることを感謝します。

Answer 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 

Answer 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] 

お知らせを、他のコピーに関連する機能の有無のヘルプシステムのヒント。