Question

我在Julia中创建了一维数组（向量），即a=[1, 2, 3, 4, 5]。然后我想创建一个新的向量b，其中b在a中具有完全相同的元素，即b=[1, 2, 3, 4, 5]。

似乎直接使用b = a只是为原始集合创建一个指针，这意味着如果我修改b并且a是可变的，则修改也会反映在{{ 1}}。例如，如果我使用a，那么!pop(b)和b=[1, 2, 3, 4]。

我想知道是否存在仅仅复制或克隆集合的官方功能，a=[1, 2, 3, 4]中的更改不会发生在b中。我发现解决方案是使用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]

请注意，帮助系统提示存在其他与复制相关的功能。

在Julia中复制或克隆一个集合

2 个答案: