Why/how 确定函数何时覆盖 Julia 中的局部变量？

Question

我对 Julia 比较陌生，正在努力移植一些 C 函数来检查速度差异。我正在努力解决的一个问题是变量的范围。具体来说，有时 Julia 中的函数调用会覆盖局部变量，有时则不会。例如，这里有一个计算最小生成树的函数：

function mst(my_X::Array{Float64})
    n = size(my_X)[1]
    N = zeros(Int16,n,n)
    tree = []
    lv = maximum(my_X)+1
    my_X[diagind(my_X)] .=lv
    indexi = 1
    for ijk in 1:(n-1)
        tree = vcat(tree, indexi)
        m = minimum(my_X[:,tree],dims = 1)
        a = zeros(Int64, length(tree))
        print(tree)
        for k in 1:length(tree)
            a[k] = sortperm(my_X[:,tree[k]])[1,]
        end
        b = sortperm(vec(m))[1]
        indexj = tree[b]
        indexi = a[b]
        N[indexi,indexj] = 1
        N[indexj,indexi] = 1
        for j in tree
            my_X[indexi,j] = lv
            my_X[j,indexi] = lv
        end
    end
    return N
end

现在我们可以将其应用于距离矩阵X:

julia> X
5×5 Array{Float64,2}:
 0.0   0.54  1.08  1.12  0.95
 0.54  0.0   0.84  0.67  1.05
 1.08  0.84  0.0   0.86  1.14
 1.12  0.67  0.86  0.0   1.2
 0.95  1.05  1.14  1.2   0.0

但是当我这样做时，它会覆盖 X

的所有条目

julia> M = mst(X)
julia> M
5×5 Array{Int16,2}:
 0  1  0  0  1
 1  0  1  1  0
 0  1  0  0  0
 0  1  0  0  0
 1  0  0  0  0
julia> X
5×5 Array{Float64,2}:
 2.2  2.2  2.2  2.2  2.2
 2.2  2.2  2.2  2.2  2.2
 2.2  2.2  2.2  2.2  2.2
 2.2  2.2  2.2  2.2  2.2
 2.2  2.2  2.2  2.2  2.2

当然，如果我在函数中明确地放置类似这样的东西，我当然可以覆盖它：

function mst(my_Z::Array{Float64})
    my_X = copy(my_Z)
     .
     .
     .

但问题似乎比这更深。例如，如果我尝试在一个简单的示例中复制它，我将无法重现问题：

function add_one(my_X::Int64)
    my_X = my_X + 1
    return my_X
end

julia> Z = 1
julia> W = add_one(Z)
julia> W
2
julia> Z
1

这是怎么回事？？我已经阅读并重新阅读了有关变量范围的 julia 帮助文档，但我无法弄清楚区别是什么。

Answer 1

这里有以下相互关联的问题：

Julia 中的值可以是可变的或不可变的。
Julia 中的变量绑定到一个值（可以是不可变的或可变的）。
一些操作可以修改可变值。

所以第一点是关于值的可变性与不变性。 Julia手册中的讨论给出了here。您可以使用 isimmutable 函数检查值是否可变。

典型案例如下：

数字、字符串、Tuple、NamedTuple、struct是不可变的

julia> isimmutable(1)
true

julia> isimmutable("sdaf")
false

julia> isimmutable((1,2,3))
true

数组、字典、mutable structs 等（在除 Tuple、NamedTuple 和 structs 之外的一般容器类型中）是可变的：

julia> isimmutable([1,2,3])
false

julia> isimmutable(Dict(1=>2))
false

不可变值和可变值之间的主要区别在于可变值可以修改其内容。这是一个简单的例子：

julia> x = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> x[1] = 10
10

julia> x
3-element Array{Int64,1}:
 10
  2
  3

现在让我们剖析我们在这里看到的内容：

赋值语句 x = [1, 2, 3] 将值（在本例中为向量）绑定到变量 x
语句x[1] = 10改变值（向量）就地

请注意，对于 Tuple 同样会失败，因为它是不可变的：

julia> x = (1,2,3)
(1, 2, 3)

julia> x[1] = 10
ERROR: MethodError: no method matching setindex!(::Tuple{Int64,Int64,Int64}, ::Int64, ::Int64)

现在我们来到第二点——将一个值绑定到一个变量名。这通常是使用 = 运算符完成的，如果在它的左侧我们看到一个像上面那样带有 x = [1,2,3] 或 x = (1,2,3).

的变量名称

请注意，特别是 +=（和类似的）也在进行重新绑定，例如：

julia> x = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> y = x
3-element Array{Int64,1}:
 1
 2
 3

julia> x += [1,2,3]
3-element Array{Int64,1}:
 2
 4
 6

julia> x
3-element Array{Int64,1}:
 2
 4
 6

julia> y
3-element Array{Int64,1}:
 1
 2
 3

因为在这种情况下它只是 x = x + [1, 2, 3] 的 shorthand，我们知道 = 重新绑定。

特别是（正如@pszufe 在评论中指出的那样）如果您将值传递给函数，则不会复制任何内容。这里发生的是函数签名中的变量绑定到传递的值（这种行为有时称为 pass by sharing）。所以你有：

julia> x = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> f(y) = y
f (generic function with 1 method)

julia> f(x) === x
true

基本上发生的事情是 "as if" 你写了 y = x。不同之处在于函数在新范围（函数范围）中创建变量 y，而 y = x 将创建 x 绑定到变量 y 在存在语句 y = x 的范围内。

另一方面，像 x[1] = 10（本质上是一个 setindex! 函数应用程序）或 x .= [1,2,3] 是就地操作（它们不重新绑定值，但尝试改变容器）。所以这是就地工作的（请注意，在示例中，我将广播与 += 结合起来以使其就位）：

julia> x = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> y = x
3-element Array{Int64,1}:
 1
 2
 3

julia> x .+= [1,2,3]
3-element Array{Int64,1}:
 2
 4
 6

julia> y
3-element Array{Int64,1}:
 2
 4
 6

但是如果我们尝试对 eg 做同样的事情。一个不可变的整数，操作将失败：

julia> x = 10
10

julia> x .+= 1
ERROR: MethodError: no method matching copyto!(::Int64, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0},Tuple{},typeof(+),Tuple{Int64,Int64}})

与为不可变值设置索引相同：

julia> x = 10
10

julia> x[] = 1
ERROR: MethodError: no method matching setindex!(::Int64, ::Int64)

最后，第三件事是哪些操作试图就地改变值。我们已经注意到其中的一些（例如 setindex!: x[10] = 10 和广播分配 x .= [1,2,3]）。一般来说，如果 f 是一些通用函数，调用 f(x) 是否会改变 x 并不总是那么容易（它可能会或可能不会改变 x 如果 x 是可变的）。因此，在 Julia 中有一个约定，即在函数名称的末尾添加 !，这些函数可能会改变其参数以直观地表示这一点（应该强调的是，这只是一个约定——特别是仅添加 ! 在函数名称的末尾对其工作方式没有直接影响）。我们已经在 setindex! 中看到了这一点（正如所讨论的，shorthand 是 x[1] = 10），但这是一个不同的例子：

julia> x = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> filter(==(1), x) # no ! so a new vector is created
1-element Array{Int64,1}:
 1

julia> x
3-element Array{Int64,1}:
 1
 2
 3

julia> filter!(==(1), x) # ! so x is mutated in place
1-element Array{Int64,1}:
 1

julia> x
1-element Array{Int64,1}:
 1

如果您使用的函数（如 setindex!）会改变其参数并希望避免突变，请在向其传递参数时使用 copy（如果您的结构是 deepcopy多重嵌套和潜在的突变可能会在更深层次上发生——但这种情况很少见。

所以在我们的例子中：

julia> x = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> y = filter!(==(1), copy(x))
1-element Array{Int64,1}:
 1

julia> y
1-element Array{Int64,1}:
 1

julia> x
3-element Array{Int64,1}:
 1
 2
 3

Why/how 确定函数何时覆盖 Julia 中的局部变量？

Why/how to detemine when a function overwrites a local variable in Julia?

scope

julia