scope - 为什么/如何确定函数何时覆盖 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 中的变量绑定(bind)到一个值(可以是不可变的或可变的)。

一些操作可以修改可变值。

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

典型案例如下:

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

julia> isimmutable(1)
true

julia> isimmutable("sdaf")
false

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

数组、字典、mutable structs等(在除 Tuple 、 NamedTuple 和 struct s 之外的一般容器类型中)是可变的:

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]将值(在本例中为向量)绑定(bind)到变量 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)

现在我们来到第二点 - 将一个值绑定(bind)到一个变量名。这通常使用 = 来完成。运算符，如果在其左侧我们看到一个变量名，如上所示 x = [1,2,3]或 x = (1,2,3) .

请特别注意 += (和类似的)正在重新绑定(bind)，例如:

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] 的简写，我们知道 =重新绑定(bind)。

特别是(如@pszufe 在评论中指出的)，如果您将值传递给函数，则不会复制任何内容。这里发生的是函数签名中的变量绑定(bind)到传递的值(这种行为有时称为共享传递)。所以你有了:

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

基本上发生的事情是“好像”你写了 y = x .不同之处在于函数创建了一个变量 y在一个新的作用域(函数的作用域)中，而 y = x将创建值的绑定(bind) x绑定(bind)到变量 y在 where 语句 y = x 的范围内存在。

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

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

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

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(x) 并不总是那么容易。会变异 x如果 f是一些通用函数(如果 x 是可变的，它可能会或可能不会变异 x)。因此在 Julia 中有一个约定添加 !在可能会改变其参数的函数名称的末尾以直观地表示这一点(应该强调这只是一个约定 - 特别是在函数名称的末尾添加 ! 对这个怎么运作)。我们已经通过 setindex! 看到了这一点。 (如所讨论的，其简写是 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