The code proposed by the OP can indeed made be more efficient, mainly by noting the fact that to form the sequence , with you do not have to compute at each step, but you can exploit the fact that , reusing the result of the previous step.

My proposed implementation is

import numpy as np

N = 3
M = 1

A = np.random.random((N, N))
B = np.random.random((N, M))

X = np.zeros((N ** 2, N * M))
rsl = slice(0, N)
X[rsl, :M] = B
for i in range(1, N):
    rsl_p, rsl = rsl, slice(i * N, (i + 1) * N)
    X[rsl, :M] = A @ X[rsl_p, :M]
    X[rsl, M : (i + 1) * M] = X[rsl_p, : i * M]

This question is more related to programming that computational science, so I add some general remarks, useful for a novice programmer.

1. never blindly translate mathematical expressions into code: think algorithmically.

   X = np.linalg.matrix_power(A,i)@B 
   

   is much slower than

   X=B; 
   for j in range(i): X = A*X
   

   if

   (exercise: compute operation count for both code fragments).

2. whenever possible reuse previous calculations.

3. pre-allocate output matrices, and do not store intermediate results in temp. matrices

mats_row=np.array([[A1,A2,A3,...,A_n]]) #Create array of matrices with shape (1,M,N,N)
mats_column=np.transpose(mats_row,(1,0,2,3)) #Make a copy with shape (M,1,N,N)
block=.5*(mats_row+mats_column) #Add, broadcasting to a (M,M,N,N) array

This works by utilizing Numpy's broadcasting capabilities. The basic idea is similar to if you added a matrix where each row was $[A_1,A_2,..A_n]$ to a matrix where each column was $[A_1,A_2,..A_n]$, but broadcasting allows you to do this without ever explicitly forming these intermediates matrices.

As of NumPy 1.13, there's numpy.block:

Block = numpy.block([[A11, A12], [A21, A22]])

For previous versions, there's bmat:

Block = numpy.bmat([[A11, A12], [A21, A22]])

numpy.bmat creates a matrix, rather than an array. This is usually a bad thing. You can call asarray on the result if you want an array, or use the A attribute:

Block = numpy.bmat([[A11, A12], [A21, A22]]).A

bmat also does some messing around with stack frames to let you do this:

Block = numpy.bmat('A11,A12; A21,A22')

bmat returns a numpy.matrix instance, as in those things you should never use because they cause all kinds of weird incompatibilities. numpy.matrix always tries to preserve at least two dimensions, so b.dot(np.zeros(4)) is 2D instead of 1D.

Make a numpy.array:

b = np.bmat([[a, a], [a, a]]).A
#                             ^

Or as of NumPy 1.13,

b = np.block([[a, a], [a, a]])

Easy way to represent your matrix in blocks (keeping intermediate steps, but you don't have to):

block_m = 8  # rows in block
block_n = 8  # cols in block
A = np.arange(256*256).reshape(256,256)  # sample data
B = A.reshape((-1, block_m, A.shape[1]//block_n, block_n))  
C = B.transpose((0,2,1,3))

This yields (in this case) a 32-by-32-by-8-by-8 array where the first two axes refer to the block matrix. i.e. C[0,0] is the 8-by-8 sub-array in the top left of your original array. In most cases, I believe C should be a view on the original array; changing C[0,0,0,0], for instance, changes A[0,0].

You can loop over the first two axes or apply vectorized functions as needed. As an example, here's me averaging the 8-by-8 subarrays:

block_means = np.sum(C, axis=(2,3)) / 64

IMO, np.eye already has everything you need, as you can define number of rows and columns separately.
So your function should simply look like

def fct(k):
    return np.eye(k**2-k, k**2)