By my tests, np.repeat is a little faster than np.tile:

X = np.repeat(arr[None,:], 3, axis=0)

Alternatively, use np.concatenate:

X = np.concatenate([[arr]] * 3, axis=0)

arr = np.arange(10000 * 1000).reshape(10000, 1000)

%timeit np.repeat(arr[None,:], 3, axis=0)
%timeit np.tile(arr, (3, 1, 1))
%timeit np.concatenate([[arr]] * 3, axis=0)
# Read-only, array cannot be modified.
%timeit np.broadcast_to(arr, (3, *arr.shape))
# Creating copy of the above.
%timeit np.broadcast_to(arr, (3, *arr.shape)).copy()

170 ms ± 3.82 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
187 ms ± 3.12 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
243 ms ± 3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
10.9 µs ± 218 ns per loop (mean ± std. dev. of 7 runs, 100000 loops 
189 ms ± 2.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)each) 

np.array_equals(np.repeat(arr[None,:], 3, axis=0), 
                np.tile(arr, (3, 1, 1))
True

There are a number of options in numpy:

1. The simplest is np.stack, with the new axis set to 0:

   result = np.stack((arr,) * m, axis=0)
   

   This is a generalization of np.vstack, which can accept a variable m in the same way:

   result = np.vstack((arr,) * m)
   

2. Since you are looking to expand the first dimension and not the second, you can use np.tile:

   result = np.tile(arr, [m, 1])
   

3. For this simple case, you can repeat the elements individually for the same result using np.repeat. This is a bit hacky, but it works just as well:

   result = np.repeat([arr], m, axis=0)
   

   If arr is already a numpy array, you can add the leading dimension more explicitly:

   result = np.repeat(arr[None, :], m, axis=0)
   

4. A slightly more convoluted method, but which showcases what is going on under the hood better is using np.concatenate:

   np.concatenate(([arr],) * m, axis=0)
   

5. In the same spirit as concatenate, you can use the constructor np.array directly:

   np.array([arr] * m)
   

6. An ugly method is to use muliplication (combined with broadcasting):

   result = arr * np.ones((m, 1), dtype=np.int8)
   

   Setting the dtype to a very small integer type pretty much ensures that the result will be promoted to the actual type of your array.

7. The previous methods copy the array multiple times to get the 2D data. But since the data is repeated, you don't actually need to copy it. Instead, you can make a view that creates a fake first dimension using broadcasting. Specifically, the np.broadcast_to function will do exactly what you want:

    result = np.broadcast_to(arr, [m, len(arr)])
   

8. There is a more general approach even than the previous to making views is np.lib.stride_tricks.as_strided.

   First, let's reiterate the warning from the documentation:

   Warning

   This function has to be used with extreme care, see notes.

   Unless you know the byte-size of the dtype you plan on using ahead of time, it's a good idea to ensure that arr is a numpy array to get the strides from it:

   arr = np.asanyarray(arr)
   result = np.lib.stride_tricks.as_strided(arr, shape=(m, arr.size), strides=(0,) + arr.strides)
   

In the last two cases, if you want to expand the view into a full buffer that contains a proper copy for each element, you can copy the data:

result = result.copy()

If you don't do the expansion, you will effectively be simulating the behavior of multiple references to the same list, where modifying any element changes all elements in the same column.

One can use np.repeat methods together with np.newaxis:

import numpy as np

test = np.random.randn(40,40,3)
result = np.repeat(test[np.newaxis,...], 10, axis=0)
print(result.shape)
>> (10, 40, 40, 3)

numpy.tile

np.tile(my_input_array, 3)

Output

array([-1.02295637, -0.60583836, -0.42240581, -0.78376377, -0.85821456,
       -1.02295637, -0.60583836, -0.42240581, -0.78376377, -0.85821456,
       -1.02295637, -0.60583836, -0.42240581, -0.78376377, -0.85821456])

Edit: just noticed @hpaulj's answer. I'll still leave my answer but he mentioned np.tile first.

This should clarify:

import numpy as np

lst = [1, 2, 3, 4]
four_list = 4 * lst
print(four_list)

np_arr = np.array(lst)
np_multiplied_arr = 4 * np_arr
print(np_multiplied_arr)

np_four_arr = np.tile(np_arr, 4)
print(np_four_arr)

Result:

[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
[ 4  8 12 16]
[1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4]

Note how the code that works to repeat (or tile) a list in Python doesn't work as expected in Numpy, but there is the .tile() operation to help out.

In [1]: data = np.arange(-50,50,10)

To repeat each element 5 times use np.repeat:

In [3]: np.repeat(data, 5)
Out[3]: 
array([-50, -50, -50, -50, -50, -40, -40, -40, -40, -40, -30, -30, -30,
       -30, -30, -20, -20, -20, -20, -20, -10, -10, -10, -10, -10,   0,
         0,   0,   0,   0,  10,  10,  10,  10,  10,  20,  20,  20,  20,
        20,  30,  30,  30,  30,  30,  40,  40,  40,  40,  40])

To repeat the array 5 times use np.tile:

In [2]: np.tile(data, 5)
Out[2]: 
array([-50, -40, -30, -20, -10,   0,  10,  20,  30,  40, -50, -40, -30,
       -20, -10,   0,  10,  20,  30,  40, -50, -40, -30, -20, -10,   0,
        10,  20,  30,  40, -50, -40, -30, -20, -10,   0,  10,  20,  30,
        40, -50, -40, -30, -20, -10,   0,  10,  20,  30,  40])

Note, however, that sometimes you can take advantage of NumPy broadcasting instead of creating a larger array with repeated elements.

For example, if

z = np.array([1, 2])
v = np.array([[3], [4], [5]])

then to add these arrays to produce

 [[4 5]
  [5 6]
  [6 7]]

you do not need to use tile:

In [12]: np.tile(z, (3,1))
Out[12]: 
array([[1, 2],
       [1, 2],
       [1, 2]])

In [13]: np.tile(v, (1,2))
Out[13]: 
array([[3, 3],
       [4, 4],
       [5, 5]])

In [14]: np.tile(z, (3,1)) + np.tile(v, (1,2))
Out[14]: 
array([[4, 5],
       [5, 6],
       [6, 7]])

Instead, NumPy will broadcast the arrays for you:

In [15]: z + v
Out[15]: 
array([[4, 5],
       [5, 6],
       [6, 7]])