我不知道你是如何比较这两个代码的，但在我的机器朱莉娅只是1000倍快。

f(x) = x^2
g(x) = x^3
h(x) = (x^2)^2
compute(x) = f(g(h(x)))

function compute_sum(B)
    for j in 1:10000
        for i in 1:10000
            B[i,j] = compute(i+j+0.0)
        end 
    end 
    sum(B)
end

B = zeros(10000, 10000)
@time compute_sum(B)
1.0337869071875959e109
  0.126618 seconds (1 allocation: 16 bytes)

还有巨蟒：

from time import time

t0 = time()
for i in range(10000):
    for j in range(10000):
        B[i, j] = compute(i+j+2)

s = np.sum(B)
print('Time:', time()-t0, 'sec')
print(s)
Time: 126.33235883712769 sec
1.0337869071875948e+109

我认为，通过省略B并使用sum的迭代器特性，甚至可以更快地实现这一点

f(x) = x^2
g(x) = x^3
h(x) = (x^2)^2
compute(x) = f(g(h(x)))

large_sum(n) = sum(compute(i+j+0.0) for i=1:n, j=1:n)
    
@time large_sum(10000)

收益率

0.115042 seconds
1.0337869071880225e109

以及

julia> @allocated large_sum(10000)
0

• edit：* 如果你想使用整数（对我来说，@AboAmmar的解决方案似乎表明Python也可以使用Float 64？）

large_sum2(n) = sum(compute(big(i+j)) for i=1:n, j=1:n)
@time s = large_sum2(10000)

其产生

46.161187 seconds (1.60 G allocations: 37.124 GiB, 23.40% gc time)
10337869071875958659210675038435022389685259621942996488934459692733527441076067397940855599887078973410000000

以及

julia> Float64(s)
1.0337869071875959e109

这看起来仍然比Python解决方案（@ AboAmmar的）快

我把你的代码合并成一个块，这样更容易计时。然后我对下面的代码做了一些修改，以提高性能。
1.正确数字的主要问题是整数溢出，因为i和j开始时是Int64类型。由于我们最后存储为Float64，因此将输入强制转换为Float64。
1.通过将代码的主要内容放入函数中，我们可以利用编译。

function f(x)
    return x^2
end

function g(x)
    return x^3
end

function h(x)
    return x^4
end

function compose(f,g,h,x)
    return f(g(h(x)))
end

println("Global block")

@time begin
    # B is an untyped global
    B = Array{Float64, 2}(undef, 10000,10000)
    for i in 1:10000
        for j in 1:10000
            # The i and j are of type Int64
            # You are experiencing integer overflow
            B[i,j] = compose(f,g,h,i+j)
        end
    end

    println(sum(B))
end

println("Global block with global typed")

@time begin
    # In recent versions of Julia, we can bind the type of globals
    BB :: Matrix{Float64} = Array{Float64, 2}(undef, 10000,10000)
    for i in 1:10000
        for j in 1:10000
            # Cast to Float64 to fix the integer overflow
            BB[i,j] = compose(f,g,h,Float64(i+j))
        end
    end

    # This should yield the correct answer
    println(sum(BB))
end

function main()
    # It is best to contain in functions that can be compiled
    # We also do not have to worry about binding globals to types
    # The following are all _local_ variables
    B = Array{Float64, 2}(undef, 10000,10000)
    T = eltype(B)
    for i in 1:10000
        @simd for j in 1:10000
            @inbounds B[i,j] = compose(f,g,h,T(i+j))
        end
    end

    println(sum(B))
end

# Execute twice to check for compilation time
println("Main 1:")
@time main() # first executing may include compilation time
println("Main 2:")
@time main() # should already be compiled now

function better()
    # As Ronny suggests, you can perform this calculation without allocating the array, saving time
    sum = 0.0
    for i in 1:10000
        for j in 1:10000
            sum += compose(f,g,h,Float64(i+j))
        end
    end
    println(sum)
end

println("Better 1:")
@time better()
println("Better 2:")
@time better()

当我执行此命令时，在速度较慢的计算机上得到以下结果：
x一个一个一个一个x一个一个二个x
请注意，您也可以在一行中执行此操作。

julia> using BenchmarkTools

julia> @benchmark mapreduce(∘(f,g,h,Float64,t->t[1]+t[2]), +,  Iterators.product(1:10000, 1:10000))
BenchmarkTools.Trial: 3 samples with 1 evaluation.
 Range (min … max):  1.783 s …  1.791 s  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     1.784 s             ┊ GC (median):    0.00%
 Time  (mean ± σ):   1.786 s ± 4.441 ms  ┊ GC (mean ± σ):  0.00% ± 0.00%

  █    █                                                 █  
  █▁▁▁▁█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█ ▁
  1.78 s        Histogram: frequency by time        1.79 s <

 Memory estimate: 0 bytes, allocs estimate: 0.

Julia中的整数是64位的（不像Python，没有大小限制）你有整数溢出。
一种选择是迭代Float64 s

jula> using BenchmarkTools 

julia> @btime B = [compose($f,$g,$h,i+j) for i in 1.0:10000.0, j in 1.0:10000.0]
  859.809 ms (2 allocations: 762.94 MiB)
10000×10000 Matrix{Float64}:
...

请注意，$符号是使用BenchmarkTools宏正确测量速度所必需的，通常在代码中不会放置它们。