Just doing d3 = array([d1,d2]) seems to work for me:

>>> from numpy import array
>>> # ... create d1 and d2 ...
>>> d1.shape
(18,18)
>>> d2.shape
(18,18)
>>> d3 = array([d1, d2])
>>> d3.shape
(2, 18, 18)

If you know all of your 2D arrays at the start, you can just stack more than two of them:

import numpy as np
a = np.zeros((3, 4))
b = np.zeros((3, 4))
c = np.stack((a, b, a))

If you already have one "stacked" array and want to add another array to it, you can use e.g. numpy.concatenate:

If the array you want to add is "flat", you would have to wrap it in a list to make the dimensions match. By default, the arrays are joined along the first dimension (same as if you were to specify axis=0 in the keyword arguments):

>>> c.shape
(2, 3, 4)
>>> np.array([a]).shape
(1, 3, 4)

c = np.concatenate((c, [a]))

If both arrays are already "stacked", this will also work:

c = np.concatenate((c, c))

There are many ways how to construct multidimensional arrays.

If you want to construct a 3D array from given 2D arrays you can do something like

import numpy

# just some 2D arrays with shape (10,20)
a1 = numpy.ones((10,20))
a2 = 2* numpy.ones((10,20))
a3 = 3* numpy.ones((10,20))

# creating 3D array with shape (3,10,20)
b = numpy.array((a1,a2,a3))

Depending on the situation there are other ways which are faster. However, as long as you use built-in constructors instead of loops you are on the fast side.

For your concrete example in Edit I would use numpy.tri

c = numpy.zeros((20,10,10))
c[:] = numpy.tri(10,10,-1) - numpy.tri(10,10,-2)

One can use np.tile. Before doing this, a dimension needs to be added at the end of the array.

In [28]: x = np.array([[ 1, 2, 3],
    ...:  [ 4, 5, 6],
    ...:  [ 7, 8, 9]])

In [29]: np.tile(x[..., None], 3)
Out[29]: 
array([[[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3]],

       [[4, 4, 4],
        [5, 5, 5],
        [6, 6, 6]],

       [[7, 7, 7],
        [8, 8, 8],
        [9, 9, 9]]])

Use numpy.repeat on the array with one extra dimension:

np.repeat(a[...,None], 3, axis=2)

Or numpy.tile:

np.tile(a[...,None], (1,1,3))

Output:

array([[[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3]],

       [[2, 2, 2],
        [3, 3, 3],
        [4, 4, 4]],

       [[4, 4, 4],
        [5, 5, 5],
        [6, 6, 6]]])

You need to use

 data.reshape((data.shape[0], data.shape[1], 1))

Example

from numpy import array
data = [[11, 22],
    [33, 44],
    [55, 66]]
data = array(data)
print(data.shape)
data = data.reshape((data.shape[0], data.shape[1], 1))
print(data.shape)

Running the example first prints the size of each dimension in the 2D array, reshapes the array, then summarizes the shape of the new 3D array.

Result

(3,2)
(3,2,1)

Source :https://machinelearningmastery.com/index-slice-reshape-numpy-arrays-machine-learning-python/

You are treating the numpy array images like an list. Have a look at numpy.stack. But in my memory the fastest way is to convert each image to an numpy array, aggregate them in a list and then turn the list into an array.

import numpy as np
images = list()
for Letter in "ABCDEFGHIJKLMNO":
    im = Image.open("ABCDEFGHIJKLMNO\\16\\"+Letter+".bmp")
    sampleimage = np.array(im.getdata())
    images.append(sampleimage)
images_array = np.array(images)

In your case the resulting array should have the size [1800,11,156] or [11,156,1800]

Your arrays have different shapes on the 0 axis, so you cannot use numpy.stack directly.

You can either use padding or put all arrays in a list. Using padding:

import numpy as np

a0 = np.empty((2,150))
a1 = np.empty((5,150))
a2 = np.empty((10,150))

max_shape = [0,0]
for a in [a0, a1, a2]:
    if max_shape[0] < a.shape[0]:
        max_shape[0] = a.shape[0]
    if max_shape[1] < a.shape[1]:
        max_shape[1] = a.shape[1]
arrays = []
for a in [a0, a1, a2]:
    arrays.append(np.pad(a, pad_width=((0, max_shape[0] - a.shape[0]),
                                       (0, max_shape[1] - a.shape[1])),
                         mode='constant'))
stacked_array = np.stack(arrays)