Julia running an order of magnitude slower than python

I could not compare your codes directly on my machine as your Python code does not execute correctly producing the timings. However, in Julia it is simple to fix the issues that @DNF and @Przemyslaw Szufel mentioned above without changing your code.
Just wrap everything in a function or let block. Then you do not need to rewrite anything in your functions. I have run such a test and the results are:

Timing of your Julia code "as is"

 22.927925 seconds (360.97 M allocations: 5.731 GiB, 3.36% gc time, 1.49% compilation time)

(it is immediately visible that something is wrong with the code as you have 361M allocations that amount to 5.7GiB of RAM)

Timing of your code if I wrap it in a function

What I do is just add two lines:

function fun()

at the top and one extra

end

at the bottom.

The timing is:

julia> fun()
  0.779523 seconds (5.00 k allocations: 16.144 MiB, 0.91% gc time)

(allocations went significantly down; this could be further optimized, but I understand you want to compare exactly the same code in both languages)

So you get 22.9 / 0.78 = 29.3 speedup. Which, given what you reported should be around 3x faster than Python.

Small coding style comment: what I needed to change is removing one blank line before function sample(num_runs) as normally Julia REPL assumes that passing two blank lines ends a definition (and when wrapping everything in a function you did not want its definition to be finished).

Having said that – this is not how normally one would write a Julia program as others have already commented. I recommend you check the Performance tips section of the Julia Manual for details.

EDIT

Here is a quick-and dirty rewrite of your code that does less allocations and is faster:

function f()
    N=1000
    T=20
    sdt=1
    base=fill(1,N)
    mb=collect(1:N)
    time_data = fill(0,floor(Int, T/sdt))

    function run(kp,km)
        fill!(base, 1)
        mb .= 1:N
        fill!(time_data, 0)
        m=N
        th=0
        time_data[1]=N
        time_temp = sdt
        
        @inbounds while th<T
            # println(th, ' ', m)
            if m==0
                println(th)
                break
            end
            
            if th>time_temp
                time_data[ceil(Int, time_temp/sdt)+1]=m
                time_temp += sdt
            end
            
            kt=m*(kp+km)
            th=th+rand(Exponential(1/kt))
            ran=kt*rand(Float64)
            index=floor(Int,ran/(kp+km))
            rem=ran-index*(kp+km)
            index=index+1
            
            if rem<km
                base[mb[index]]=0
                tmp=mb[index]
                mb[index]=mb[m]
                mb[m]=tmp
                m=m-1
            else
                pos=rand(1:N)
                if base[pos]==0
                    base[pos]=1
                    mb[m+1]=pos
                    m=m+1
                end
            end
            
        end
        return time_data
    end

    function sample(num_runs)
        time_data_avg = fill(0.0, floor(Int, T/sdt))
        td_var=fill(0.0, floor(Int, T/sdt))
        for i in 1:num_runs
            m = run(2,1)
            time_data_avg .+= m ./ num_runs
            td_var .+= m.*(m ./ num_runs)
        end
        td_var .-= time_data_avg.^2
        
        return time_data_avg, td_var
    end

    @time begin
        tm,tv=sample(1000)
    end
end

It does:

julia> f();
  0.739664 seconds (2 allocations: 448 bytes)

While the same using your original code is:

julia> f();
  0.778454 seconds (5.00 k allocations: 16.144 MiB)

(so the difference in timing is not super big but noticeable, but allocations are significantly lower, which means that less strain on GC; I have not analyzed the logic of your code – I only changed the memory management)