In [1]:

    

import numpy as np


    

In [2]:

    

print("Small size")
a = np.ones(shape=(4, 500))
%timeit -n10000 np.zeros_like(a)
%timeit -n10000 np.zeros(shape=a.shape)
print("Large size")
a = np.ones(shape=(8, 50000))
%timeit -n100 np.zeros_like(a)
%timeit -n100 np.zeros(shape=a.shape)


    

    




Small size
5.91 µs ± 406 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
2.06 µs ± 66.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Large size
800 µs ± 11.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
18.2 µs ± 1.17 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [3]:

    

print("Small size")
a = np.ones(shape=(4, 500))
%timeit -n10000 np.ones_like(a)
%timeit -n10000 np.ones(shape=a.shape)
print("Large size")
a = np.ones(shape=(8, 50000))
%timeit -n100 np.ones_like(a)
%timeit -n100 np.ones(shape=a.shape)


    

    




Small size
4.13 µs ± 173 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
3.82 µs ± 84.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Large size
803 µs ± 29 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
806 µs ± 14.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [4]:

    

print("Small size")
a = np.ones(shape=(4, 500))
%timeit -n10000 np.full_like(a, 1.1)
%timeit -n10000 np.full(a.shape, 1.1)
print("Large size")
a = np.ones(shape=(8, 50000))
%timeit -n100 np.full_like(a, 1.1)
%timeit -n100 np.full(a.shape, 1.1)


    

    




Small size
4.12 µs ± 251 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
4.4 µs ± 112 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Large size
794 µs ± 16.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
796 µs ± 16.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [5]:

    

print("Small size")
a = np.empty(shape=(4, 500))
%timeit -n10000 np.empty_like(a)
%timeit -n10000 np.empty(a.shape)
print("Large size")
a = np.ones(shape=(8, 50000))
%timeit -n100 np.empty_like(a)
%timeit -n100 np.empty(a.shape)


    

    




Small size
366 ns ± 47.7 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
542 ns ± 21.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Large size
15.9 µs ± 667 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)
17.5 µs ± 1.71 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [6]:

    

print("Small size")
a = np.ones(500)
%timeit -n10000 np.r_[[a], [a], [a], [a]]
%timeit -n10000 np.concatenate(([a], [a], [a], [a]))
%timeit -n10000 np.vstack((a, a, a, a))
%timeit -n10000 np.array([a,a,a,a]) # another approach for this case
%timeit -n10000 np.array([a, a, a, a]).reshape((-1, a.shape[-1]))
assert np.allclose(np.r_[[a], [a], [a], [a]], np.concatenate(([a], [a], [a], [a])))
assert np.allclose(np.r_[[a], [a], [a], [a]], np.vstack((a, a, a, a)))
assert np.allclose(np.r_[[a], [a], [a], [a]], np.array([a,a,a,a]))
assert np.allclose(np.r_[[a], [a], [a], [a]], np.array([a, a, a, a]).reshape((-1, a.shape[-1])))
print("\nLarge size")
a = np.random.rand(8, 50000)
%timeit -n100 np.r_[a, a, a, a]
%timeit -n100 np.concatenate((a, a, a, a))
%timeit -n100 np.vstack((a, a, a, a))
%timeit -n100 np.array([a, a, a, a]).reshape((-1, a.shape[1]))

assert np.allclose(np.r_[a, a, a, a], np.concatenate((a, a, a, a)))
assert np.allclose(np.r_[a, a, a, a], np.vstack((a, a, a, a)))
assert np.allclose(np.r_[a, a, a, a], np.array([a, a, a, a]).reshape((-1, a.shape[1])))


    

    




Small size
22.4 µs ± 236 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
9.2 µs ± 82.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
12.6 µs ± 142 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
3.43 µs ± 66.8 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
4.85 µs ± 85.1 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Large size
3.79 ms ± 90.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.71 ms ± 42.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
4.33 ms ± 553 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
4.04 ms ± 312 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [7]:

    

print("Small size")
U = np.ones(shape=(2, 400))
%timeit -n10000 np.c_[U[:, 0], U]
%timeit -n10000 np.hstack((U[:, 0, np.newaxis], U))
%timeit -n10000 Unew = np.empty(shape=(U.shape[0], U.shape[1] + 1)); Unew[:, 0] = U[:, 0]; Unew[:, 1:] = U;

assert np.allclose(np.c_[U[:, 0], U], np.hstack((U[:, 0, np.newaxis], U)))
Unew = np.empty(shape=(U.shape[0], U.shape[1] + 1)); Unew[:, 0] = U[:, 0]; Unew[:, 1:] = U;
assert np.allclose(np.c_[U[:, 0], U], Unew)

print("\nLarge size")
U = np.ones(shape=(3, 400000))
%timeit -n100 np.c_[U[:, 0], U]
%timeit -n100 np.hstack((U[:, 0, np.newaxis], U))
%timeit -n100 Unew = np.empty(shape=(U.shape[0], U.shape[1] + 1)); Unew[:, 0] = U[:, 0]; Unew[:, 1:] = U;
assert np.allclose(np.c_[U[:, 0], U], np.hstack((U[:, 0, np.newaxis], U)))
Unew = np.empty(shape=(U.shape[0], U.shape[1] + 1)); Unew[:, 0] = U[:, 0]; Unew[:, 1:] = U;
assert np.allclose(np.c_[U[:, 0], U], Unew)


    

    




Small size
33.3 µs ± 592 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
7.04 µs ± 140 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
3.74 µs ± 102 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Large size
3.25 ms ± 54.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.19 ms ± 27.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.2 ms ± 60.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [8]:

    

print("Small size")
U = np.ones(shape=(4, 200))
%timeit -n10000 np.diff(U, axis=-1)
%timeit -n10000 U[..., 1:] - U[..., :-1]
assert np.allclose(np.diff(U, axis=-1), U[..., 1:] - U[..., :-1])

print("Large size")
U = np.ones(shape=(20, 10000))
%timeit -n100 np.diff(U, axis=-1)
%timeit -n100 U[..., 1:] - U[..., :-1]
assert np.allclose(np.diff(U, axis=-1), U[..., 1:] - U[..., :-1])


    

    




Small size
8.39 µs ± 428 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
3.81 µs ± 170 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Large size
457 µs ± 22.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
451 µs ± 20.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [9]:

    

a = np.arange(5000)
%timeit -n1000 a.copy()
%timeit -n1000 np.array(a)
%timeit -n1000 np.r_[a]
%timeit -n1000 anew = np.empty_like(a); anew[:] = a[:];


    

    




2.41 µs ± 893 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.67 µs ± 448 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
14 µs ± 5.85 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2.2 µs ± 211 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)